From 505f7d8832a961d44ca2bb477c36d5bf8c4e1e7b Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Tue, 9 Mar 2010 14:29:51 +0100 Subject: new libspice api: make image_compression_t part of the public api. --- server/red_common.h | 11 +---------- server/red_dispatcher.c | 7 ++++--- server/red_worker.c | 47 +++++++++++++++++++++++++---------------------- server/red_worker.h | 2 +- server/reds.c | 40 ++++++++++++++++++++-------------------- server/spice.h | 10 ++++++++++ 6 files changed, 61 insertions(+), 56 deletions(-) (limited to 'server') diff --git a/server/red_common.h b/server/red_common.h index 4a847483..7f6fdbc4 100644 --- a/server/red_common.h +++ b/server/red_common.h @@ -21,6 +21,7 @@ #include #include +#include "spice.h" #include #include @@ -62,16 +63,6 @@ } \ } -typedef enum { - IMAGE_COMPRESS_INVALID, - IMAGE_COMPRESS_AUTO_GLZ, - IMAGE_COMPRESS_AUTO_LZ, - IMAGE_COMPRESS_QUIC, - IMAGE_COMPRESS_GLZ, - IMAGE_COMPRESS_LZ, - IMAGE_COMPRESS_OFF, -} image_compression_t; - enum { STREAM_VIDEO_INVALID, STREAM_VIDEO_OFF, diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c index 27274c8c..2eb510b7 100644 --- a/server/red_dispatcher.c +++ b/server/red_dispatcher.c @@ -62,7 +62,7 @@ typedef struct RedWorkeState { } RedWorkeState; extern uint32_t streaming_video; -extern image_compression_t image_compression; +extern spice_image_compression_t image_compression; static RedDispatcher *dispatchers = NULL; @@ -388,7 +388,8 @@ void red_dispatcher_set_mm_time(uint32_t mm_time) static inline int calc_compression_level() { ASSERT(streaming_video != STREAM_VIDEO_INVALID); - if ((streaming_video != STREAM_VIDEO_OFF) || (image_compression != IMAGE_COMPRESS_QUIC)) { + if ((streaming_video != STREAM_VIDEO_OFF) || + (image_compression != SPICE_IMAGE_COMPRESS_QUIC)) { return 0; } else { return 1; @@ -403,7 +404,7 @@ void red_dispatcher_on_ic_change() RedWorkeMessage message = RED_WORKER_MESSAGE_SET_COMPRESSION; now->qxl_interface->set_compression_level(now->qxl_interface, compression_level); write_message(now->channel, &message); - send_data(now->channel, &image_compression, sizeof(image_compression_t)); + send_data(now->channel, &image_compression, sizeof(spice_image_compression_t)); now = now->next; } } diff --git a/server/red_worker.c b/server/red_worker.c index 59374d0b..640aa158 100644 --- a/server/red_worker.c +++ b/server/red_worker.c @@ -934,7 +934,7 @@ typedef struct RedWorker { ImageCache image_cache; - image_compression_t image_compression; + spice_image_compression_t image_compression; uint32_t mouse_mode; @@ -5874,13 +5874,14 @@ static inline int red_compress_image(DisplayChannel *display_channel, RedImage *dest, SpiceBitmap *src, Drawable *drawable, compress_send_data_t* o_comp_data) { - image_compression_t image_compression = display_channel->base.worker->image_compression; + spice_image_compression_t image_compression = + display_channel->base.worker->image_compression; int quic_compress = FALSE; - if ((image_compression == IMAGE_COMPRESS_OFF) || + if ((image_compression == SPICE_IMAGE_COMPRESS_OFF) || ((src->y * src->stride) < MIN_SIZE_TO_COMPRESS)) { // TODO: change the size cond return FALSE; - } else if (image_compression == IMAGE_COMPRESS_QUIC) { + } else if (image_compression == SPICE_IMAGE_COMPRESS_QUIC) { if (BITMAP_FMT_IS_PLT[src->format]) { return FALSE; } else { @@ -5892,16 +5893,16 @@ static inline int red_compress_image(DisplayChannel *display_channel, of the image in bytes (2) unstable bitmaps */ if (_stride_is_extra(src) || (src->flags & QXL_BITMAP_UNSTABLE)) { - if ((image_compression == IMAGE_COMPRESS_LZ) || - (image_compression == IMAGE_COMPRESS_GLZ) || + if ((image_compression == SPICE_IMAGE_COMPRESS_LZ) || + (image_compression == SPICE_IMAGE_COMPRESS_GLZ) || BITMAP_FMT_IS_PLT[src->format]) { return FALSE; } else { quic_compress = TRUE; } } else { - if ((image_compression == IMAGE_COMPRESS_AUTO_LZ) || - (image_compression == IMAGE_COMPRESS_AUTO_GLZ)) { + if ((image_compression == SPICE_IMAGE_COMPRESS_AUTO_LZ) || + (image_compression == SPICE_IMAGE_COMPRESS_AUTO_GLZ)) { if ((src->x < MIN_DIMENSION_TO_QUIC) || (src->y < MIN_DIMENSION_TO_QUIC)) { quic_compress = FALSE; } else { @@ -5927,13 +5928,13 @@ static inline int red_compress_image(DisplayChannel *display_channel, } else { int glz; int ret; - if ((image_compression == IMAGE_COMPRESS_AUTO_GLZ) || - (image_compression == IMAGE_COMPRESS_GLZ)) { + if ((image_compression == SPICE_IMAGE_COMPRESS_AUTO_GLZ) || + (image_compression == SPICE_IMAGE_COMPRESS_GLZ)) { glz = BITMAP_FMT_IS_RGB[src->format] && ( (src->x * src->y) < glz_enc_dictionary_get_size( display_channel->glz_dict->dict)); - } else if ((image_compression == IMAGE_COMPRESS_AUTO_LZ) || - (image_compression == IMAGE_COMPRESS_LZ)) { + } else if ((image_compression == SPICE_IMAGE_COMPRESS_AUTO_LZ) || + (image_compression == SPICE_IMAGE_COMPRESS_LZ)) { glz = FALSE; } else { red_error("invalid image compression type %u", image_compression); @@ -6090,9 +6091,10 @@ static void fill_brush(DisplayChannel *display_channel, SpiceBrush *brush, Drawa static void fill_mask(DisplayChannel *display_channel, SpiceQMask *mask, Drawable *drawable) { if (mask->bitmap) { - if (display_channel->base.worker->image_compression != IMAGE_COMPRESS_OFF) { - image_compression_t save_img_comp = display_channel->base.worker->image_compression; - display_channel->base.worker->image_compression = IMAGE_COMPRESS_OFF; + if (display_channel->base.worker->image_compression != SPICE_IMAGE_COMPRESS_OFF) { + spice_image_compression_t save_img_comp = + display_channel->base.worker->image_compression; + display_channel->base.worker->image_compression = SPICE_IMAGE_COMPRESS_OFF; fill_bits(display_channel, &mask->bitmap, drawable); display_channel->base.worker->image_compression = save_img_comp; } else { @@ -8836,24 +8838,25 @@ static void handle_dev_input(EventListener *listener, uint32_t events) red_migrate_cursor(worker); break; case RED_WORKER_MESSAGE_SET_COMPRESSION: - receive_data(worker->channel, &worker->image_compression, sizeof(image_compression_t)); + receive_data(worker->channel, &worker->image_compression, + sizeof(spice_image_compression_t)); switch (worker->image_compression) { - case IMAGE_COMPRESS_AUTO_LZ: + case SPICE_IMAGE_COMPRESS_AUTO_LZ: red_printf("ic auto_lz"); break; - case IMAGE_COMPRESS_AUTO_GLZ: + case SPICE_IMAGE_COMPRESS_AUTO_GLZ: red_printf("ic auto_glz"); break; - case IMAGE_COMPRESS_QUIC: + case SPICE_IMAGE_COMPRESS_QUIC: red_printf("ic quic"); break; - case IMAGE_COMPRESS_LZ: + case SPICE_IMAGE_COMPRESS_LZ: red_printf("ic lz"); break; - case IMAGE_COMPRESS_GLZ: + case SPICE_IMAGE_COMPRESS_GLZ: red_printf("ic glz"); break; - case IMAGE_COMPRESS_OFF: + case SPICE_IMAGE_COMPRESS_OFF: red_printf("ic off"); break; default: diff --git a/server/red_worker.h b/server/red_worker.h index 765b7d86..141caee3 100644 --- a/server/red_worker.h +++ b/server/red_worker.h @@ -89,7 +89,7 @@ typedef struct WorkerInitData { uint32_t *pending; uint32_t num_renderers; uint32_t renderers[RED_MAX_RENDERERS]; - image_compression_t image_compression; + spice_image_compression_t image_compression; int streaming_video; uint32_t num_memslots; uint32_t num_memslots_groups; diff --git a/server/reds.c b/server/reds.c index e9f6fc44..68718244 100644 --- a/server/reds.c +++ b/server/reds.c @@ -84,7 +84,7 @@ static int ticketing_enabled = 1; //Ticketing is enabled by default static pthread_mutex_t *lock_cs; static long *lock_count; uint32_t streaming_video = STREAM_VIDEO_FILTER; -image_compression_t image_compression = IMAGE_COMPRESS_AUTO_GLZ; +spice_image_compression_t image_compression = SPICE_IMAGE_COMPRESS_AUTO_GLZ; void *red_tunnel = NULL; int agent_mouse = TRUE; @@ -3606,25 +3606,25 @@ static void reds_do_info_spice() } core->term_printf(core, " ticketing=%s", ticketing_enabled ? "on" : "off"); switch (image_compression) { - case IMAGE_COMPRESS_AUTO_GLZ: + case SPICE_IMAGE_COMPRESS_AUTO_GLZ: core->term_printf(core, " ic=auto_glz"); break; - case IMAGE_COMPRESS_AUTO_LZ: + case SPICE_IMAGE_COMPRESS_AUTO_LZ: core->term_printf(core, " ic=auto_lz"); break; - case IMAGE_COMPRESS_QUIC: + case SPICE_IMAGE_COMPRESS_QUIC: core->term_printf(core, " ic=quic"); break; - case IMAGE_COMPRESS_LZ: + case SPICE_IMAGE_COMPRESS_LZ: core->term_printf(core, " ic=lz"); break; - case IMAGE_COMPRESS_GLZ: + case SPICE_IMAGE_COMPRESS_GLZ: core->term_printf(core, " ic=glz"); break; - case IMAGE_COMPRESS_OFF: + case SPICE_IMAGE_COMPRESS_OFF: core->term_printf(core, " ic=off"); break; - case IMAGE_COMPRESS_INVALID: + case SPICE_IMAGE_COMPRESS_INVALID: default: core->term_printf(core, " ic=invalid"); } @@ -3648,7 +3648,7 @@ static void reds_do_info_spice() snd_get_playback_compression() ? "on" : "off"); } -static void set_image_compression(image_compression_t val) +static void set_image_compression(spice_image_compression_t val) { if (val == image_compression) { return; @@ -3657,28 +3657,28 @@ static void set_image_compression(image_compression_t val) red_dispatcher_on_ic_change(); } -static image_compression_t reds_get_image_compression(const char *val) +static spice_image_compression_t reds_get_image_compression(const char *val) { if ((strcmp(val, "on") == 0) || (strcmp(val, "auto_glz") == 0)) { - return IMAGE_COMPRESS_AUTO_GLZ; + return SPICE_IMAGE_COMPRESS_AUTO_GLZ; } else if (strcmp(val, "auto_lz") == 0) { - return IMAGE_COMPRESS_AUTO_LZ; + return SPICE_IMAGE_COMPRESS_AUTO_LZ; } else if (strcmp(val, "quic") == 0) { - return IMAGE_COMPRESS_QUIC; + return SPICE_IMAGE_COMPRESS_QUIC; } else if (strcmp(val, "glz") == 0) { - return IMAGE_COMPRESS_GLZ; + return SPICE_IMAGE_COMPRESS_GLZ; } else if (strcmp(val, "lz") == 0) { - return IMAGE_COMPRESS_LZ; + return SPICE_IMAGE_COMPRESS_LZ; } else if (strcmp(val, "off") == 0) { - return IMAGE_COMPRESS_OFF; + return SPICE_IMAGE_COMPRESS_OFF; } - return IMAGE_COMPRESS_INVALID; + return SPICE_IMAGE_COMPRESS_INVALID; } static void reds_do_set_image_compression(const char *val) { - image_compression_t real_val = reds_get_image_compression(val); - if (real_val == IMAGE_COMPRESS_INVALID) { + spice_image_compression_t real_val = reds_get_image_compression(val); + if (real_val == SPICE_IMAGE_COMPRESS_INVALID) { core->term_printf(core, "bad image compression arg\n"); return; } @@ -3990,7 +3990,7 @@ int __attribute__ ((visibility ("default"))) spice_parse_args(const char *in_arg goto error; } image_compression = reds_get_image_compression(val); - if (image_compression == IMAGE_COMPRESS_INVALID) { + if (image_compression == SPICE_IMAGE_COMPRESS_INVALID) { goto error; } break; diff --git a/server/spice.h b/server/spice.h index be0df427..39fadc96 100644 --- a/server/spice.h +++ b/server/spice.h @@ -49,4 +49,14 @@ int spice_server_add_interface(SpiceServer *s, VDInterface *interface); int spice_server_remove_interface(SpiceServer *s, VDInterface *interface); int spice_server_kbd_leds(SpiceServer *s, KeyboardInterface *kbd, int leds); +typedef enum { + SPICE_IMAGE_COMPRESS_INVALID = 0, + SPICE_IMAGE_COMPRESS_OFF = 1, + SPICE_IMAGE_COMPRESS_AUTO_GLZ = 2, + SPICE_IMAGE_COMPRESS_AUTO_LZ = 3, + SPICE_IMAGE_COMPRESS_QUIC = 4, + SPICE_IMAGE_COMPRESS_GLZ = 5, + SPICE_IMAGE_COMPRESS_LZ = 6, +} spice_image_compression_t; + #endif -- cgit