From patchwork Wed Jun 16 07:12:05 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Corentin Chary X-Patchwork-Id: 55850 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [199.232.76.165]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 55FAF1007D2 for ; Wed, 16 Jun 2010 16:35:51 +1000 (EST) Received: from localhost ([127.0.0.1]:46318 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OOmDx-0005PN-VE for incoming@patchwork.ozlabs.org; Wed, 16 Jun 2010 02:35:46 -0400 Received: from [140.186.70.92] (port=53331 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OOlqz-0001t3-Bd for qemu-devel@nongnu.org; Wed, 16 Jun 2010 02:12:07 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OOlqv-00031o-2q for qemu-devel@nongnu.org; Wed, 16 Jun 2010 02:12:01 -0400 Received: from iksaif.net ([88.191.73.63]:35948) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OOlqu-00030f-Ec for qemu-devel@nongnu.org; Wed, 16 Jun 2010 02:11:56 -0400 Received: from tartiflon (lal69-3-82-241-209-44.fbx.proxad.net [82.241.209.44]) (Authenticated sender: corentincj@iksaif.net) by iksaif.net (Postfix) with ESMTPA id 8AFF4C9001F; Wed, 16 Jun 2010 08:16:17 +0200 (CEST) From: Corentin Chary To: qemu-devel@nongnu.org Date: Wed, 16 Jun 2010 09:12:05 +0200 Message-Id: <1276672333-14831-9-git-send-email-corentincj@iksaif.net> X-Mailer: git-send-email 1.7.1 In-Reply-To: <1276672333-14831-1-git-send-email-corentincj@iksaif.net> References: <1276672333-14831-1-git-send-email-corentincj@iksaif.net> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 3) Cc: Corentin Chary , Anthony Liguori , Alexander Graf Subject: [Qemu-devel] [PATCH 08/16] vnc: tight add PNG encoding X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Introduce a new encoding: VNC_ENCODING_TIGHT_PNG (0x17) and a new tight filter VNC_TIGHT_PNG (0x0A). When the client tells it supports the 0x17 encoding, the server will use tight, but will always send encoding pixels using PNG instead of zlib. If the client also told it support JPEG, then the server can send JPEG, because PNG will only be used in the cases zlib was used in normal tight. This encoding was introduced to speed up HTML5 based VNC clients like noVNC [1], but can also be used on devices like iPhone where PNG can be rendered in hardware. [1] http://github.com/kanaka/noVNC/ Signed-off-by: Corentin Chary --- Makefile.target | 1 + configure | 37 +++++++ ui/vnc-enc-tight.c | 277 ++++++++++++++++++++++++++++++++++++++++++++++------ ui/vnc-enc-tight.h | 17 ++-- ui/vnc.c | 9 +- ui/vnc.h | 11 ++ 6 files changed, 311 insertions(+), 41 deletions(-) diff --git a/Makefile.target b/Makefile.target index d9e888a..a3ea025 100644 --- a/Makefile.target +++ b/Makefile.target @@ -178,6 +178,7 @@ LIBS+=-lz QEMU_CFLAGS += $(VNC_TLS_CFLAGS) QEMU_CFLAGS += $(VNC_SASL_CFLAGS) QEMU_CFLAGS += $(VNC_JPEG_CFLAGS) +QEMU_CFLAGS += $(VNC_PNG_CFLAGS) # xen backend driver support obj-$(CONFIG_XEN) += xen_machine_pv.o xen_domainbuild.o diff --git a/configure b/configure index 304b4b0..d4c34f6 100755 --- a/configure +++ b/configure @@ -269,6 +269,7 @@ vde="" vnc_tls="" vnc_sasl="" vnc_jpeg="" +vnc_png="" xen="" linux_aio="" vhost_net="" @@ -579,6 +580,10 @@ for opt do ;; --enable-vnc-jpeg) vnc_jpeg="yes" ;; + --disable-vnc-png) vnc_png="no" + ;; + --enable-vnc-png) vnc_png="yes" + ;; --disable-slirp) slirp="no" ;; --disable-uuid) uuid="no" @@ -825,6 +830,8 @@ echo " --disable-vnc-sasl disable SASL encryption for VNC server" echo " --enable-vnc-sasl enable SASL encryption for VNC server" echo " --disable-vnc-jpeg disable JPEG lossy compression for VNC server" echo " --enable-vnc-jpeg enable JPEG lossy compression for VNC server" +echo " --disable-vnc-png disable PNG compression for VNC server" +echo " --enable-vnc-png enable PNG compression for VNC server" echo " --disable-curses disable curses output" echo " --enable-curses enable curses output" echo " --disable-curl disable curl connectivity" @@ -1265,6 +1272,31 @@ EOF fi ########################################## +# VNC PNG detection +if test "$vnc_png" = "yes" ; then +cat > $TMPC < +#include +int main(void) { + png_structp png_ptr; + png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); + return 0; +} +EOF + vnc_png_cflags="" + vnc_png_libs="-lpng" + if compile_prog "$vnc_png_cflags" "$vnc_png_libs" ; then + vnc_png=yes + libs_softmmu="$vnc_png_libs $libs_softmmu" + else + if test "$vnc_png" = "yes" ; then + feature_not_found "vnc-png" + fi + vnc_png=no + fi +fi + +########################################## # fnmatch() probe, used for ACL routines fnmatch="no" cat > $TMPC << EOF @@ -2093,6 +2125,7 @@ echo "Mixer emulation $mixemu" echo "VNC TLS support $vnc_tls" echo "VNC SASL support $vnc_sasl" echo "VNC JPEG support $vnc_jpeg" +echo "VNC PNG support $vnc_png" if test -n "$sparc_cpu"; then echo "Target Sparc Arch $sparc_cpu" fi @@ -2233,6 +2266,10 @@ if test "$vnc_jpeg" = "yes" ; then echo "CONFIG_VNC_JPEG=y" >> $config_host_mak echo "VNC_JPEG_CFLAGS=$vnc_jpeg_cflags" >> $config_host_mak fi +if test "$vnc_png" = "yes" ; then + echo "CONFIG_VNC_PNG=y" >> $config_host_mak + echo "VNC_PNG_CFLAGS=$vnc_png_cflags" >> $config_host_mak +fi if test "$fnmatch" = "yes" ; then echo "CONFIG_FNMATCH=y" >> $config_host_mak fi diff --git a/ui/vnc-enc-tight.c b/ui/vnc-enc-tight.c index 4ff88a8..007d88f 100644 --- a/ui/vnc-enc-tight.c +++ b/ui/vnc-enc-tight.c @@ -26,13 +26,18 @@ * 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" @@ -63,6 +68,28 @@ static const struct { { 65536, 2048, 32, 8192, 9, 9, 9, 6, 200, 500, 96, 80, 200, 500 } }; +#ifdef CONFIG_VNC_PNG +static int send_png_rect(VncState *vs, int x, int y, int w, int h, + QDict *palette); + +static bool tight_can_send_png_rect(VncState *vs, int w, int h) +{ + if (!vnc_has_feature(vs, VNC_FEATURE_TIGHT_PNG)) { + return false; + } + + if (ds_get_bytes_per_pixel(vs->ds) == 1 || + vs->clientds.pf.bytes_per_pixel == 1) { + return false; + } + + if (w * h < VNC_TIGHT_PNG_MIN_RECT_SIZE) { + return false; + } + return true; +} +#endif + /* * Code to guess if given rectangle is suitable for smooth image * compression (by applying "gradient" filter or JPEG coder). @@ -466,6 +493,7 @@ static void print_palette(const char *key, QObject *obj, void *opaque) src = (uint##bpp##_t *) buf; \ \ for (i = 0; i < count; i++) { \ + \ rgb = *src++; \ rep = 0; \ while (i < count && *src == rgb) { \ @@ -937,11 +965,17 @@ 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; +#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) { @@ -975,12 +1009,27 @@ static int send_solid_rect(VncState *vs) 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; int stream = 1; 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; + QDict *palette = qdict_new(); + int bpp = vs->clientds.pf.bytes_per_pixel * 8; + + tight_palette_insert(palette, bg, bpp, 2); + tight_palette_insert(palette, fg, bpp, 2); + ret = send_png_rect(vs, x, y, w, h, palette); + QDECREF(palette); + return ret; + } +#endif + bytes = ((w + 7) / 8) * h; vnc_write_u8(vs, (stream | VNC_TIGHT_EXPLICIT_FILTER) << 4); @@ -1021,6 +1070,9 @@ 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) @@ -1041,14 +1093,14 @@ static void write_palette(const char *key, QObject *obj, void *opaque) } } -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; 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); @@ -1076,13 +1128,20 @@ static bool send_gradient_rect(VncState *vs, int w, int h) 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, struct QDict *palette) { int stream = 2; int level = tight_conf[vs->tight_compression].idx_zlib_level; int colors; size_t bytes; +#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 = qdict_size(palette); vnc_write_u8(vs, (stream | VNC_TIGHT_EXPLICIT_FILTER) << 4); @@ -1130,12 +1189,9 @@ static int send_palette_rect(VncState *vs, int w, int h, struct QDict *palette) 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 +1208,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,21 +1242,26 @@ 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); + rgb_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); + rgb_prepare_row32(vs, dst, x, y, count); else - jpeg_prepare_row16(vs, dst, x, y, count); + 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. */ @@ -1245,7 +1306,7 @@ 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); buffer_reserve(&vs->tight_jpeg, 2048); @@ -1271,7 +1332,7 @@ static int send_jpeg_rect(VncState *vs, int x, int y, int w, int h, int quality) 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); @@ -1289,6 +1350,162 @@ static int send_jpeg_rect(VncState *vs, int x, int y, int w, int h, int quality) } #endif /* CONFIG_VNC_JPEG */ +/* + * PNG compression stuff. + */ +#ifdef CONFIG_VNC_PNG +static void write_png_palette(const char *key, QObject *obj, 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)); + png_colorp color = &priv->png_palette[idx]; + uint32_t pix; + + if (bytes == 4) { + pix = tight_palette_buf2rgb(32, (uint8_t *)key); + } else { + pix = tight_palette_buf2rgb(16, (uint8_t *)key); + } + + 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, + QDict *palette) +{ + png_byte color_type; + png_structp png_ptr; + png_infop info_ptr; + png_colorp png_palette = NULL; + size_t offset; + int level = tight_conf[vs->tight_compression].raw_zlib_level; + 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); + + 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) * + qdict_size(palette)); + + priv.vs = vs; + priv.png_palette = png_palette; + qdict_iter(palette, write_png_palette, &priv); + + png_set_PLTE(png_ptr, info_ptr, png_palette, qdict_size(palette)); + + offset = vs->tight.offset; + if (vs->clientds.pf.bytes_per_pixel == 4) { + tight_encode_indexed_rect32(vs->tight.buffer, w * h, palette); + } else { + tight_encode_indexed_rect16(vs->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.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); @@ -1323,23 +1540,23 @@ static int send_sub_rect(VncState *vs, int x, int y, int w, int h) if (colors == 0) { if (tight_detect_smooth_image(vs, w, h)) { if (vs->tight_quality == -1) { - ret = send_gradient_rect(vs, w, h); + ret = send_gradient_rect(vs, x, y, w, h); } else { #ifdef CONFIG_VNC_JPEG 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); + ret = send_full_color_rect(vs, x, y, w, h); #endif } } 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 && @@ -1348,10 +1565,10 @@ static int send_sub_rect(VncState *vs, int x, int y, int w, int h) 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); + ret = send_palette_rect(vs, x, y, w, h, palette); #endif } QDECREF(palette); diff --git a/ui/vnc-enc-tight.h b/ui/vnc-enc-tight.h index 9b0910c..dc7150a 100644 --- a/ui/vnc-enc-tight.h +++ b/ui/vnc-enc-tight.h @@ -42,8 +42,9 @@ * bit 3: if 1, then compression stream 3 should be reset; * bits 7-4: if 1000 (0x08), then the compression type is "fill", * if 1001 (0x09), then the compression type is "jpeg", + * if 1010 (0x0A), then the compression type is "png", * if 0xxx, then the compression type is "basic", - * values greater than 1001 are not valid. + * values greater than 1010 are not valid. * * If the compression type is "basic", then bits 6..4 of the * compression control byte (those xxx in 0xxx) specify the following: @@ -53,17 +54,17 @@ * bit 6: if 1, then a "filter id" byte is following this byte. * *-- The data that follows after the compression control byte described - * above depends on the compression type ("fill", "jpeg" or "basic"). + * above depends on the compression type ("fill", "jpeg", "png" or "basic"). * *-- If the compression type is "fill", then the only pixel value follows, in * client pixel format (see NOTE 1). This value applies to all pixels of the * rectangle. * - *-- If the compression type is "jpeg", the following data stream looks like - * this: + *-- If the compression type is "jpeg" or "png", the following data stream + * looks like this: * * 1..3 bytes: data size (N) in compact representation; - * N bytes: JPEG image. + * N bytes: JPEG or PNG image. * * Data size is compactly represented in one, two or three bytes, according * to the following scheme: @@ -144,7 +145,7 @@ *-- NOTE 2. The decoder must reset compression streams' states before * decoding the rectangle, if some of bits 0,1,2,3 in the compression control * byte are set to 1. Note that the decoder must reset zlib streams even if - * the compression type is "fill" or "jpeg". + * the compression type is "fill", "jpeg" or "png". * *-- NOTE 3. The "gradient" filter and "jpeg" compression may be used only * when bits-per-pixel value is either 16 or 32, not 8. @@ -158,7 +159,8 @@ #define VNC_TIGHT_EXPLICIT_FILTER 0x04 #define VNC_TIGHT_FILL 0x08 #define VNC_TIGHT_JPEG 0x09 -#define VNC_TIGHT_MAX_SUBENCODING 0x09 +#define VNC_TIGHT_PNG 0x0A +#define VNC_TIGHT_MAX_SUBENCODING 0x0A /* Filters to improve compression efficiency */ #define VNC_TIGHT_FILTER_COPY 0x00 @@ -174,6 +176,7 @@ #define VNC_TIGHT_MAX_SPLIT_TILE_SIZE 16 #define VNC_TIGHT_JPEG_MIN_RECT_SIZE 4096 +#define VNC_TIGHT_PNG_MIN_RECT_SIZE 4096 #define VNC_TIGHT_DETECT_SUBROW_WIDTH 7 #define VNC_TIGHT_DETECT_MIN_WIDTH 8 #define VNC_TIGHT_DETECT_MIN_HEIGHT 8 diff --git a/ui/vnc.c b/ui/vnc.c index ccd7aad..d87a1bf 100644 --- a/ui/vnc.c +++ b/ui/vnc.c @@ -351,10 +351,6 @@ void do_info_vnc(Monitor *mon, QObject **ret_data) } } -static inline uint32_t vnc_has_feature(VncState *vs, int feature) { - return (vs->features & (1 << feature)); -} - /* TODO 1) Get the queue working for IO. 2) there is some weirdness when using the -S option (the screen is grey @@ -659,6 +655,7 @@ static int send_framebuffer_update(VncState *vs, int x, int y, int w, int h) n = vnc_hextile_send_framebuffer_update(vs, x, y, w, h); break; case VNC_ENCODING_TIGHT: + case VNC_ENCODING_TIGHT_PNG: n = vnc_tight_send_framebuffer_update(vs, x, y, w, h); break; default: @@ -1669,6 +1666,10 @@ static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings) vs->features |= VNC_FEATURE_TIGHT_MASK; vs->vnc_encoding = enc; break; + case VNC_ENCODING_TIGHT_PNG: + vs->features |= VNC_FEATURE_TIGHT_PNG_MASK; + vs->vnc_encoding = enc; + break; case VNC_ENCODING_ZLIB: vs->features |= VNC_FEATURE_ZLIB_MASK; vs->vnc_encoding = enc; diff --git a/ui/vnc.h b/ui/vnc.h index ec90cd3..f69a1e3 100644 --- a/ui/vnc.h +++ b/ui/vnc.h @@ -182,6 +182,9 @@ struct VncState #ifdef CONFIG_VNC_JPEG Buffer tight_jpeg; #endif +#ifdef CONFIG_VNC_PNG + Buffer tight_png; +#endif int tight_levels[4]; z_stream tight_stream[4]; @@ -245,6 +248,7 @@ enum { #define VNC_ENCODING_HEXTILE 0x00000005 #define VNC_ENCODING_ZLIB 0x00000006 #define VNC_ENCODING_TIGHT 0x00000007 +#define VNC_ENCODING_TIGHT_PNG 0x00000017 #define VNC_ENCODING_ZLIBHEX 0x00000008 #define VNC_ENCODING_TRLE 0x0000000f #define VNC_ENCODING_ZRLE 0x00000010 @@ -275,6 +279,7 @@ enum { #define VNC_TIGHT_CCB_TYPE_MASK (0x0f << 4) #define VNC_TIGHT_CCB_TYPE_FILL (0x08 << 4) #define VNC_TIGHT_CCB_TYPE_JPEG (0x09 << 4) +#define VNC_TIGHT_CCB_TYPE_PNG (0x0A << 4) #define VNC_TIGHT_CCB_BASIC_MAX (0x07 << 4) #define VNC_TIGHT_CCB_BASIC_ZLIB (0x03 << 4) #define VNC_TIGHT_CCB_BASIC_FILTER (0x04 << 4) @@ -293,6 +298,7 @@ enum { #define VNC_FEATURE_ZLIB 5 #define VNC_FEATURE_COPYRECT 6 #define VNC_FEATURE_RICH_CURSOR 7 +#define VNC_FEATURE_TIGHT_PNG 8 #define VNC_FEATURE_RESIZE_MASK (1 << VNC_FEATURE_RESIZE) #define VNC_FEATURE_HEXTILE_MASK (1 << VNC_FEATURE_HEXTILE) @@ -302,6 +308,7 @@ enum { #define VNC_FEATURE_ZLIB_MASK (1 << VNC_FEATURE_ZLIB) #define VNC_FEATURE_COPYRECT_MASK (1 << VNC_FEATURE_COPYRECT) #define VNC_FEATURE_RICH_CURSOR_MASK (1 << VNC_FEATURE_RICH_CURSOR) +#define VNC_FEATURE_TIGHT_PNG_MASK (1 << VNC_FEATURE_TIGHT_PNG) /* Client -> Server message IDs */ @@ -405,6 +412,10 @@ void buffer_append(Buffer *buffer, const void *data, size_t len); char *vnc_socket_local_addr(const char *format, int fd); char *vnc_socket_remote_addr(const char *format, int fd); +static inline uint32_t vnc_has_feature(VncState *vs, int feature) { + return (vs->features & (1 << feature)); +} + /* Framebuffer */ void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h, int32_t encoding);