pxcloud/spice
5
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice synced 2025-12-27 07:29:32 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

use QXLState instead of RedDispatcher

Browse Source 
Considering that:
- QXLState is the state of QXLInstance implementation;
- RedDispatcher is the implementation of QXL;
- qif (QXLInterface*) field can be computed really easy from QXLInstance;
- most of its state is private.
Make all structure private and use QXLState instead of RedDispatcher.

Signed-off-by: Frediano Ziglio <fziglio@redhat.com>
Acked-by: Jonathon Jongsma <jjongsma@redhat.com>
Acked-by: Christophe Fergeau <cfergeau@redhat.com>
This commit is contained in:
Frediano Ziglio 2016-02-25 18:54:09 +00:00
parent 5916dd8fa6
commit e9ed125dbd
11 changed files with 370 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/cursor-channel.c
View File

@ -116,7 +116,7 @@ static void cursor_item_unref(CursorItem *item)
return;
cursor_cmd = item->red_cursor;
item->qxl->st->qif->release_resource(item->qxl, cursor_cmd->release_info_ext);
qxl_get_interface(item->qxl)->release_resource(item->qxl, cursor_cmd->release_info_ext);
red_put_cursor_cmd(cursor_cmd);
free(cursor_cmd);

17
server/dcc-send.c
View File

@ -2306,18 +2306,13 @@ static void marshall_gl_scanout(RedChannelClient *rcc,
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
DisplayChannel *display_channel = DCC_TO_DC(dcc);
QXLInstance* qxl = display_channel->common.qxl;
SpiceMsgDisplayGlScanoutUnix *so = &qxl->st->scanout;
pthread_mutex_lock(&qxl->st->scanout_mutex);
if (so->drm_dma_buf_fd == -1)
goto end;
red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_GL_SCANOUT_UNIX, NULL);
spice_marshall_msg_display_gl_scanout_unix(m, so);
end:
pthread_mutex_unlock(&qxl->st->scanout_mutex);
SpiceMsgDisplayGlScanoutUnix *so = red_qxl_get_gl_scanout(qxl->st);
if (so != NULL) {
red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_GL_SCANOUT_UNIX, NULL);
spice_marshall_msg_display_gl_scanout_unix(m, so);
}
red_qxl_put_gl_scanout(qxl->st, so);
}
static void marshall_gl_draw(RedChannelClient *rcc,

4
server/dcc.c
View File

@ -467,7 +467,8 @@ void dcc_start(DisplayChannelClient *dcc)
dcc_create_all_streams(dcc);
}
if (qxl->st->scanout.drm_dma_buf_fd >= 0) {
SpiceMsgDisplayGlScanoutUnix *scanout = red_qxl_get_gl_scanout(qxl->st);
if (scanout) {
if (reds_stream_is_plain_unix(rcc->stream) &&
red_channel_client_test_remote_cap(rcc, SPICE_DISPLAY_CAP_GL_SCANOUT)) {
red_channel_client_pipe_add(rcc, dcc_gl_scanout_item_new(rcc, NULL, 0));
@ -476,6 +477,7 @@ void dcc_start(DisplayChannelClient *dcc)
spice_printerr("FIXME: GL not supported on this kind of connection");
}
}
red_qxl_put_gl_scanout(qxl->st, scanout);
}
static void dcc_destroy_stream_agents(DisplayChannelClient *dcc)

8
server/display-channel.c
View File

@ -268,10 +268,10 @@ void display_channel_surface_unref(DisplayChannel *display, uint32_t surface_id)
surface->context.canvas->ops->destroy(surface->context.canvas);
if (surface->create.info) {
qxl->st->qif->release_resource(qxl, surface->create);
qxl_get_interface(qxl)->release_resource(qxl, surface->create);
}
if (surface->destroy.info) {
qxl->st->qif->release_resource(qxl, surface->destroy);
qxl_get_interface(qxl)->release_resource(qxl, surface->destroy);
}
region_destroy(&surface->draw_dirty_region);
@ -2162,9 +2162,7 @@ static void set_gl_draw_async_count(DisplayChannel *display, int num)
display->gl_draw_async_count = num;
if (num == 0) {
struct AsyncCommand *async = qxl->st->gl_draw_async;
qxl->st->gl_draw_async = NULL;
red_qxl_async_complete(qxl->st->dispatcher, async);
red_qxl_gl_draw_async_complete(qxl->st);
}
}

495
server/red-qxl.c
View File

File diff suppressed because it is too large Load Diff

37
server/red-qxl.h
View File

@ -20,27 +20,30 @@
#include "red-channel.h"
typedef struct RedDispatcher RedDispatcher;
typedef struct QXLState QXLState;
typedef struct AsyncCommand AsyncCommand;
void red_qxl_init(QXLInstance *qxl);
void red_qxl_set_mm_time(RedDispatcher *dispatcher, uint32_t);
void red_qxl_on_ic_change(RedDispatcher *dispatcher, SpiceImageCompression ic);
void red_qxl_on_sv_change(RedDispatcher *dispatcher, int sv);
void red_qxl_set_mouse_mode(RedDispatcher *dispatcher, uint32_t mode);
void red_qxl_attach_worker(RedDispatcher *dispatcher);
void red_qxl_set_compression_level(RedDispatcher *dispatcher, int level);
void red_qxl_stop(RedDispatcher *dispatcher);
void red_qxl_start(RedDispatcher *dispatcher);
uint32_t red_qxl_get_ram_size(RedDispatcher *dispatcher);
void red_qxl_async_complete(struct RedDispatcher *, AsyncCommand *);
struct Dispatcher *red_qxl_get_dispatcher(struct RedDispatcher *);
gboolean red_qxl_use_client_monitors_config(RedDispatcher *dispatcher);
gboolean red_qxl_client_monitors_config(RedDispatcher *dispatcher, VDAgentMonitorsConfig *monitors_config);
gboolean red_qxl_get_primary_active(RedDispatcher *dispatcher);
gboolean red_qxl_get_allow_client_mouse(RedDispatcher *dispatcher, gint *x_res, gint *y_res);
void red_qxl_set_mm_time(QXLState *qxl_state, uint32_t);
void red_qxl_on_ic_change(QXLState *qxl_state, SpiceImageCompression ic);
void red_qxl_on_sv_change(QXLState *qxl_state, int sv);
void red_qxl_set_mouse_mode(QXLState *qxl_state, uint32_t mode);
void red_qxl_attach_worker(QXLState *qxl_state);
void red_qxl_set_compression_level(QXLState *qxl_state, int level);
void red_qxl_stop(QXLState *qxl_state);
void red_qxl_start(QXLState *qxl_state);
uint32_t red_qxl_get_ram_size(QXLState *qxl_state);
void red_qxl_async_complete(QXLState *qxl_state, AsyncCommand *cmd);
struct Dispatcher *red_qxl_get_dispatcher(QXLState *qxl_state);
gboolean red_qxl_use_client_monitors_config(QXLState *qxl_state);
gboolean red_qxl_client_monitors_config(QXLState *qxl_state, VDAgentMonitorsConfig *monitors_config);
gboolean red_qxl_get_primary_active(QXLState *qxl_state);
gboolean red_qxl_get_allow_client_mouse(QXLState *qxl_state, gint *x_res, gint *y_res);
SpiceMsgDisplayGlScanoutUnix *red_qxl_get_gl_scanout(QXLState *qxl_state);
void red_qxl_put_gl_scanout(QXLState *qxl_state, SpiceMsgDisplayGlScanoutUnix *scanout);
void red_qxl_gl_draw_async_complete(QXLState *qxl);
typedef uint32_t RedWorkerMessage;
@ -267,6 +270,6 @@ enum {
RED_DISPATCHER_PENDING_OOM,
};
void red_qxl_clear_pending(RedDispatcher *red_dispatcher, int pending);
void red_qxl_clear_pending(QXLState *qxl_state, int pending);
#endif

57
server/red-worker.c
View File

@ -60,7 +60,7 @@
struct RedWorker {
pthread_t thread;
QXLInstance *qxl;
RedDispatcher *red_dispatcher;
QXLState *qxl_state;
SpiceWatch *dispatch_watch;
int running;
SpiceCoreInterfaceInternal core;
@ -127,8 +127,8 @@ void red_drawable_unref(RedDrawable *red_drawable)
if (--red_drawable->refs) {
return;
}
red_drawable->qxl->st->qif->release_resource(red_drawable->qxl,
red_drawable->release_info_ext);
qxl_get_interface(red_drawable->qxl)->release_resource(red_drawable->qxl,
red_drawable->release_info_ext);
red_put_drawable(red_drawable);
free(red_drawable);
}
@ -145,12 +145,12 @@ static int red_process_cursor(RedWorker *worker, int *ring_is_empty)
*ring_is_empty = FALSE;
while (red_channel_max_pipe_size(RED_CHANNEL(worker->cursor_channel)) <= MAX_PIPE_SIZE) {
if (!worker->qxl->st->qif->get_cursor_command(worker->qxl, &ext_cmd)) {
if (!qxl_get_interface(worker->qxl)->get_cursor_command(worker->qxl, &ext_cmd)) {
*ring_is_empty = TRUE;
if (worker->cursor_poll_tries < CMD_RING_POLL_RETRIES) {
worker->event_timeout = MIN(worker->event_timeout, CMD_RING_POLL_TIMEOUT);
} else if (worker->cursor_poll_tries == CMD_RING_POLL_RETRIES &&
!worker->qxl->st->qif->req_cursor_notification(worker->qxl)) {
!qxl_get_interface(worker->qxl)->req_cursor_notification(worker->qxl)) {
continue;
}
worker->cursor_poll_tries++;
@ -203,12 +203,12 @@ static int red_process_display(RedWorker *worker, int *ring_is_empty)
worker->process_display_generation++;
*ring_is_empty = FALSE;
while (red_channel_max_pipe_size(RED_CHANNEL(worker->display_channel)) <= MAX_PIPE_SIZE) {
if (!worker->qxl->st->qif->get_command(worker->qxl, &ext_cmd)) {
if (!qxl_get_interface(worker->qxl)->get_command(worker->qxl, &ext_cmd)) {
*ring_is_empty = TRUE;
if (worker->display_poll_tries < CMD_RING_POLL_RETRIES) {
worker->event_timeout = MIN(worker->event_timeout, CMD_RING_POLL_TIMEOUT);
} else if (worker->display_poll_tries == CMD_RING_POLL_RETRIES &&
!worker->qxl->st->qif->req_cmd_notification(worker->qxl)) {
!qxl_get_interface(worker->qxl)->req_cmd_notification(worker->qxl)) {
continue;
}
worker->display_poll_tries++;
@ -245,9 +245,9 @@ static int red_process_display(RedWorker *worker, int *ring_is_empty)
spice_warning("Invalid surface in QXL_CMD_UPDATE");
} else {
display_channel_draw(worker->display_channel, &update.area, update.surface_id);
worker->qxl->st->qif->notify_update(worker->qxl, update.update_id);
qxl_get_interface(worker->qxl)->notify_update(worker->qxl, update.update_id);
}
worker->qxl->st->qif->release_resource(worker->qxl, update.release_info_ext);
qxl_get_interface(worker->qxl)->release_resource(worker->qxl, update.release_info_ext);
red_put_update_cmd(&update);
break;
}
@ -262,7 +262,7 @@ static int red_process_display(RedWorker *worker, int *ring_is_empty)
/* alert: accessing message.data is insecure */
spice_warning("MESSAGE: %s", message.data);
#endif
worker->qxl->st->qif->release_resource(worker->qxl, message.release_info_ext);
qxl_get_interface(worker->qxl)->release_resource(worker->qxl, message.release_info_ext);
red_put_message(&message);
break;
}
@ -507,11 +507,12 @@ static void guest_set_client_capabilities(RedWorker *worker)
SPICE_DISPLAY_CAP_COMPOSITE,
SPICE_DISPLAY_CAP_A8_SURFACE,
};
QXLInterface *qif = qxl_get_interface(worker->qxl);
if (worker->qxl->st->qif->base.major_version < 3 ||
(worker->qxl->st->qif->base.major_version == 3 &&
worker->qxl->st->qif->base.minor_version < 2) ||
!worker->qxl->st->qif->set_client_capabilities) {
if (qif->base.major_version < 3 ||
(qif->base.major_version == 3 &&
qif->base.minor_version < 2) ||
!qif->set_client_capabilities) {
return;
}
#define SET_CAP(a,c) \
@ -525,7 +526,7 @@ static void guest_set_client_capabilities(RedWorker *worker)
}
if ((worker->display_channel == NULL) ||
(RED_CHANNEL(worker->display_channel)->clients_num == 0)) {
worker->qxl->st->qif->set_client_capabilities(worker->qxl, FALSE, caps);
qif->set_client_capabilities(worker->qxl, FALSE, caps);
} else {
// Take least common denominator
for (i = 0 ; i < sizeof(caps_available) / sizeof(caps_available[0]); ++i) {
@ -538,7 +539,7 @@ static void guest_set_client_capabilities(RedWorker *worker)
CLEAR_CAP(caps, caps_available[i]);
}
}
worker->qxl->st->qif->set_client_capabilities(worker->qxl, TRUE, caps);
qif->set_client_capabilities(worker->qxl, TRUE, caps);
}
}
@ -577,15 +578,15 @@ static void handle_dev_update_async(void *opaque, void *payload)
uint32_t num_dirty_rects = 0;
spice_return_if_fail(worker->running);
spice_return_if_fail(worker->qxl->st->qif->update_area_complete);
spice_return_if_fail(qxl_get_interface(worker->qxl)->update_area_complete);
flush_display_commands(worker);
display_channel_update(worker->display_channel,
msg->surface_id, &msg->qxl_area, msg->clear_dirty_region,
&qxl_dirty_rects, &num_dirty_rects);
worker->qxl->st->qif->update_area_complete(worker->qxl, msg->surface_id,
qxl_dirty_rects, num_dirty_rects);
qxl_get_interface(worker->qxl)->update_area_complete(worker->qxl, msg->surface_id,
qxl_dirty_rects, num_dirty_rects);
free(qxl_dirty_rects);
}
@ -823,7 +824,7 @@ static void handle_dev_wakeup(void *opaque, void *payload)
RedWorker *worker = opaque;
stat_inc_counter(reds, worker->wakeup_counter, 1);
red_qxl_clear_pending(worker->red_dispatcher, RED_DISPATCHER_PENDING_WAKEUP);
red_qxl_clear_pending(worker->qxl_state, RED_DISPATCHER_PENDING_WAKEUP);
}
static void handle_dev_oom(void *opaque, void *payload)
@ -844,16 +845,16 @@ static void handle_dev_oom(void *opaque, void *payload)
while (red_process_display(worker, &ring_is_empty)) {
red_channel_push(display_red_channel);
}
if (worker->qxl->st->qif->flush_resources(worker->qxl) == 0) {
if (qxl_get_interface(worker->qxl)->flush_resources(worker->qxl) == 0) {
display_channel_free_some(worker->display_channel);
worker->qxl->st->qif->flush_resources(worker->qxl);
qxl_get_interface(worker->qxl)->flush_resources(worker->qxl);
}
spice_debug("OOM2 #draw=%u, #glz_draw=%u current %u pipes %u",
display->drawable_count,
display->glz_drawable_count,
display->current_size,
red_channel_sum_pipes_size(display_red_channel));
red_qxl_clear_pending(worker->red_dispatcher, RED_DISPATCHER_PENDING_OOM);
red_qxl_clear_pending(worker->qxl_state, RED_DISPATCHER_PENDING_OOM);
}
static void handle_dev_reset_cursor(void *opaque, void *payload)
@ -1194,7 +1195,7 @@ static void worker_handle_dispatcher_async_done(void *opaque,
RedWorkerMessageAsync *msg_async = payload;
spice_debug(NULL);
red_qxl_async_complete(worker->red_dispatcher, msg_async->cmd);
red_qxl_async_complete(worker->qxl_state, msg_async->cmd);
}
static void worker_dispatcher_record(void *opaque, uint32_t message_type, void *payload)
@ -1462,14 +1463,14 @@ static GSourceFuncs worker_source_funcs = {
.dispatch = worker_source_dispatch,
};
RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher)
RedWorker* red_worker_new(QXLInstance *qxl, QXLState *qxl_state)
{
QXLDevInitInfo init_info;
RedWorker *worker;
Dispatcher *dispatcher;
const char *record_filename;
qxl->st->qif->get_init_info(qxl, &init_info);
qxl_get_interface(qxl)->get_init_info(qxl, &init_info);
worker = spice_new0(RedWorker, 1);
worker->core = event_loop_core;
@ -1487,10 +1488,10 @@ RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher)
spice_error("failed to write replay header");
}
}
dispatcher = red_qxl_get_dispatcher(red_dispatcher);
dispatcher = red_qxl_get_dispatcher(qxl_state);
dispatcher_set_opaque(dispatcher, worker);
worker->red_dispatcher = red_dispatcher;
worker->qxl_state = qxl_state;
worker->qxl = qxl;
register_callbacks(dispatcher);
if (worker->record_fd) {

2
server/red-worker.h
View File

@ -90,7 +90,7 @@ static inline void red_pipes_add_verb(RedChannel *channel, uint16_t verb)
}
}
RedWorker* red_worker_new(QXLInstance *qxl, RedDispatcher *red_dispatcher);
RedWorker* red_worker_new(QXLInstance *qxl, QXLState *qxl_state);
bool red_worker_run(RedWorker *worker);
RedChannel* red_worker_get_cursor_channel(RedWorker *worker);
RedChannel* red_worker_get_display_channel(RedWorker *worker);

2
server/reds-private.h
View File

@ -241,7 +241,7 @@ struct RedsState {
RedSSLParameters ssl_parameters;
SpiceCoreInterfaceInternal *core;
GList *dispatchers;
GList *qxl_states;
MainDispatcher *main_dispatcher;
};

80
server/reds.c
View File

@ -570,8 +570,8 @@ static void reds_set_mouse_mode(RedsState *reds, uint32_t mode)
}
reds->mouse_mode = mode;
for (l = reds->dispatchers; l != NULL; l = l->next)
red_qxl_set_mouse_mode(l->data, mode);
for (l = reds->qxl_states; l != NULL; l = l->next)
red_qxl_set_mouse_mode((QXLState*) l->data, mode);
main_channel_push_mouse_mode(reds->main_channel, reds->mouse_mode, reds->is_client_mouse_allowed);
}
@ -584,7 +584,7 @@ gboolean reds_get_agent_mouse(const RedsState *reds)
static void reds_update_mouse_mode(RedsState *reds)
{
int allowed = 0;
int qxl_count = g_list_length(reds->dispatchers);
int qxl_count = g_list_length(reds->qxl_states);
if ((reds->agent_mouse && reds->vdagent) ||
(inputs_channel_has_tablet(reds->inputs_channel) && qxl_count == 1)) {
@ -1681,7 +1681,7 @@ static void reds_handle_main_link(RedsState *reds, RedLinkInfo *link)
}
if (!mig_target) {
main_channel_push_init(mcc, g_list_length(reds->dispatchers),
main_channel_push_init(mcc, g_list_length(reds->qxl_states),
reds->mouse_mode, reds->is_client_mouse_allowed,
reds_get_mm_time() - MM_TIME_DELTA,
reds_qxl_ram_size(reds));
@ -1827,7 +1827,7 @@ void reds_on_client_semi_seamless_migrate_complete(RedsState *reds, RedClient *c
mcc = red_client_get_main(client);
// TODO: not doing net test. consider doing it on client_migrate_info
main_channel_push_init(mcc, g_list_length(reds->dispatchers),
main_channel_push_init(mcc, g_list_length(reds->qxl_states),
reds->mouse_mode, reds->is_client_mouse_allowed,
reds_get_mm_time() - MM_TIME_DELTA,
reds_qxl_ram_size(reds));
@ -3199,7 +3199,7 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
}
} else if (strcmp(interface->type, SPICE_INTERFACE_QXL) == 0) {
QXLInstance *qxl;
RedDispatcher *dispatcher;
QXLState *qxl_state;
spice_info("SPICE_INTERFACE_QXL");
if (interface->major_version != SPICE_INTERFACE_QXL_MAJOR ||
@ -3209,21 +3209,17 @@ SPICE_GNUC_VISIBLE int spice_server_add_interface(SpiceServer *s,
}
qxl = SPICE_CONTAINEROF(sin, QXLInstance, base);
qxl->st = spice_new0(QXLState, 1);
pthread_mutex_init(&qxl->st->scanout_mutex, NULL);
qxl->st->scanout.drm_dma_buf_fd = -1;
qxl->st->qif = SPICE_CONTAINEROF(interface, QXLInterface, base);
red_qxl_init(qxl);
dispatcher = qxl->st->dispatcher;
reds->dispatchers = g_list_prepend(reds->dispatchers, dispatcher);
qxl_state = qxl->st;
reds->qxl_states = g_list_prepend(reds->qxl_states, qxl_state);
/* this function has to be called after the dispatcher is on the list
* as QXLInstance clients expect the dispatcher to be on the list when
/* this function has to be called after the qxl is on the list
* as QXLInstance clients expect the qxl to be on the list when
* this callback is called. This as clients assume they can start the
* dispatchers. Also note that this should be the first callback to
* qxl_states. Also note that this should be the first callback to
* be called. */
red_qxl_attach_worker(dispatcher);
red_qxl_set_compression_level(dispatcher, calc_compression_level(reds));
red_qxl_attach_worker(qxl_state);
red_qxl_set_compression_level(qxl_state, calc_compression_level(reds));
} else if (strcmp(interface->type, SPICE_INTERFACE_TABLET) == 0) {
SpiceTabletInstance *tablet = SPICE_CONTAINEROF(sin, SpiceTabletInstance, base);
spice_info("SPICE_INTERFACE_TABLET");
@ -4150,13 +4146,13 @@ void reds_update_client_mouse_allowed(RedsState *reds)
int x_res = 0;
int y_res = 0;
GList *l;
int num_active_workers = g_list_length(reds->dispatchers);
int num_active_workers = g_list_length(reds->qxl_states);
if (num_active_workers > 0) {
allow_now = TRUE;
for (l = reds->dispatchers; l != NULL && allow_now; l = l->next) {
for (l = reds->qxl_states; l != NULL && allow_now; l = l->next) {
RedDispatcher *now = l->data;
QXLState *now = l->data;
if (red_qxl_get_primary_active(now)) {
allow_now = red_qxl_get_allow_client_mouse(now, &x_res, &y_res);
break;
@ -4174,12 +4170,12 @@ gboolean reds_use_client_monitors_config(RedsState *reds)
{
GList *l;
if (reds->dispatchers == NULL) {
if (reds->qxl_states == NULL) {
return FALSE;
}
for (l = reds->dispatchers; l != NULL ; l = l->next) {
RedDispatcher *now = l->data;
for (l = reds->qxl_states; l != NULL ; l = l->next) {
QXLState *now = l->data;
if (!red_qxl_use_client_monitors_config(now))
return FALSE;
@ -4191,8 +4187,8 @@ void reds_client_monitors_config(RedsState *reds, VDAgentMonitorsConfig *monitor
{
GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next) {
RedDispatcher *now = l->data;
for (l = reds->qxl_states; l != NULL; l = l->next) {
QXLState *now = l->data;
if (!red_qxl_client_monitors_config(now, monitors_config)) {
/* this is a normal condition, some qemu devices might not implement it */
spice_debug("QXLInterface::client_monitors_config failed\n");
@ -4204,8 +4200,8 @@ void reds_set_mm_time(RedsState *reds, uint32_t mm_time)
{
GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next) {
RedDispatcher *now = l->data;
for (l = reds->qxl_states; l != NULL; l = l->next) {
QXLState *now = l->data;
red_qxl_set_mm_time(now, mm_time);
}
}
@ -4227,10 +4223,10 @@ void reds_on_ic_change(RedsState *reds)
int compression_level = calc_compression_level(reds);
GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next) {
RedDispatcher *d = l->data;
red_qxl_set_compression_level(d, compression_level);
red_qxl_on_ic_change(d, spice_server_get_image_compression(reds));
for (l = reds->qxl_states; l != NULL; l = l->next) {
QXLState *q = l->data;
red_qxl_set_compression_level(q, compression_level);
red_qxl_on_ic_change(q, spice_server_get_image_compression(reds));
}
}
@ -4239,10 +4235,10 @@ void reds_on_sv_change(RedsState *reds)
int compression_level = calc_compression_level(reds);
GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next) {
RedDispatcher *d = l->data;
red_qxl_set_compression_level(d, compression_level);
red_qxl_on_sv_change(d, reds_get_streaming_video(reds));
for (l = reds->qxl_states; l != NULL; l = l->next) {
QXLState *q = l->data;
red_qxl_set_compression_level(q, compression_level);
red_qxl_on_sv_change(q, reds_get_streaming_video(reds));
}
}
@ -4250,26 +4246,26 @@ void reds_on_vm_stop(RedsState *reds)
{
GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next)
red_qxl_stop(l->data);
for (l = reds->qxl_states; l != NULL; l = l->next)
red_qxl_stop((QXLState*) l->data);
}
void reds_on_vm_start(RedsState *reds)
{
GList *l;
for (l = reds->dispatchers; l != NULL; l = l->next)
red_qxl_start(l->data);
for (l = reds->qxl_states; l != NULL; l = l->next)
red_qxl_start((QXLState*) l->data);
}
uint32_t reds_qxl_ram_size(RedsState *reds)
{
RedDispatcher *first;
if (!reds->dispatchers) {
QXLState *first;
if (!reds->qxl_states) {
return 0;
}
first = reds->dispatchers->data;
first = reds->qxl_states->data;
return red_qxl_get_ram_size(first);
}

11
server/reds.h
View File

@ -34,13 +34,10 @@
typedef struct RedsState RedsState;
extern RedsState *reds;
struct QXLState {
QXLInterface *qif;
struct RedDispatcher *dispatcher;
pthread_mutex_t scanout_mutex;
SpiceMsgDisplayGlScanoutUnix scanout;
struct AsyncCommand *gl_draw_async;
};
static inline QXLInterface * qxl_get_interface(QXLInstance *qxl)
{
return SPICE_CONTAINEROF(qxl->base.sif, QXLInterface, base);
}
struct TunnelWorker;
struct SpiceNetWireState {