X-Git-Url: https://repo.jachan.dev/qemu.git/blobdiff_plain/5d8efe39a2e2f9479da1aefefa7325a1e7cb630b..07f59737d8350fda70171bb7c23d18512d9c038a:/ui/vnc-enc-tight.c diff --git a/ui/vnc-enc-tight.c b/ui/vnc-enc-tight.c index ade8e5f846..af45edd872 100644 --- a/ui/vnc-enc-tight.c +++ b/ui/vnc-enc-tight.c @@ -26,18 +26,23 @@ * THE SOFTWARE. */ -#include "qemu-common.h" +#include "config-host.h" +#ifdef CONFIG_VNC_PNG +#include +#endif #ifdef CONFIG_VNC_JPEG #include #include #endif +#include "qemu-common.h" + #include "bswap.h" -#include "qdict.h" #include "qint.h" #include "vnc.h" #include "vnc-enc-tight.h" +#include "vnc-palette.h" /* Compression level stuff. The following array contains various encoder parameters for each of 10 compression levels (0..9). @@ -63,22 +68,60 @@ static const struct { { 65536, 2048, 32, 8192, 9, 9, 9, 6, 200, 500, 96, 80, 200, 500 } }; + +static int tight_send_framebuffer_update(VncState *vs, int x, int y, + int w, int h); + +#ifdef CONFIG_VNC_PNG +static const struct { + int png_zlib_level, png_filters; +} tight_png_conf[] = { + { 0, PNG_NO_FILTERS }, + { 1, PNG_NO_FILTERS }, + { 2, PNG_NO_FILTERS }, + { 3, PNG_NO_FILTERS }, + { 4, PNG_NO_FILTERS }, + { 5, PNG_ALL_FILTERS }, + { 6, PNG_ALL_FILTERS }, + { 7, PNG_ALL_FILTERS }, + { 8, PNG_ALL_FILTERS }, + { 9, PNG_ALL_FILTERS }, +}; + +static int send_png_rect(VncState *vs, int x, int y, int w, int h, + VncPalette *palette); + +static bool tight_can_send_png_rect(VncState *vs, int w, int h) +{ + if (vs->tight.type != VNC_ENCODING_TIGHT_PNG) { + return false; + } + + if (ds_get_bytes_per_pixel(vs->ds) == 1 || + vs->clientds.pf.bytes_per_pixel == 1) { + return false; + } + + return true; +} +#endif + /* * Code to guess if given rectangle is suitable for smooth image * compression (by applying "gradient" filter or JPEG coder). */ -static uint +static unsigned int tight_detect_smooth_image24(VncState *vs, int w, int h) { int off; int x, y, d, dx; - uint c; - uint stats[256]; + unsigned int c; + unsigned int stats[256]; int pixels = 0; int pix, left[3]; - uint errors; - unsigned char *buf = vs->tight.buffer; + unsigned int errors; + unsigned char *buf = vs->tight.tight.buffer; /* * If client is big-endian, color samples begin from the second @@ -134,18 +177,18 @@ tight_detect_smooth_image24(VncState *vs, int w, int h) #define DEFINE_DETECT_FUNCTION(bpp) \ \ - static uint \ + static unsigned int \ tight_detect_smooth_image##bpp(VncState *vs, int w, int h) { \ bool endian; \ uint##bpp##_t pix; \ int max[3], shift[3]; \ int x, y, d, dx; \ - uint c; \ - uint stats[256]; \ + unsigned int c; \ + unsigned int stats[256]; \ int pixels = 0; \ int sample, sum, left[3]; \ - uint errors; \ - unsigned char *buf = vs->tight.buffer; \ + unsigned int errors; \ + unsigned char *buf = vs->tight.tight.buffer; \ \ endian = ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) != \ (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG)); \ @@ -166,7 +209,7 @@ tight_detect_smooth_image24(VncState *vs, int w, int h) d < w - x - VNC_TIGHT_DETECT_SUBROW_WIDTH; d++) { \ pix = ((uint##bpp##_t *)buf)[(y+d)*w+x+d]; \ if (endian) { \ - pix = bswap_##bpp(pix); \ + pix = bswap##bpp(pix); \ } \ for (c = 0; c < 3; c++) { \ left[c] = (int)(pix >> shift[c] & max[c]); \ @@ -175,7 +218,7 @@ tight_detect_smooth_image24(VncState *vs, int w, int h) dx++) { \ pix = ((uint##bpp##_t *)buf)[(y+d)*w+x+d+dx]; \ if (endian) { \ - pix = bswap_##bpp(pix); \ + pix = bswap##bpp(pix); \ } \ sum = 0; \ for (c = 0; c < 3; c++) { \ @@ -224,9 +267,9 @@ DEFINE_DETECT_FUNCTION(32) static int tight_detect_smooth_image(VncState *vs, int w, int h) { - uint errors; - int compression = vs->tight_compression; - int quality = vs->tight_quality; + unsigned int errors; + int compression = vs->tight.compression; + int quality = vs->tight.quality; if (!vs->vd->lossy) { return 0; @@ -238,7 +281,7 @@ tight_detect_smooth_image(VncState *vs, int w, int h) return 0; } - if (vs->tight_quality != -1) { + if (vs->tight.quality != (uint8_t)-1) { if (w * h < VNC_TIGHT_JPEG_MIN_RECT_SIZE) { return 0; } @@ -249,9 +292,9 @@ tight_detect_smooth_image(VncState *vs, int w, int h) } if (vs->clientds.pf.bytes_per_pixel == 4) { - if (vs->tight_pixel24) { + if (vs->tight.pixel24) { errors = tight_detect_smooth_image24(vs, w, h); - if (vs->tight_quality != -1) { + if (vs->tight.quality != (uint8_t)-1) { return (errors < tight_conf[quality].jpeg_threshold24); } return (errors < tight_conf[compression].gradient_threshold24); @@ -270,79 +313,18 @@ tight_detect_smooth_image(VncState *vs, int w, int h) /* * Code to determine how many different colors used in rectangle. */ - -static void tight_palette_rgb2buf(uint32_t rgb, int bpp, uint8_t buf[6]) -{ - memset(buf, 0, 6); - - if (bpp == 32) { - buf[0] = ((rgb >> 24) & 0xFF); - buf[1] = ((rgb >> 16) & 0xFF); - buf[2] = ((rgb >> 8) & 0xFF); - buf[3] = ((rgb >> 0) & 0xFF); - buf[4] = ((buf[0] & 1) == 0) << 3 | ((buf[1] & 1) == 0) << 2; - buf[4]|= ((buf[2] & 1) == 0) << 1 | ((buf[3] & 1) == 0) << 0; - buf[0] |= 1; - buf[1] |= 1; - buf[2] |= 1; - buf[3] |= 1; - } - if (bpp == 16) { - buf[0] = ((rgb >> 8) & 0xFF); - buf[1] = ((rgb >> 0) & 0xFF); - buf[2] = ((buf[0] & 1) == 0) << 1 | ((buf[1] & 1) == 0) << 0; - buf[0] |= 1; - buf[1] |= 1; - } -} - -static uint32_t tight_palette_buf2rgb(int bpp, const uint8_t *buf) -{ - uint32_t rgb = 0; - - if (bpp == 32) { - rgb |= ((buf[0] & ~1) | !((buf[4] >> 3) & 1)) << 24; - rgb |= ((buf[1] & ~1) | !((buf[4] >> 2) & 1)) << 16; - rgb |= ((buf[2] & ~1) | !((buf[4] >> 1) & 1)) << 8; - rgb |= ((buf[3] & ~1) | !((buf[4] >> 0) & 1)) << 0; - } - if (bpp == 16) { - rgb |= ((buf[0] & ~1) | !((buf[2] >> 1) & 1)) << 8; - rgb |= ((buf[1] & ~1) | !((buf[2] >> 0) & 1)) << 0; - } - return rgb; -} - - -static int tight_palette_insert(QDict *palette, uint32_t rgb, int bpp, int max) -{ - uint8_t key[6]; - int idx = qdict_size(palette); - bool present; - - tight_palette_rgb2buf(rgb, bpp, key); - present = qdict_haskey(palette, (char *)key); - if (idx >= max && !present) { - return 0; - } - if (!present) { - qdict_put(palette, (char *)key, qint_from_int(idx)); - } - return qdict_size(palette); -} - #define DEFINE_FILL_PALETTE_FUNCTION(bpp) \ \ static int \ tight_fill_palette##bpp(VncState *vs, int x, int y, \ int max, size_t count, \ uint32_t *bg, uint32_t *fg, \ - struct QDict **palette) { \ + VncPalette **palette) { \ uint##bpp##_t *data; \ uint##bpp##_t c0, c1, ci; \ int i, n0, n1; \ \ - data = (uint##bpp##_t *)vs->tight.buffer; \ + data = (uint##bpp##_t *)vs->tight.tight.buffer; \ \ c0 = data[0]; \ i = 1; \ @@ -384,24 +366,23 @@ static int tight_palette_insert(QDict *palette, uint32_t rgb, int bpp, int max) return 0; \ } \ \ - *palette = qdict_new(); \ - tight_palette_insert(*palette, c0, bpp, max); \ - tight_palette_insert(*palette, c1, bpp, max); \ - tight_palette_insert(*palette, ci, bpp, max); \ + *palette = palette_new(max, bpp); \ + palette_put(*palette, c0); \ + palette_put(*palette, c1); \ + palette_put(*palette, ci); \ \ for (i++; i < count; i++) { \ if (data[i] == ci) { \ continue; \ } else { \ ci = data[i]; \ - if (!tight_palette_insert(*palette, (uint32_t)ci, \ - bpp, max)) { \ + if (!palette_put(*palette, (uint32_t)ci)) { \ return 0; \ } \ } \ } \ \ - return qdict_size(*palette); \ + return palette_size(*palette); \ } DEFINE_FILL_PALETTE_FUNCTION(8) @@ -410,13 +391,13 @@ DEFINE_FILL_PALETTE_FUNCTION(32) static int tight_fill_palette(VncState *vs, int x, int y, size_t count, uint32_t *bg, uint32_t *fg, - struct QDict **palette) + VncPalette **palette) { int max; - max = count / tight_conf[vs->tight_compression].idx_max_colors_divisor; + max = count / tight_conf[vs->tight.compression].idx_max_colors_divisor; if (max < 2 && - count >= tight_conf[vs->tight_compression].mono_min_rect_size) { + count >= tight_conf[vs->tight.compression].mono_min_rect_size) { max = 2; } if (max >= 256) { @@ -435,20 +416,6 @@ static int tight_fill_palette(VncState *vs, int x, int y, return 0; } -/* Callback to dump a palette with qdict_iter -static void print_palette(const char *key, QObject *obj, void *opaque) -{ - uint8_t idx = qint_get_int(qobject_to_qint(obj)); - uint32_t rgb = tight_palette_buf2rgb(32, (uint8_t *)key); - - fprintf(stderr, "%.2x ", (unsigned char)*key); - while (*key++) - fprintf(stderr, "%.2x ", (unsigned char)*key); - - fprintf(stderr, ": idx: %x rgb: %x\n", idx, rgb); -} -*/ - /* * Converting truecolor samples into palette indices. */ @@ -456,30 +423,28 @@ static void print_palette(const char *key, QObject *obj, void *opaque) \ static void \ tight_encode_indexed_rect##bpp(uint8_t *buf, int count, \ - struct QDict *palette) { \ + VncPalette *palette) { \ uint##bpp##_t *src; \ uint##bpp##_t rgb; \ - uint8_t key[6]; \ int i, rep; \ uint8_t idx; \ \ src = (uint##bpp##_t *) buf; \ \ for (i = 0; i < count; i++) { \ + \ rgb = *src++; \ rep = 0; \ while (i < count && *src == rgb) { \ rep++, src++, i++; \ } \ - tight_palette_rgb2buf(rgb, bpp, key); \ - if (!qdict_haskey(palette, (char *)key)) { \ - /* \ - * Should never happen, but don't break everything \ - * if it does, use the first color instead \ - */ \ + idx = palette_idx(palette, rgb); \ + /* \ + * Should never happen, but don't break everything \ + * if it does, use the first color instead \ + */ \ + if (idx == (uint8_t)-1) { \ idx = 0; \ - } else { \ - idx = qdict_get_int(palette, (char *)key); \ } \ while (rep >= 0) { \ *buf++ = idx; \ @@ -564,7 +529,7 @@ tight_filter_gradient24(VncState *vs, uint8_t *buf, int w, int h) int x, y, c; buf32 = (uint32_t *)buf; - memset(vs->tight_gradient.buffer, 0, w * 3 * sizeof(int)); + memset(vs->tight.gradient.buffer, 0, w * 3 * sizeof(int)); if ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) == (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG)) { @@ -582,7 +547,7 @@ tight_filter_gradient24(VncState *vs, uint8_t *buf, int w, int h) upper[c] = 0; here[c] = 0; } - prev = (int *)vs->tight_gradient.buffer; + prev = (int *)vs->tight.gradient.buffer; for (x = 0; x < w; x++) { pix32 = *buf32++; for (c = 0; c < 3; c++) { @@ -622,7 +587,7 @@ tight_filter_gradient24(VncState *vs, uint8_t *buf, int w, int h) int prediction; \ int x, y, c; \ \ - memset (vs->tight_gradient.buffer, 0, w * 3 * sizeof(int)); \ + memset (vs->tight.gradient.buffer, 0, w * 3 * sizeof(int)); \ \ endian = ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) != \ (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG)); \ @@ -639,11 +604,11 @@ tight_filter_gradient24(VncState *vs, uint8_t *buf, int w, int h) upper[c] = 0; \ here[c] = 0; \ } \ - prev = (int *)vs->tight_gradient.buffer; \ + prev = (int *)vs->tight.gradient.buffer; \ for (x = 0; x < w; x++) { \ pix = *buf; \ if (endian) { \ - pix = bswap_##bpp(pix); \ + pix = bswap##bpp(pix); \ } \ diff = 0; \ for (c = 0; c < 3; c++) { \ @@ -663,7 +628,7 @@ tight_filter_gradient24(VncState *vs, uint8_t *buf, int w, int h) << shift[c]; \ } \ if (endian) { \ - diff = bswap_##bpp(diff); \ + diff = bswap##bpp(diff); \ } \ *buf++ = diff; \ } \ @@ -676,7 +641,7 @@ DEFINE_GRADIENT_FILTER_FUNCTION(32) /* * Check if a rectangle is all of the same color. If needSameColor is * set to non-zero, then also check that its color equals to the - * *colorPtr value. The result is 1 if the test is successfull, and in + * *colorPtr value. The result is 1 if the test is successful, and in * that case new color will be stored in *colorPtr. */ @@ -809,7 +774,7 @@ static void extend_solid_area(VncState *vs, int x, int y, int w, int h, static int tight_init_stream(VncState *vs, int stream_id, int level, int strategy) { - z_streamp zstream = &vs->tight_stream[stream_id]; + z_streamp zstream = &vs->tight.stream[stream_id]; if (zstream->opaque == NULL) { int err; @@ -827,15 +792,15 @@ static int tight_init_stream(VncState *vs, int stream_id, return -1; } - vs->tight_levels[stream_id] = level; + vs->tight.levels[stream_id] = level; zstream->opaque = vs; } - if (vs->tight_levels[stream_id] != level) { + if (vs->tight.levels[stream_id] != level) { if (deflateParams(zstream, level, strategy) != Z_OK) { return -1; } - vs->tight_levels[stream_id] = level; + vs->tight.levels[stream_id] = level; } return 0; } @@ -863,11 +828,11 @@ static void tight_send_compact_size(VncState *vs, size_t len) static int tight_compress_data(VncState *vs, int stream_id, size_t bytes, int level, int strategy) { - z_streamp zstream = &vs->tight_stream[stream_id]; + z_streamp zstream = &vs->tight.stream[stream_id]; int previous_out; if (bytes < VNC_TIGHT_MIN_TO_COMPRESS) { - vnc_write(vs, vs->tight.buffer, vs->tight.offset); + vnc_write(vs, vs->tight.tight.buffer, vs->tight.tight.offset); return bytes; } @@ -876,13 +841,13 @@ static int tight_compress_data(VncState *vs, int stream_id, size_t bytes, } /* reserve memory in output buffer */ - buffer_reserve(&vs->tight_zlib, bytes + 64); + buffer_reserve(&vs->tight.zlib, bytes + 64); /* set pointers */ - zstream->next_in = vs->tight.buffer; - zstream->avail_in = vs->tight.offset; - zstream->next_out = vs->tight_zlib.buffer + vs->tight_zlib.offset; - zstream->avail_out = vs->tight_zlib.capacity - vs->tight_zlib.offset; + zstream->next_in = vs->tight.tight.buffer; + zstream->avail_in = vs->tight.tight.offset; + zstream->next_out = vs->tight.zlib.buffer + vs->tight.zlib.offset; + zstream->avail_out = vs->tight.zlib.capacity - vs->tight.zlib.offset; zstream->data_type = Z_BINARY; previous_out = zstream->total_out; @@ -892,13 +857,13 @@ static int tight_compress_data(VncState *vs, int stream_id, size_t bytes, return -1; } - vs->tight_zlib.offset = vs->tight_zlib.capacity - zstream->avail_out; + vs->tight.zlib.offset = vs->tight.zlib.capacity - zstream->avail_out; bytes = zstream->total_out - previous_out; tight_send_compact_size(vs, bytes); - vnc_write(vs, vs->tight_zlib.buffer, bytes); + vnc_write(vs, vs->tight.zlib.buffer, bytes); - buffer_reset(&vs->tight_zlib); + buffer_reset(&vs->tight.zlib); return bytes; } @@ -937,22 +902,28 @@ static void tight_pack24(VncState *vs, uint8_t *buf, size_t count, size_t *ret) } } -static int send_full_color_rect(VncState *vs, int w, int h) +static int send_full_color_rect(VncState *vs, int x, int y, int w, int h) { int stream = 0; - size_t bytes; + ssize_t bytes; + +#ifdef CONFIG_VNC_PNG + if (tight_can_send_png_rect(vs, w, h)) { + return send_png_rect(vs, x, y, w, h, NULL); + } +#endif vnc_write_u8(vs, stream << 4); /* no flushing, no filter */ - if (vs->tight_pixel24) { - tight_pack24(vs, vs->tight.buffer, w * h, &vs->tight.offset); + if (vs->tight.pixel24) { + tight_pack24(vs, vs->tight.tight.buffer, w * h, &vs->tight.tight.offset); bytes = 3; } else { bytes = vs->clientds.pf.bytes_per_pixel; } bytes = tight_compress_data(vs, stream, w * h * bytes, - tight_conf[vs->tight_compression].raw_zlib_level, + tight_conf[vs->tight.compression].raw_zlib_level, Z_DEFAULT_STRATEGY); return (bytes >= 0); @@ -964,22 +935,37 @@ static int send_solid_rect(VncState *vs) vnc_write_u8(vs, VNC_TIGHT_FILL << 4); /* no flushing, no filter */ - if (vs->tight_pixel24) { - tight_pack24(vs, vs->tight.buffer, 1, &vs->tight.offset); + if (vs->tight.pixel24) { + tight_pack24(vs, vs->tight.tight.buffer, 1, &vs->tight.tight.offset); bytes = 3; } else { bytes = vs->clientds.pf.bytes_per_pixel; } - vnc_write(vs, vs->tight.buffer, bytes); + vnc_write(vs, vs->tight.tight.buffer, bytes); return 1; } -static int send_mono_rect(VncState *vs, int w, int h, uint32_t bg, uint32_t fg) +static int send_mono_rect(VncState *vs, int x, int y, + int w, int h, uint32_t bg, uint32_t fg) { - size_t bytes; + ssize_t bytes; int stream = 1; - int level = tight_conf[vs->tight_compression].mono_zlib_level; + int level = tight_conf[vs->tight.compression].mono_zlib_level; + +#ifdef CONFIG_VNC_PNG + if (tight_can_send_png_rect(vs, w, h)) { + int ret; + int bpp = vs->clientds.pf.bytes_per_pixel * 8; + VncPalette *palette = palette_new(2, bpp); + + palette_put(palette, bg); + palette_put(palette, fg); + ret = send_png_rect(vs, x, y, w, h, palette); + palette_destroy(palette); + return ret; + } +#endif bytes = ((w + 7) / 8) * h; @@ -993,26 +979,26 @@ static int send_mono_rect(VncState *vs, int w, int h, uint32_t bg, uint32_t fg) uint32_t buf[2] = {bg, fg}; size_t ret = sizeof (buf); - if (vs->tight_pixel24) { + if (vs->tight.pixel24) { tight_pack24(vs, (unsigned char*)buf, 2, &ret); } vnc_write(vs, buf, ret); - tight_encode_mono_rect32(vs->tight.buffer, w, h, bg, fg); + tight_encode_mono_rect32(vs->tight.tight.buffer, w, h, bg, fg); break; } case 2: vnc_write(vs, &bg, 2); vnc_write(vs, &fg, 2); - tight_encode_mono_rect16(vs->tight.buffer, w, h, bg, fg); + tight_encode_mono_rect16(vs->tight.tight.buffer, w, h, bg, fg); break; default: vnc_write_u8(vs, bg); vnc_write_u8(vs, fg); - tight_encode_mono_rect8(vs->tight.buffer, w, h, bg, fg); + tight_encode_mono_rect8(vs->tight.tight.buffer, w, h, bg, fg); break; } - vs->tight.offset = bytes; + vs->tight.tight.offset = bytes; bytes = tight_compress_data(vs, stream, bytes, level, Z_DEFAULT_STRATEGY); return (bytes >= 0); @@ -1021,69 +1007,74 @@ static int send_mono_rect(VncState *vs, int w, int h, uint32_t bg, uint32_t fg) struct palette_cb_priv { VncState *vs; uint8_t *header; +#ifdef CONFIG_VNC_PNG + png_colorp png_palette; +#endif }; -static void write_palette(const char *key, QObject *obj, void *opaque) +static void write_palette(int idx, uint32_t color, void *opaque) { struct palette_cb_priv *priv = opaque; VncState *vs = priv->vs; uint32_t bytes = vs->clientds.pf.bytes_per_pixel; - uint8_t idx = qint_get_int(qobject_to_qint(obj)); if (bytes == 4) { - uint32_t color = tight_palette_buf2rgb(32, (uint8_t *)key); - ((uint32_t*)priv->header)[idx] = color; } else { - uint16_t color = tight_palette_buf2rgb(16, (uint8_t *)key); - ((uint16_t*)priv->header)[idx] = color; } } -static bool send_gradient_rect(VncState *vs, int w, int h) +static bool send_gradient_rect(VncState *vs, int x, int y, int w, int h) { int stream = 3; - int level = tight_conf[vs->tight_compression].gradient_zlib_level; - size_t bytes; + int level = tight_conf[vs->tight.compression].gradient_zlib_level; + ssize_t bytes; if (vs->clientds.pf.bytes_per_pixel == 1) - return send_full_color_rect(vs, w, h); + return send_full_color_rect(vs, x, y, w, h); vnc_write_u8(vs, (stream | VNC_TIGHT_EXPLICIT_FILTER) << 4); vnc_write_u8(vs, VNC_TIGHT_FILTER_GRADIENT); - buffer_reserve(&vs->tight_gradient, w * 3 * sizeof (int)); + buffer_reserve(&vs->tight.gradient, w * 3 * sizeof (int)); - if (vs->tight_pixel24) { - tight_filter_gradient24(vs, vs->tight.buffer, w, h); + if (vs->tight.pixel24) { + tight_filter_gradient24(vs, vs->tight.tight.buffer, w, h); bytes = 3; } else if (vs->clientds.pf.bytes_per_pixel == 4) { - tight_filter_gradient32(vs, (uint32_t *)vs->tight.buffer, w, h); + tight_filter_gradient32(vs, (uint32_t *)vs->tight.tight.buffer, w, h); bytes = 4; } else { - tight_filter_gradient16(vs, (uint16_t *)vs->tight.buffer, w, h); + tight_filter_gradient16(vs, (uint16_t *)vs->tight.tight.buffer, w, h); bytes = 2; } - buffer_reset(&vs->tight_gradient); + buffer_reset(&vs->tight.gradient); bytes = w * h * bytes; - vs->tight.offset = bytes; + vs->tight.tight.offset = bytes; bytes = tight_compress_data(vs, stream, bytes, level, Z_FILTERED); return (bytes >= 0); } -static int send_palette_rect(VncState *vs, int w, int h, struct QDict *palette) +static int send_palette_rect(VncState *vs, int x, int y, + int w, int h, VncPalette *palette) { int stream = 2; - int level = tight_conf[vs->tight_compression].idx_zlib_level; + int level = tight_conf[vs->tight.compression].idx_zlib_level; int colors; - size_t bytes; + ssize_t bytes; - colors = qdict_size(palette); +#ifdef CONFIG_VNC_PNG + if (tight_can_send_png_rect(vs, w, h)) { + return send_png_rect(vs, x, y, w, h, palette); + } +#endif + + colors = palette_size(palette); vnc_write_u8(vs, (stream | VNC_TIGHT_EXPLICIT_FILTER) << 4); vnc_write_u8(vs, VNC_TIGHT_FILTER_PALETTE); @@ -1093,29 +1084,29 @@ static int send_palette_rect(VncState *vs, int w, int h, struct QDict *palette) case 4: { size_t old_offset, offset; - uint32_t header[qdict_size(palette)]; + uint32_t header[palette_size(palette)]; struct palette_cb_priv priv = { vs, (uint8_t *)header }; old_offset = vs->output.offset; - qdict_iter(palette, write_palette, &priv); + palette_iter(palette, write_palette, &priv); vnc_write(vs, header, sizeof(header)); - if (vs->tight_pixel24) { + if (vs->tight.pixel24) { tight_pack24(vs, vs->output.buffer + old_offset, colors, &offset); vs->output.offset = old_offset + offset; } - tight_encode_indexed_rect32(vs->tight.buffer, w * h, palette); + tight_encode_indexed_rect32(vs->tight.tight.buffer, w * h, palette); break; } case 2: { - uint16_t header[qdict_size(palette)]; + uint16_t header[palette_size(palette)]; struct palette_cb_priv priv = { vs, (uint8_t *)header }; - qdict_iter(palette, write_palette, &priv); + palette_iter(palette, write_palette, &priv); vnc_write(vs, header, sizeof(header)); - tight_encode_indexed_rect16(vs->tight.buffer, w * h, palette); + tight_encode_indexed_rect16(vs->tight.tight.buffer, w * h, palette); break; } default: @@ -1123,19 +1114,16 @@ static int send_palette_rect(VncState *vs, int w, int h, struct QDict *palette) break; } bytes = w * h; - vs->tight.offset = bytes; + vs->tight.tight.offset = bytes; bytes = tight_compress_data(vs, stream, bytes, level, Z_DEFAULT_STRATEGY); return (bytes >= 0); } -/* - * JPEG compression stuff. - */ -#ifdef CONFIG_VNC_JPEG -static void jpeg_prepare_row24(VncState *vs, uint8_t *dst, int x, int y, - int count) +#if defined(CONFIG_VNC_JPEG) || defined(CONFIG_VNC_PNG) +static void rgb_prepare_row24(VncState *vs, uint8_t *dst, int x, int y, + int count) { VncDisplay *vd = vs->vd; uint32_t *fbptr; @@ -1152,11 +1140,11 @@ static void jpeg_prepare_row24(VncState *vs, uint8_t *dst, int x, int y, } } -#define DEFINE_JPEG_GET_ROW_FUNCTION(bpp) \ +#define DEFINE_RGB_GET_ROW_FUNCTION(bpp) \ \ static void \ - jpeg_prepare_row##bpp(VncState *vs, uint8_t *dst, \ - int x, int y, int count) \ + rgb_prepare_row##bpp(VncState *vs, uint8_t *dst, \ + int x, int y, int count) \ { \ VncDisplay *vd = vs->vd; \ uint##bpp##_t *fbptr; \ @@ -1186,20 +1174,30 @@ static void jpeg_prepare_row24(VncState *vs, uint8_t *dst, int x, int y, } \ } -DEFINE_JPEG_GET_ROW_FUNCTION(16) -DEFINE_JPEG_GET_ROW_FUNCTION(32) +DEFINE_RGB_GET_ROW_FUNCTION(16) +DEFINE_RGB_GET_ROW_FUNCTION(32) -static void jpeg_prepare_row(VncState *vs, uint8_t *dst, int x, int y, - int count) +static void rgb_prepare_row(VncState *vs, uint8_t *dst, int x, int y, + int count) { - if (vs->tight_pixel24) - jpeg_prepare_row24(vs, dst, x, y, count); - else if (ds_get_bytes_per_pixel(vs->ds) == 4) - jpeg_prepare_row32(vs, dst, x, y, count); - else - jpeg_prepare_row16(vs, dst, x, y, count); + if (ds_get_bytes_per_pixel(vs->ds) == 4) { + if (vs->ds->surface->pf.rmax == 0xFF && + vs->ds->surface->pf.gmax == 0xFF && + vs->ds->surface->pf.bmax == 0xFF) { + rgb_prepare_row24(vs, dst, x, y, count); + } else { + rgb_prepare_row32(vs, dst, x, y, count); + } + } else { + rgb_prepare_row16(vs, dst, x, y, count); + } } +#endif /* CONFIG_VNC_JPEG or CONFIG_VNC_PNG */ +/* + * JPEG compression stuff. + */ +#ifdef CONFIG_VNC_JPEG /* * Destination manager implementation for JPEG library. */ @@ -1208,7 +1206,7 @@ static void jpeg_prepare_row(VncState *vs, uint8_t *dst, int x, int y, static void jpeg_init_destination(j_compress_ptr cinfo) { VncState *vs = cinfo->client_data; - Buffer *buffer = &vs->tight_jpeg; + Buffer *buffer = &vs->tight.jpeg; cinfo->dest->next_output_byte = (JOCTET *)buffer->buffer + buffer->offset; cinfo->dest->free_in_buffer = (size_t)(buffer->capacity - buffer->offset); @@ -1218,7 +1216,7 @@ static void jpeg_init_destination(j_compress_ptr cinfo) static boolean jpeg_empty_output_buffer(j_compress_ptr cinfo) { VncState *vs = cinfo->client_data; - Buffer *buffer = &vs->tight_jpeg; + Buffer *buffer = &vs->tight.jpeg; buffer->offset = buffer->capacity; buffer_reserve(buffer, 2048); @@ -1230,7 +1228,7 @@ static boolean jpeg_empty_output_buffer(j_compress_ptr cinfo) static void jpeg_term_destination(j_compress_ptr cinfo) { VncState *vs = cinfo->client_data; - Buffer *buffer = &vs->tight_jpeg; + Buffer *buffer = &vs->tight.jpeg; buffer->offset = buffer->capacity - cinfo->dest->free_in_buffer; } @@ -1245,11 +1243,9 @@ static int send_jpeg_rect(VncState *vs, int x, int y, int w, int h, int quality) int dy; if (ds_get_bytes_per_pixel(vs->ds) == 1) - return send_full_color_rect(vs, w, h); + return send_full_color_rect(vs, x, y, w, h); - buf = qemu_malloc(w * 3); - row[0] = buf; - buffer_reserve(&vs->tight_jpeg, 2048); + buffer_reserve(&vs->tight.jpeg, 2048); cinfo.err = jpeg_std_error(&jerr); jpeg_create_compress(&cinfo); @@ -1270,96 +1266,280 @@ static int send_jpeg_rect(VncState *vs, int x, int y, int w, int h, int quality) jpeg_start_compress(&cinfo, true); + buf = qemu_malloc(w * 3); + row[0] = buf; for (dy = 0; dy < h; dy++) { - jpeg_prepare_row(vs, buf, x, y + dy, w); + rgb_prepare_row(vs, buf, x, y + dy, w); jpeg_write_scanlines(&cinfo, row, 1); } + qemu_free(buf); jpeg_finish_compress(&cinfo); jpeg_destroy_compress(&cinfo); vnc_write_u8(vs, VNC_TIGHT_JPEG << 4); - tight_send_compact_size(vs, vs->tight_jpeg.offset); - vnc_write(vs, vs->tight_jpeg.buffer, vs->tight_jpeg.offset); - buffer_reset(&vs->tight_jpeg); + tight_send_compact_size(vs, vs->tight.jpeg.offset); + vnc_write(vs, vs->tight.jpeg.buffer, vs->tight.jpeg.offset); + buffer_reset(&vs->tight.jpeg); return 1; } #endif /* CONFIG_VNC_JPEG */ +/* + * PNG compression stuff. + */ +#ifdef CONFIG_VNC_PNG +static void write_png_palette(int idx, uint32_t pix, void *opaque) +{ + struct palette_cb_priv *priv = opaque; + VncState *vs = priv->vs; + png_colorp color = &priv->png_palette[idx]; + + if (vs->tight.pixel24) + { + color->red = (pix >> vs->clientds.pf.rshift) & vs->clientds.pf.rmax; + color->green = (pix >> vs->clientds.pf.gshift) & vs->clientds.pf.gmax; + color->blue = (pix >> vs->clientds.pf.bshift) & vs->clientds.pf.bmax; + } + else + { + int red, green, blue; + + red = (pix >> vs->clientds.pf.rshift) & vs->clientds.pf.rmax; + green = (pix >> vs->clientds.pf.gshift) & vs->clientds.pf.gmax; + blue = (pix >> vs->clientds.pf.bshift) & vs->clientds.pf.bmax; + color->red = ((red * 255 + vs->clientds.pf.rmax / 2) / + vs->clientds.pf.rmax); + color->green = ((green * 255 + vs->clientds.pf.gmax / 2) / + vs->clientds.pf.gmax); + color->blue = ((blue * 255 + vs->clientds.pf.bmax / 2) / + vs->clientds.pf.bmax); + } +} + +static void png_write_data(png_structp png_ptr, png_bytep data, + png_size_t length) +{ + VncState *vs = png_get_io_ptr(png_ptr); + + buffer_reserve(&vs->tight.png, vs->tight.png.offset + length); + memcpy(vs->tight.png.buffer + vs->tight.png.offset, data, length); + + vs->tight.png.offset += length; +} + +static void png_flush_data(png_structp png_ptr) +{ +} + +static void *vnc_png_malloc(png_structp png_ptr, png_size_t size) +{ + return qemu_malloc(size); +} + +static void vnc_png_free(png_structp png_ptr, png_voidp ptr) +{ + qemu_free(ptr); +} + +static int send_png_rect(VncState *vs, int x, int y, int w, int h, + VncPalette *palette) +{ + png_byte color_type; + png_structp png_ptr; + png_infop info_ptr; + png_colorp png_palette = NULL; + int level = tight_png_conf[vs->tight.compression].png_zlib_level; + int filters = tight_png_conf[vs->tight.compression].png_filters; + uint8_t *buf; + int dy; + + png_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL, + NULL, vnc_png_malloc, vnc_png_free); + + if (png_ptr == NULL) + return -1; + + info_ptr = png_create_info_struct(png_ptr); + + if (info_ptr == NULL) { + png_destroy_write_struct(&png_ptr, NULL); + return -1; + } + + png_set_write_fn(png_ptr, (void *) vs, png_write_data, png_flush_data); + png_set_compression_level(png_ptr, level); + png_set_filter(png_ptr, PNG_FILTER_TYPE_DEFAULT, filters); + + if (palette) { + color_type = PNG_COLOR_TYPE_PALETTE; + } else { + color_type = PNG_COLOR_TYPE_RGB; + } + + png_set_IHDR(png_ptr, info_ptr, w, h, + 8, color_type, PNG_INTERLACE_NONE, + PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); + + if (color_type == PNG_COLOR_TYPE_PALETTE) { + struct palette_cb_priv priv; + + png_palette = png_malloc(png_ptr, sizeof(*png_palette) * + palette_size(palette)); + + priv.vs = vs; + priv.png_palette = png_palette; + palette_iter(palette, write_png_palette, &priv); + + png_set_PLTE(png_ptr, info_ptr, png_palette, palette_size(palette)); + + if (vs->clientds.pf.bytes_per_pixel == 4) { + tight_encode_indexed_rect32(vs->tight.tight.buffer, w * h, palette); + } else { + tight_encode_indexed_rect16(vs->tight.tight.buffer, w * h, palette); + } + } + + png_write_info(png_ptr, info_ptr); + + buffer_reserve(&vs->tight.png, 2048); + buf = qemu_malloc(w * 3); + for (dy = 0; dy < h; dy++) + { + if (color_type == PNG_COLOR_TYPE_PALETTE) { + memcpy(buf, vs->tight.tight.buffer + (dy * w), w); + } else { + rgb_prepare_row(vs, buf, x, y + dy, w); + } + png_write_row(png_ptr, buf); + } + qemu_free(buf); + + png_write_end(png_ptr, NULL); + + if (color_type == PNG_COLOR_TYPE_PALETTE) { + png_free(png_ptr, png_palette); + } + + png_destroy_write_struct(&png_ptr, &info_ptr); + + vnc_write_u8(vs, VNC_TIGHT_PNG << 4); + + tight_send_compact_size(vs, vs->tight.png.offset); + vnc_write(vs, vs->tight.png.buffer, vs->tight.png.offset); + buffer_reset(&vs->tight.png); + return 1; +} +#endif /* CONFIG_VNC_PNG */ + static void vnc_tight_start(VncState *vs) { - buffer_reset(&vs->tight); + buffer_reset(&vs->tight.tight); // make the output buffer be the zlib buffer, so we can compress it later - vs->tight_tmp = vs->output; - vs->output = vs->tight; + vs->tight.tmp = vs->output; + vs->output = vs->tight.tight; } static void vnc_tight_stop(VncState *vs) { // switch back to normal output/zlib buffers - vs->tight = vs->output; - vs->output = vs->tight_tmp; + vs->tight.tight = vs->output; + vs->output = vs->tight.tmp; } -static int send_sub_rect(VncState *vs, int x, int y, int w, int h) +static int send_sub_rect_nojpeg(VncState *vs, int x, int y, int w, int h, + int bg, int fg, int colors, VncPalette *palette) { - struct QDict *palette = NULL; - uint32_t bg = 0, fg = 0; - int colors; - int ret = 0; + int ret; - vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_TIGHT); - - vnc_tight_start(vs); - vnc_raw_send_framebuffer_update(vs, x, y, w, h); - vnc_tight_stop(vs); + if (colors == 0) { + if (tight_detect_smooth_image(vs, w, h)) { + ret = send_gradient_rect(vs, x, y, w, h); + } else { + ret = send_full_color_rect(vs, x, y, w, h); + } + } else if (colors == 1) { + ret = send_solid_rect(vs); + } else if (colors == 2) { + ret = send_mono_rect(vs, x, y, w, h, bg, fg); + } else if (colors <= 256) { + ret = send_palette_rect(vs, x, y, w, h, palette); + } else { + ret = 0; + } + return ret; +} - colors = tight_fill_palette(vs, x, y, w * h, &fg, &bg, &palette); +#ifdef CONFIG_VNC_JPEG +static int send_sub_rect_jpeg(VncState *vs, int x, int y, int w, int h, + int bg, int fg, int colors, + VncPalette *palette) +{ + int ret; if (colors == 0) { if (tight_detect_smooth_image(vs, w, h)) { - if (vs->tight_quality == -1) { - ret = send_gradient_rect(vs, w, h); - } else { -#ifdef CONFIG_VNC_JPEG - int quality = tight_conf[vs->tight_quality].jpeg_quality; + int quality = tight_conf[vs->tight.quality].jpeg_quality; - ret = send_jpeg_rect(vs, x, y, w, h, quality); -#else - ret = send_full_color_rect(vs, w, h); -#endif - } + ret = send_jpeg_rect(vs, x, y, w, h, quality); } else { - ret = send_full_color_rect(vs, w, h); + ret = send_full_color_rect(vs, x, y, w, h); } } else if (colors == 1) { ret = send_solid_rect(vs); } else if (colors == 2) { - ret = send_mono_rect(vs, w, h, bg, fg); + ret = send_mono_rect(vs, x, y, w, h, bg, fg); } else if (colors <= 256) { -#ifdef CONFIG_VNC_JPEG - if (colors > 96 && vs->tight_quality != -1 && vs->tight_quality <= 3 && + if (colors > 96 && tight_detect_smooth_image(vs, w, h)) { - int quality = tight_conf[vs->tight_quality].jpeg_quality; + int quality = tight_conf[vs->tight.quality].jpeg_quality; ret = send_jpeg_rect(vs, x, y, w, h, quality); } else { - ret = send_palette_rect(vs, w, h, palette); + ret = send_palette_rect(vs, x, y, w, h, palette); } -#else - ret = send_palette_rect(vs, w, h, palette); + } else { + ret = 0; + } + return ret; +} #endif + +static int send_sub_rect(VncState *vs, int x, int y, int w, int h) +{ + VncPalette *palette = NULL; + uint32_t bg = 0, fg = 0; + int colors; + int ret = 0; + + vnc_framebuffer_update(vs, x, y, w, h, vs->tight.type); + + vnc_tight_start(vs); + vnc_raw_send_framebuffer_update(vs, x, y, w, h); + vnc_tight_stop(vs); + + colors = tight_fill_palette(vs, x, y, w * h, &fg, &bg, &palette); + +#ifdef CONFIG_VNC_JPEG + if (vs->tight.quality != (uint8_t)-1) { + ret = send_sub_rect_jpeg(vs, x, y, w, h, bg, fg, colors, palette); + } else { + ret = send_sub_rect_nojpeg(vs, x, y, w, h, bg, fg, colors, palette); } - QDECREF(palette); +#else + ret = send_sub_rect_nojpeg(vs, x, y, w, h, bg, fg, colors, palette); +#endif + + palette_destroy(palette); return ret; } static int send_sub_rect_solid(VncState *vs, int x, int y, int w, int h) { - vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_TIGHT); + vnc_framebuffer_update(vs, x, y, w, h, vs->tight.type); vnc_tight_start(vs); vnc_raw_send_framebuffer_update(vs, x, y, w, h); @@ -1376,8 +1556,8 @@ static int send_rect_simple(VncState *vs, int x, int y, int w, int h) int rw, rh; int n = 0; - max_size = tight_conf[vs->tight_compression].max_rect_size; - max_width = tight_conf[vs->tight_compression].max_rect_width; + max_size = tight_conf[vs->tight.compression].max_rect_size; + max_width = tight_conf[vs->tight.compression].max_rect_width; if (w > max_width || w * h > max_size) { max_sub_width = (w > max_width) ? max_width : w; @@ -1452,8 +1632,8 @@ static int find_large_solid_color_rect(VncState *vs, int x, int y, n += send_rect_simple(vs, x, y, w, y_best-y); } if (x_best != x) { - n += vnc_tight_send_framebuffer_update(vs, x, y_best, - x_best-x, h_best); + n += tight_send_framebuffer_update(vs, x, y_best, + x_best-x, h_best); } /* Send solid-color rectangle. */ @@ -1462,14 +1642,14 @@ static int find_large_solid_color_rect(VncState *vs, int x, int y, /* Send remaining rectangles (at right and bottom). */ if (x_best + w_best != x + w) { - n += vnc_tight_send_framebuffer_update(vs, x_best+w_best, - y_best, - w-(x_best-x)-w_best, - h_best); + n += tight_send_framebuffer_update(vs, x_best+w_best, + y_best, + w-(x_best-x)-w_best, + h_best); } if (y_best + h_best != y + h) { - n += vnc_tight_send_framebuffer_update(vs, x, y_best+h_best, - w, h-(y_best-y)-h_best); + n += tight_send_framebuffer_update(vs, x, y_best+h_best, + w, h-(y_best-y)-h_best); } /* Return after all recursive calls are done. */ @@ -1479,16 +1659,16 @@ static int find_large_solid_color_rect(VncState *vs, int x, int y, return n + send_rect_simple(vs, x, y, w, h); } -int vnc_tight_send_framebuffer_update(VncState *vs, int x, int y, - int w, int h) +static int tight_send_framebuffer_update(VncState *vs, int x, int y, + int w, int h) { int max_rows; if (vs->clientds.pf.bytes_per_pixel == 4 && vs->clientds.pf.rmax == 0xFF && vs->clientds.pf.bmax == 0xFF && vs->clientds.pf.gmax == 0xFF) { - vs->tight_pixel24 = true; + vs->tight.pixel24 = true; } else { - vs->tight_pixel24 = false; + vs->tight.pixel24 = false; } if (w * h < VNC_TIGHT_MIN_SPLIT_RECT_SIZE) @@ -1496,25 +1676,42 @@ int vnc_tight_send_framebuffer_update(VncState *vs, int x, int y, /* Calculate maximum number of rows in one non-solid rectangle. */ - max_rows = tight_conf[vs->tight_compression].max_rect_size; - max_rows /= MIN(tight_conf[vs->tight_compression].max_rect_width, w); + max_rows = tight_conf[vs->tight.compression].max_rect_size; + max_rows /= MIN(tight_conf[vs->tight.compression].max_rect_width, w); return find_large_solid_color_rect(vs, x, y, w, h, max_rows); } +int vnc_tight_send_framebuffer_update(VncState *vs, int x, int y, + int w, int h) +{ + vs->tight.type = VNC_ENCODING_TIGHT; + return tight_send_framebuffer_update(vs, x, y, w, h); +} + +int vnc_tight_png_send_framebuffer_update(VncState *vs, int x, int y, + int w, int h) +{ + vs->tight.type = VNC_ENCODING_TIGHT_PNG; + return tight_send_framebuffer_update(vs, x, y, w, h); +} + void vnc_tight_clear(VncState *vs) { int i; - for (i=0; itight_stream); i++) { - if (vs->tight_stream[i].opaque) { - deflateEnd(&vs->tight_stream[i]); + for (i=0; itight.stream); i++) { + if (vs->tight.stream[i].opaque) { + deflateEnd(&vs->tight.stream[i]); } } - buffer_free(&vs->tight); - buffer_free(&vs->tight_zlib); - buffer_free(&vs->tight_gradient); + buffer_free(&vs->tight.tight); + buffer_free(&vs->tight.zlib); + buffer_free(&vs->tight.gradient); #ifdef CONFIG_VNC_JPEG - buffer_free(&vs->tight_jpeg); + buffer_free(&vs->tight.jpeg); +#endif +#ifdef CONFIG_VNC_PNG + buffer_free(&vs->tight.png); #endif }