Use 'Red' prefix to match internal type naming convention
---
server/cache-item.h | 6 +-
server/cache-item.tmpl.c | 18 ++--
server/cursor-channel.c | 71 ++++++++--------
server/dcc-send.c | 155 ++++++++++++++++++----------------
server/dcc.c | 189 +++++++++++++++++++++--------------------
server/dcc.h | 24 +++---
server/display-channel.c | 22 ++---
server/display-channel.h | 46 +++++-----
server/inputs-channel.c | 52 ++++++------
server/main-channel.c | 214 +++++++++++++++++++++++------------------------
server/red-channel.c | 34 ++++----
server/red-channel.h | 10 +--
server/red-worker.h | 16 ++--
server/reds.c | 35 ++++----
server/smartcard.c | 53 ++++++------
server/spicevmc.c | 56 ++++++-------
server/stream.c | 26 +++---
server/stream.h | 10 +--
18 files changed, 529 insertions(+), 508 deletions(-)
diff --git a/server/cache-item.h b/server/cache-item.h
index 90c82d3..7dde902 100644
--- a/server/cache-item.h
+++ b/server/cache-item.h
@@ -21,14 +21,14 @@
#include "red-channel.h"
#include "common/ring.h"
-typedef struct CacheItem CacheItem;
+typedef struct RedCacheItem RedCacheItem;
-struct CacheItem {
+struct RedCacheItem {
union {
RedPipeItem pipe_data;
struct {
RingItem lru_link;
- CacheItem *next;
+ RedCacheItem *next;
} cache_data;
} u;
uint64_t id;
diff --git a/server/cache-item.tmpl.c b/server/cache-item.tmpl.c
index d63e576..0617bea 100644
--- a/server/cache-item.tmpl.c
+++ b/server/cache-item.tmpl.c
@@ -48,9 +48,9 @@
#define CHANNEL_FROM_RCC(rcc) SPICE_CONTAINEROF((rcc)->channel, CHANNEL, common.base);
-static CacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id)
+static RedCacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id)
{
- CacheItem *item = channel_client->CACHE_NAME[CACHE_HASH_KEY(id)];
+ RedCacheItem *item = channel_client->CACHE_NAME[CACHE_HASH_KEY(id)];
while (item) {
if (item->id == id) {
@@ -63,9 +63,9 @@ static CacheItem *FUNC_NAME(find)(CHANNELCLIENT *channel_client, uint64_t id)
return item;
}
-static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item)
+static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, RedCacheItem *item)
{
- CacheItem **now;
+ RedCacheItem **now;
spice_assert(item);
now = &channel_client->CACHE_NAME[CACHE_HASH_KEY(item->id)];
@@ -81,20 +81,20 @@ static void FUNC_NAME(remove)(CHANNELCLIENT *channel_client, CacheItem *item)
channel_client->VAR_NAME(items)--;
channel_client->VAR_NAME(available) += item->size;
- red_pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE_INVAL_ONE);
+ red_pipe_item_init(&item->u.pipe_data, RED_PIPE_ITEM_TYPE_INVAL_ONE);
red_channel_client_pipe_add_tail_and_push(&channel_client->common.base, &item->u.pipe_data); // for now
}
static int FUNC_NAME(add)(CHANNELCLIENT *channel_client, uint64_t id, size_t size)
{
- CacheItem *item;
+ RedCacheItem *item;
int key;
- item = spice_new(CacheItem, 1);
+ item = spice_new(RedCacheItem, 1);
channel_client->VAR_NAME(available) -= size;
while (channel_client->VAR_NAME(available) < 0) {
- CacheItem *tail = (CacheItem *)ring_get_tail(&channel_client->VAR_NAME(lru));
+ RedCacheItem *tail = (RedCacheItem *)ring_get_tail(&channel_client->VAR_NAME(lru));
if (!tail) {
channel_client->VAR_NAME(available) += size;
free(item);
@@ -119,7 +119,7 @@ static void FUNC_NAME(reset)(CHANNELCLIENT *channel_client, long size)
for (i = 0; i < CACHE_HASH_SIZE; i++) {
while (channel_client->CACHE_NAME[i]) {
- CacheItem *item = channel_client->CACHE_NAME[i];
+ RedCacheItem *item = channel_client->CACHE_NAME[i];
channel_client->CACHE_NAME[i] = item->u.cache_data.next;
free(item);
}
diff --git a/server/cursor-channel.c b/server/cursor-channel.c
index e2bb706..697d61d 100644
--- a/server/cursor-channel.c
+++ b/server/cursor-channel.c
@@ -32,9 +32,9 @@
#define CURSOR_CACHE_HASH_KEY(id) ((id) & CURSOR_CACHE_HASH_MASK)
enum {
- PIPE_ITEM_TYPE_CURSOR = PIPE_ITEM_TYPE_COMMON_LAST,
- PIPE_ITEM_TYPE_CURSOR_INIT,
- PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
+ RED_PIPE_ITEM_TYPE_CURSOR = RED_PIPE_ITEM_TYPE_COMMON_LAST,
+ RED_PIPE_ITEM_TYPE_CURSOR_INIT,
+ RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
};
typedef struct CursorItem {
@@ -45,11 +45,11 @@ typedef struct CursorItem {
G_STATIC_ASSERT(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
-typedef struct CursorPipeItem {
+typedef struct RedCursorPipeItem {
RedPipeItem base;
CursorItem *cursor_item;
int refs;
-} CursorPipeItem;
+} RedCursorPipeItem;
struct CursorChannel {
CommonGraphicsChannel common; // Must be the first thing
@@ -69,7 +69,7 @@ struct CursorChannel {
struct CursorChannelClient {
CommonGraphicsChannelClient common;
- CacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE];
+ RedCacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE];
Ring cursor_cache_lru;
long cursor_cache_available;
uint32_t cursor_cache_items;
@@ -134,9 +134,9 @@ static void cursor_set_item(CursorChannel *cursor, CursorItem *item)
static RedPipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data, int num)
{
- CursorPipeItem *item = spice_malloc0(sizeof(CursorPipeItem));
+ RedCursorPipeItem *item = spice_malloc0(sizeof(RedCursorPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_CURSOR);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_CURSOR);
item->refs = 1;
item->cursor_item = data;
item->cursor_item->refs++;
@@ -203,7 +203,8 @@ void cursor_channel_disconnect(CursorChannel *cursor_channel)
}
-static void put_cursor_pipe_item(CursorChannelClient *ccc, CursorPipeItem *pipe_item)
+static void put_cursor_pipe_item(CursorChannelClient *ccc,
+ RedCursorPipeItem *pipe_item)
{
spice_return_if_fail(pipe_item);
spice_return_if_fail(pipe_item->refs > 0);
@@ -232,15 +233,15 @@ static void cursor_channel_client_release_item_before_push(CursorChannelClient *
RedPipeItem *item)
{
switch (item->type) {
- case PIPE_ITEM_TYPE_CURSOR: {
- CursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
+ case RED_PIPE_ITEM_TYPE_CURSOR: {
+ RedCursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, RedCursorPipeItem, base);
put_cursor_pipe_item(ccc, cursor_pipe_item);
break;
}
- case PIPE_ITEM_TYPE_INVAL_ONE:
- case PIPE_ITEM_TYPE_VERB:
- case PIPE_ITEM_TYPE_CURSOR_INIT:
- case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
+ case RED_PIPE_ITEM_TYPE_INVAL_ONE:
+ case RED_PIPE_ITEM_TYPE_VERB:
+ case RED_PIPE_ITEM_TYPE_CURSOR_INIT:
+ case RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
free(item);
break;
default:
@@ -252,8 +253,8 @@ static void cursor_channel_client_release_item_after_push(CursorChannelClient *c
RedPipeItem *item)
{
switch (item->type) {
- case PIPE_ITEM_TYPE_CURSOR: {
- CursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
+ case RED_PIPE_ITEM_TYPE_CURSOR: {
+ RedCursorPipeItem *cursor_pipe_item = SPICE_CONTAINEROF(item, RedCursorPipeItem, base);
put_cursor_pipe_item(ccc, cursor_pipe_item);
break;
}
@@ -285,7 +286,8 @@ static void red_marshall_cursor_init(RedChannelClient *rcc, SpiceMarshaller *bas
}
static void cursor_marshall(RedChannelClient *rcc,
- SpiceMarshaller *m, CursorPipeItem *cursor_pipe_item)
+ SpiceMarshaller *m,
+ RedCursorPipeItem *cursor_pipe_item)
{
CursorChannel *cursor_channel = SPICE_CONTAINEROF(rcc->channel, CursorChannel, common.base);
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
@@ -338,7 +340,8 @@ static void cursor_marshall(RedChannelClient *rcc,
}
static inline void red_marshall_inval(RedChannelClient *rcc,
- SpiceMarshaller *base_marshaller, CacheItem *cach_item)
+ SpiceMarshaller *base_marshaller,
+ RedCacheItem *cach_item)
{
SpiceMsgDisplayInvalOne inval_one;
@@ -354,20 +357,20 @@ static void cursor_channel_send_item(RedChannelClient *rcc, RedPipeItem *pipe_it
CursorChannelClient *ccc = RCC_TO_CCC(rcc);
switch (pipe_item->type) {
- case PIPE_ITEM_TYPE_CURSOR:
- cursor_marshall(rcc, m, SPICE_CONTAINEROF(pipe_item, CursorPipeItem, base));
+ case RED_PIPE_ITEM_TYPE_CURSOR:
+ cursor_marshall(rcc, m, SPICE_CONTAINEROF(pipe_item, RedCursorPipeItem, base));
break;
- case PIPE_ITEM_TYPE_INVAL_ONE:
- red_marshall_inval(rcc, m, (CacheItem *)pipe_item);
+ case RED_PIPE_ITEM_TYPE_INVAL_ONE:
+ red_marshall_inval(rcc, m, (RedCacheItem *)pipe_item);
break;
- case PIPE_ITEM_TYPE_VERB:
- red_marshall_verb(rcc, (VerbItem*)pipe_item);
+ case RED_PIPE_ITEM_TYPE_VERB:
+ red_marshall_verb(rcc, (RedVerbItem*)pipe_item);
break;
- case PIPE_ITEM_TYPE_CURSOR_INIT:
+ case RED_PIPE_ITEM_TYPE_CURSOR_INIT:
red_reset_cursor_cache(rcc);
red_marshall_cursor_init(rcc, m, pipe_item);
break;
- case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
+ case RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
red_reset_cursor_cache(rcc);
red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_INVAL_ALL, NULL);
break;
@@ -379,7 +382,7 @@ static void cursor_channel_send_item(RedChannelClient *rcc, RedPipeItem *pipe_it
red_channel_client_begin_send_message(rcc);
}
-static CursorPipeItem *cursor_pipe_item_ref(CursorPipeItem *item)
+static RedCursorPipeItem *cursor_pipe_item_ref(RedCursorPipeItem *item)
{
spice_return_val_if_fail(item, NULL);
spice_return_val_if_fail(item->refs > 0, NULL);
@@ -391,11 +394,11 @@ static CursorPipeItem *cursor_pipe_item_ref(CursorPipeItem *item)
static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, RedPipeItem *item)
{
- CursorPipeItem *cursor_pipe_item;
+ RedCursorPipeItem *cursor_pipe_item;
spice_return_if_fail(item);
- cursor_pipe_item = SPICE_CONTAINEROF(item, CursorPipeItem, base);
+ cursor_pipe_item = SPICE_CONTAINEROF(item, RedCursorPipeItem, base);
cursor_pipe_item_ref(cursor_pipe_item);
}
@@ -443,7 +446,7 @@ void cursor_channel_client_migrate(CursorChannelClient* client)
spice_return_if_fail(client);
rcc = RED_CHANNEL_CLIENT(client);
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
red_channel_client_default_migrate(rcc);
}
@@ -531,7 +534,7 @@ void cursor_channel_reset(CursorChannel *cursor)
cursor->cursor_trail_length = cursor->cursor_trail_frequency = 0;
if (red_channel_is_connected(channel)) {
- red_channel_pipes_add_type(channel, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
+ red_channel_pipes_add_type(channel, RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
if (!cursor->common.during_target_migrate) {
red_pipes_add_verb(channel, SPICE_MSG_CURSOR_RESET);
}
@@ -555,9 +558,9 @@ void cursor_channel_init(CursorChannel *cursor, CursorChannelClient *client)
if (client)
red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(client),
- PIPE_ITEM_TYPE_CURSOR_INIT);
+ RED_PIPE_ITEM_TYPE_CURSOR_INIT);
else
- red_channel_pipes_add_type(RED_CHANNEL(cursor), PIPE_ITEM_TYPE_CURSOR_INIT);
+ red_channel_pipes_add_type(RED_CHANNEL(cursor), RED_PIPE_ITEM_TYPE_CURSOR_INIT);
}
void cursor_channel_set_mouse_mode(CursorChannel *cursor, uint32_t mode)
diff --git a/server/dcc-send.c b/server/dcc-send.c
index 799d5df..efbc454 100644
--- a/server/dcc-send.c
+++ b/server/dcc-send.c
@@ -514,7 +514,7 @@ static void fill_attr(SpiceMarshaller *m, SpiceLineAttr *attr)
static void marshall_qxl_draw_fill(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -608,9 +608,9 @@ static int pipe_rendered_drawables_intersect_with_areas(DisplayChannelClient *dc
{
Drawable *drawable;
- if (pipe_item->type != PIPE_ITEM_TYPE_DRAW)
+ if (pipe_item->type != RED_PIPE_ITEM_TYPE_DRAW)
continue;
- drawable = SPICE_CONTAINEROF(pipe_item, DrawablePipeItem, dpi_pipe_item)->drawable;
+ drawable = SPICE_CONTAINEROF(pipe_item, RedDrawablePipeItem, dpi_pipe_item)->drawable;
if (ring_item_is_linked(&drawable->list_link))
continue; // item hasn't been rendered
@@ -699,12 +699,12 @@ static void red_pipe_replace_rendered_drawables_with_images(DisplayChannelClient
pipe_item;
pipe_item = (RedPipeItem *)ring_prev(pipe, &pipe_item->link)) {
Drawable *drawable;
- DrawablePipeItem *dpi;
- ImageItem *image;
+ RedDrawablePipeItem *dpi;
+ RedImageItem *image;
- if (pipe_item->type != PIPE_ITEM_TYPE_DRAW)
+ if (pipe_item->type != RED_PIPE_ITEM_TYPE_DRAW)
continue;
- dpi = SPICE_CONTAINEROF(pipe_item, DrawablePipeItem, dpi_pipe_item);
+ dpi = SPICE_CONTAINEROF(pipe_item, RedDrawablePipeItem, dpi_pipe_item);
drawable = dpi->drawable;
if (ring_item_is_linked(&drawable->list_link))
continue; // item hasn't been rendered
@@ -803,7 +803,7 @@ static void red_add_lossless_drawable_dependencies(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_fill(RedChannelClient *rcc,
SpiceMarshaller *m,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -860,7 +860,8 @@ static void red_lossy_marshall_qxl_draw_fill(RedChannelClient *rcc,
static FillBitsType red_marshall_qxl_draw_opaque(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi, int src_allowed_lossy)
+ RedDrawablePipeItem *dpi,
+ int src_allowed_lossy)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -893,7 +894,7 @@ static FillBitsType red_marshall_qxl_draw_opaque(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_opaque(RedChannelClient *rcc,
SpiceMarshaller *m,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -958,7 +959,8 @@ static void red_lossy_marshall_qxl_draw_opaque(RedChannelClient *rcc,
static FillBitsType red_marshall_qxl_draw_copy(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi, int src_allowed_lossy)
+ RedDrawablePipeItem *dpi,
+ int src_allowed_lossy)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -984,7 +986,7 @@ static FillBitsType red_marshall_qxl_draw_copy(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_copy(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -1009,7 +1011,7 @@ static void red_lossy_marshall_qxl_draw_copy(RedChannelClient *rcc,
static void red_marshall_qxl_draw_transparent(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
Drawable *item = dpi->drawable;
@@ -1029,7 +1031,7 @@ static void red_marshall_qxl_draw_transparent(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_transparent(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -1056,7 +1058,7 @@ static void red_lossy_marshall_qxl_draw_transparent(RedChannelClient *rcc,
static FillBitsType red_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi,
+ RedDrawablePipeItem *dpi,
int src_allowed_lossy)
{
Drawable *item = dpi->drawable;
@@ -1081,7 +1083,7 @@ static FillBitsType red_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1108,7 +1110,7 @@ static void red_lossy_marshall_qxl_draw_alpha_blend(RedChannelClient *rcc,
static void red_marshall_qxl_copy_bits(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -1123,7 +1125,7 @@ static void red_marshall_qxl_copy_bits(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_copy_bits(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1152,7 +1154,7 @@ static void red_lossy_marshall_qxl_copy_bits(RedChannelClient *rcc,
static void red_marshall_qxl_draw_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1176,7 +1178,7 @@ static void red_marshall_qxl_draw_blend(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_blend(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1218,7 +1220,7 @@ static void red_lossy_marshall_qxl_draw_blend(RedChannelClient *rcc,
static void red_marshall_qxl_draw_blackness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -1238,7 +1240,7 @@ static void red_marshall_qxl_draw_blackness(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_blackness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1252,7 +1254,7 @@ static void red_lossy_marshall_qxl_draw_blackness(RedChannelClient *rcc,
static void red_marshall_qxl_draw_whiteness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -1272,7 +1274,7 @@ static void red_marshall_qxl_draw_whiteness(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_whiteness(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1312,7 +1314,7 @@ static void red_lossy_marshall_qxl_draw_inverse(RedChannelClient *rcc,
static void red_marshall_qxl_draw_rop3(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1341,7 +1343,7 @@ static void red_marshall_qxl_draw_rop3(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_rop3(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1396,7 +1398,7 @@ static void red_lossy_marshall_qxl_draw_rop3(RedChannelClient *rcc,
static void red_marshall_qxl_draw_composite(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1421,7 +1423,7 @@ static void red_marshall_qxl_draw_composite(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_composite(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1477,7 +1479,7 @@ static void red_lossy_marshall_qxl_draw_composite(RedChannelClient *rcc,
static void red_marshall_qxl_draw_stroke(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1502,7 +1504,7 @@ static void red_marshall_qxl_draw_stroke(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_stroke(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1557,7 +1559,7 @@ static void red_lossy_marshall_qxl_draw_stroke(RedChannelClient *rcc,
static void red_marshall_qxl_draw_text(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1584,7 +1586,7 @@ static void red_marshall_qxl_draw_text(RedChannelClient *rcc,
static void red_lossy_marshall_qxl_draw_text(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
@@ -1768,8 +1770,8 @@ static int red_marshall_stream_data(RedChannelClient *rcc,
}
static inline void marshall_inval_palette(RedChannelClient *rcc,
- SpiceMarshaller *base_marshaller,
- CacheItem *cache_item)
+ SpiceMarshaller *base_marshaller,
+ RedCacheItem *cache_item)
{
SpiceMsgDisplayInvalOne inval_one;
@@ -1915,7 +1917,9 @@ static void display_channel_marshall_reset_cache(RedChannelClient *rcc,
&wait);
}
-static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageItem *item)
+static void red_marshall_image(RedChannelClient *rcc,
+ SpiceMarshaller *m,
+ RedImageItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
DisplayChannel *display = DCC_TO_DC(dcc);
@@ -2009,7 +2013,7 @@ static void red_marshall_image(RedChannelClient *rcc, SpiceMarshaller *m, ImageI
static void marshall_lossy_qxl_drawable(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- DrawablePipeItem *dpi)
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
switch (item->red_drawable->type) {
@@ -2061,7 +2065,8 @@ static void marshall_lossy_qxl_drawable(RedChannelClient *rcc,
}
static void marshall_lossless_qxl_drawable(RedChannelClient *rcc,
- SpiceMarshaller *m, DrawablePipeItem *dpi)
+ SpiceMarshaller *m,
+ RedDrawablePipeItem *dpi)
{
Drawable *item = dpi->drawable;
RedDrawable *drawable = item->red_drawable;
@@ -2115,7 +2120,8 @@ static void marshall_lossless_qxl_drawable(RedChannelClient *rcc,
}
static void marshall_qxl_drawable(RedChannelClient *rcc,
- SpiceMarshaller *m, DrawablePipeItem *dpi)
+ SpiceMarshaller *m,
+ RedDrawablePipeItem *dpi)
{
spice_return_if_fail(rcc);
@@ -2173,7 +2179,7 @@ static void marshall_stream_start(RedChannelClient *rcc,
static void marshall_stream_clip(RedChannelClient *rcc,
SpiceMarshaller *base_marshaller,
- StreamClipItem *item)
+ RedStreamClipItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
StreamAgent *agent = item->stream_agent;
@@ -2203,7 +2209,7 @@ static void marshall_stream_end(RedChannelClient *rcc,
}
static void marshall_upgrade(RedChannelClient *rcc, SpiceMarshaller *m,
- UpgradeItem *item)
+ RedUpgradeItem *item)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
RedDrawable *red_drawable;
@@ -2319,7 +2325,7 @@ static void marshall_gl_draw(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
- GlDrawItem *p = SPICE_CONTAINEROF(item, GlDrawItem, base);
+ RedGlDrawItem *p = SPICE_CONTAINEROF(item, RedGlDrawItem, base);
red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_GL_DRAW, NULL);
spice_marshall_msg_display_gl_draw(m, &p->draw);
@@ -2367,80 +2373,81 @@ void dcc_send_item(DisplayChannelClient *dcc, RedPipeItem *pipe_item)
reset_send_data(dcc);
switch (pipe_item->type) {
- case PIPE_ITEM_TYPE_DRAW: {
- DrawablePipeItem *dpi = SPICE_CONTAINEROF(pipe_item, DrawablePipeItem, dpi_pipe_item);
+ case RED_PIPE_ITEM_TYPE_DRAW: {
+ RedDrawablePipeItem *dpi = SPICE_CONTAINEROF(pipe_item, RedDrawablePipeItem, dpi_pipe_item);
marshall_qxl_drawable(rcc, m, dpi);
break;
}
- case PIPE_ITEM_TYPE_INVAL_ONE:
- marshall_inval_palette(rcc, m, (CacheItem *)pipe_item);
+ case RED_PIPE_ITEM_TYPE_INVAL_ONE:
+ marshall_inval_palette(rcc, m, (RedCacheItem *)pipe_item);
break;
- case PIPE_ITEM_TYPE_STREAM_CREATE: {
+ case RED_PIPE_ITEM_TYPE_STREAM_CREATE: {
StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent, create_item);
marshall_stream_start(rcc, m, agent);
break;
}
- case PIPE_ITEM_TYPE_STREAM_CLIP: {
- StreamClipItem* clip_item = (StreamClipItem *)pipe_item;
+ case RED_PIPE_ITEM_TYPE_STREAM_CLIP: {
+ RedStreamClipItem* clip_item = (RedStreamClipItem *)pipe_item;
marshall_stream_clip(rcc, m, clip_item);
break;
}
- case PIPE_ITEM_TYPE_STREAM_DESTROY: {
+ case RED_PIPE_ITEM_TYPE_STREAM_DESTROY: {
StreamAgent *agent = SPICE_CONTAINEROF(pipe_item, StreamAgent, destroy_item);
marshall_stream_end(rcc, m, agent);
break;
}
- case PIPE_ITEM_TYPE_UPGRADE:
- marshall_upgrade(rcc, m, (UpgradeItem *)pipe_item);
+ case RED_PIPE_ITEM_TYPE_UPGRADE:
+ marshall_upgrade(rcc, m, (RedUpgradeItem *)pipe_item);
break;
- case PIPE_ITEM_TYPE_VERB:
- red_marshall_verb(rcc, (VerbItem*)pipe_item);
+ case RED_PIPE_ITEM_TYPE_VERB:
+ red_marshall_verb(rcc, (RedVerbItem*)pipe_item);
break;
- case PIPE_ITEM_TYPE_MIGRATE_DATA:
+ case RED_PIPE_ITEM_TYPE_MIGRATE_DATA:
display_channel_marshall_migrate_data(rcc, m);
break;
- case PIPE_ITEM_TYPE_IMAGE:
- red_marshall_image(rcc, m, (ImageItem *)pipe_item);
+ case RED_PIPE_ITEM_TYPE_IMAGE:
+ red_marshall_image(rcc, m, (RedImageItem *)pipe_item);
break;
- case PIPE_ITEM_TYPE_PIXMAP_SYNC:
+ case RED_PIPE_ITEM_TYPE_PIXMAP_SYNC:
display_channel_marshall_pixmap_sync(rcc, m);
break;
- case PIPE_ITEM_TYPE_PIXMAP_RESET:
+ case RED_PIPE_ITEM_TYPE_PIXMAP_RESET:
display_channel_marshall_reset_cache(rcc, m);
break;
- case PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
+ case RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
dcc_palette_cache_reset(dcc);
red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_INVAL_ALL_PALETTES, NULL);
break;
- case PIPE_ITEM_TYPE_CREATE_SURFACE: {
- SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(pipe_item, SurfaceCreateItem,
- pipe_item);
+ case RED_PIPE_ITEM_TYPE_CREATE_SURFACE: {
+ RedSurfaceCreateItem *surface_create = SPICE_CONTAINEROF(pipe_item, RedSurfaceCreateItem,
+ pipe_item);
marshall_surface_create(rcc, m, &surface_create->surface_create);
break;
}
- case PIPE_ITEM_TYPE_DESTROY_SURFACE: {
- SurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(pipe_item, SurfaceDestroyItem,
- pipe_item);
+ case RED_PIPE_ITEM_TYPE_DESTROY_SURFACE: {
+ RedSurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(pipe_item, RedSurfaceDestroyItem,
+ pipe_item);
marshall_surface_destroy(rcc, m, surface_destroy->surface_destroy.surface_id);
break;
}
- case PIPE_ITEM_TYPE_MONITORS_CONFIG: {
- MonitorsConfigItem *monconf_item = SPICE_CONTAINEROF(pipe_item,
- MonitorsConfigItem, pipe_item);
+ case RED_PIPE_ITEM_TYPE_MONITORS_CONFIG: {
+ RedMonitorsConfigItem *monconf_item = SPICE_CONTAINEROF(pipe_item,
+ RedMonitorsConfigItem,
+ pipe_item);
marshall_monitors_config(rcc, m, monconf_item->monitors_config);
break;
}
- case PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT: {
- StreamActivateReportItem *report_item = SPICE_CONTAINEROF(pipe_item,
- StreamActivateReportItem,
- pipe_item);
+ case RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT: {
+ RedStreamActivateReportItem *report_item = SPICE_CONTAINEROF(pipe_item,
+ RedStreamActivateReportItem,
+ pipe_item);
marshall_stream_activate_report(rcc, m, report_item->stream_id);
break;
}
- case PIPE_ITEM_TYPE_GL_SCANOUT:
+ case RED_PIPE_ITEM_TYPE_GL_SCANOUT:
marshall_gl_scanout(rcc, m, pipe_item);
break;
- case PIPE_ITEM_TYPE_GL_DRAW:
+ case RED_PIPE_ITEM_TYPE_GL_DRAW:
marshall_gl_draw(rcc, m, pipe_item);
break;
default:
diff --git a/server/dcc.c b/server/dcc.c
index 5b45096..e9fb9f7 100644
--- a/server/dcc.c
+++ b/server/dcc.c
@@ -24,13 +24,16 @@
#define DISPLAY_CLIENT_SHORT_TIMEOUT 15000000000ULL //nano
-static SurfaceCreateItem *surface_create_item_new(RedChannel* channel,
- uint32_t surface_id, uint32_t width,
- uint32_t height, uint32_t format, uint32_t flags)
+static RedSurfaceCreateItem *red_surface_create_item_new(RedChannel* channel,
+ uint32_t surface_id,
+ uint32_t width,
+ uint32_t height,
+ uint32_t format,
+ uint32_t flags)
{
- SurfaceCreateItem *create;
+ RedSurfaceCreateItem *create;
- create = spice_malloc(sizeof(SurfaceCreateItem));
+ create = spice_malloc(sizeof(RedSurfaceCreateItem));
create->surface_create.surface_id = surface_id;
create->surface_create.width = width;
@@ -38,13 +41,13 @@ static SurfaceCreateItem *surface_create_item_new(RedChannel* channel,
create->surface_create.flags = flags;
create->surface_create.format = format;
- red_pipe_item_init(&create->pipe_item, PIPE_ITEM_TYPE_CREATE_SURFACE);
+ red_pipe_item_init(&create->pipe_item, RED_PIPE_ITEM_TYPE_CREATE_SURFACE);
return create;
}
int dcc_drawable_is_in_pipe(DisplayChannelClient *dcc, Drawable *drawable)
{
- DrawablePipeItem *dpi;
+ RedDrawablePipeItem *dpi;
RingItem *dpi_link, *dpi_next;
DRAWABLE_FOREACH_DPI_SAFE(drawable, dpi_link, dpi_next, dpi) {
@@ -77,14 +80,14 @@ int dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int surface
item = (RedPipeItem *) ring;
while ((item = (RedPipeItem *)ring_next(ring, (RingItem *)item))) {
Drawable *drawable;
- DrawablePipeItem *dpi = NULL;
+ RedDrawablePipeItem *dpi = NULL;
int depend_found = FALSE;
- if (item->type == PIPE_ITEM_TYPE_DRAW) {
- dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
+ if (item->type == RED_PIPE_ITEM_TYPE_DRAW) {
+ dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem, dpi_pipe_item);
drawable = dpi->drawable;
- } else if (item->type == PIPE_ITEM_TYPE_UPGRADE) {
- drawable = ((UpgradeItem *)item)->drawable;
+ } else if (item->type == RED_PIPE_ITEM_TYPE_UPGRADE) {
+ drawable = ((RedUpgradeItem *)item)->drawable;
} else {
continue;
}
@@ -138,7 +141,7 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id)
{
DisplayChannel *display;
RedSurface *surface;
- SurfaceCreateItem *create;
+ RedSurfaceCreateItem *create;
uint32_t flags;
if (!dcc) {
@@ -154,21 +157,25 @@ void dcc_create_surface(DisplayChannelClient *dcc, int surface_id)
return;
}
surface = &display->surfaces[surface_id];
- create = surface_create_item_new(RED_CHANNEL_CLIENT(dcc)->channel,
- surface_id, surface->context.width, surface->context.height,
- surface->context.format, flags);
+ create = red_surface_create_item_new(RED_CHANNEL_CLIENT(dcc)->channel,
+ surface_id, surface->context.width,
+ surface->context.height,
+ surface->context.format, flags);
dcc->surface_client_created[surface_id] = TRUE;
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &create->pipe_item);
}
// adding the pipe item after pos. If pos == NULL, adding to head.
-ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int surface_id,
- SpiceRect *area, RedPipeItem *pos, int can_lossy)
+RedImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc,
+ int surface_id,
+ SpiceRect *area,
+ RedPipeItem *pos,
+ int can_lossy)
{
DisplayChannel *display = DCC_TO_DC(dcc);
RedSurface *surface = &display->surfaces[surface_id];
SpiceCanvas *canvas = surface->context.canvas;
- ImageItem *item;
+ RedImageItem *item;
int stride;
int width;
int height;
@@ -182,9 +189,9 @@ ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int surface_id,
bpp = SPICE_SURFACE_FMT_DEPTH(surface->context.format) / 8;
stride = width * bpp;
- item = (ImageItem *)spice_malloc_n_m(height, stride, sizeof(ImageItem));
+ item = (RedImageItem *)spice_malloc_n_m(height, stride, sizeof(RedImageItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_IMAGE);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_IMAGE);
item->surface_id = surface_id;
item->image_format =
@@ -274,9 +281,10 @@ static void add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra
dcc_push_surface_image(dcc, drawable->surface_id);
}
-void drawable_pipe_item_free(RedPipeItem *item)
+void red_drawable_pipe_item_free(RedPipeItem *item)
{
- DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
+ RedDrawablePipeItem *dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem,
+ dpi_pipe_item);
DisplayChannel *display = DCC_TO_DC(dpi->dcc);
g_return_if_fail(item->refcount == 0);
@@ -287,24 +295,25 @@ void drawable_pipe_item_free(RedPipeItem *item)
free(dpi);
}
-static DrawablePipeItem *drawable_pipe_item_new(DisplayChannelClient *dcc, Drawable *drawable)
+static RedDrawablePipeItem *red_drawable_pipe_item_new(DisplayChannelClient *dcc,
+ Drawable *drawable)
{
- DrawablePipeItem *dpi;
+ RedDrawablePipeItem *dpi;
dpi = spice_malloc0(sizeof(*dpi));
dpi->drawable = drawable;
dpi->dcc = dcc;
ring_item_init(&dpi->base);
ring_add(&drawable->pipes, &dpi->base);
- red_pipe_item_init_full(&dpi->dpi_pipe_item, PIPE_ITEM_TYPE_DRAW,
- (GDestroyNotify)drawable_pipe_item_free);
+ red_pipe_item_init_full(&dpi->dpi_pipe_item, RED_PIPE_ITEM_TYPE_DRAW,
+ (GDestroyNotify)red_drawable_pipe_item_free);
drawable->refs++;
return dpi;
}
void dcc_prepend_drawable(DisplayChannelClient *dcc, Drawable *drawable)
{
- DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
+ RedDrawablePipeItem *dpi = red_drawable_pipe_item_new(dcc, drawable);
add_drawable_surface_images(dcc, drawable);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item);
@@ -312,7 +321,7 @@ void dcc_prepend_drawable(DisplayChannelClient *dcc, Drawable *drawable)
void dcc_append_drawable(DisplayChannelClient *dcc, Drawable *drawable)
{
- DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
+ RedDrawablePipeItem *dpi = red_drawable_pipe_item_new(dcc, drawable);
add_drawable_surface_images(dcc, drawable);
red_channel_client_pipe_add_tail_and_push(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item);
@@ -320,7 +329,7 @@ void dcc_append_drawable(DisplayChannelClient *dcc, Drawable *drawable)
void dcc_add_drawable_after(DisplayChannelClient *dcc, Drawable *drawable, RedPipeItem *pos)
{
- DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
+ RedDrawablePipeItem *dpi = red_drawable_pipe_item_new(dcc, drawable);
add_drawable_surface_images(dcc, drawable);
red_channel_client_pipe_add_after(RED_CHANNEL_CLIENT(dcc), &dpi->dpi_pipe_item, pos);
@@ -336,8 +345,8 @@ static void dcc_init_stream_agents(DisplayChannelClient *dcc)
agent->stream = &display->streams_buf[i];
region_init(&agent->vis_region);
region_init(&agent->clip);
- red_pipe_item_init(&agent->create_item, PIPE_ITEM_TYPE_STREAM_CREATE);
- red_pipe_item_init(&agent->destroy_item, PIPE_ITEM_TYPE_STREAM_DESTROY);
+ red_pipe_item_init(&agent->create_item, RED_PIPE_ITEM_TYPE_STREAM_CREATE);
+ red_pipe_item_init(&agent->destroy_item, RED_PIPE_ITEM_TYPE_STREAM_DESTROY);
}
dcc->use_mjpeg_encoder_rate_control =
red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_STREAM_REPORT);
@@ -447,7 +456,7 @@ void dcc_start(DisplayChannelClient *dcc)
red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(dcc));
if (display->surfaces[0].context.canvas) {
display_channel_current_flush(display, 0);
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
dcc_create_surface(dcc, 0);
dcc_push_surface_image(dcc, 0);
dcc_push_monitors_config(dcc);
@@ -497,7 +506,7 @@ void dcc_stop(DisplayChannelClient *dcc)
void dcc_stream_agent_clip(DisplayChannelClient* dcc, StreamAgent *agent)
{
- StreamClipItem *item = stream_clip_item_new(agent);
+ RedStreamClipItem *item = red_stream_clip_item_new(agent);
int n_rects;
item->clip_type = SPICE_CLIP_TYPE_RECTS;
@@ -510,22 +519,22 @@ void dcc_stream_agent_clip(DisplayChannelClient* dcc, StreamAgent *agent)
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), (RedPipeItem *)item);
}
-static void monitors_config_item_free(MonitorsConfigItem *item)
+static void red_monitors_config_item_free(RedMonitorsConfigItem *item)
{
monitors_config_unref(item->monitors_config);
free(item);
}
-static MonitorsConfigItem *monitors_config_item_new(RedChannel* channel,
- MonitorsConfig *monitors_config)
+static RedMonitorsConfigItem *red_monitors_config_item_new(RedChannel* channel,
+ MonitorsConfig *monitors_config)
{
- MonitorsConfigItem *mci;
+ RedMonitorsConfigItem *mci;
- mci = (MonitorsConfigItem *)spice_malloc(sizeof(*mci));
+ mci = (RedMonitorsConfigItem *)spice_malloc(sizeof(*mci));
mci->monitors_config = monitors_config;
- red_pipe_item_init_full(&mci->pipe_item, PIPE_ITEM_TYPE_MONITORS_CONFIG,
- (GDestroyNotify)monitors_config_item_free);
+ red_pipe_item_init_full(&mci->pipe_item, RED_PIPE_ITEM_TYPE_MONITORS_CONFIG,
+ (GDestroyNotify)red_monitors_config_item_free);
return mci;
}
@@ -533,7 +542,7 @@ void dcc_push_monitors_config(DisplayChannelClient *dcc)
{
DisplayChannel *dc = DCC_TO_DC(dcc);
MonitorsConfig *monitors_config = dc->monitors_config;
- MonitorsConfigItem *mci;
+ RedMonitorsConfigItem *mci;
if (monitors_config == NULL) {
spice_warning("monitors_config is NULL");
@@ -545,27 +554,27 @@ void dcc_push_monitors_config(DisplayChannelClient *dcc)
return;
}
- mci = monitors_config_item_new(dcc->common.base.channel,
- monitors_config_ref(dc->monitors_config));
+ mci = red_monitors_config_item_new(dcc->common.base.channel,
+ monitors_config_ref(dc->monitors_config));
red_channel_client_pipe_add(&dcc->common.base, &mci->pipe_item);
red_channel_client_push(&dcc->common.base);
}
-static SurfaceDestroyItem *surface_destroy_item_new(RedChannel *channel,
- uint32_t surface_id)
+static RedSurfaceDestroyItem *red_surface_destroy_item_new(RedChannel *channel,
+ uint32_t surface_id)
{
- SurfaceDestroyItem *destroy;
+ RedSurfaceDestroyItem *destroy;
- destroy = spice_malloc(sizeof(SurfaceDestroyItem));
+ destroy = spice_malloc(sizeof(RedSurfaceDestroyItem));
destroy->surface_destroy.surface_id = surface_id;
- red_pipe_item_init(&destroy->pipe_item, PIPE_ITEM_TYPE_DESTROY_SURFACE);
+ red_pipe_item_init(&destroy->pipe_item, RED_PIPE_ITEM_TYPE_DESTROY_SURFACE);
return destroy;
}
RedPipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
{
- GlScanoutUnixItem *item = spice_new(GlScanoutUnixItem, 1);
+ RedGlScanoutUnixItem *item = spice_new(RedGlScanoutUnixItem, 1);
spice_return_val_if_fail(item != NULL, NULL);
/* FIXME: on !unix peer, start streaming with a video codec */
@@ -576,7 +585,7 @@ RedPipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int num)
return NULL;
}
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_SCANOUT);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_GL_SCANOUT);
return &item->base;
}
@@ -585,7 +594,7 @@ RedPipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
{
DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
const SpiceMsgDisplayGlDraw *draw = data;
- GlDrawItem *item = spice_new(GlDrawItem, 1);
+ RedGlDrawItem *item = spice_new(RedGlDrawItem, 1);
spice_return_val_if_fail(item != NULL, NULL);
if (!red_channel_client_test_remote_cap(rcc, SPICE_DISPLAY_CAP_GL_SCANOUT)) {
@@ -596,7 +605,7 @@ RedPipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
dcc->gl_draw_ongoing = TRUE;
item->draw = *draw;
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_DRAW);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_GL_DRAW);
return &item->base;
}
@@ -605,7 +614,7 @@ void dcc_destroy_surface(DisplayChannelClient *dcc, uint32_t surface_id)
{
DisplayChannel *display;
RedChannel *channel;
- SurfaceDestroyItem *destroy;
+ RedSurfaceDestroyItem *destroy;
if (!dcc) {
return;
@@ -620,7 +629,7 @@ void dcc_destroy_surface(DisplayChannelClient *dcc, uint32_t surface_id)
}
dcc->surface_client_created[surface_id] = FALSE;
- destroy = surface_destroy_item_new(channel, surface_id);
+ destroy = red_surface_destroy_item_new(channel, surface_id);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &destroy->pipe_item);
}
@@ -1302,7 +1311,7 @@ int dcc_pixmap_cache_unlocked_add(DisplayChannelClient *dcc, uint64_t id,
if (cache->generation != dcc->pixmap_cache_generation) {
if (!dcc->pending_pixmaps_sync) {
red_channel_client_pipe_add_type(
- RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_PIXMAP_SYNC);
+ RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_PIXMAP_SYNC);
dcc->pending_pixmaps_sync = TRUE;
}
free(item);
@@ -1554,9 +1563,9 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
if (migrate_data->pixmap_cache_freezer) {
/* activating the cache. The cache will start to be active after
- * pixmap_cache_reset is called, when handling PIPE_ITEM_TYPE_PIXMAP_RESET */
+ * pixmap_cache_reset is called, when handling RED_PIPE_ITEM_TYPE_PIXMAP_RESET */
dcc->pixmap_cache->size = migrate_data->pixmap_cache_size;
- red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_PIXMAP_RESET);
+ red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_PIXMAP_RESET);
}
if (dcc_handle_migrate_glz_dictionary(dcc, migrate_data)) {
@@ -1585,7 +1594,7 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
spice_return_val_if_fail(surfaces_restored, FALSE);
- red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
+ red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(dcc), RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
/* enable sending messages */
red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(dcc));
return TRUE;
@@ -1594,16 +1603,16 @@ int dcc_handle_migrate_data(DisplayChannelClient *dcc, uint32_t size, void *mess
static void release_item_after_push(DisplayChannelClient *dcc, RedPipeItem *item)
{
switch (item->type) {
- case PIPE_ITEM_TYPE_DRAW:
- case PIPE_ITEM_TYPE_IMAGE:
- case PIPE_ITEM_TYPE_STREAM_CLIP:
- case PIPE_ITEM_TYPE_UPGRADE:
- case PIPE_ITEM_TYPE_MONITORS_CONFIG:
+ case RED_PIPE_ITEM_TYPE_DRAW:
+ case RED_PIPE_ITEM_TYPE_IMAGE:
+ case RED_PIPE_ITEM_TYPE_STREAM_CLIP:
+ case RED_PIPE_ITEM_TYPE_UPGRADE:
+ case RED_PIPE_ITEM_TYPE_MONITORS_CONFIG:
red_pipe_item_unref(item);
break;
- case PIPE_ITEM_TYPE_GL_SCANOUT:
- case PIPE_ITEM_TYPE_GL_DRAW:
- case PIPE_ITEM_TYPE_VERB:
+ case RED_PIPE_ITEM_TYPE_GL_SCANOUT:
+ case RED_PIPE_ITEM_TYPE_GL_DRAW:
+ case RED_PIPE_ITEM_TYPE_VERB:
free(item);
break;
default:
@@ -1619,49 +1628,49 @@ static void release_item_before_push(DisplayChannelClient *dcc, RedPipeItem *ite
spice_debug("item.type: %d", item->type);
switch (item->type) {
- case PIPE_ITEM_TYPE_DRAW: {
- DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, dpi_pipe_item);
+ case RED_PIPE_ITEM_TYPE_DRAW: {
+ RedDrawablePipeItem *dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem, dpi_pipe_item);
ring_remove(&dpi->base);
red_pipe_item_unref(item);
break;
}
- case PIPE_ITEM_TYPE_STREAM_CREATE: {
+ case RED_PIPE_ITEM_TYPE_STREAM_CREATE: {
StreamAgent *agent = SPICE_CONTAINEROF(item, StreamAgent, create_item);
stream_agent_unref(display, agent);
break;
}
- case PIPE_ITEM_TYPE_STREAM_DESTROY: {
+ case RED_PIPE_ITEM_TYPE_STREAM_DESTROY: {
StreamAgent *agent = SPICE_CONTAINEROF(item, StreamAgent, destroy_item);
stream_agent_unref(display, agent);
break;
}
- case PIPE_ITEM_TYPE_STREAM_CLIP:
- case PIPE_ITEM_TYPE_UPGRADE:
- case PIPE_ITEM_TYPE_IMAGE:
- case PIPE_ITEM_TYPE_MONITORS_CONFIG:
+ case RED_PIPE_ITEM_TYPE_STREAM_CLIP:
+ case RED_PIPE_ITEM_TYPE_UPGRADE:
+ case RED_PIPE_ITEM_TYPE_IMAGE:
+ case RED_PIPE_ITEM_TYPE_MONITORS_CONFIG:
red_pipe_item_unref(item);
break;
- case PIPE_ITEM_TYPE_CREATE_SURFACE: {
- SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(item, SurfaceCreateItem,
- pipe_item);
+ case RED_PIPE_ITEM_TYPE_CREATE_SURFACE: {
+ RedSurfaceCreateItem *surface_create = SPICE_CONTAINEROF(item, RedSurfaceCreateItem,
+ pipe_item);
free(surface_create);
break;
}
- case PIPE_ITEM_TYPE_DESTROY_SURFACE: {
- SurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(item, SurfaceDestroyItem,
- pipe_item);
+ case RED_PIPE_ITEM_TYPE_DESTROY_SURFACE: {
+ RedSurfaceDestroyItem *surface_destroy = SPICE_CONTAINEROF(item, RedSurfaceDestroyItem,
+ pipe_item);
free(surface_destroy);
break;
}
- case PIPE_ITEM_TYPE_INVAL_ONE:
- case PIPE_ITEM_TYPE_VERB:
- case PIPE_ITEM_TYPE_MIGRATE_DATA:
- case PIPE_ITEM_TYPE_PIXMAP_SYNC:
- case PIPE_ITEM_TYPE_PIXMAP_RESET:
- case PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
- case PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT:
- case PIPE_ITEM_TYPE_GL_SCANOUT:
- case PIPE_ITEM_TYPE_GL_DRAW:
+ case RED_PIPE_ITEM_TYPE_INVAL_ONE:
+ case RED_PIPE_ITEM_TYPE_VERB:
+ case RED_PIPE_ITEM_TYPE_MIGRATE_DATA:
+ case RED_PIPE_ITEM_TYPE_PIXMAP_SYNC:
+ case RED_PIPE_ITEM_TYPE_PIXMAP_RESET:
+ case RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE:
+ case RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT:
+ case RED_PIPE_ITEM_TYPE_GL_SCANOUT:
+ case RED_PIPE_ITEM_TYPE_GL_DRAW:
free(item);
break;
default:
diff --git a/server/dcc.h b/server/dcc.h
index 52cd22a..509a6c6 100644
--- a/server/dcc.h
+++ b/server/dcc.h
@@ -82,7 +82,7 @@ struct DisplayChannelClient {
uint32_t pixmap_cache_generation;
int pending_pixmaps_sync;
- CacheItem *palette_cache[PALETTE_CACHE_HASH_SIZE];
+ RedCacheItem *palette_cache[PALETTE_CACHE_HASH_SIZE];
Ring palette_cache_lru;
long palette_cache_available;
uint32_t palette_cache_items;
@@ -121,21 +121,21 @@ struct DisplayChannelClient {
SPICE_CONTAINEROF((dcc)->common.base.channel, DisplayChannel, common.base)
#define RCC_TO_DCC(rcc) SPICE_CONTAINEROF((rcc), DisplayChannelClient, common.base)
-typedef struct SurfaceCreateItem {
+typedef struct RedSurfaceCreateItem {
SpiceMsgSurfaceCreate surface_create;
RedPipeItem pipe_item;
-} SurfaceCreateItem;
+} RedSurfaceCreateItem;
-typedef struct GlScanoutUnixItem {
+typedef struct RedGlScanoutUnixItem {
RedPipeItem base;
-} GlScanoutUnixItem;
+} RedGlScanoutUnixItem;
-typedef struct GlDrawItem {
+typedef struct RedGlDrawItem {
RedPipeItem base;
SpiceMsgDisplayGlDraw draw;
-} GlDrawItem;
+} RedGlDrawItem;
-typedef struct ImageItem {
+typedef struct RedImageItem {
RedPipeItem base;
SpicePoint pos;
int width;
@@ -147,15 +147,15 @@ typedef struct ImageItem {
uint32_t image_flags;
int can_lossy;
uint8_t data[0];
-} ImageItem;
+} RedImageItem;
-typedef struct DrawablePipeItem {
+typedef struct RedDrawablePipeItem {
RingItem base; /* link for a list of pipe items held by Drawable */
RedPipeItem dpi_pipe_item; /* link for the client's pipe itself */
Drawable *drawable;
DisplayChannelClient *dcc;
uint8_t refs;
-} DrawablePipeItem;
+} RedDrawablePipeItem;
DisplayChannelClient* dcc_new (DisplayChannel *display,
RedClient *client,
@@ -186,7 +186,7 @@ void dcc_create_surface (DisplayCha
int surface_id);
void dcc_push_surface_image (DisplayChannelClient *dcc,
int surface_id);
-ImageItem * dcc_add_surface_area_image (DisplayChannelClient *dcc,
+RedImageItem * dcc_add_surface_area_image (DisplayChannelClient *dcc,
int surface_id,
SpiceRect *area,
RedPipeItem *pos,
diff --git a/server/display-channel.c b/server/display-channel.c
index d24b6a6..74cc357 100644
--- a/server/display-channel.c
+++ b/server/display-channel.c
@@ -344,7 +344,7 @@ static void pipes_add_drawable(DisplayChannel *display, Drawable *drawable)
static void pipes_add_drawable_after(DisplayChannel *display,
Drawable *drawable, Drawable *pos_after)
{
- DrawablePipeItem *dpi_pos_after;
+ RedDrawablePipeItem *dpi_pos_after;
RingItem *dpi_link, *dpi_next;
DisplayChannelClient *dcc;
int num_other_linked = 0;
@@ -403,11 +403,11 @@ static void current_remove_drawable(DisplayChannel *display, Drawable *item)
static void drawable_remove_from_pipes(Drawable *drawable)
{
- DrawablePipeItem *dpi;
+ RedDrawablePipeItem *dpi;
RingItem *item, *next;
RING_FOREACH_SAFE(item, next, &drawable->pipes) {
- dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, base);
+ dpi = SPICE_CONTAINEROF(item, RedDrawablePipeItem, base);
if (red_pipe_item_is_linked(&dpi->dpi_pipe_item)) {
red_channel_client_pipe_remove_and_release(RED_CHANNEL_CLIENT(dpi->dcc),
&dpi->dpi_pipe_item);
@@ -504,7 +504,7 @@ static int current_add_equal(DisplayChannel *display, DrawItem *item, TreeItem *
if (is_same_drawable(drawable, other_drawable)) {
DisplayChannelClient *dcc;
- DrawablePipeItem *dpi;
+ RedDrawablePipeItem *dpi;
RingItem *worker_ring_item, *dpi_ring_item;
other_drawable->refs++;
@@ -518,7 +518,7 @@ static int current_add_equal(DisplayChannel *display, DrawItem *item, TreeItem *
while (worker_ring_item) {
dcc = SPICE_CONTAINEROF(worker_ring_item, DisplayChannelClient,
common.base.channel_link);
- dpi = SPICE_CONTAINEROF(dpi_ring_item, DrawablePipeItem, base);
+ dpi = SPICE_CONTAINEROF(dpi_ring_item, RedDrawablePipeItem, base);
while (worker_ring_item && (!dpi || dcc != dpi->dcc)) {
dcc_prepend_drawable(dcc, drawable);
worker_ring_item = ring_next(&RED_CHANNEL(display)->clients,
@@ -1849,7 +1849,7 @@ void display_channel_destroy_surfaces(DisplayChannel *display)
spice_warn_if_fail(ring_is_empty(&display->streams));
if (red_channel_is_connected(RED_CHANNEL(display))) {
- red_channel_pipes_add_type(RED_CHANNEL(display), PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
+ red_channel_pipes_add_type(RED_CHANNEL(display), RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
red_pipes_add_verb(RED_CHANNEL(display), SPICE_MSG_DISPLAY_STREAM_DESTROY_ALL);
}
@@ -1970,10 +1970,10 @@ static void hold_item(RedChannelClient *rcc, RedPipeItem *item)
spice_return_if_fail(item);
switch (item->type) {
- case PIPE_ITEM_TYPE_DRAW:
- case PIPE_ITEM_TYPE_IMAGE:
- case PIPE_ITEM_TYPE_STREAM_CLIP:
- case PIPE_ITEM_TYPE_UPGRADE:
+ case RED_PIPE_ITEM_TYPE_DRAW:
+ case RED_PIPE_ITEM_TYPE_IMAGE:
+ case RED_PIPE_ITEM_TYPE_STREAM_CLIP:
+ case RED_PIPE_ITEM_TYPE_UPGRADE:
red_pipe_item_ref(item);
break;
default:
@@ -1994,7 +1994,7 @@ static int handle_migrate_flush_mark(RedChannelClient *rcc)
DisplayChannel *display_channel = SPICE_CONTAINEROF(rcc->channel, DisplayChannel, common.base);
RedChannel *channel = RED_CHANNEL(display_channel);
- red_channel_pipes_add_type(channel, PIPE_ITEM_TYPE_MIGRATE_DATA);
+ red_channel_pipes_add_type(channel, RED_PIPE_ITEM_TYPE_MIGRATE_DATA);
return TRUE;
}
diff --git a/server/display-channel.h b/server/display-channel.h
index 13f1499..9050716 100644
--- a/server/display-channel.h
+++ b/server/display-channel.h
@@ -81,7 +81,7 @@ struct Drawable {
uint32_t process_commands_generation;
};
-#define LINK_TO_DPI(ptr) SPICE_CONTAINEROF((ptr), DrawablePipeItem, base)
+#define LINK_TO_DPI(ptr) SPICE_CONTAINEROF((ptr), RedDrawablePipeItem, base)
#define DRAWABLE_FOREACH_DPI_SAFE(drawable, link, next, dpi) \
SAFE_FOREACH(link, next, drawable, &(drawable)->pipes, dpi, LINK_TO_DPI(link))
@@ -91,22 +91,22 @@ struct Drawable {
SAFE_FOREACH(link, next, drawable, &(drawable)->glz_ring, glz, LINK_TO_GLZ(link))
enum {
- PIPE_ITEM_TYPE_DRAW = PIPE_ITEM_TYPE_COMMON_LAST,
- PIPE_ITEM_TYPE_IMAGE,
- PIPE_ITEM_TYPE_STREAM_CREATE,
- PIPE_ITEM_TYPE_STREAM_CLIP,
- PIPE_ITEM_TYPE_STREAM_DESTROY,
- PIPE_ITEM_TYPE_UPGRADE,
- PIPE_ITEM_TYPE_MIGRATE_DATA,
- PIPE_ITEM_TYPE_PIXMAP_SYNC,
- PIPE_ITEM_TYPE_PIXMAP_RESET,
- PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE,
- PIPE_ITEM_TYPE_CREATE_SURFACE,
- PIPE_ITEM_TYPE_DESTROY_SURFACE,
- PIPE_ITEM_TYPE_MONITORS_CONFIG,
- PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT,
- PIPE_ITEM_TYPE_GL_SCANOUT,
- PIPE_ITEM_TYPE_GL_DRAW,
+ RED_PIPE_ITEM_TYPE_DRAW = RED_PIPE_ITEM_TYPE_COMMON_LAST,
+ RED_PIPE_ITEM_TYPE_IMAGE,
+ RED_PIPE_ITEM_TYPE_STREAM_CREATE,
+ RED_PIPE_ITEM_TYPE_STREAM_CLIP,
+ RED_PIPE_ITEM_TYPE_STREAM_DESTROY,
+ RED_PIPE_ITEM_TYPE_UPGRADE,
+ RED_PIPE_ITEM_TYPE_MIGRATE_DATA,
+ RED_PIPE_ITEM_TYPE_PIXMAP_SYNC,
+ RED_PIPE_ITEM_TYPE_PIXMAP_RESET,
+ RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE,
+ RED_PIPE_ITEM_TYPE_CREATE_SURFACE,
+ RED_PIPE_ITEM_TYPE_DESTROY_SURFACE,
+ RED_PIPE_ITEM_TYPE_MONITORS_CONFIG,
+ RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT,
+ RED_PIPE_ITEM_TYPE_GL_SCANOUT,
+ RED_PIPE_ITEM_TYPE_GL_DRAW,
};
typedef struct MonitorsConfig {
@@ -116,10 +116,10 @@ typedef struct MonitorsConfig {
QXLHead heads[0];
} MonitorsConfig;
-typedef struct MonitorsConfigItem {
+typedef struct RedMonitorsConfigItem {
RedPipeItem pipe_item;
MonitorsConfig *monitors_config;
-} MonitorsConfigItem;
+} RedMonitorsConfigItem;
MonitorsConfig* monitors_config_new (QXLHead *heads, ssize_t nheads,
ssize_t max);
@@ -237,17 +237,17 @@ static inline int get_stream_id(DisplayChannel *display, Stream *stream)
return (int)(stream - display->streams_buf);
}
-typedef struct SurfaceDestroyItem {
+typedef struct RedSurfaceDestroyItem {
SpiceMsgSurfaceDestroy surface_destroy;
RedPipeItem pipe_item;
-} SurfaceDestroyItem;
+} RedSurfaceDestroyItem;
-typedef struct UpgradeItem {
+typedef struct RedUpgradeItem {
RedPipeItem base;
DisplayChannelClient *dcc;
Drawable *drawable;
SpiceClipRects *rects;
-} UpgradeItem;
+} RedUpgradeItem;
DisplayChannel* display_channel_new (SpiceServer *reds,
diff --git a/server/inputs-channel.c b/server/inputs-channel.c
index 81a8d4a..d1af9cf 100644
--- a/server/inputs-channel.c
+++ b/server/inputs-channel.c
@@ -116,25 +116,25 @@ struct InputsChannel {
};
enum {
- PIPE_ITEM_INPUTS_INIT = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_MOUSE_MOTION_ACK,
- PIPE_ITEM_KEY_MODIFIERS,
- PIPE_ITEM_MIGRATE_DATA,
+ RED_PIPE_ITEM_INPUTS_INIT = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
+ RED_PIPE_ITEM_MOUSE_MOTION_ACK,
+ RED_PIPE_ITEM_KEY_MODIFIERS,
+ RED_PIPE_ITEM_MIGRATE_DATA,
};
-typedef struct InputsPipeItem {
+typedef struct RedInputsPipeItem {
RedPipeItem base;
-} InputsPipeItem;
+} RedInputsPipeItem;
-typedef struct KeyModifiersPipeItem {
+typedef struct RedKeyModifiersPipeItem {
RedPipeItem base;
uint8_t modifiers;
-} KeyModifiersPipeItem;
+} RedKeyModifiersPipeItem;
-typedef struct InputsInitPipeItem {
+typedef struct RedInputsInitPipeItem {
RedPipeItem base;
uint8_t modifiers;
-} InputsInitPipeItem;
+} RedInputsInitPipeItem;
static SpiceTimer *key_modifiers_timer;
@@ -229,12 +229,12 @@ static uint8_t kbd_get_leds(SpiceKbdInstance *sin)
return sif->get_leds(sin);
}
-static RedPipeItem *inputs_key_modifiers_item_new(
+static RedPipeItem *red_inputs_key_modifiers_item_new(
RedChannelClient *rcc, void *data, int num)
{
- KeyModifiersPipeItem *item = spice_malloc(sizeof(KeyModifiersPipeItem));
+ RedKeyModifiersPipeItem *item = spice_malloc(sizeof(RedKeyModifiersPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_KEY_MODIFIERS);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_KEY_MODIFIERS);
item->modifiers = *(uint8_t *)data;
return &item->base;
}
@@ -265,30 +265,30 @@ static void inputs_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
switch (base->type) {
- case PIPE_ITEM_KEY_MODIFIERS:
+ case RED_PIPE_ITEM_KEY_MODIFIERS:
{
SpiceMsgInputsKeyModifiers key_modifiers;
red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_KEY_MODIFIERS, base);
key_modifiers.modifiers =
- SPICE_CONTAINEROF(base, KeyModifiersPipeItem, base)->modifiers;
+ SPICE_CONTAINEROF(base, RedKeyModifiersPipeItem, base)->modifiers;
spice_marshall_msg_inputs_key_modifiers(m, &key_modifiers);
break;
}
- case PIPE_ITEM_INPUTS_INIT:
+ case RED_PIPE_ITEM_INPUTS_INIT:
{
SpiceMsgInputsInit inputs_init;
red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_INIT, base);
inputs_init.keyboard_modifiers =
- SPICE_CONTAINEROF(base, InputsInitPipeItem, base)->modifiers;
+ SPICE_CONTAINEROF(base, RedInputsInitPipeItem, base)->modifiers;
spice_marshall_msg_inputs_init(m, &inputs_init);
break;
}
- case PIPE_ITEM_MOUSE_MOTION_ACK:
+ case RED_PIPE_ITEM_MOUSE_MOTION_ACK:
red_channel_client_init_send_data(rcc, SPICE_MSG_INPUTS_MOUSE_MOTION_ACK, base);
break;
- case PIPE_ITEM_MIGRATE_DATA:
+ case RED_PIPE_ITEM_MIGRATE_DATA:
inputs_channel_send_migrate_data(rcc, m, base);
break;
default:
@@ -339,7 +339,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
!inputs_channel->src_during_migrate) {
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
icc->motion_count = 0;
}
if (mouse && reds_get_mouse_mode(reds) == SPICE_MOUSE_MODE_SERVER) {
@@ -357,7 +357,7 @@ static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
if (++icc->motion_count % SPICE_INPUT_MOTION_ACK_BUNCH == 0 &&
!inputs_channel->src_during_migrate) {
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
icc->motion_count = 0;
}
if (reds_get_mouse_mode(reds) != SPICE_MOUSE_MODE_CLIENT) {
@@ -500,10 +500,10 @@ static void inputs_channel_on_disconnect(RedChannelClient *rcc)
static void inputs_pipe_add_init(RedChannelClient *rcc)
{
- InputsInitPipeItem *item = spice_malloc(sizeof(InputsInitPipeItem));
+ RedInputsInitPipeItem *item = spice_malloc(sizeof(RedInputsInitPipeItem));
InputsChannel *inputs = SPICE_CONTAINEROF(rcc->channel, InputsChannel, base);
- red_pipe_item_init(&item->base, PIPE_ITEM_INPUTS_INIT);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_INPUTS_INIT);
item->modifiers = kbd_get_leds(inputs_channel_get_keyboard(inputs));
red_channel_client_pipe_add_push(rcc, &item->base);
}
@@ -569,7 +569,7 @@ static void inputs_channel_push_keyboard_modifiers(InputsChannel *inputs, uint8_
return;
}
red_channel_pipes_new_add_push(&inputs->base,
- inputs_key_modifiers_item_new, (void*)&modifiers);
+ red_inputs_key_modifiers_item_new, (void*)&modifiers);
}
void inputs_channel_on_keyboard_leds_change(InputsChannel *inputs, uint8_t leds)
@@ -585,7 +585,7 @@ static void key_modifiers_sender(void *opaque)
static int inputs_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
{
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MIGRATE_DATA);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MIGRATE_DATA);
return TRUE;
}
@@ -612,7 +612,7 @@ static int inputs_channel_handle_migrate_data(RedChannelClient *rcc,
for (; icc->motion_count >= SPICE_INPUT_MOTION_ACK_BUNCH;
icc->motion_count -= SPICE_INPUT_MOTION_ACK_BUNCH) {
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_MOUSE_MOTION_ACK);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_MOUSE_MOTION_ACK);
}
return TRUE;
}
diff --git a/server/main-channel.c b/server/main-channel.c
index b904e33..33f8eed 100644
--- a/server/main-channel.c
+++ b/server/main-channel.c
@@ -60,54 +60,54 @@
static const uint8_t zero_page[ZERO_BUF_SIZE] = {0};
enum {
- PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_TYPE_MAIN_PING,
- PIPE_ITEM_TYPE_MAIN_MOUSE_MODE,
- PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED,
- PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN,
- PIPE_ITEM_TYPE_MAIN_AGENT_DATA,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA,
- PIPE_ITEM_TYPE_MAIN_INIT,
- PIPE_ITEM_TYPE_MAIN_NOTIFY,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST,
- PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME,
- PIPE_ITEM_TYPE_MAIN_NAME,
- PIPE_ITEM_TYPE_MAIN_UUID,
- PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS,
+ RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
+ RED_PIPE_ITEM_TYPE_MAIN_PING,
+ RED_PIPE_ITEM_TYPE_MAIN_MOUSE_MODE,
+ RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED,
+ RED_PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN,
+ RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA,
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA,
+ RED_PIPE_ITEM_TYPE_MAIN_INIT,
+ RED_PIPE_ITEM_TYPE_MAIN_NOTIFY,
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN,
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS,
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST,
+ RED_PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME,
+ RED_PIPE_ITEM_TYPE_MAIN_NAME,
+ RED_PIPE_ITEM_TYPE_MAIN_UUID,
+ RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS,
};
-typedef struct RefsPipeItem {
+typedef struct RedRefsPipeItem {
RedPipeItem base;
int *refs;
-} RefsPipeItem;
+} RedRefsPipeItem;
-typedef struct PingPipeItem {
+typedef struct RedPingPipeItem {
RedPipeItem base;
int size;
-} PingPipeItem;
+} RedPingPipeItem;
-typedef struct MouseModePipeItem {
+typedef struct RedMouseModePipeItem {
RedPipeItem base;
int current_mode;
int is_client_mouse_allowed;
-} MouseModePipeItem;
+} RedMouseModePipeItem;
-typedef struct TokensPipeItem {
+typedef struct RedTokensPipeItem {
RedPipeItem base;
int tokens;
-} TokensPipeItem;
+} RedTokensPipeItem;
-typedef struct AgentDataPipeItem {
+typedef struct RedAgentDataPipeItem {
RedPipeItem base;
uint8_t* data;
size_t len;
spice_marshaller_item_free_func free_data;
void *opaque;
-} AgentDataPipeItem;
+} RedAgentDataPipeItem;
-typedef struct InitPipeItem {
+typedef struct RedInitPipeItem {
RedPipeItem base;
int connection_id;
int display_channels_hint;
@@ -115,27 +115,27 @@ typedef struct InitPipeItem {
int is_client_mouse_allowed;
int multi_media_time;
int ram_hint;
-} InitPipeItem;
+} RedInitPipeItem;
-typedef struct NamePipeItem {
+typedef struct RedNamePipeItem {
RedPipeItem base;
SpiceMsgMainName msg;
-} NamePipeItem;
+} RedNamePipeItem;
-typedef struct UuidPipeItem {
+typedef struct RedUuidPipeItem {
RedPipeItem base;
SpiceMsgMainUuid msg;
-} UuidPipeItem;
+} RedUuidPipeItem;
-typedef struct NotifyPipeItem {
+typedef struct RedNotifyPipeItem {
RedPipeItem base;
char *msg;
-} NotifyPipeItem;
+} RedNotifyPipeItem;
-typedef struct MultiMediaTimePipeItem {
+typedef struct RedMultiMediaTimePipeItem {
RedPipeItem base;
int time;
-} MultiMediaTimePipeItem;
+} RedMultiMediaTimePipeItem;
struct MainChannelClient {
RedChannelClient base;
@@ -223,29 +223,29 @@ typedef struct MainMouseModeItemInfo {
static RedPipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void *data, int num)
{
- MouseModePipeItem *item = spice_malloc(sizeof(MouseModePipeItem));
+ RedMouseModePipeItem *item = spice_malloc(sizeof(RedMouseModePipeItem));
MainMouseModeItemInfo *info = data;
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
item->current_mode = info->current_mode;
item->is_client_mouse_allowed = info->is_client_mouse_allowed;
return &item->base;
}
-static RedPipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
+static RedPipeItem *red_ping_item_new(MainChannelClient *mcc, int size)
{
- PingPipeItem *item = spice_malloc(sizeof(PingPipeItem));
+ RedPingPipeItem *item = spice_malloc(sizeof(RedPingPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_PING);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_PING);
item->size = size;
return &item->base;
}
static RedPipeItem *main_agent_tokens_item_new(RedChannelClient *rcc, uint32_t num_tokens)
{
- TokensPipeItem *item = spice_malloc(sizeof(TokensPipeItem));
+ RedTokensPipeItem *item = spice_malloc(sizeof(RedTokensPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
item->tokens = num_tokens;
return &item->base;
}
@@ -254,9 +254,9 @@ static RedPipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* dat
spice_marshaller_item_free_func free_data,
void *opaque)
{
- AgentDataPipeItem *item = spice_malloc(sizeof(AgentDataPipeItem));
+ RedAgentDataPipeItem *item = spice_malloc(sizeof(RedAgentDataPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
item->data = data;
item->len = len;
item->free_data = free_data;
@@ -269,9 +269,9 @@ static RedPipeItem *main_init_item_new(MainChannelClient *mcc,
int is_client_mouse_allowed, int multi_media_time,
int ram_hint)
{
- InitPipeItem *item = spice_malloc(sizeof(InitPipeItem));
+ RedInitPipeItem *item = spice_malloc(sizeof(RedInitPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_INIT);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_INIT);
item->connection_id = connection_id;
item->display_channels_hint = display_channels_hint;
item->current_mouse_mode = current_mouse_mode;
@@ -283,9 +283,9 @@ static RedPipeItem *main_init_item_new(MainChannelClient *mcc,
static RedPipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
{
- NamePipeItem *item = spice_malloc(sizeof(NamePipeItem) + strlen(name) + 1);
+ RedNamePipeItem *item = spice_malloc(sizeof(RedNamePipeItem) + strlen(name) + 1);
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NAME);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_NAME);
item->msg.name_len = strlen(name) + 1;
memcpy(&item->msg.name, name, item->msg.name_len);
@@ -294,9 +294,9 @@ static RedPipeItem *main_name_item_new(MainChannelClient *mcc, const char *name)
static RedPipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uuid[16])
{
- UuidPipeItem *item = spice_malloc(sizeof(UuidPipeItem));
+ RedUuidPipeItem *item = spice_malloc(sizeof(RedUuidPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_UUID);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_UUID);
memcpy(item->msg.uuid, uuid, sizeof(item->msg.uuid));
return &item->base;
@@ -304,10 +304,10 @@ static RedPipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t uui
static RedPipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int num)
{
- NotifyPipeItem *item = spice_malloc(sizeof(NotifyPipeItem));
+ RedNotifyPipeItem *item = spice_malloc(sizeof(RedNotifyPipeItem));
const char *msg = data;
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NOTIFY);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_NOTIFY);
item->msg = spice_strdup(msg);
return &item->base;
}
@@ -315,10 +315,10 @@ static RedPipeItem *main_notify_item_new(RedChannelClient *rcc, void *data, int
static RedPipeItem *main_multi_media_time_item_new(
RedChannelClient *rcc, void *data, int num)
{
- MultiMediaTimePipeItem *item, *info = data;
+ RedMultiMediaTimePipeItem *item, *info = data;
- item = spice_malloc(sizeof(MultiMediaTimePipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
+ item = spice_malloc(sizeof(RedMultiMediaTimePipeItem));
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
item->time = info->time;
return &item->base;
}
@@ -330,7 +330,7 @@ static void main_channel_push_channels(MainChannelClient *mcc)
"during migration");
return;
}
- red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST);
+ red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST);
}
static void main_channel_marshall_channels(RedChannelClient *rcc,
@@ -354,14 +354,14 @@ int main_channel_client_push_ping(MainChannelClient *mcc, int size)
if (mcc == NULL) {
return FALSE;
}
- item = main_ping_item_new(mcc, size);
+ item = red_ping_item_new(mcc, size);
red_channel_client_pipe_add_push(&mcc->base, item);
return TRUE;
}
static void main_channel_marshall_ping(RedChannelClient *rcc,
SpiceMarshaller *m,
- PingPipeItem *item)
+ RedPingPipeItem *item)
{
MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient, base);
SpiceMsgPing ping;
@@ -393,7 +393,7 @@ void main_channel_push_mouse_mode(MainChannel *main_chan, int current_mode,
static void main_channel_marshall_mouse_mode(RedChannelClient *rcc,
SpiceMarshaller *m,
- MouseModePipeItem *item)
+ RedMouseModePipeItem *item)
{
SpiceMsgMainMouseMode mouse_mode;
@@ -409,7 +409,7 @@ static void main_channel_marshall_mouse_mode(RedChannelClient *rcc,
void main_channel_push_agent_connected(MainChannel *main_chan)
{
if (red_channel_test_remote_cap(&main_chan->base, SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS)) {
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS);
+ red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS);
} else {
red_channel_pipes_add_empty_msg(&main_chan->base, SPICE_MSG_MAIN_AGENT_CONNECTED);
}
@@ -428,7 +428,7 @@ static void main_channel_marshall_agent_connected(SpiceMarshaller *m,
void main_channel_push_agent_disconnected(MainChannel *main_chan)
{
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED);
+ red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED);
}
static void main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
@@ -450,7 +450,7 @@ void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_
}
static void main_channel_marshall_tokens(RedChannelClient *rcc,
- SpiceMarshaller *m, TokensPipeItem *item)
+ SpiceMarshaller *m, RedTokensPipeItem *item)
{
SpiceMsgMainAgentTokens tokens;
@@ -470,7 +470,7 @@ void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data,
static void main_channel_marshall_agent_data(RedChannelClient *rcc,
SpiceMarshaller *m,
- AgentDataPipeItem *item)
+ RedAgentDataPipeItem *item)
{
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_AGENT_DATA, &item->base);
spice_marshaller_add_ref(m, item->data, item->len);
@@ -478,7 +478,7 @@ static void main_channel_marshall_agent_data(RedChannelClient *rcc,
static void main_channel_push_migrate_data_item(MainChannel *main_chan)
{
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA);
+ red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA);
}
static void main_channel_marshall_migrate_data_item(RedChannelClient *rcc,
@@ -526,9 +526,9 @@ void main_channel_push_init(MainChannelClient *mcc,
static void main_channel_marshall_init(RedChannelClient *rcc,
SpiceMarshaller *m,
- InitPipeItem *item)
+ RedInitPipeItem *item)
{
- SpiceMsgMainInit init; // TODO - remove this copy, make InitPipeItem reuse SpiceMsgMainInit
+ SpiceMsgMainInit init; // TODO - remove this copy, make RedInitPipeItem reuse SpiceMsgMainInit
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_INIT, &item->base);
@@ -577,7 +577,7 @@ void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg)
}
static void main_channel_marshall_notify(RedChannelClient *rcc,
- SpiceMarshaller *m, NotifyPipeItem *item)
+ SpiceMarshaller *m, RedNotifyPipeItem *item)
{
SpiceMsgNotify notify;
@@ -636,7 +636,7 @@ static void main_channel_marshall_migrate_begin_seamless(SpiceMarshaller *m,
void main_channel_push_multi_media_time(MainChannel *main_chan, int time)
{
- MultiMediaTimePipeItem info = {
+ RedMultiMediaTimePipeItem info = {
.time = time,
};
@@ -662,7 +662,7 @@ static void main_channel_fill_mig_target(MainChannel *main_channel, RedsMigSpice
void main_channel_migrate_switch(MainChannel *main_chan, RedsMigSpice *mig_target)
{
main_channel_fill_mig_target(main_chan, mig_target);
- red_channel_pipes_add_type(&main_chan->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
+ red_channel_pipes_add_type(&main_chan->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
}
static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelClient *rcc,
@@ -690,7 +690,7 @@ static void main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelC
static void main_channel_marshall_multi_media_time(RedChannelClient *rcc,
SpiceMarshaller *m,
- MultiMediaTimePipeItem *item)
+ RedMultiMediaTimePipeItem *item)
{
SpiceMsgMainMultiMediaTime time_mes;
@@ -708,7 +708,7 @@ static void main_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
* we ignore any pipe item that arrives before the INIT msg is sent.
* For seamless we don't send INIT, and the connection continues from the same place
* it stopped on the src side. */
- if (!mcc->init_sent && !mcc->seamless_mig_dst && base->type != PIPE_ITEM_TYPE_MAIN_INIT) {
+ if (!mcc->init_sent && !mcc->seamless_mig_dst && base->type != RED_PIPE_ITEM_TYPE_MAIN_INIT) {
spice_printerr("Init msg for client %p was not sent yet "
"(client is probably during semi-seamless migration). Ignoring msg type %d",
rcc->client, base->type);
@@ -716,65 +716,65 @@ static void main_channel_send_item(RedChannelClient *rcc, RedPipeItem *base)
return;
}
switch (base->type) {
- case PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST:
+ case RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST:
main_channel_marshall_channels(rcc, m, base);
break;
- case PIPE_ITEM_TYPE_MAIN_PING:
+ case RED_PIPE_ITEM_TYPE_MAIN_PING:
main_channel_marshall_ping(rcc, m,
- SPICE_CONTAINEROF(base, PingPipeItem, base));
+ SPICE_CONTAINEROF(base, RedPingPipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_MOUSE_MODE:
+ case RED_PIPE_ITEM_TYPE_MAIN_MOUSE_MODE:
{
- MouseModePipeItem *item =
- SPICE_CONTAINEROF(base, MouseModePipeItem, base);
+ RedMouseModePipeItem *item =
+ SPICE_CONTAINEROF(base, RedMouseModePipeItem, base);
main_channel_marshall_mouse_mode(rcc, m, item);
break;
}
- case PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED:
+ case RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED:
main_channel_marshall_agent_disconnected(rcc, m, base);
break;
- case PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN:
+ case RED_PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN:
main_channel_marshall_tokens(rcc, m,
- SPICE_CONTAINEROF(base, TokensPipeItem, base));
+ SPICE_CONTAINEROF(base, RedTokensPipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_AGENT_DATA:
+ case RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA:
main_channel_marshall_agent_data(rcc, m,
- SPICE_CONTAINEROF(base, AgentDataPipeItem, base));
+ SPICE_CONTAINEROF(base, RedAgentDataPipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA:
+ case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA:
main_channel_marshall_migrate_data_item(rcc, m, base);
break;
- case PIPE_ITEM_TYPE_MAIN_INIT:
+ case RED_PIPE_ITEM_TYPE_MAIN_INIT:
mcc->init_sent = TRUE;
main_channel_marshall_init(rcc, m,
- SPICE_CONTAINEROF(base, InitPipeItem, base));
+ SPICE_CONTAINEROF(base, RedInitPipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_NOTIFY:
+ case RED_PIPE_ITEM_TYPE_MAIN_NOTIFY:
main_channel_marshall_notify(rcc, m,
- SPICE_CONTAINEROF(base, NotifyPipeItem, base));
+ SPICE_CONTAINEROF(base, RedNotifyPipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN:
+ case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN:
main_channel_marshall_migrate_begin(m, rcc, base);
break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS:
+ case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS:
main_channel_marshall_migrate_begin_seamless(m, rcc, base);
break;
- case PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME:
+ case RED_PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME:
main_channel_marshall_multi_media_time(rcc, m,
- SPICE_CONTAINEROF(base, MultiMediaTimePipeItem, base));
+ SPICE_CONTAINEROF(base, RedMultiMediaTimePipeItem, base));
break;
- case PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST:
+ case RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST:
main_channel_marshall_migrate_switch(m, rcc, base);
break;
- case PIPE_ITEM_TYPE_MAIN_NAME:
+ case RED_PIPE_ITEM_TYPE_MAIN_NAME:
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_NAME, base);
- spice_marshall_msg_main_name(m, &SPICE_CONTAINEROF(base, NamePipeItem, base)->msg);
+ spice_marshall_msg_main_name(m, &SPICE_CONTAINEROF(base, RedNamePipeItem, base)->msg);
break;
- case PIPE_ITEM_TYPE_MAIN_UUID:
+ case RED_PIPE_ITEM_TYPE_MAIN_UUID:
red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_UUID, base);
- spice_marshall_msg_main_uuid(m, &SPICE_CONTAINEROF(base, UuidPipeItem, base)->msg);
+ spice_marshall_msg_main_uuid(m, &SPICE_CONTAINEROF(base, RedUuidPipeItem, base)->msg);
break;
- case PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS:
+ case RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS:
main_channel_marshall_agent_connected(m, rcc, base);
break;
default:
@@ -787,14 +787,14 @@ static void main_channel_release_pipe_item(RedChannelClient *rcc,
RedPipeItem *base, int item_pushed)
{
switch (base->type) {
- case PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
- AgentDataPipeItem *data = (AgentDataPipeItem *)base;
+ case RED_PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
+ RedAgentDataPipeItem *data = (RedAgentDataPipeItem *)base;
data->free_data(data->data, data->opaque);
break;
}
- case PIPE_ITEM_TYPE_MAIN_NOTIFY: {
- NotifyPipeItem *data = (NotifyPipeItem *)base;
+ case RED_PIPE_ITEM_TYPE_MAIN_NOTIFY: {
+ RedNotifyPipeItem *data = (RedNotifyPipeItem *)base;
free(data->msg);
break;
}
@@ -861,9 +861,9 @@ void main_channel_migrate_dst_complete(MainChannelClient *mcc)
if (mcc->mig_wait_prev_try_seamless) {
spice_assert(mcc->base.channel->clients_num == 1);
red_channel_client_pipe_add_type(&mcc->base,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
} else {
- red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
+ red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
}
mcc->mig_wait_connect = TRUE;
mcc->mig_wait_prev_complete = FALSE;
@@ -1211,7 +1211,7 @@ static int main_channel_connect_semi_seamless(MainChannel *main_channel)
mcc->mig_wait_prev_try_seamless = FALSE;
} else {
red_channel_client_pipe_add_type(&mcc->base,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
mcc->mig_wait_connect = TRUE;
}
mcc->mig_connect_ok = FALSE;
@@ -1238,7 +1238,7 @@ static int main_channel_connect_seamless(MainChannel *main_channel)
mcc->mig_wait_prev_try_seamless = TRUE;
} else {
red_channel_client_pipe_add_type(&mcc->base,
- PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
+ RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
mcc->mig_wait_connect = TRUE;
}
mcc->mig_connect_ok = FALSE;
@@ -1325,7 +1325,7 @@ int main_channel_migrate_src_complete(MainChannel *main_chan, int success)
} else {
if (success) {
spice_printerr("client %p SWITCH_HOST", mcc->base.client);
- red_channel_client_pipe_add_type(&mcc->base, PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
+ red_channel_client_pipe_add_type(&mcc->base, RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
}
}
mcc->mig_connect_ok = FALSE;
diff --git a/server/red-channel.c b/server/red-channel.c
index 834ddb7..d9aab01 100644
--- a/server/red-channel.c
+++ b/server/red-channel.c
@@ -44,10 +44,10 @@
#include "main-dispatcher.h"
#include "utils.h"
-typedef struct EmptyMsgPipeItem {
+typedef struct RedEmptyMsgPipeItem {
RedPipeItem base;
int msg;
-} EmptyMsgPipeItem;
+} RedEmptyMsgPipeItem;
#define PING_TEST_TIMEOUT_MS (MSEC_PER_SEC * 15)
#define PING_TEST_IDLE_NET_TIMEOUT_MS (MSEC_PER_SEC / 10)
@@ -477,7 +477,7 @@ static void red_channel_client_reset_send_data(RedChannelClient *rcc)
void red_channel_client_push_set_ack(RedChannelClient *rcc)
{
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SET_ACK);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_SET_ACK);
}
static void red_channel_client_send_set_ack(RedChannelClient *rcc)
@@ -512,7 +512,7 @@ static void red_channel_client_send_migrate(RedChannelClient *rcc)
static void red_channel_client_send_empty_msg(RedChannelClient *rcc, RedPipeItem *base)
{
- EmptyMsgPipeItem *msg_pipe_item = SPICE_CONTAINEROF(base, EmptyMsgPipeItem, base);
+ RedEmptyMsgPipeItem *msg_pipe_item = SPICE_CONTAINEROF(base, RedEmptyMsgPipeItem, base);
red_channel_client_init_send_data(rcc, msg_pipe_item->msg, NULL);
red_channel_client_begin_send_message(rcc);
@@ -562,16 +562,16 @@ static void red_channel_client_send_item(RedChannelClient *rcc, RedPipeItem *ite
spice_assert(red_channel_client_no_item_being_sent(rcc));
red_channel_client_reset_send_data(rcc);
switch (item->type) {
- case PIPE_ITEM_TYPE_SET_ACK:
+ case RED_PIPE_ITEM_TYPE_SET_ACK:
red_channel_client_send_set_ack(rcc);
break;
- case PIPE_ITEM_TYPE_MIGRATE:
+ case RED_PIPE_ITEM_TYPE_MIGRATE:
red_channel_client_send_migrate(rcc);
break;
- case PIPE_ITEM_TYPE_EMPTY_MSG:
+ case RED_PIPE_ITEM_TYPE_EMPTY_MSG:
red_channel_client_send_empty_msg(rcc, item);
break;
- case PIPE_ITEM_TYPE_PING:
+ case RED_PIPE_ITEM_TYPE_PING:
red_channel_client_send_ping(rcc);
break;
default:
@@ -584,10 +584,10 @@ static void red_channel_client_send_item(RedChannelClient *rcc, RedPipeItem *ite
static void red_channel_client_release_item(RedChannelClient *rcc, RedPipeItem *item, int item_pushed)
{
switch (item->type) {
- case PIPE_ITEM_TYPE_SET_ACK:
- case PIPE_ITEM_TYPE_EMPTY_MSG:
- case PIPE_ITEM_TYPE_MIGRATE:
- case PIPE_ITEM_TYPE_PING:
+ case RED_PIPE_ITEM_TYPE_SET_ACK:
+ case RED_PIPE_ITEM_TYPE_EMPTY_MSG:
+ case RED_PIPE_ITEM_TYPE_MIGRATE:
+ case RED_PIPE_ITEM_TYPE_PING:
free(item);
break;
default:
@@ -733,8 +733,8 @@ static void red_channel_client_push_ping(RedChannelClient *rcc)
rcc->latency_monitor.state = PING_STATE_WARMUP;
rcc->latency_monitor.warmup_was_sent = FALSE;
rcc->latency_monitor.id = rand();
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_PING);
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_PING);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_PING);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_PING);
}
static void red_channel_client_ping_timer(void *opaque)
@@ -1013,7 +1013,7 @@ void red_channel_client_default_migrate(RedChannelClient *rcc)
rcc->channel->core->timer_remove(rcc->connectivity_monitor.timer);
rcc->connectivity_monitor.timer = NULL;
}
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_MIGRATE);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_MIGRATE);
}
RedChannel *red_channel_create(int size,
@@ -1737,9 +1737,9 @@ void red_channel_pipes_add_type(RedChannel *channel, int pipe_item_type)
void red_channel_client_pipe_add_empty_msg(RedChannelClient *rcc, int msg_type)
{
- EmptyMsgPipeItem *item = spice_new(EmptyMsgPipeItem, 1);
+ RedEmptyMsgPipeItem *item = spice_new(RedEmptyMsgPipeItem, 1);
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_EMPTY_MSG);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_EMPTY_MSG);
item->msg = msg_type;
red_channel_client_pipe_add(rcc, &item->base);
red_channel_client_push(rcc);
diff --git a/server/red-channel.h b/server/red-channel.h
index be5ae99..d169a9a 100644
--- a/server/red-channel.h
+++ b/server/red-channel.h
@@ -140,12 +140,12 @@ typedef struct MainChannelClient MainChannelClient;
* but we keep the 100 first allocated for base channel approach.
* */
enum {
- PIPE_ITEM_TYPE_SET_ACK=1,
- PIPE_ITEM_TYPE_MIGRATE,
- PIPE_ITEM_TYPE_EMPTY_MSG,
- PIPE_ITEM_TYPE_PING,
+ RED_PIPE_ITEM_TYPE_SET_ACK=1,
+ RED_PIPE_ITEM_TYPE_MIGRATE,
+ RED_PIPE_ITEM_TYPE_EMPTY_MSG,
+ RED_PIPE_ITEM_TYPE_PING,
- PIPE_ITEM_TYPE_CHANNEL_BASE=101,
+ RED_PIPE_ITEM_TYPE_CHANNEL_BASE=101,
};
typedef uint8_t *(*channel_alloc_msg_recv_buf_proc)(RedChannelClient *channel,
diff --git a/server/red-worker.h b/server/red-worker.h
index 731afc7..d7525e0 100644
--- a/server/red-worker.h
+++ b/server/red-worker.h
@@ -50,27 +50,27 @@ typedef struct CommonGraphicsChannel {
#define COMMON_GRAPHICS_CHANNEL(Channel) ((CommonGraphicsChannel*)(Channel))
enum {
- PIPE_ITEM_TYPE_VERB = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_TYPE_INVAL_ONE,
+ RED_PIPE_ITEM_TYPE_VERB = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
+ RED_PIPE_ITEM_TYPE_INVAL_ONE,
- PIPE_ITEM_TYPE_COMMON_LAST
+ RED_PIPE_ITEM_TYPE_COMMON_LAST
};
-typedef struct VerbItem {
+typedef struct RedVerbItem {
RedPipeItem base;
uint16_t verb;
-} VerbItem;
+} RedVerbItem;
-static inline void red_marshall_verb(RedChannelClient *rcc, VerbItem *item)
+static inline void red_marshall_verb(RedChannelClient *rcc, RedVerbItem *item)
{
red_channel_client_init_send_data(rcc, item->verb, NULL);
}
static inline void red_pipe_add_verb(RedChannelClient* rcc, uint16_t verb)
{
- VerbItem *item = spice_new(VerbItem, 1);
+ RedVerbItem *item = spice_new(RedVerbItem, 1);
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_VERB);
item->verb = verb;
red_channel_client_pipe_add(rcc, &item->base);
}
diff --git a/server/reds.c b/server/reds.c
index 4a8caea..d89b04b 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -166,13 +166,13 @@ struct ChannelSecurityOptions {
ChannelSecurityOptions *next;
};
-typedef struct VDIReadBuf {
+typedef struct RedVDIReadBuf {
RedPipeItem parent;
RedCharDeviceVDIPort *dev;
int len;
uint8_t data[SPICE_AGENT_MAX_DATA_SIZE];
-} VDIReadBuf;
+} RedVDIReadBuf;
enum {
VDI_PORT_READ_STATE_READ_HEADER,
@@ -196,7 +196,7 @@ struct RedCharDeviceVDIPortPrivate {
uint32_t message_receive_len;
uint8_t *receive_pos;
uint32_t receive_len;
- VDIReadBuf *current_read_buf;
+ RedVDIReadBuf *current_read_buf;
AgentMsgFilter read_filter;
VDIChunkHeader vdi_chunk_header;
@@ -261,8 +261,8 @@ static void reds_set_mouse_mode(RedsState *reds, uint32_t mode);
static uint32_t reds_qxl_ram_size(RedsState *reds);
static int calc_compression_level(RedsState *reds);
-static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev);
-static void vdi_port_read_buf_free(VDIReadBuf *buf);
+static RedVDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev);
+static void vdi_port_read_buf_free(RedVDIReadBuf *buf);
static ChannelSecurityOptions *reds_find_channel_security(RedsState *reds, int id)
{
@@ -703,13 +703,14 @@ static void reds_agent_remove(RedsState *reds)
static void vdi_port_read_buf_release(uint8_t *data, void *opaque)
{
- VDIReadBuf *buf = (VDIReadBuf *)opaque;
+ RedVDIReadBuf *buf = (RedVDIReadBuf *)opaque;
red_pipe_item_unref(buf);
}
/* returns TRUE if the buffer can be forwarded */
-static gboolean vdi_port_read_buf_process(RedCharDeviceVDIPort *dev, VDIReadBuf *buf, gboolean *error)
+static gboolean vdi_port_read_buf_process(RedCharDeviceVDIPort *dev,
+ RedVDIReadBuf *buf, gboolean *error)
{
int res;
@@ -738,7 +739,7 @@ static gboolean vdi_port_read_buf_process(RedCharDeviceVDIPort *dev, VDIReadBuf
}
}
-static void vdi_read_buf_init(VDIReadBuf *buf)
+static void vdi_read_buf_init(RedVDIReadBuf *buf)
{
g_return_if_fail(buf != NULL);
/* Bogus pipe item type, we only need the RingItem and refcounting
@@ -748,17 +749,17 @@ static void vdi_read_buf_init(VDIReadBuf *buf)
(GDestroyNotify)vdi_port_read_buf_free);
}
-static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
+static RedVDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
{
RingItem *item;
- VDIReadBuf *buf;
+ RedVDIReadBuf *buf;
if (!(item = ring_get_head(&dev->priv->read_bufs))) {
return NULL;
}
ring_remove(item);
- buf = SPICE_CONTAINEROF(item, VDIReadBuf, parent.link);
+ buf = SPICE_CONTAINEROF(item, RedVDIReadBuf, parent.link);
g_warn_if_fail(buf->parent.refcount == 0);
vdi_read_buf_init(buf);
@@ -766,7 +767,7 @@ static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
return buf;
}
-static void vdi_port_read_buf_free(VDIReadBuf *buf)
+static void vdi_port_read_buf_free(RedVDIReadBuf *buf)
{
g_warn_if_fail(buf->parent.refcount == 0);
ring_add(&buf->dev->priv->read_bufs, (RingItem *)buf);
@@ -788,7 +789,7 @@ static RedPipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *s
RedsState *reds;
RedCharDeviceVDIPort *dev = RED_CHAR_DEVICE_VDIPORT(sin->st);
SpiceCharDeviceInterface *sif;
- VDIReadBuf *dispatch_buf;
+ RedVDIReadBuf *dispatch_buf;
int n;
g_object_get(dev, "spice-server", &reds, NULL);
@@ -861,7 +862,7 @@ static void vdi_port_send_msg_to_client(RedPipeItem *msg,
RedClient *client,
void *opaque)
{
- VDIReadBuf *agent_data_buf = (VDIReadBuf *)msg;
+ RedVDIReadBuf *agent_data_buf = (RedVDIReadBuf *)msg;
red_pipe_item_ref(agent_data_buf);
main_channel_client_push_agent_data(red_client_get_main(client),
@@ -1201,7 +1202,7 @@ void reds_on_main_channel_migrate(RedsState *reds, MainChannelClient *mcc)
if (agent_dev->priv->read_filter.msg_data_to_read ||
read_data_len > sizeof(VDAgentMessage)) { /* msg header has been read */
- VDIReadBuf *read_buf = agent_dev->priv->current_read_buf;
+ RedVDIReadBuf *read_buf = agent_dev->priv->current_read_buf;
gboolean error = FALSE;
spice_debug("push partial read %u (msg first chunk? %d)", read_data_len,
@@ -4297,7 +4298,7 @@ red_char_device_vdi_port_init(RedCharDeviceVDIPort *self)
self->priv->receive_len = sizeof(self->priv->vdi_chunk_header);
for (i = 0; i < REDS_VDI_PORT_NUM_RECEIVE_BUFFS; i++) {
- VDIReadBuf *buf = spice_new0(VDIReadBuf, 1);
+ RedVDIReadBuf *buf = spice_new0(RedVDIReadBuf, 1);
vdi_read_buf_init(buf);
buf->dev = self;
g_warn_if_fail(!self->priv->agent_attached);
@@ -4314,7 +4315,7 @@ red_char_device_vdi_port_finalize(GObject *object)
RedCharDeviceVDIPort *dev = RED_CHAR_DEVICE_VDIPORT(object);
free(dev->priv->mig_data);
- /* FIXME: need to free the VDIReadBuf allocated previously */
+ /* FIXME: need to free the RedVDIReadBuf allocated previously */
}
static void
diff --git a/server/smartcard.c b/server/smartcard.c
index 75c5dd2..a42bcd8 100644
--- a/server/smartcard.c
+++ b/server/smartcard.c
@@ -77,24 +77,24 @@ struct RedCharDeviceSmartcardPrivate {
};
enum {
- PIPE_ITEM_TYPE_ERROR = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_TYPE_SMARTCARD_DATA,
- PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA,
+ RED_PIPE_ITEM_TYPE_ERROR = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
+ RED_PIPE_ITEM_TYPE_SMARTCARD_DATA,
+ RED_PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA,
};
-typedef struct ErrorItem {
+typedef struct RedErrorItem {
RedPipeItem base;
VSCMsgHeader vheader;
VSCMsgError error;
-} ErrorItem;
+} RedErrorItem;
-typedef struct MsgItem {
+typedef struct RedMsgItem {
RedPipeItem base;
VSCMsgHeader* vheader;
-} MsgItem;
+} RedMsgItem;
-static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader);
+static RedMsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader);
static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem *item);
typedef struct SmartCardChannel {
@@ -113,7 +113,7 @@ static void smartcard_char_device_attach_client(
SpiceCharDeviceInstance *char_device, SmartCardChannelClient *scc);
static void smartcard_channel_write_to_reader(RedCharDeviceWriteBuffer *write_buf);
-static MsgItem *smartcard_char_device_on_message_from_device(
+static RedMsgItem *smartcard_char_device_on_message_from_device(
RedCharDeviceSmartcard *dev, VSCMsgHeader *header);
static RedCharDeviceSmartcard *smartcard_device_new(RedsState *reds, SpiceCharDeviceInstance *sin);
static void smartcard_init(RedsState *reds);
@@ -140,7 +140,7 @@ static RedPipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance *sin,
int actual_length;
while ((n = sif->read(sin, dev->priv->buf_pos, dev->priv->buf_size - dev->priv->buf_used)) > 0) {
- MsgItem *msg_to_client;
+ RedMsgItem *msg_to_client;
dev->priv->buf_pos += n;
dev->priv->buf_used += n;
@@ -190,8 +190,8 @@ static void smartcard_remove_client(RedClient *client, void *opaque)
red_channel_client_shutdown(&dev->priv->scc->base);
}
-MsgItem *smartcard_char_device_on_message_from_device(RedCharDeviceSmartcard *dev,
- VSCMsgHeader *vheader)
+RedMsgItem *smartcard_char_device_on_message_from_device(RedCharDeviceSmartcard *dev,
+ VSCMsgHeader *vheader)
{
VSCMsgHeader *sent_header;
@@ -441,7 +441,7 @@ static void smartcard_channel_send_data(RedChannelClient *rcc, SpiceMarshaller *
static void smartcard_channel_send_error(
RedChannelClient *rcc, SpiceMarshaller *m, RedPipeItem *item)
{
- ErrorItem* error_item = (ErrorItem*)item;
+ RedErrorItem* error_item = (RedErrorItem*)item;
smartcard_channel_send_data(rcc, m, item, &error_item->vheader);
}
@@ -449,7 +449,7 @@ static void smartcard_channel_send_error(
static void smartcard_channel_send_msg(RedChannelClient *rcc,
SpiceMarshaller *m, RedPipeItem *item)
{
- MsgItem* msg_item = (MsgItem*)item;
+ RedMsgItem* msg_item = (RedMsgItem*)item;
smartcard_channel_send_data(rcc, m, item, msg_item->vheader);
}
@@ -488,13 +488,13 @@ static void smartcard_channel_send_item(RedChannelClient *rcc, RedPipeItem *item
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
switch (item->type) {
- case PIPE_ITEM_TYPE_ERROR:
+ case RED_PIPE_ITEM_TYPE_ERROR:
smartcard_channel_send_error(rcc, m, item);
break;
- case PIPE_ITEM_TYPE_SMARTCARD_DATA:
+ case RED_PIPE_ITEM_TYPE_SMARTCARD_DATA:
smartcard_channel_send_msg(rcc, m, item);
break;
- case PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA:
+ case RED_PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA:
smartcard_channel_send_migrate_data(rcc, m, item);
break;
default:
@@ -508,7 +508,7 @@ static void smartcard_channel_send_item(RedChannelClient *rcc, RedPipeItem *item
static void smartcard_channel_release_pipe_item(RedChannelClient *rcc,
RedPipeItem *item, int item_pushed)
{
- if (item->type == PIPE_ITEM_TYPE_SMARTCARD_DATA) {
+ if (item->type == RED_PIPE_ITEM_TYPE_SMARTCARD_DATA) {
red_pipe_item_unref(item);
} else {
free(item);
@@ -538,11 +538,11 @@ static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc,
static void smartcard_push_error(RedChannelClient *rcc, uint32_t reader_id, VSCErrorCode error)
{
- ErrorItem *error_item = spice_new0(ErrorItem, 1);
+ RedErrorItem *error_item = spice_new0(RedErrorItem, 1);
- red_pipe_item_init(&error_item->base, PIPE_ITEM_TYPE_ERROR);
+ red_pipe_item_init(&error_item->base, RED_PIPE_ITEM_TYPE_ERROR);
- error_item->base.type = PIPE_ITEM_TYPE_ERROR;
+ error_item->base.type = RED_PIPE_ITEM_TYPE_ERROR;
error_item->vheader.reader_id = reader_id;
error_item->vheader.type = VSC_Error;
error_item->vheader.length = sizeof(error_item->error);
@@ -550,17 +550,18 @@ static void smartcard_push_error(RedChannelClient *rcc, uint32_t reader_id, VSCE
smartcard_channel_client_pipe_add_push(rcc, &error_item->base);
}
-static void smartcard_free_vsc_msg_item(MsgItem *item)
+static void smartcard_free_vsc_msg_item(RedMsgItem *item)
{
free(item->vheader);
free(item);
}
-static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *vheader)
+static RedMsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc,
+ VSCMsgHeader *vheader)
{
- MsgItem *msg_item = spice_new0(MsgItem, 1);
+ RedMsgItem *msg_item = spice_new0(RedMsgItem, 1);
- red_pipe_item_init_full(&msg_item->base, PIPE_ITEM_TYPE_SMARTCARD_DATA,
+ red_pipe_item_init_full(&msg_item->base, RED_PIPE_ITEM_TYPE_SMARTCARD_DATA,
(GDestroyNotify)smartcard_free_vsc_msg_item);
msg_item->vheader = vheader;
return msg_item;
@@ -635,7 +636,7 @@ static void smartcard_channel_write_to_reader(RedCharDeviceWriteBuffer *write_bu
static int smartcard_channel_client_handle_migrate_flush_mark(RedChannelClient *rcc)
{
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_SMARTCARD_MIGRATE_DATA);
return TRUE;
}
diff --git a/server/spicevmc.c b/server/spicevmc.c
index 3588b8d..7eb7ab9 100644
--- a/server/spicevmc.c
+++ b/server/spicevmc.c
@@ -42,20 +42,20 @@
/* 64K should be enough for all but the largest writes + 32 bytes hdr */
#define BUF_SIZE (64 * 1024 + 32)
-typedef struct SpiceVmcPipeItem {
+typedef struct RedVmcPipeItem {
RedPipeItem base;
/* writes which don't fit this will get split, this is not a problem */
uint8_t buf[BUF_SIZE];
uint32_t buf_used;
-} SpiceVmcPipeItem;
+} RedVmcPipeItem;
typedef struct SpiceVmcState {
RedChannel channel; /* Must be the first item */
RedChannelClient *rcc;
RedCharDevice *chardev;
SpiceCharDeviceInstance *chardev_sin;
- SpiceVmcPipeItem *pipe_item;
+ RedVmcPipeItem *pipe_item;
RedCharDeviceWriteBuffer *recv_from_client_buf;
uint8_t port_opened;
} SpiceVmcState;
@@ -87,22 +87,22 @@ static RedCharDevice *red_char_device_spicevmc_new(SpiceCharDeviceInstance *sin,
G_DEFINE_TYPE(RedCharDeviceSpiceVmc, red_char_device_spicevmc, RED_TYPE_CHAR_DEVICE)
-typedef struct PortInitPipeItem {
+typedef struct RedPortInitPipeItem {
RedPipeItem base;
char* name;
uint8_t opened;
-} PortInitPipeItem;
+} RedPortInitPipeItem;
-typedef struct PortEventPipeItem {
+typedef struct RedPortEventPipeItem {
RedPipeItem base;
uint8_t event;
-} PortEventPipeItem;
+} RedPortEventPipeItem;
enum {
- PIPE_ITEM_TYPE_SPICEVMC_DATA = PIPE_ITEM_TYPE_CHANNEL_BASE,
- PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA,
- PIPE_ITEM_TYPE_PORT_INIT,
- PIPE_ITEM_TYPE_PORT_EVENT,
+ RED_PIPE_ITEM_TYPE_SPICEVMC_DATA = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
+ RED_PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA,
+ RED_PIPE_ITEM_TYPE_PORT_INIT,
+ RED_PIPE_ITEM_TYPE_PORT_EVENT,
};
static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin,
@@ -110,7 +110,7 @@ static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *
{
SpiceVmcState *state = opaque;
SpiceCharDeviceInterface *sif;
- SpiceVmcPipeItem *msg_item;
+ RedVmcPipeItem *msg_item;
int n;
sif = spice_char_device_get_interface(sin);
@@ -120,8 +120,8 @@ static RedPipeItem *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *
}
if (!state->pipe_item) {
- msg_item = spice_new0(SpiceVmcPipeItem, 1);
- red_pipe_item_init_full(&msg_item->base, PIPE_ITEM_TYPE_SPICEVMC_DATA, free);
+ msg_item = spice_new0(RedVmcPipeItem, 1);
+ red_pipe_item_init_full(&msg_item->base, RED_PIPE_ITEM_TYPE_SPICEVMC_DATA, free);
} else {
spice_assert(state->pipe_item->buf_used == 0);
msg_item = state->pipe_item;
@@ -145,7 +145,7 @@ static void spicevmc_chardev_send_msg_to_client(RedPipeItem *msg,
void *opaque)
{
SpiceVmcState *state = opaque;
- SpiceVmcPipeItem *vmc_msg = (SpiceVmcPipeItem *)msg;
+ RedVmcPipeItem *vmc_msg = (RedVmcPipeItem *)msg;
spice_assert(state->rcc->client == client);
red_pipe_item_ref(vmc_msg);
@@ -156,9 +156,9 @@ static void spicevmc_port_send_init(RedChannelClient *rcc)
{
SpiceVmcState *state = SPICE_CONTAINEROF(rcc->channel, SpiceVmcState, channel);
SpiceCharDeviceInstance *sin = state->chardev_sin;
- PortInitPipeItem *item = spice_malloc(sizeof(PortInitPipeItem));
+ RedPortInitPipeItem *item = spice_malloc(sizeof(RedPortInitPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_INIT);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_PORT_INIT);
item->name = strdup(sin->portname);
item->opened = state->port_opened;
red_channel_client_pipe_add_push(rcc, &item->base);
@@ -166,9 +166,9 @@ static void spicevmc_port_send_init(RedChannelClient *rcc)
static void spicevmc_port_send_event(RedChannelClient *rcc, uint8_t event)
{
- PortEventPipeItem *item = spice_malloc(sizeof(PortEventPipeItem));
+ RedPortEventPipeItem *item = spice_malloc(sizeof(RedPortEventPipeItem));
- red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_EVENT);
+ red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_PORT_EVENT);
item->event = event;
red_channel_client_pipe_add_push(rcc, &item->base);
}
@@ -252,7 +252,7 @@ static SpiceVmcState *spicevmc_red_channel_client_get_state(RedChannelClient *rc
static int spicevmc_channel_client_handle_migrate_flush_mark(RedChannelClient *rcc)
{
- red_channel_client_pipe_add_type(rcc, PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA);
+ red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA);
return TRUE;
}
@@ -369,7 +369,7 @@ static void spicevmc_red_channel_send_data(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
- SpiceVmcPipeItem *i = SPICE_CONTAINEROF(item, SpiceVmcPipeItem, base);
+ RedVmcPipeItem *i = SPICE_CONTAINEROF(item, RedVmcPipeItem, base);
red_channel_client_init_send_data(rcc, SPICE_MSG_SPICEVMC_DATA, item);
spice_marshaller_add_ref(m, i->buf, i->buf_used);
@@ -393,7 +393,7 @@ static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
- PortInitPipeItem *i = SPICE_CONTAINEROF(item, PortInitPipeItem, base);
+ RedPortInitPipeItem *i = SPICE_CONTAINEROF(item, RedPortInitPipeItem, base);
SpiceMsgPortInit init;
red_channel_client_init_send_data(rcc, SPICE_MSG_PORT_INIT, item);
@@ -407,7 +407,7 @@ static void spicevmc_red_channel_send_port_event(RedChannelClient *rcc,
SpiceMarshaller *m,
RedPipeItem *item)
{
- PortEventPipeItem *i = SPICE_CONTAINEROF(item, PortEventPipeItem, base);
+ RedPortEventPipeItem *i = SPICE_CONTAINEROF(item, RedPortEventPipeItem, base);
SpiceMsgPortEvent event;
red_channel_client_init_send_data(rcc, SPICE_MSG_PORT_EVENT, item);
@@ -421,16 +421,16 @@ static void spicevmc_red_channel_send_item(RedChannelClient *rcc,
SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
switch (item->type) {
- case PIPE_ITEM_TYPE_SPICEVMC_DATA:
+ case RED_PIPE_ITEM_TYPE_SPICEVMC_DATA:
spicevmc_red_channel_send_data(rcc, m, item);
break;
- case PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA:
+ case RED_PIPE_ITEM_TYPE_SPICEVMC_MIGRATE_DATA:
spicevmc_red_channel_send_migrate_data(rcc, m, item);
break;
- case PIPE_ITEM_TYPE_PORT_INIT:
+ case RED_PIPE_ITEM_TYPE_PORT_INIT:
spicevmc_red_channel_send_port_init(rcc, m, item);
break;
- case PIPE_ITEM_TYPE_PORT_EVENT:
+ case RED_PIPE_ITEM_TYPE_PORT_EVENT:
spicevmc_red_channel_send_port_event(rcc, m, item);
break;
default:
@@ -445,7 +445,7 @@ static void spicevmc_red_channel_release_pipe_item(RedChannelClient *rcc,
RedPipeItem *item,
int item_pushed)
{
- if (item->type == PIPE_ITEM_TYPE_SPICEVMC_DATA) {
+ if (item->type == RED_PIPE_ITEM_TYPE_SPICEVMC_DATA) {
red_pipe_item_unref(item);
} else {
free(item);
diff --git a/server/stream.c b/server/stream.c
index cc9f47b..c042b5a 100644
--- a/server/stream.c
+++ b/server/stream.c
@@ -133,7 +133,7 @@ void stream_agent_unref(DisplayChannel *display, StreamAgent *agent)
stream_unref(display, agent->stream);
}
-void stream_clip_item_free(StreamClipItem *item)
+void red_stream_clip_item_free(RedStreamClipItem *item)
{
g_return_if_fail(item != NULL);
DisplayChannel *display = DCC_TO_DC(item->stream_agent->dcc);
@@ -145,11 +145,11 @@ void stream_clip_item_free(StreamClipItem *item)
free(item);
}
-StreamClipItem *stream_clip_item_new(StreamAgent *agent)
+RedStreamClipItem *red_stream_clip_item_new(StreamAgent *agent)
{
- StreamClipItem *item = spice_new(StreamClipItem, 1);
- red_pipe_item_init_full((RedPipeItem *)item, PIPE_ITEM_TYPE_STREAM_CLIP,
- (GDestroyNotify)stream_clip_item_free);
+ RedStreamClipItem *item = spice_new(RedStreamClipItem, 1);
+ red_pipe_item_init_full((RedPipeItem *)item, RED_PIPE_ITEM_TYPE_STREAM_CLIP,
+ (GDestroyNotify)red_stream_clip_item_free);
item->stream_agent = agent;
agent->stream->refs++;
@@ -316,7 +316,7 @@ void detach_stream(DisplayChannel *display, Stream *stream,
static void before_reattach_stream(DisplayChannel *display,
Stream *stream, Drawable *new_frame)
{
- DrawablePipeItem *dpi;
+ RedDrawablePipeItem *dpi;
DisplayChannelClient *dcc;
int index;
StreamAgent *agent;
@@ -731,11 +731,11 @@ void dcc_create_stream(DisplayChannelClient *dcc, Stream *stream)
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &agent->create_item);
if (red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc), SPICE_DISPLAY_CAP_STREAM_REPORT)) {
- StreamActivateReportItem *report_pipe_item = spice_malloc0(sizeof(*report_pipe_item));
+ RedStreamActivateReportItem *report_pipe_item = spice_malloc0(sizeof(*report_pipe_item));
agent->report_id = rand();
red_pipe_item_init(&report_pipe_item->pipe_item,
- PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
+ RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
report_pipe_item->stream_id = get_stream_id(DCC_TO_DC(dcc), stream);
red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &report_pipe_item->pipe_item);
}
@@ -758,7 +758,7 @@ void stream_agent_stop(StreamAgent *agent)
}
}
-static void upgrade_item_free(UpgradeItem *item)
+static void red_upgrade_item_free(RedUpgradeItem *item)
{
g_return_if_fail(item != NULL);
DisplayChannel *display = DCC_TO_DC(item->dcc);
@@ -793,7 +793,7 @@ static void dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
if (stream->current &&
region_contains(&stream->current->tree_item.base.rgn, &agent->vis_region)) {
RedChannelClient *rcc;
- UpgradeItem *upgrade_item;
+ RedUpgradeItem *upgrade_item;
int n_rects;
/* (1) The caller should detach the drawable from the stream. This will
@@ -808,9 +808,9 @@ static void dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
stream_id, stream->current->sized_stream != NULL);
rect_debug(&stream->current->red_drawable->bbox);
rcc = RED_CHANNEL_CLIENT(dcc);
- upgrade_item = spice_new(UpgradeItem, 1);
- red_pipe_item_init_full(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE,
- (GDestroyNotify)upgrade_item_free);
+ upgrade_item = spice_new(RedUpgradeItem, 1);
+ red_pipe_item_init_full(&upgrade_item->base, RED_PIPE_ITEM_TYPE_UPGRADE,
+ (GDestroyNotify)red_upgrade_item_free);
upgrade_item->drawable = stream->current;
upgrade_item->drawable->refs++;
upgrade_item->dcc = dcc;
diff --git a/server/stream.h b/server/stream.h
index 5b59212..bff7ca7 100644
--- a/server/stream.h
+++ b/server/stream.h
@@ -46,10 +46,10 @@ typedef struct DisplayChannel DisplayChannel;
typedef struct Stream Stream;
-typedef struct StreamActivateReportItem {
+typedef struct RedStreamActivateReportItem {
RedPipeItem pipe_item;
uint32_t stream_id;
-} StreamActivateReportItem;
+} RedStreamActivateReportItem;
enum {
STREAM_FRAME_NONE,
@@ -99,14 +99,14 @@ typedef struct StreamAgent {
#endif
} StreamAgent;
-typedef struct StreamClipItem {
+typedef struct RedStreamClipItem {
RedPipeItem base;
StreamAgent *stream_agent;
int clip_type;
SpiceClipRects *rects;
-} StreamClipItem;
+} RedStreamClipItem;
-StreamClipItem * stream_clip_item_new (StreamAgent *agent);
+RedStreamClipItem * red_stream_clip_item_new (StreamAgent *agent);
typedef struct ItemTrace {
red_time_t time;
--
2.4.11
_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel