pxcloud/spice
5
0
Fork 0
mirror of https://gitlab.uni-freiburg.de/opensourcevdi/spice synced 2026-01-11 08:07:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

server/red_channel (all): add red_channel_get_marshaller

Browse Source 
For ussage in the send_item callback. It's only valid during this
time anyway (should make it return NULL in other occasions?)

No more direct usage of RedChannel.send_data.marshaller by channels.
This commit is contained in:
Alon Levy 2010-11-09 16:00:49 +02:00
parent 9e46945a61
commit 8002a30f9c
5 changed files with 205 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
server/inputs_channel.c
View File

@ -254,8 +254,7 @@ static void inputs_channel_release_pipe_item(RedChannel *channel,
static void inputs_channel_send_item(RedChannel *channel, PipeItem *base)
{
InputsChannel *inputs_channel = (InputsChannel *)channel;
SpiceMarshaller *m = inputs_channel->base.send_data.marshaller;
SpiceMarshaller *m = red_channel_get_marshaller(channel);
red_channel_init_send_data(channel, base->type, base);
switch (base->type) {

93
server/main_channel.c
View File

@ -280,15 +280,14 @@ static void main_channel_push_channels(MainChannel *main_chan)
red_channel_pipe_add_push(&main_chan->base, &item->base);
}
static void main_channel_marshall_channels(MainChannel *main_chan)
static void main_channel_marshall_channels(SpiceMarshaller *m)
{
SpiceMsgChannels* channels_info;
channels_info = (SpiceMsgChannels *)spice_malloc(sizeof(SpiceMsgChannels)
+ reds_num_of_channels() * sizeof(SpiceChannelId));
reds_fill_channels(channels_info);
spice_marshall_msg_main_channels_list(
main_chan->base.send_data.marshaller, channels_info);
spice_marshall_msg_main_channels_list(m, channels_info);
free(channels_info);
}
@ -305,13 +304,12 @@ int main_channel_push_ping(Channel *channel, int size)
return TRUE;
}
static void main_channel_marshall_ping(MainChannel *main_chan, int size)
static void main_channel_marshall_ping(SpiceMarshaller *m, int size, int ping_id)
{
struct timespec time_space;
SpiceMsgPing ping;
SpiceMarshaller *m = main_chan->base.send_data.marshaller;
ping.id = ++main_chan->ping_id;
ping.id = ping_id;
clock_gettime(CLOCK_MONOTONIC, &time_space);
ping.timestamp = time_space.tv_sec * 1000000LL + time_space.tv_nsec / 1000LL;
spice_marshall_msg_ping(m, &ping);
@ -334,7 +332,7 @@ void main_channel_push_mouse_mode(Channel *channel, int current_mode,
red_channel_pipe_add_push(&main_chan->base, &item->base);
}
static void main_channel_marshall_mouse_mode(MainChannel *main_chan, int current_mode, int is_client_mouse_allowed)
static void main_channel_marshall_mouse_mode(SpiceMarshaller *m, int current_mode, int is_client_mouse_allowed)
{
SpiceMsgMainMouseMode mouse_mode;
mouse_mode.supported_modes = SPICE_MOUSE_MODE_SERVER;
@ -342,8 +340,7 @@ static void main_channel_marshall_mouse_mode(MainChannel *main_chan, int current
mouse_mode.supported_modes |= SPICE_MOUSE_MODE_CLIENT;
}
mouse_mode.current_mode = current_mode;
spice_marshall_msg_main_mouse_mode(main_chan->base.send_data.marshaller,
&mouse_mode);
spice_marshall_msg_main_mouse_mode(m, &mouse_mode);
}
void main_channel_push_agent_connected(Channel *channel)
@ -364,13 +361,12 @@ void main_channel_push_agent_disconnected(Channel *channel)
red_channel_pipe_add_push(&main_chan->base, &item->base);
}
static void main_channel_marshall_agent_disconnected(MainChannel *main_chan)
static void main_channel_marshall_agent_disconnected(SpiceMarshaller *m)
{
SpiceMsgMainAgentDisconnect disconnect;
disconnect.error_code = SPICE_LINK_ERR_OK;
spice_marshall_msg_main_agent_disconnected(
main_chan->base.send_data.marshaller, &disconnect);
spice_marshall_msg_main_agent_disconnected(m, &disconnect);
}
void main_channel_push_tokens(Channel *channel, uint32_t num_tokens)
@ -381,13 +377,12 @@ void main_channel_push_tokens(Channel *channel, uint32_t num_tokens)
red_channel_pipe_add_push(&main_chan->base, &item->base);
}
static void main_channel_marshall_tokens(MainChannel *main_chan, uint32_t num_tokens)
static void main_channel_marshall_tokens(SpiceMarshaller *m, uint32_t num_tokens)
{
SpiceMsgMainAgentTokens tokens;
tokens.num_tokens = num_tokens;
spice_marshall_msg_main_agent_token(
main_chan->base.send_data.marshaller, &tokens);
spice_marshall_msg_main_agent_token(m, &tokens);
}
void main_channel_push_agent_data(Channel *channel, uint8_t* data, size_t len,
@ -400,10 +395,10 @@ void main_channel_push_agent_data(Channel *channel, uint8_t* data, size_t len,
red_channel_pipe_add_push(&main_chan->base, &item->base);
}
static void main_channel_marshall_agent_data(MainChannel *main_chan,
static void main_channel_marshall_agent_data(SpiceMarshaller *m,
AgentDataPipeItem *item)
{
spice_marshaller_add_ref_full(main_chan->base.send_data.marshaller,
spice_marshaller_add_ref_full(m,
item->data, item->len, item->free_data, item->opaque);
}
@ -414,14 +409,13 @@ static void main_channel_push_migrate_data_item(MainChannel *main_chan)
red_channel_pipe_add_push(&main_chan->base, &item->base);
}
static void main_channel_marshall_migrate_data_item(MainChannel *main_chan)
static void main_channel_marshall_migrate_data_item(SpiceMarshaller *m, int serial, int ping_id)
{
SpiceMarshaller *m = main_chan->base.send_data.marshaller;
MainMigrateData *data = (MainMigrateData *)spice_marshaller_reserve_space(m, sizeof(MainMigrateData));
reds_marshall_migrate_data_item(m, data); // TODO: from reds split. ugly separation.
data->serial = red_channel_get_message_serial(&main_chan->base);
data->ping_id = main_chan->ping_id;
data->serial = serial;
data->ping_id = ping_id;
}
static void main_channel_receive_migrate_data(MainChannel *main_chan,
@ -445,7 +439,7 @@ void main_channel_push_init(Channel *channel, int connection_id,
red_channel_pipe_add_push(&main_chan->base, &item->base);
}
static void main_channel_marshall_init(MainChannel *main_chan,
static void main_channel_marshall_init(SpiceMarshaller *m,
InitPipeItem *item)
{
SpiceMsgMainInit init;
@ -461,7 +455,7 @@ static void main_channel_marshall_init(MainChannel *main_chan,
init.agent_tokens = REDS_AGENT_WINDOW_SIZE;
init.multi_media_time = item->multi_media_time;
init.ram_hint = item->ram_hint;
spice_marshall_msg_main_init(main_chan->base.send_data.marshaller, &init);
spice_marshall_msg_main_init(m, &init);
}
void main_channel_push_notify(Channel *channel, uint8_t *mess, const int mess_len)
@ -472,10 +466,9 @@ void main_channel_push_notify(Channel *channel, uint8_t *mess, const int mess_le
red_channel_pipe_add_push(&main_chan->base, &item->base);
}
static void main_channel_marshall_notify(MainChannel *main_chan, NotifyPipeItem *item)
static void main_channel_marshall_notify(SpiceMarshaller *m, NotifyPipeItem *item)
{
SpiceMsgNotify notify;
SpiceMarshaller *m = main_chan->base.send_data.marshaller;
notify.time_stamp = get_time_stamp(); // TODO - move to main_new_notify_item
notify.severity = SPICE_NOTIFY_SEVERITY_WARN;
@ -497,7 +490,7 @@ void main_channel_push_migrate_begin(Channel *channel, int port, int sport,
red_channel_pipe_add_push(&main_chan->base, &item->base);
}
static void main_channel_marshall_migrate_begin(MainChannel *main_chan,
static void main_channel_marshall_migrate_begin(SpiceMarshaller *m,
MigrateBeginPipeItem *item)
{
SpiceMsgMainMigrationBegin migrate;
@ -509,8 +502,7 @@ static void main_channel_marshall_migrate_begin(MainChannel *main_chan,
migrate.pub_key_type = item->cert_pub_key_type;
migrate.pub_key_size = item->cert_pub_key_len;
migrate.pub_key_data = item->cert_pub_key;
spice_marshall_msg_main_migrate_begin(main_chan->base.send_data.marshaller,
&migrate);
spice_marshall_msg_main_migrate_begin(m, &migrate);
}
void main_channel_push_migrate(Channel *channel)
@ -521,12 +513,12 @@ void main_channel_push_migrate(Channel *channel)
red_channel_pipe_add_push(&main_chan->base, &item->base);
}
static void main_channel_marshall_migrate(MainChannel *main_chan)
static void main_channel_marshall_migrate(SpiceMarshaller *m)
{
SpiceMsgMigrate migrate;
migrate.flags = SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER;
spice_marshall_msg_migrate(main_chan->base.send_data.marshaller, &migrate);
spice_marshall_msg_migrate(m, &migrate);
}
void main_channel_push_migrate_cancel(Channel *channel)
@ -564,85 +556,86 @@ void main_channel_push_migrate_switch(Channel *channel)
main_migrate_switch_item_new(main_chan));
}
static void main_channel_marshall_migrate_switch(MainChannel *main_chan)
static void main_channel_marshall_migrate_switch(SpiceMarshaller *m)
{
SpiceMsgMainMigrationSwitchHost migrate;
red_printf("");
reds_fill_mig_switch(&migrate);
spice_marshall_msg_main_migrate_switch_host(
main_chan->base.send_data.marshaller, &migrate);
spice_marshall_msg_main_migrate_switch_host(m, &migrate);
reds_mig_release();
}
static void main_channel_marshall_multi_media_time(MainChannel *main_chan,
static void main_channel_marshall_multi_media_time(SpiceMarshaller *m,
MultiMediaTimePipeItem *item)
{
SpiceMsgMainMultiMediaTime time_mes;
time_mes.time = item->time;
spice_marshall_msg_main_multi_media_time(
main_chan->base.send_data.marshaller, &time_mes);
spice_marshall_msg_main_multi_media_time(m, &time_mes);
}
static void main_channel_send_item(RedChannel *channel, PipeItem *base)
{
SpiceMarshaller *m = red_channel_get_marshaller(channel);
MainChannel *main_chan = SPICE_CONTAINEROF(channel, MainChannel, base);
red_channel_init_send_data(channel, base->type, base);
switch (base->type) {
case SPICE_MSG_MAIN_CHANNELS_LIST:
main_channel_marshall_channels(main_chan);
main_channel_marshall_channels(m);
break;
case SPICE_MSG_PING:
main_channel_marshall_ping(main_chan,
SPICE_CONTAINEROF(base, PingPipeItem, base)->size);
main_channel_marshall_ping(m,
SPICE_CONTAINEROF(base, PingPipeItem, base)->size, ++main_chan->ping_id);
break;
case SPICE_MSG_MAIN_MOUSE_MODE:
{
MouseModePipeItem *item =
SPICE_CONTAINEROF(base, MouseModePipeItem, base);
main_channel_marshall_mouse_mode(main_chan,
main_channel_marshall_mouse_mode(m,
item->current_mode, item->is_client_mouse_allowed);
break;
}
case SPICE_MSG_MAIN_AGENT_DISCONNECTED:
main_channel_marshall_agent_disconnected(main_chan);
main_channel_marshall_agent_disconnected(m);
break;
case SPICE_MSG_MAIN_AGENT_TOKEN:
main_channel_marshall_tokens(main_chan,
main_channel_marshall_tokens(m,
SPICE_CONTAINEROF(base, TokensPipeItem, base)->tokens);
break;
case SPICE_MSG_MAIN_AGENT_DATA:
main_channel_marshall_agent_data(main_chan,
main_channel_marshall_agent_data(m,
SPICE_CONTAINEROF(base, AgentDataPipeItem, base));
break;
case SPICE_MSG_MIGRATE_DATA:
main_channel_marshall_migrate_data_item(main_chan);
main_channel_marshall_migrate_data_item(m,
red_channel_get_message_serial(&main_chan->base),
main_chan->ping_id);
break;
case SPICE_MSG_MAIN_INIT:
main_channel_marshall_init(main_chan,
main_channel_marshall_init(m,
SPICE_CONTAINEROF(base, InitPipeItem, base));
break;
case SPICE_MSG_NOTIFY:
main_channel_marshall_notify(main_chan,
main_channel_marshall_notify(m,
SPICE_CONTAINEROF(base, NotifyPipeItem, base));
break;
case SPICE_MSG_MIGRATE:
main_channel_marshall_migrate(main_chan);
main_channel_marshall_migrate(m);
break;
case SPICE_MSG_MAIN_MIGRATE_BEGIN:
main_channel_marshall_migrate_begin(main_chan,
main_channel_marshall_migrate_begin(m,
SPICE_CONTAINEROF(base, MigrateBeginPipeItem, base));
break;
case SPICE_MSG_MAIN_MULTI_MEDIA_TIME:
main_channel_marshall_multi_media_time(main_chan,
main_channel_marshall_multi_media_time(m,
SPICE_CONTAINEROF(base, MultiMediaTimePipeItem, base));
break;
case SPICE_MSG_MAIN_MIGRATE_SWITCH_HOST:
main_channel_marshall_migrate_switch(main_chan);
main_channel_marshall_migrate_switch(m);
break;
};
red_channel_begin_send_message(channel);

4
server/red_channel.c
View File

@ -672,3 +672,7 @@ void red_channel_ack_set_client_window(RedChannel *channel, int client_window)
channel->ack_data.client_window = client_window;
}
SpiceMarshaller *red_channel_get_marshaller(RedChannel *channel)
{
return channel->send_data.marshaller;
}

1
server/red_channel.h
View File

@ -256,5 +256,6 @@ void red_channel_pipe_clear(RedChannel *channel);
// handle_channel_events - this is the only one that was used before, and was in red_channel.c
void red_channel_receive(RedChannel *channel);
void red_channel_send(RedChannel *channel);
SpiceMarshaller *red_channel_get_marshaller(RedChannel *channel);
#endif

278
server/red_worker.c
View File

@ -4454,16 +4454,15 @@ static inline void fill_rects_clip(SpiceMarshaller *m, SpiceClipRects *data)
}
}
static void fill_base(DisplayChannel *display_channel, Drawable *drawable)
static void fill_base(SpiceMarshaller *base_marshaller, Drawable *drawable)
{
RedChannel *channel = &display_channel->common.base;
SpiceMsgDisplayBase base;
base.surface_id = drawable->surface_id;
base.box = drawable->red_drawable->bbox;
base.clip = drawable->red_drawable->clip;
spice_marshall_DisplayBase(channel->send_data.marshaller, &base);
spice_marshall_DisplayBase(base_marshaller, &base);
}
static inline void fill_palette(DisplayChannel *display_channel,
@ -6293,6 +6292,7 @@ static void red_add_lossless_drawable_dependencies(RedWorker *worker,
static void red_send_qxl_draw_fill(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedChannel *channel = &display_channel->common.base;
@ -6302,9 +6302,9 @@ static void red_send_qxl_draw_fill(RedWorker *worker,
SpiceFill fill;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_FILL, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
fill = drawable->u.fill;
spice_marshall_Fill(channel->send_data.marshaller,
spice_marshall_Fill(base_marshaller,
&fill,
&brush_pat_out,
&mask_bitmap_out);
@ -6319,6 +6319,7 @@ static void red_send_qxl_draw_fill(RedWorker *worker,
static void red_lossy_send_qxl_draw_fill(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *m,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6347,7 +6348,7 @@ static void red_lossy_send_qxl_draw_fill(RedWorker *worker,
!(brush_is_lossy && (brush_bitmap_data.type == BITMAP_DATA_TYPE_SURFACE))) {
int has_mask = !!drawable->u.fill.mask.bitmap;
red_send_qxl_draw_fill(worker, display_channel, item);
red_send_qxl_draw_fill(worker, display_channel, m, item);
// either the brush operation is opaque, or the dest is not lossy
surface_lossy_region_update(worker, display_channel, item, has_mask, FALSE);
@ -6375,6 +6376,7 @@ static void red_lossy_send_qxl_draw_fill(RedWorker *worker,
static FillBitsType red_send_qxl_draw_opaque(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item, int src_allowed_lossy)
{
RedChannel *channel = &display_channel->common.base;
@ -6386,9 +6388,9 @@ static FillBitsType red_send_qxl_draw_opaque(RedWorker *worker,
FillBitsType src_send_type;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_OPAQUE, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
opaque = drawable->u.opaque;
spice_marshall_Opaque(channel->send_data.marshaller,
spice_marshall_Opaque(base_marshaller,
&opaque,
&src_bitmap_out,
&brush_pat_out,
@ -6407,6 +6409,7 @@ static FillBitsType red_send_qxl_draw_opaque(RedWorker *worker,
static void red_lossy_send_qxl_draw_opaque(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *m,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6438,7 +6441,7 @@ static void red_lossy_send_qxl_draw_opaque(RedWorker *worker,
FillBitsType src_send_type;
int has_mask = !!drawable->u.opaque.mask.bitmap;
src_send_type = red_send_qxl_draw_opaque(worker, display_channel, item, src_allowed_lossy);
src_send_type = red_send_qxl_draw_opaque(worker, display_channel, m, item, src_allowed_lossy);
if (src_send_type == FILL_BITS_TYPE_COMPRESS_LOSSY) {
src_is_lossy = TRUE;
@ -6471,6 +6474,7 @@ static void red_lossy_send_qxl_draw_opaque(RedWorker *worker,
static FillBitsType red_send_qxl_draw_copy(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item, int src_allowed_lossy)
{
RedChannel *channel = &display_channel->common.base;
@ -6481,9 +6485,9 @@ static FillBitsType red_send_qxl_draw_copy(RedWorker *worker,
FillBitsType src_send_type;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_COPY, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
copy = drawable->u.copy;
spice_marshall_Copy(channel->send_data.marshaller,
spice_marshall_Copy(base_marshaller,
&copy,
&src_bitmap_out,
&mask_bitmap_out);
@ -6496,6 +6500,7 @@ static FillBitsType red_send_qxl_draw_copy(RedWorker *worker,
static void red_lossy_send_qxl_draw_copy(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6507,7 +6512,7 @@ static void red_lossy_send_qxl_draw_copy(RedWorker *worker,
src_is_lossy = is_bitmap_lossy(display_channel, drawable->u.copy.src_bitmap,
&drawable->u.copy.src_area, item, &src_bitmap_data);
src_send_type = red_send_qxl_draw_copy(worker, display_channel, item, TRUE);
src_send_type = red_send_qxl_draw_copy(worker, display_channel, base_marshaller, item, TRUE);
if (src_send_type == FILL_BITS_TYPE_COMPRESS_LOSSY) {
src_is_lossy = TRUE;
@ -6521,6 +6526,7 @@ static void red_lossy_send_qxl_draw_copy(RedWorker *worker,
static void red_send_qxl_draw_transparent(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedChannel *channel = &display_channel->common.base;
@ -6529,9 +6535,9 @@ static void red_send_qxl_draw_transparent(RedWorker *worker,
SpiceTransparent transparent;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_TRANSPARENT, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
transparent = drawable->u.transparent;
spice_marshall_Transparent(channel->send_data.marshaller,
spice_marshall_Transparent(base_marshaller,
&transparent,
&src_bitmap_out);
fill_bits(display_channel, src_bitmap_out, transparent.src_bitmap, item, FALSE);
@ -6539,6 +6545,7 @@ static void red_send_qxl_draw_transparent(RedWorker *worker,
static void red_lossy_send_qxl_draw_transparent(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6549,7 +6556,7 @@ static void red_lossy_send_qxl_draw_transparent(RedWorker *worker,
&drawable->u.transparent.src_area, item, &src_bitmap_data);
if (!src_is_lossy || (src_bitmap_data.type != BITMAP_DATA_TYPE_SURFACE)) {
red_send_qxl_draw_transparent(worker, display_channel, item);
red_send_qxl_draw_transparent(worker, display_channel, base_marshaller, item);
// don't update surface lossy region since transperent areas might be lossy
} else {
@ -6566,6 +6573,7 @@ static void red_lossy_send_qxl_draw_transparent(RedWorker *worker,
static FillBitsType red_send_qxl_draw_alpha_blend(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item,
int src_allowed_lossy)
{
@ -6576,9 +6584,9 @@ static FillBitsType red_send_qxl_draw_alpha_blend(RedWorker *worker,
FillBitsType src_send_type;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_ALPHA_BLEND, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
alpha_blend = drawable->u.alpha_blend;
spice_marshall_AlphaBlend(channel->send_data.marshaller,
spice_marshall_AlphaBlend(base_marshaller,
&alpha_blend,
&src_bitmap_out);
src_send_type = fill_bits(display_channel, src_bitmap_out, alpha_blend.src_bitmap, item, src_allowed_lossy);
@ -6588,6 +6596,7 @@ static FillBitsType red_send_qxl_draw_alpha_blend(RedWorker *worker,
static void red_lossy_send_qxl_draw_alpha_blend(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6598,7 +6607,7 @@ static void red_lossy_send_qxl_draw_alpha_blend(RedWorker *worker,
src_is_lossy = is_bitmap_lossy(display_channel, drawable->u.alpha_blend.src_bitmap,
&drawable->u.alpha_blend.src_area, item, &src_bitmap_data);
src_send_type = red_send_qxl_draw_alpha_blend(worker, display_channel, item, TRUE);
src_send_type = red_send_qxl_draw_alpha_blend(worker, display_channel, base_marshaller, item, TRUE);
if (src_send_type == FILL_BITS_TYPE_COMPRESS_LOSSY) {
src_is_lossy = TRUE;
@ -6613,6 +6622,7 @@ static void red_lossy_send_qxl_draw_alpha_blend(RedWorker *worker,
static void red_send_qxl_copy_bits(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedChannel *channel = &display_channel->common.base;
@ -6620,14 +6630,15 @@ static void red_send_qxl_copy_bits(RedWorker *worker,
SpicePoint copy_bits;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_COPY_BITS, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
copy_bits = drawable->u.copy_bits.src_pos;
spice_marshall_Point(channel->send_data.marshaller,
spice_marshall_Point(base_marshaller,
&copy_bits);
}
static void red_lossy_send_qxl_copy_bits(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6637,7 +6648,7 @@ static void red_lossy_send_qxl_copy_bits(RedWorker *worker,
int src_is_lossy;
SpiceRect src_lossy_area;
red_send_qxl_copy_bits(worker, display_channel, item);
red_send_qxl_copy_bits(worker, display_channel, base_marshaller, item);
horz_offset = drawable->u.copy_bits.src_pos.x - drawable->bbox.left;
vert_offset = drawable->u.copy_bits.src_pos.y - drawable->bbox.top;
@ -6656,6 +6667,7 @@ static void red_lossy_send_qxl_copy_bits(RedWorker *worker,
static void red_send_qxl_draw_blend(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedChannel *channel = &display_channel->common.base;
@ -6665,9 +6677,9 @@ static void red_send_qxl_draw_blend(RedWorker *worker,
SpiceBlend blend;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_BLEND, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
blend = drawable->u.blend;
spice_marshall_Blend(channel->send_data.marshaller,
spice_marshall_Blend(base_marshaller,
&blend,
&src_bitmap_out,
&mask_bitmap_out);
@ -6679,6 +6691,7 @@ static void red_send_qxl_draw_blend(RedWorker *worker,
static void red_lossy_send_qxl_draw_blend(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6694,7 +6707,7 @@ static void red_lossy_send_qxl_draw_blend(RedWorker *worker,
if (!dest_is_lossy &&
(!src_is_lossy || (src_bitmap_data.type != BITMAP_DATA_TYPE_SURFACE))) {
red_send_qxl_draw_blend(worker, display_channel, item);
red_send_qxl_draw_blend(worker, display_channel, base_marshaller, item);
} else {
int resend_surface_ids[2];
SpiceRect *resend_areas[2];
@ -6719,6 +6732,7 @@ static void red_lossy_send_qxl_draw_blend(RedWorker *worker,
static void red_send_qxl_draw_blackness(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedChannel *channel = &display_channel->common.base;
@ -6727,10 +6741,10 @@ static void red_send_qxl_draw_blackness(RedWorker *worker,
SpiceBlackness blackness;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_BLACKNESS, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
blackness = drawable->u.blackness;
spice_marshall_Blackness(channel->send_data.marshaller,
spice_marshall_Blackness(base_marshaller,
&blackness,
&mask_bitmap_out);
@ -6739,18 +6753,20 @@ static void red_send_qxl_draw_blackness(RedWorker *worker,
static void red_lossy_send_qxl_draw_blackness(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
int has_mask = !!drawable->u.blackness.mask.bitmap;
red_send_qxl_draw_blackness(worker, display_channel, item);
red_send_qxl_draw_blackness(worker, display_channel, base_marshaller, item);
surface_lossy_region_update(worker, display_channel, item, has_mask, FALSE);
}
static void red_send_qxl_draw_whiteness(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedChannel *channel = &display_channel->common.base;
@ -6759,10 +6775,10 @@ static void red_send_qxl_draw_whiteness(RedWorker *worker,
SpiceWhiteness whiteness;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_WHITENESS, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
whiteness = drawable->u.whiteness;
spice_marshall_Whiteness(channel->send_data.marshaller,
spice_marshall_Whiteness(base_marshaller,
&whiteness,
&mask_bitmap_out);
@ -6771,18 +6787,20 @@ static void red_send_qxl_draw_whiteness(RedWorker *worker,
static void red_lossy_send_qxl_draw_whiteness(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
int has_mask = !!drawable->u.whiteness.mask.bitmap;
red_send_qxl_draw_whiteness(worker, display_channel, item);
red_send_qxl_draw_whiteness(worker, display_channel, base_marshaller, item);
surface_lossy_region_update(worker, display_channel, item, has_mask, FALSE);
}
static void red_send_qxl_draw_inverse(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6791,10 +6809,10 @@ static void red_send_qxl_draw_inverse(RedWorker *worker,
SpiceInvers inverse;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_INVERS, NULL);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
inverse = drawable->u.invers;
spice_marshall_Invers(channel->send_data.marshaller,
spice_marshall_Invers(base_marshaller,
&inverse,
&mask_bitmap_out);
@ -6803,13 +6821,15 @@ static void red_send_qxl_draw_inverse(RedWorker *worker,
static void red_lossy_send_qxl_draw_inverse(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
red_send_qxl_draw_inverse(worker, display_channel, item);
red_send_qxl_draw_inverse(worker, display_channel, base_marshaller, item);
}
static void red_send_qxl_draw_rop3(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6820,9 +6840,9 @@ static void red_send_qxl_draw_rop3(RedWorker *worker,
SpiceMarshaller *mask_bitmap_out;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_ROP3, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
rop3 = drawable->u.rop3;
spice_marshall_Rop3(channel->send_data.marshaller,
spice_marshall_Rop3(base_marshaller,
&rop3,
&src_bitmap_out,
&brush_pat_out,
@ -6838,6 +6858,7 @@ static void red_send_qxl_draw_rop3(RedWorker *worker,
static void red_lossy_send_qxl_draw_rop3(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6859,7 +6880,7 @@ static void red_lossy_send_qxl_draw_rop3(RedWorker *worker,
(!brush_is_lossy || (brush_bitmap_data.type != BITMAP_DATA_TYPE_SURFACE)) &&
!dest_is_lossy) {
int has_mask = !!drawable->u.rop3.mask.bitmap;
red_send_qxl_draw_rop3(worker, display_channel, item);
red_send_qxl_draw_rop3(worker, display_channel, base_marshaller, item);
surface_lossy_region_update(worker, display_channel, item, has_mask, FALSE);
} else {
@ -6892,6 +6913,7 @@ static void red_lossy_send_qxl_draw_rop3(RedWorker *worker,
static void red_send_qxl_draw_stroke(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6901,9 +6923,9 @@ static void red_send_qxl_draw_stroke(RedWorker *worker,
SpiceMarshaller *style_out;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_STROKE, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
stroke = drawable->u.stroke;
spice_marshall_Stroke(channel->send_data.marshaller,
spice_marshall_Stroke(base_marshaller,
&stroke,
&style_out,
&brush_pat_out);
@ -6916,6 +6938,7 @@ static void red_send_qxl_draw_stroke(RedWorker *worker,
static void red_lossy_send_qxl_draw_stroke(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6943,7 +6966,7 @@ static void red_lossy_send_qxl_draw_stroke(RedWorker *worker,
if (!dest_is_lossy &&
(!brush_is_lossy || (brush_bitmap_data.type != BITMAP_DATA_TYPE_SURFACE)))
{
red_send_qxl_draw_stroke(worker, display_channel, item);
red_send_qxl_draw_stroke(worker, display_channel, base_marshaller, item);
} else {
int resend_surface_ids[2];
SpiceRect *resend_areas[2];
@ -6970,6 +6993,7 @@ static void red_lossy_send_qxl_draw_stroke(RedWorker *worker,
static void red_send_qxl_draw_text(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -6979,9 +7003,9 @@ static void red_send_qxl_draw_text(RedWorker *worker,
SpiceMarshaller *back_brush_pat_out;
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_DRAW_TEXT, &item->pipe_item);
fill_base(display_channel, item);
fill_base(base_marshaller, item);
text = drawable->u.text;
spice_marshall_Text(channel->send_data.marshaller,
spice_marshall_Text(base_marshaller,
&text,
&brush_pat_out,
&back_brush_pat_out);
@ -6996,6 +7020,7 @@ static void red_send_qxl_draw_text(RedWorker *worker,
static void red_lossy_send_qxl_draw_text(RedWorker *worker,
DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
@ -7031,7 +7056,7 @@ static void red_lossy_send_qxl_draw_text(RedWorker *worker,
if (!dest_is_lossy &&
(!fg_is_lossy || (fg_bitmap_data.type != BITMAP_DATA_TYPE_SURFACE)) &&
(!bg_is_lossy || (bg_bitmap_data.type != BITMAP_DATA_TYPE_SURFACE))) {
red_send_qxl_draw_text(worker, display_channel, item);
red_send_qxl_draw_text(worker, display_channel, base_marshaller, item);
} else {
int resend_surface_ids[3];
SpiceRect *resend_areas[3];
@ -7060,47 +7085,47 @@ static void red_lossy_send_qxl_draw_text(RedWorker *worker,
}
static void red_lossy_send_qxl_drawable(RedWorker *worker, DisplayChannel *display_channel,
Drawable *item)
SpiceMarshaller *base_marshaller, Drawable *item)
{
switch (item->red_drawable->type) {
case QXL_DRAW_FILL:
red_lossy_send_qxl_draw_fill(worker, display_channel, item);
red_lossy_send_qxl_draw_fill(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_OPAQUE:
red_lossy_send_qxl_draw_opaque(worker, display_channel, item);
red_lossy_send_qxl_draw_opaque(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_COPY:
red_lossy_send_qxl_draw_copy(worker, display_channel, item);
red_lossy_send_qxl_draw_copy(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_TRANSPARENT:
red_lossy_send_qxl_draw_transparent(worker, display_channel, item);
red_lossy_send_qxl_draw_transparent(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_ALPHA_BLEND:
red_lossy_send_qxl_draw_alpha_blend(worker, display_channel, item);
red_lossy_send_qxl_draw_alpha_blend(worker, display_channel, base_marshaller, item);
break;
case QXL_COPY_BITS:
red_lossy_send_qxl_copy_bits(worker, display_channel, item);
red_lossy_send_qxl_copy_bits(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_BLEND:
red_lossy_send_qxl_draw_blend(worker, display_channel, item);
red_lossy_send_qxl_draw_blend(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_BLACKNESS:
red_lossy_send_qxl_draw_blackness(worker, display_channel, item);
red_lossy_send_qxl_draw_blackness(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_WHITENESS:
red_lossy_send_qxl_draw_whiteness(worker, display_channel, item);
red_lossy_send_qxl_draw_whiteness(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_INVERS:
red_lossy_send_qxl_draw_inverse(worker, display_channel, item);
red_lossy_send_qxl_draw_inverse(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_ROP3:
red_lossy_send_qxl_draw_rop3(worker, display_channel, item);
red_lossy_send_qxl_draw_rop3(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_STROKE:
red_lossy_send_qxl_draw_stroke(worker, display_channel, item);
red_lossy_send_qxl_draw_stroke(worker, display_channel, base_marshaller, item);
break;
case QXL_DRAW_TEXT:
red_lossy_send_qxl_draw_text(worker, display_channel, item);
red_lossy_send_qxl_draw_text(worker, display_channel, base_marshaller, item);
break;
default:
red_error("invalid type");
@ -7113,49 +7138,49 @@ static void red_lossy_send_qxl_drawable(RedWorker *worker, DisplayChannel *displ
}
static inline void red_send_qxl_drawable(RedWorker *worker, DisplayChannel *display_channel,
Drawable *item)
SpiceMarshaller *m, Drawable *item)
{
RedDrawable *drawable = item->red_drawable;
switch (drawable->type) {
case QXL_DRAW_FILL:
red_send_qxl_draw_fill(worker, display_channel, item);
red_send_qxl_draw_fill(worker, display_channel, m, item);
break;
case QXL_DRAW_OPAQUE:
red_send_qxl_draw_opaque(worker, display_channel, item, FALSE);
red_send_qxl_draw_opaque(worker, display_channel, m, item, FALSE);
break;
case QXL_DRAW_COPY:
red_send_qxl_draw_copy(worker, display_channel, item, FALSE);
red_send_qxl_draw_copy(worker, display_channel, m, item, FALSE);
break;
case QXL_DRAW_TRANSPARENT:
red_send_qxl_draw_transparent(worker, display_channel, item);
red_send_qxl_draw_transparent(worker, display_channel, m, item);
break;
case QXL_DRAW_ALPHA_BLEND:
red_send_qxl_draw_alpha_blend(worker, display_channel, item, FALSE);
red_send_qxl_draw_alpha_blend(worker, display_channel, m, item, FALSE);
break;
case QXL_COPY_BITS:
red_send_qxl_copy_bits(worker, display_channel, item);
red_send_qxl_copy_bits(worker, display_channel, m, item);
break;
case QXL_DRAW_BLEND:
red_send_qxl_draw_blend(worker, display_channel, item);
red_send_qxl_draw_blend(worker, display_channel, m, item);
break;
case QXL_DRAW_BLACKNESS:
red_send_qxl_draw_blackness(worker, display_channel, item);
red_send_qxl_draw_blackness(worker, display_channel, m, item);
break;
case QXL_DRAW_WHITENESS:
red_send_qxl_draw_whiteness(worker, display_channel, item);
red_send_qxl_draw_whiteness(worker, display_channel, m, item);
break;
case QXL_DRAW_INVERS:
red_send_qxl_draw_inverse(worker, display_channel, item);
red_send_qxl_draw_inverse(worker, display_channel, m, item);
break;
case QXL_DRAW_ROP3:
red_send_qxl_draw_rop3(worker, display_channel, item);
red_send_qxl_draw_rop3(worker, display_channel, m, item);
break;
case QXL_DRAW_STROKE:
red_send_qxl_draw_stroke(worker, display_channel, item);
red_send_qxl_draw_stroke(worker, display_channel, m, item);
break;
case QXL_DRAW_TEXT:
red_send_qxl_draw_text(worker, display_channel, item);
red_send_qxl_draw_text(worker, display_channel, m, item);
break;
default:
red_error("invalid type");
@ -7444,7 +7469,8 @@ static int red_rgb16bpp_to_24 (RedWorker *worker, const SpiceRect *src,
return TRUE;
}
static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable *drawable)
static inline int red_send_stream_data(DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller, Drawable *drawable)
{
Stream *stream = drawable->stream;
SpiceImage *image;
@ -7525,8 +7551,8 @@ static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable
stream_data.id = stream - worker->streams_buf;
stream_data.multi_media_time = drawable->red_drawable->mm_time;
stream_data.data_size = n;
spice_marshall_msg_display_stream_data(channel->send_data.marshaller, &stream_data);
spice_marshaller_add_ref(channel->send_data.marshaller,
spice_marshall_msg_display_stream_data(base_marshaller, &stream_data);
spice_marshaller_add_ref(base_marshaller,
display_channel->send_data.stream_outbuf, n);
display_begin_send_message(display_channel);
@ -7534,16 +7560,18 @@ static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable
return TRUE;
}
static inline void send_qxl_drawable(DisplayChannel *display_channel, Drawable *item)
static inline void send_qxl_drawable(DisplayChannel *display_channel,
SpiceMarshaller *m, Drawable *item)
{
ASSERT(display_channel);
if (item->stream && red_send_stream_data(display_channel, item)) {
if (item->stream && red_send_stream_data(display_channel, m, item)) {
return;
}
if (!display_channel->enable_jpeg)
red_send_qxl_drawable(display_channel->common.worker, display_channel, item);
red_send_qxl_drawable(display_channel->common.worker, display_channel, m, item);
else
red_lossy_send_qxl_drawable(display_channel->common.worker, display_channel, item);
red_lossy_send_qxl_drawable(display_channel->common.worker, display_channel, m, item);
}
static inline void red_send_verb(RedChannel *channel, uint16_t verb)
@ -7560,35 +7588,38 @@ static inline void display_send_verb(DisplayChannel *channel, uint16_t verb)
display_begin_send_message(channel);
}
static inline void __red_send_inval(RedChannel *channel, CacheItem *cach_item)
static inline void __red_send_inval(RedChannel *channel,
SpiceMarshaller *base_marshaller, CacheItem *cach_item)
{
SpiceMsgDisplayInvalOne inval_one;
red_channel_init_send_data(channel, cach_item->inval_type, NULL);
inval_one.id = *(uint64_t *)&cach_item->id;
spice_marshall_msg_cursor_inval_one(channel->send_data.marshaller, &inval_one);
spice_marshall_msg_cursor_inval_one(base_marshaller, &inval_one);
}
static void red_send_inval(RedChannel *channel, CacheItem *cach_item)
static void red_send_inval(RedChannel *channel,
SpiceMarshaller *base_marshaller, CacheItem *cach_item)
{
__red_send_inval(channel, cach_item);
__red_send_inval(channel, base_marshaller, cach_item);
red_channel_begin_send_message(channel);
}
static void red_display_send_inval(DisplayChannel *display_channel, CacheItem *cach_item)
static void red_display_send_inval(DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller, CacheItem *cach_item)
{
__red_send_inval((RedChannel *)display_channel, cach_item);
__red_send_inval((RedChannel *)display_channel, base_marshaller, cach_item);
display_begin_send_message(display_channel);
}
static void display_channel_send_migrate(DisplayChannel *display_channel)
static void display_channel_send_migrate(DisplayChannel *display_channel, SpiceMarshaller *base_marshaller)
{
SpiceMsgMigrate migrate;
red_channel_init_send_data(&display_channel->common.base, SPICE_MSG_MIGRATE, NULL);
migrate.flags = SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER;
spice_marshall_msg_migrate(display_channel->common.base.send_data.marshaller, &migrate);
spice_marshall_msg_migrate(base_marshaller, &migrate);
display_channel->expect_migrate_mark = TRUE;
display_begin_send_message(display_channel);
}
@ -7662,7 +7693,7 @@ static void display_channel_reset_cache(DisplayChannel *display_channel)
display_begin_send_message(display_channel);
}
static void red_send_image(DisplayChannel *display_channel, ImageItem *item)
static void red_send_image(DisplayChannel *display_channel, SpiceMarshaller *m, ImageItem *item)
{
RedChannel *channel;
SpiceImage red_image;
@ -7723,8 +7754,6 @@ static void red_send_image(DisplayChannel *display_channel, ImageItem *item)
copy.data.mask.pos.y = 0;
copy.data.mask.bitmap = 0;
SpiceMarshaller *m = channel->send_data.marshaller;
spice_marshall_msg_display_draw_copy(m, &copy,
&src_bitmap_out, &mask_bitmap_out);
@ -7800,7 +7829,7 @@ static void red_send_image(DisplayChannel *display_channel, ImageItem *item)
spice_chunks_destroy(chunks);
}
static void red_display_send_upgrade(DisplayChannel *display_channel, UpgradeItem *item)
static void red_display_send_upgrade(DisplayChannel *display_channel, SpiceMarshaller *m, UpgradeItem *item)
{
RedChannel *channel;
RedDrawable *red_drawable;
@ -7823,8 +7852,6 @@ static void red_display_send_upgrade(DisplayChannel *display_channel, UpgradeIte
copy.base.clip.rects = item->rects;
copy.data = red_drawable->u.copy;
SpiceMarshaller *m = channel->send_data.marshaller;
spice_marshall_msg_display_draw_copy(m, &copy,
&src_bitmap_out, &mask_bitmap_out);
@ -7833,7 +7860,8 @@ static void red_display_send_upgrade(DisplayChannel *display_channel, UpgradeIte
display_begin_send_message(display_channel);
}
static void red_display_send_stream_start(DisplayChannel *display_channel, StreamAgent *agent)
static void red_display_send_stream_start(DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller, StreamAgent *agent)
{
RedChannel *channel = &display_channel->common.base;
Stream *stream = agent->stream;
@ -7865,13 +7893,14 @@ static void red_display_send_stream_start(DisplayChannel *display_channel, Strea
stream_create.clip.rects = &clip_rects;
}
spice_marshall_msg_display_stream_create(channel->send_data.marshaller, &stream_create);
spice_marshall_msg_display_stream_create(base_marshaller, &stream_create);
display_begin_send_message(display_channel);
}
static void red_display_send_stream_clip(DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller,
StreamClipItem *item)
{
RedChannel *channel = &display_channel->common.base;
@ -7888,12 +7917,13 @@ static void red_display_send_stream_clip(DisplayChannel *display_channel,
stream_clip.clip.type = item->clip_type;
stream_clip.clip.rects = item->rects;
spice_marshall_msg_display_stream_clip(channel->send_data.marshaller, &stream_clip);
spice_marshall_msg_display_stream_clip(base_marshaller, &stream_clip);
display_begin_send_message(display_channel);
}
static void red_display_send_stream_end(DisplayChannel *display_channel, StreamAgent* agent)
static void red_display_send_stream_end(DisplayChannel *display_channel,
SpiceMarshaller *base_marshaller, StreamAgent* agent)
{
RedChannel *channel = &display_channel->common.base;
SpiceMsgDisplayStreamDestroy destroy;
@ -7901,15 +7931,16 @@ static void red_display_send_stream_end(DisplayChannel *display_channel, StreamA
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_STREAM_DESTROY, NULL);
destroy.id = agent - display_channel->stream_agents;
spice_marshall_msg_display_stream_destroy(channel->send_data.marshaller, &destroy);
spice_marshall_msg_display_stream_destroy(base_marshaller, &destroy);
display_begin_send_message(display_channel);
}
static void red_cursor_send_inval(CursorChannel *channel, CacheItem *cach_item)
static void red_cursor_send_inval(CursorChannel *channel,
SpiceMarshaller *m, CacheItem *cach_item)
{
ASSERT(channel);
red_send_inval((RedChannel *)channel, cach_item);
red_send_inval((RedChannel *)channel, m, cach_item);
}
static void red_send_cursor_init(CursorChannel *channel)
@ -7935,7 +7966,8 @@ static void red_send_cursor_init(CursorChannel *channel)
red_channel_begin_send_message(&channel->common.base);
}
static void red_send_local_cursor(CursorChannel *cursor_channel, LocalCursor *cursor)
static void red_send_local_cursor(CursorChannel *cursor_channel,
SpiceMarshaller *base_marshaller, LocalCursor *cursor)
{
RedChannel *channel;
SpiceMsgCursorSet cursor_set;
@ -7950,8 +7982,8 @@ static void red_send_local_cursor(CursorChannel *cursor_channel, LocalCursor *cu
cursor_set.visible = worker->cursor_visible;
fill_cursor(cursor_channel, &cursor_set.cursor, &cursor->base, &info);
spice_marshall_msg_cursor_set(channel->send_data.marshaller, &cursor_set);
add_buf_from_info(channel, channel->send_data.marshaller, &info);
spice_marshall_msg_cursor_set(base_marshaller, &cursor_set);
add_buf_from_info(channel, base_marshaller, &info);
red_channel_begin_send_message(channel);
@ -7969,18 +8001,17 @@ static void cursor_channel_send_migrate(CursorChannel *cursor_channel)
red_channel_begin_send_message((RedChannel*)cursor_channel);
}
static void red_send_cursor(CursorChannel *cursor_channel, CursorItem *cursor)
static void red_send_cursor(CursorChannel *cursor_channel,
SpiceMarshaller *m, CursorItem *cursor)
{
RedChannel *channel;
RedCursorCmd *cmd;
SpiceMarshaller *m;
RedWorker *worker;
ASSERT(cursor_channel);
channel = &cursor_channel->common.base;
worker = cursor_channel->common.worker;
m = channel->send_data.marshaller;
cmd = cursor->red_cursor;
switch (cmd->type) {
@ -8028,7 +8059,8 @@ static void red_send_cursor(CursorChannel *cursor_channel, CursorItem *cursor)
red_release_cursor(worker, cursor);
}
static void red_send_surface_create(DisplayChannel *display, SpiceMsgSurfaceCreate *surface_create)
static void red_send_surface_create(DisplayChannel *display,
SpiceMarshaller *base_marshaller, SpiceMsgSurfaceCreate *surface_create)
{
RedChannel *channel;
@ -8038,12 +8070,13 @@ static void red_send_surface_create(DisplayChannel *display, SpiceMsgSurfaceCrea
region_init(&display->surface_client_lossy_region[surface_create->surface_id]);
red_channel_init_send_data(channel, SPICE_MSG_DISPLAY_SURFACE_CREATE, NULL);
spice_marshall_msg_display_surface_create(channel->send_data.marshaller, surface_create);
spice_marshall_msg_display_surface_create(base_marshaller, surface_create);
red_channel_begin_send_message(channel);
}
static void red_send_surface_destroy(DisplayChannel *display, uint32_t surface_id)
static void red_send_surface_destroy(DisplayChannel *display,
SpiceMarshaller *base_marshaller, uint32_t surface_id)
{
RedChannel *channel;
SpiceMsgSurfaceDestroy surface_destroy;
@ -8056,13 +8089,14 @@ static void red_send_surface_destroy(DisplayChannel *display, uint32_t surface_i
surface_destroy.surface_id = surface_id;
spice_marshall_msg_display_surface_destroy(channel->send_data.marshaller, &surface_destroy);
spice_marshall_msg_display_surface_destroy(base_marshaller, &surface_destroy);
red_channel_begin_send_message(channel);
}
static void display_channel_send_item(RedChannel *base, PipeItem *pipe_item)
{
SpiceMarshaller *m = red_channel_get_marshaller(base);
DisplayChannel *display_channel = (DisplayChannel *)red_ref_channel(base);
RedWorker *worker = display_channel->common.worker;
@ -8070,34 +8104,34 @@ static void display_channel_send_item(RedChannel *base, PipeItem *pipe_item)
switch (pipe_item->type) {
case PIPE_ITEM_TYPE_DRAW: {
Drawable *drawable = SPICE_CONTAINEROF(pipe_item, Drawable, pipe_item);
send_qxl_drawable(display_channel, drawable);
send_qxl_drawable(display_channel, m, drawable);
release_drawable(worker, drawable);
break;
}
case PIPE_ITEM_TYPE_INVAL_ONE:
red_display_send_inval(display_channel, (CacheItem *)pipe_item);
red_display_send_inval(display_channel, m, (CacheItem *)pipe_item);
free(pipe_item);
break;
case PIPE_ITEM_TYPE_STREAM_CREATE: {
StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent, create_item);
red_display_send_stream_start(display_channel, agent);
red_display_send_stream_start(display_channel, m, agent);
red_display_release_stream(display_channel, agent);
break;
}
case PIPE_ITEM_TYPE_STREAM_CLIP: {
StreamClipItem* clip_item = (StreamClipItem *)pipe_item;
red_display_send_stream_clip(display_channel, clip_item);
red_display_send_stream_clip(display_channel, m, clip_item);
red_display_release_stream_clip(display_channel, clip_item);
break;
}
case PIPE_ITEM_TYPE_STREAM_DESTROY: {
StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent, destroy_item);
red_display_send_stream_end(display_channel, agent);
red_display_send_stream_end(display_channel, m, agent);
red_display_release_stream(display_channel, agent);
break;
}
case PIPE_ITEM_TYPE_UPGRADE:
red_display_send_upgrade(display_channel, (UpgradeItem *)pipe_item);
red_display_send_upgrade(display_channel, m, (UpgradeItem *)pipe_item);
release_upgrade_item(worker, (UpgradeItem *)pipe_item);
break;
case PIPE_ITEM_TYPE_VERB:
@ -8106,7 +8140,7 @@ static void display_channel_send_item(RedChannel *base, PipeItem *pipe_item)
break;
case PIPE_ITEM_TYPE_MIGRATE:
red_printf("PIPE_ITEM_TYPE_MIGRATE");
display_channel_send_migrate(display_channel);
display_channel_send_migrate(display_channel, m);
free(pipe_item);
break;
case PIPE_ITEM_TYPE_MIGRATE_DATA:
@ -8114,7 +8148,7 @@ static void display_channel_send_item(RedChannel *base, PipeItem *pipe_item)
free(pipe_item);
break;
case PIPE_ITEM_TYPE_IMAGE:
red_send_image(display_channel, (ImageItem *)pipe_item);
red_send_image(display_channel, m, (ImageItem *)pipe_item);
release_image_item((ImageItem *)pipe_item);
break;
case PIPE_ITEM_TYPE_PIXMAP_SYNC:
@ -8133,14 +8167,14 @@ static void display_channel_send_item(RedChannel *base, PipeItem *pipe_item)
case PIPE_ITEM_TYPE_CREATE_SURFACE: {
SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(pipe_item, SurfaceCreateItem,
pipe_item);
red_send_surface_create(display_channel, &surface_create->surface_create);
red_send_surface_create(display_channel, m, &surface_create->surface_create);
free(surface_create);
break;
}
case PIPE_ITEM_TYPE_DESTROY_SURFACE: {
SurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(pipe_item, SurfaceDestroyItem,
pipe_item);
red_send_surface_destroy(display_channel, surface_destroy->surface_destroy.surface_id);
red_send_surface_destroy(display_channel, m, surface_destroy->surface_destroy.surface_id);
free(surface_destroy);
break;
}
@ -8152,18 +8186,19 @@ static void display_channel_send_item(RedChannel *base, PipeItem *pipe_item)
static void cursor_channel_send_item(RedChannel *channel, PipeItem *pipe_item)
{
SpiceMarshaller *m = red_channel_get_marshaller(channel);
CursorChannel *cursor_channel = SPICE_CONTAINEROF(channel, CursorChannel, common.base);
red_ref_channel(channel);
switch (pipe_item->type) {
case PIPE_ITEM_TYPE_CURSOR:
red_send_cursor(cursor_channel, (CursorItem *)pipe_item);
red_send_cursor(cursor_channel, m, (CursorItem *)pipe_item);
break;
case PIPE_ITEM_TYPE_LOCAL_CURSOR:
red_send_local_cursor(cursor_channel, (LocalCursor *)pipe_item);
red_send_local_cursor(cursor_channel, m, (LocalCursor *)pipe_item);
break;
case PIPE_ITEM_TYPE_INVAL_ONE:
red_cursor_send_inval(cursor_channel, (CacheItem *)pipe_item);
red_cursor_send_inval(cursor_channel, m, (CacheItem *)pipe_item);
free(pipe_item);
break;
case PIPE_ITEM_TYPE_VERB:
@ -8277,7 +8312,6 @@ static void red_disconnect_channel(RedChannel *channel)
channel->stream = NULL;
channel->send_data.blocked = FALSE;
channel->send_data.size = 0;
spice_marshaller_reset(channel->send_data.marshaller);
red_unref_channel(channel);
}