[Spice-commits] 3 commits - server/dcc.c server/display-channel.c server/display-channel.h
Frediano Ziglio
fziglio at kemper.freedesktop.org
Wed Feb 17 08:57:49 UTC 2016
server/dcc.c | 241 ++++++++++++++++++++++++++++-------------------
server/display-channel.c | 11 ++
server/display-channel.h | 1
3 files changed, 156 insertions(+), 97 deletions(-)
New commits:
commit af3aa4b1f459f6c92d06e8388ea52629e80e8df5
Author: Pavel Grunt <pgrunt at redhat.com>
Date: Mon Feb 15 13:57:59 2016 +0100
compress-stat: Add not compressed image to statistics
To see how many images and data could not be compressed.
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/dcc.c b/server/dcc.c
index 8d49bc8..196ddb7 100644
--- a/server/dcc.c
+++ b/server/dcc.c
@@ -1192,29 +1192,35 @@ int dcc_compress_image(DisplayChannelClient *dcc,
{
DisplayChannel *display_channel = DCC_TO_DC(dcc);
SpiceImageCompression image_compression;
+ stat_start_time_t start_time;
+ int success = FALSE;
+
+ stat_start_time_init(&start_time, &display_channel->off_stat);
image_compression = get_compression_for_bitmap(src, dcc->image_compression, drawable);
switch (image_compression) {
case SPICE_IMAGE_COMPRESSION_OFF:
- return FALSE;
+ break;
case SPICE_IMAGE_COMPRESSION_QUIC:
if (can_lossy && display_channel->enable_jpeg &&
(src->format != SPICE_BITMAP_FMT_RGBA || !bitmap_has_extra_stride(src))) {
- return dcc_compress_image_jpeg(dcc, dest, src, o_comp_data);
+ success = dcc_compress_image_jpeg(dcc, dest, src, o_comp_data);
+ break;
}
- return dcc_compress_image_quic(dcc, dest, src, o_comp_data);
+ success = dcc_compress_image_quic(dcc, dest, src, o_comp_data);
+ break;
case SPICE_IMAGE_COMPRESSION_GLZ:
if ((src->x * src->y) < glz_enc_dictionary_get_size(dcc->glz_dict->dict)) {
- int ret, frozen;
+ int frozen;
/* using the global dictionary only if it is not frozen */
pthread_rwlock_rdlock(&dcc->glz_dict->encode_lock);
frozen = dcc->glz_dict->migrate_freeze;
if (!frozen) {
- ret = dcc_compress_image_glz(dcc, dest, src, drawable, o_comp_data);
+ success = dcc_compress_image_glz(dcc, dest, src, drawable, o_comp_data);
}
pthread_rwlock_unlock(&dcc->glz_dict->encode_lock);
if (!frozen) {
- return ret;
+ break;
}
}
goto lz_compress;
@@ -1222,16 +1228,24 @@ int dcc_compress_image(DisplayChannelClient *dcc,
case SPICE_IMAGE_COMPRESSION_LZ4:
if (red_channel_client_test_remote_cap(&dcc->common.base,
SPICE_DISPLAY_CAP_LZ4_COMPRESSION)) {
- return dcc_compress_image_lz4(dcc, dest, src, o_comp_data);
+ success = dcc_compress_image_lz4(dcc, dest, src, o_comp_data);
+ break;
}
#endif
lz_compress:
case SPICE_IMAGE_COMPRESSION_LZ:
- return dcc_compress_image_lz(dcc, dest, src, o_comp_data);
+ success = dcc_compress_image_lz(dcc, dest, src, o_comp_data);
+ break;
default:
spice_error("invalid image compression type %u", image_compression);
}
- return FALSE;
+
+ if (!success) {
+ uint64_t image_size = src->stride * src->y;
+ stat_compress_add(&display_channel->off_stat, start_time, image_size, image_size);
+ }
+
+ return success;
}
#define CLIENT_PALETTE_CACHE
diff --git a/server/display-channel.c b/server/display-channel.c
index 82dbe03..3b5e169 100644
--- a/server/display-channel.c
+++ b/server/display-channel.c
@@ -36,6 +36,7 @@ void display_channel_compress_stats_reset(DisplayChannel *display)
{
spice_return_if_fail(display);
+ stat_reset(&display->off_stat);
stat_reset(&display->quic_stat);
stat_reset(&display->lz_stat);
stat_reset(&display->glz_stat);
@@ -58,6 +59,12 @@ void display_channel_compress_stats_print(const DisplayChannel *display_channel)
spice_info("==> Compression stats for display %u", display_channel->common.base.id);
spice_info("Method \t count \torig_size(MB)\tenc_size(MB)\tenc_time(s)");
+ spice_info("OFF \t%8d\t%13.2f\t%12.2f\t%12.2f",
+ display_channel->off_stat.count,
+ stat_byte_to_mega(display_channel->off_stat.orig_size),
+ stat_byte_to_mega(display_channel->off_stat.comp_size),
+ stat_cpu_time_to_sec(display_channel->off_stat.total)
+ );
spice_info("QUIC \t%8d\t%13.2f\t%12.2f\t%12.2f",
display_channel->quic_stat.count,
stat_byte_to_mega(display_channel->quic_stat.orig_size),
@@ -103,18 +110,21 @@ void display_channel_compress_stats_print(const DisplayChannel *display_channel)
spice_info("-------------------------------------------------------------------");
spice_info("Total \t%8d\t%13.2f\t%12.2f\t%12.2f",
display_channel->lz_stat.count + display_channel->glz_stat.count +
+ display_channel->off_stat.count +
display_channel->quic_stat.count +
display_channel->jpeg_stat.count +
display_channel->lz4_stat.count +
display_channel->jpeg_alpha_stat.count,
stat_byte_to_mega(display_channel->lz_stat.orig_size +
display_channel->glz_stat.orig_size +
+ display_channel->off_stat.orig_size +
display_channel->quic_stat.orig_size +
display_channel->jpeg_stat.orig_size +
display_channel->lz4_stat.orig_size +
display_channel->jpeg_alpha_stat.orig_size),
stat_byte_to_mega(display_channel->lz_stat.comp_size +
glz_enc_size +
+ display_channel->off_stat.comp_size +
display_channel->quic_stat.comp_size +
display_channel->jpeg_stat.comp_size +
display_channel->lz4_stat.comp_size +
@@ -122,6 +132,7 @@ void display_channel_compress_stats_print(const DisplayChannel *display_channel)
stat_cpu_time_to_sec(display_channel->lz_stat.total +
display_channel->glz_stat.total +
display_channel->zlib_glz_stat.total +
+ display_channel->off_stat.total +
display_channel->quic_stat.total +
display_channel->jpeg_stat.total +
display_channel->lz4_stat.total +
diff --git a/server/display-channel.h b/server/display-channel.h
index 13b13b1..fc993e8 100644
--- a/server/display-channel.h
+++ b/server/display-channel.h
@@ -213,6 +213,7 @@ struct DisplayChannel {
uint64_t *add_to_cache_counter;
uint64_t *non_cache_counter;
#endif
+ stat_info_t off_stat;
stat_info_t lz_stat;
stat_info_t glz_stat;
stat_info_t quic_stat;
commit 1948566ce89c0a655ee63667ad0bd61537a5126b
Author: Pavel Grunt <pgrunt at redhat.com>
Date: Mon Feb 15 13:57:58 2016 +0100
dcc: Move COMPRESS_DEBUG to compression functions
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/dcc.c b/server/dcc.c
index bd79bea..8d49bc8 100644
--- a/server/dcc.c
+++ b/server/dcc.c
@@ -719,6 +719,10 @@ static int dcc_compress_image_glz(DisplayChannelClient *dcc,
int glz_size;
int zlib_size;
+#ifdef COMPRESS_DEBUG
+ spice_info("LZ global compress fmt=%d", src->format);
+#endif
+
encoder_data_init(&glz_data->data, dcc);
glz_drawable = get_glz_drawable(dcc, drawable);
@@ -792,6 +796,10 @@ static int dcc_compress_image_lz(DisplayChannelClient *dcc,
stat_start_time_t start_time;
stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->lz_stat);
+#ifdef COMPRESS_DEBUG
+ spice_info("LZ LOCAL compress");
+#endif
+
encoder_data_init(&lz_data->data, dcc);
if (setjmp(lz_data->data.jmp_env)) {
@@ -860,6 +868,10 @@ static int dcc_compress_image_jpeg(DisplayChannelClient *dcc, SpiceImage *dest,
stat_start_time_t start_time;
stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->jpeg_alpha_stat);
+#ifdef COMPRESS_DEBUG
+ spice_info("JPEG compress");
+#endif
+
switch (src->format) {
case SPICE_BITMAP_FMT_16BIT:
jpeg_in_type = JPEG_IMAGE_TYPE_RGB16;
@@ -975,6 +987,10 @@ static int dcc_compress_image_lz4(DisplayChannelClient *dcc, SpiceImage *dest,
stat_start_time_t start_time;
stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->lz4_stat);
+#ifdef COMPRESS_DEBUG
+ spice_info("LZ4 compress");
+#endif
+
encoder_data_init(&lz4_data->data, dcc);
if (setjmp(lz4_data->data.jmp_env)) {
@@ -1022,6 +1038,10 @@ static int dcc_compress_image_quic(DisplayChannelClient *dcc, SpiceImage *dest,
stat_start_time_t start_time;
stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->quic_stat);
+#ifdef COMPRESS_DEBUG
+ spice_info("QUIC compress");
+#endif
+
switch (src->format) {
case SPICE_BITMAP_FMT_32BIT:
type = QUIC_IMAGE_TYPE_RGB32;
@@ -1180,14 +1200,8 @@ int dcc_compress_image(DisplayChannelClient *dcc,
case SPICE_IMAGE_COMPRESSION_QUIC:
if (can_lossy && display_channel->enable_jpeg &&
(src->format != SPICE_BITMAP_FMT_RGBA || !bitmap_has_extra_stride(src))) {
-#ifdef COMPRESS_DEBUG
- spice_info("JPEG compress");
-#endif
return dcc_compress_image_jpeg(dcc, dest, src, o_comp_data);
}
-#ifdef COMPRESS_DEBUG
- spice_info("QUIC compress");
-#endif
return dcc_compress_image_quic(dcc, dest, src, o_comp_data);
case SPICE_IMAGE_COMPRESSION_GLZ:
if ((src->x * src->y) < glz_enc_dictionary_get_size(dcc->glz_dict->dict)) {
@@ -1196,9 +1210,6 @@ int dcc_compress_image(DisplayChannelClient *dcc,
pthread_rwlock_rdlock(&dcc->glz_dict->encode_lock);
frozen = dcc->glz_dict->migrate_freeze;
if (!frozen) {
-#ifdef COMPRESS_DEBUG
- spice_info("LZ global compress fmt=%d", src->format);
-#endif
ret = dcc_compress_image_glz(dcc, dest, src, drawable, o_comp_data);
}
pthread_rwlock_unlock(&dcc->glz_dict->encode_lock);
@@ -1211,17 +1222,11 @@ int dcc_compress_image(DisplayChannelClient *dcc,
case SPICE_IMAGE_COMPRESSION_LZ4:
if (red_channel_client_test_remote_cap(&dcc->common.base,
SPICE_DISPLAY_CAP_LZ4_COMPRESSION)) {
-#ifdef COMPRESS_DEBUG
- spice_info("LZ4 compress");
-#endif
return dcc_compress_image_lz4(dcc, dest, src, o_comp_data);
}
#endif
lz_compress:
case SPICE_IMAGE_COMPRESSION_LZ:
-#ifdef COMPRESS_DEBUG
- spice_info("LZ LOCAL compress");
-#endif
return dcc_compress_image_lz(dcc, dest, src, o_comp_data);
default:
spice_error("invalid image compression type %u", image_compression);
commit f401eb07f985b32b6f07287aab43cb82781d2aba
Author: Pavel Grunt <pgrunt at redhat.com>
Date: Tue Feb 16 17:44:40 2016 +0100
dcc: Rewrite dcc_image_compress
Rules are now:
Compression type:
off -> uncompressed
quic -> jpeg if possible else quic else off
lz -> lz if possible else off
glz -> glz if possible else lz else off
auto_lz -> lz if possible else jpeg else quic else off
auto_glz -> glz if possible else lz else jpeg else quic else off
lz4 -> lz4 if possible else lz else off
jpeg is used only when jpeg-wan-compression allows it
Acked-by: Frediano Ziglio <fziglio at redhat.com>
diff --git a/server/dcc.c b/server/dcc.c
index dca9a64..bd79bea 100644
--- a/server/dcc.c
+++ b/server/dcc.c
@@ -1081,124 +1081,152 @@ static int dcc_compress_image_quic(DisplayChannelClient *dcc, SpiceImage *dest,
return TRUE;
}
-#define MIN_SIZE_TO_COMPRESS 54
#define MIN_DIMENSION_TO_QUIC 3
+/**
+ * quic doesn't handle:
+ * (1) palette
+ */
+static bool can_quic_compress(SpiceBitmap *bitmap)
+{
+ return !bitmap_fmt_is_plt(bitmap->format) &&
+ bitmap->x >= MIN_DIMENSION_TO_QUIC && bitmap->y >= MIN_DIMENSION_TO_QUIC;
+}
+/**
+ * lz doesn't handle:
+ * (1) bitmaps with strides that are larger than the width of the image in bytes
+ * (2) unstable bitmaps
+ */
+static bool can_lz_compress(SpiceBitmap *bitmap)
+{
+ return !bitmap_has_extra_stride(bitmap) &&
+ !(bitmap->data->flags & SPICE_CHUNKS_FLAGS_UNSTABLE);
+}
+
+#define MIN_SIZE_TO_COMPRESS 54
+static SpiceImageCompression get_compression_for_bitmap(SpiceBitmap *bitmap,
+ SpiceImageCompression preferred_compression,
+ Drawable *drawable)
+{
+ if (bitmap->y * bitmap->stride < MIN_SIZE_TO_COMPRESS) { // TODO: change the size cond
+ return SPICE_IMAGE_COMPRESSION_OFF;
+ }
+ if (preferred_compression == SPICE_IMAGE_COMPRESSION_OFF) {
+ return SPICE_IMAGE_COMPRESSION_OFF;
+ }
+ if (preferred_compression == SPICE_IMAGE_COMPRESSION_QUIC) {
+ if (can_quic_compress(bitmap)) {
+ return SPICE_IMAGE_COMPRESSION_QUIC;
+ }
+ return SPICE_IMAGE_COMPRESSION_OFF;
+ }
+
+ if (preferred_compression == SPICE_IMAGE_COMPRESSION_AUTO_GLZ ||
+ preferred_compression == SPICE_IMAGE_COMPRESSION_AUTO_LZ) {
+ if (can_quic_compress(bitmap)) {
+ if (drawable == NULL ||
+ drawable->copy_bitmap_graduality == BITMAP_GRADUAL_INVALID) {
+ if (bitmap_fmt_has_graduality(bitmap->format) &&
+ bitmap_get_graduality_level(bitmap) == BITMAP_GRADUAL_HIGH) {
+ return SPICE_IMAGE_COMPRESSION_QUIC;
+ }
+ } else if (!can_lz_compress(bitmap) ||
+ drawable->copy_bitmap_graduality == BITMAP_GRADUAL_HIGH) {
+ return SPICE_IMAGE_COMPRESSION_QUIC;
+ }
+ }
+ if (preferred_compression == SPICE_IMAGE_COMPRESSION_AUTO_LZ) {
+ preferred_compression = SPICE_IMAGE_COMPRESSION_LZ;
+ } else {
+ preferred_compression = SPICE_IMAGE_COMPRESSION_GLZ;
+ }
+ }
+
+ if (preferred_compression == SPICE_IMAGE_COMPRESSION_GLZ) {
+ if (drawable == NULL || !bitmap_fmt_has_graduality(bitmap->format)) {
+ preferred_compression = SPICE_IMAGE_COMPRESSION_LZ;
+ }
+ }
+
+ if (preferred_compression == SPICE_IMAGE_COMPRESSION_LZ4) {
+ if (!bitmap_fmt_is_rgb(bitmap->format)) {
+ preferred_compression = SPICE_IMAGE_COMPRESSION_LZ;
+ }
+ }
+
+ if (preferred_compression == SPICE_IMAGE_COMPRESSION_LZ ||
+ preferred_compression == SPICE_IMAGE_COMPRESSION_LZ4 ||
+ preferred_compression == SPICE_IMAGE_COMPRESSION_GLZ) {
+ if (can_lz_compress(bitmap)) {
+ return preferred_compression;
+ }
+ return SPICE_IMAGE_COMPRESSION_OFF;
+ }
+
+ return SPICE_IMAGE_COMPRESSION_INVALID;
+}
+
int dcc_compress_image(DisplayChannelClient *dcc,
SpiceImage *dest, SpiceBitmap *src, Drawable *drawable,
int can_lossy,
compress_send_data_t* o_comp_data)
{
DisplayChannel *display_channel = DCC_TO_DC(dcc);
- SpiceImageCompression image_compression = dcc->image_compression;
- int quic_compress = FALSE;
+ SpiceImageCompression image_compression;
- if ((image_compression == SPICE_IMAGE_COMPRESSION_OFF) ||
- ((src->y * src->stride) < MIN_SIZE_TO_COMPRESS)) { // TODO: change the size cond
+ image_compression = get_compression_for_bitmap(src, dcc->image_compression, drawable);
+ switch (image_compression) {
+ case SPICE_IMAGE_COMPRESSION_OFF:
return FALSE;
- } else if (image_compression == SPICE_IMAGE_COMPRESSION_QUIC) {
- if (bitmap_fmt_is_plt(src->format)) {
- return FALSE;
- } else {
- quic_compress = TRUE;
- }
- } else {
- /*
- lz doesn't handle (1) bitmaps with strides that are larger than the width
- of the image in bytes (2) unstable bitmaps
- */
- if (bitmap_has_extra_stride(src) || (src->data->flags & SPICE_CHUNKS_FLAGS_UNSTABLE)) {
- if ((image_compression == SPICE_IMAGE_COMPRESSION_LZ) ||
- (image_compression == SPICE_IMAGE_COMPRESSION_GLZ) ||
- (image_compression == SPICE_IMAGE_COMPRESSION_LZ4) ||
- bitmap_fmt_is_plt(src->format)) {
- return FALSE;
- } else {
- quic_compress = TRUE;
- }
- } else {
- if ((image_compression == SPICE_IMAGE_COMPRESSION_AUTO_LZ) ||
- (image_compression == SPICE_IMAGE_COMPRESSION_AUTO_GLZ)) {
- if ((src->x < MIN_DIMENSION_TO_QUIC) || (src->y < MIN_DIMENSION_TO_QUIC)) {
- quic_compress = FALSE;
- } else {
- if (drawable == NULL ||
- drawable->copy_bitmap_graduality == BITMAP_GRADUAL_INVALID) {
- quic_compress = bitmap_fmt_has_graduality(src->format) &&
- bitmap_get_graduality_level(src) == BITMAP_GRADUAL_HIGH;
- } else {
- quic_compress = (drawable->copy_bitmap_graduality == BITMAP_GRADUAL_HIGH);
- }
- }
- } else {
- quic_compress = FALSE;
- }
+ case SPICE_IMAGE_COMPRESSION_QUIC:
+ if (can_lossy && display_channel->enable_jpeg &&
+ (src->format != SPICE_BITMAP_FMT_RGBA || !bitmap_has_extra_stride(src))) {
+#ifdef COMPRESS_DEBUG
+ spice_info("JPEG compress");
+#endif
+ return dcc_compress_image_jpeg(dcc, dest, src, o_comp_data);
}
- }
-
- if (quic_compress) {
#ifdef COMPRESS_DEBUG
spice_info("QUIC compress");
#endif
- // if bitmaps is picture-like, compress it using jpeg
- if (can_lossy && display_channel->enable_jpeg &&
- ((image_compression == SPICE_IMAGE_COMPRESSION_AUTO_LZ) ||
- (image_compression == SPICE_IMAGE_COMPRESSION_AUTO_GLZ))) {
- // if we use lz for alpha, the stride can't be extra
- if (src->format != SPICE_BITMAP_FMT_RGBA || !bitmap_has_extra_stride(src)) {
- return dcc_compress_image_jpeg(dcc, dest, src, o_comp_data);
- }
- }
return dcc_compress_image_quic(dcc, dest, src, o_comp_data);
- } else {
- int glz;
- int ret;
- if ((image_compression == SPICE_IMAGE_COMPRESSION_AUTO_GLZ) ||
- (image_compression == SPICE_IMAGE_COMPRESSION_GLZ)) {
- glz = drawable != NULL && bitmap_fmt_has_graduality(src->format) &&
- ((src->x * src->y) < glz_enc_dictionary_get_size(dcc->glz_dict->dict));
- } else if ((image_compression == SPICE_IMAGE_COMPRESSION_AUTO_LZ) ||
- (image_compression == SPICE_IMAGE_COMPRESSION_LZ) ||
- (image_compression == SPICE_IMAGE_COMPRESSION_LZ4)) {
- glz = FALSE;
- } else {
- spice_error("invalid image compression type %u", image_compression);
- return FALSE;
- }
-
- if (glz) {
+ case SPICE_IMAGE_COMPRESSION_GLZ:
+ if ((src->x * src->y) < glz_enc_dictionary_get_size(dcc->glz_dict->dict)) {
+ int ret, frozen;
/* using the global dictionary only if it is not frozen */
pthread_rwlock_rdlock(&dcc->glz_dict->encode_lock);
- if (!dcc->glz_dict->migrate_freeze) {
- ret = dcc_compress_image_glz(dcc,
- dest, src,
- drawable, o_comp_data);
- } else {
- glz = FALSE;
+ frozen = dcc->glz_dict->migrate_freeze;
+ if (!frozen) {
+#ifdef COMPRESS_DEBUG
+ spice_info("LZ global compress fmt=%d", src->format);
+#endif
+ ret = dcc_compress_image_glz(dcc, dest, src, drawable, o_comp_data);
}
pthread_rwlock_unlock(&dcc->glz_dict->encode_lock);
+ if (!frozen) {
+ return ret;
+ }
}
-
- if (!glz) {
+ goto lz_compress;
#ifdef USE_LZ4
- if (image_compression == SPICE_IMAGE_COMPRESSION_LZ4 &&
- bitmap_fmt_is_rgb(src->format) &&
- red_channel_client_test_remote_cap(&dcc->common.base,
- SPICE_DISPLAY_CAP_LZ4_COMPRESSION)) {
- ret = dcc_compress_image_lz4(dcc, dest, src, o_comp_data);
- } else
-#endif
- ret = dcc_compress_image_lz(dcc, dest, src, o_comp_data);
+ case SPICE_IMAGE_COMPRESSION_LZ4:
+ if (red_channel_client_test_remote_cap(&dcc->common.base,
+ SPICE_DISPLAY_CAP_LZ4_COMPRESSION)) {
#ifdef COMPRESS_DEBUG
- spice_info("LZ LOCAL compress");
+ spice_info("LZ4 compress");
#endif
+ return dcc_compress_image_lz4(dcc, dest, src, o_comp_data);
}
+#endif
+lz_compress:
+ case SPICE_IMAGE_COMPRESSION_LZ:
#ifdef COMPRESS_DEBUG
- else {
- spice_info("LZ global compress fmt=%d", src->format);
- }
+ spice_info("LZ LOCAL compress");
#endif
- return ret;
+ return dcc_compress_image_lz(dcc, dest, src, o_comp_data);
+ default:
+ spice_error("invalid image compression type %u", image_compression);
}
+ return FALSE;
}
#define CLIENT_PALETTE_CACHE
More information about the Spice-commits
mailing list