2 * QEMU VNC display driver: tight encoding
4 * From libvncserver/libvncserver/tight.c
5 * Copyright (C) 2000, 2001 Const Kaplinsky. All Rights Reserved.
6 * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
8 * Copyright (C) 2010 Corentin Chary <corentin.chary@gmail.com>
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29 #include "config-host.h"
31 /* This needs to be before jpeglib.h line because of conflict with
32 INT32 definitions between jmorecfg.h (included by jpeglib.h) and
33 Win32 basetsd.h (included by windows.h). */
34 #include "qemu-common.h"
39 #ifdef CONFIG_VNC_JPEG
47 #include "vnc-enc-tight.h"
48 #include "vnc-palette.h"
50 /* Compression level stuff. The following array contains various
51 encoder parameters for each of 10 compression levels (0..9).
52 Last three parameters correspond to JPEG quality levels (0..9). */
55 int max_rect_size
, max_rect_width
;
56 int mono_min_rect_size
, gradient_min_rect_size
;
57 int idx_zlib_level
, mono_zlib_level
, raw_zlib_level
, gradient_zlib_level
;
58 int gradient_threshold
, gradient_threshold24
;
59 int idx_max_colors_divisor
;
60 int jpeg_quality
, jpeg_threshold
, jpeg_threshold24
;
62 { 512, 32, 6, 65536, 0, 0, 0, 0, 0, 0, 4, 5, 10000, 23000 },
63 { 2048, 128, 6, 65536, 1, 1, 1, 0, 0, 0, 8, 10, 8000, 18000 },
64 { 6144, 256, 8, 65536, 3, 3, 2, 0, 0, 0, 24, 15, 6500, 15000 },
65 { 10240, 1024, 12, 65536, 5, 5, 3, 0, 0, 0, 32, 25, 5000, 12000 },
66 { 16384, 2048, 12, 65536, 6, 6, 4, 0, 0, 0, 32, 37, 4000, 10000 },
67 { 32768, 2048, 12, 4096, 7, 7, 5, 4, 150, 380, 32, 50, 3000, 8000 },
68 { 65536, 2048, 16, 4096, 7, 7, 6, 4, 170, 420, 48, 60, 2000, 5000 },
69 { 65536, 2048, 16, 4096, 8, 8, 7, 5, 180, 450, 64, 70, 1000, 2500 },
70 { 65536, 2048, 32, 8192, 9, 9, 8, 6, 190, 475, 64, 75, 500, 1200 },
71 { 65536, 2048, 32, 8192, 9, 9, 9, 6, 200, 500, 96, 80, 200, 500 }
75 static int tight_send_framebuffer_update(VncState
*vs
, int x
, int y
,
78 #ifdef CONFIG_VNC_JPEG
80 double jpeg_freq_min
; /* Don't send JPEG if the freq is bellow */
81 double jpeg_freq_threshold
; /* Always send JPEG if the freq is above */
82 int jpeg_idx
; /* Allow indexed JPEG */
83 int jpeg_full
; /* Allow full color JPEG */
84 } tight_jpeg_conf
[] = {
100 int png_zlib_level
, png_filters
;
101 } tight_png_conf
[] = {
102 { 0, PNG_NO_FILTERS
},
103 { 1, PNG_NO_FILTERS
},
104 { 2, PNG_NO_FILTERS
},
105 { 3, PNG_NO_FILTERS
},
106 { 4, PNG_NO_FILTERS
},
107 { 5, PNG_ALL_FILTERS
},
108 { 6, PNG_ALL_FILTERS
},
109 { 7, PNG_ALL_FILTERS
},
110 { 8, PNG_ALL_FILTERS
},
111 { 9, PNG_ALL_FILTERS
},
114 static int send_png_rect(VncState
*vs
, int x
, int y
, int w
, int h
,
115 VncPalette
*palette
);
117 static bool tight_can_send_png_rect(VncState
*vs
, int w
, int h
)
119 if (vs
->tight
.type
!= VNC_ENCODING_TIGHT_PNG
) {
123 if (ds_get_bytes_per_pixel(vs
->ds
) == 1 ||
124 vs
->clientds
.pf
.bytes_per_pixel
== 1) {
133 * Code to guess if given rectangle is suitable for smooth image
134 * compression (by applying "gradient" filter or JPEG coder).
138 tight_detect_smooth_image24(VncState
*vs
, int w
, int h
)
143 unsigned int stats
[256];
147 unsigned char *buf
= vs
->tight
.tight
.buffer
;
150 * If client is big-endian, color samples begin from the second
151 * byte (offset 1) of a 32-bit pixel value.
153 off
= !!(vs
->clientds
.flags
& QEMU_BIG_ENDIAN_FLAG
);
155 memset(stats
, 0, sizeof (stats
));
157 for (y
= 0, x
= 0; y
< h
&& x
< w
;) {
158 for (d
= 0; d
< h
- y
&& d
< w
- x
- VNC_TIGHT_DETECT_SUBROW_WIDTH
;
160 for (c
= 0; c
< 3; c
++) {
161 left
[c
] = buf
[((y
+d
)*w
+x
+d
)*4+off
+c
] & 0xFF;
163 for (dx
= 1; dx
<= VNC_TIGHT_DETECT_SUBROW_WIDTH
; dx
++) {
164 for (c
= 0; c
< 3; c
++) {
165 pix
= buf
[((y
+d
)*w
+x
+d
+dx
)*4+off
+c
] & 0xFF;
166 stats
[abs(pix
- left
[c
])]++;
181 /* 95% smooth or more ... */
182 if (stats
[0] * 33 / pixels
>= 95) {
187 for (c
= 1; c
< 8; c
++) {
188 errors
+= stats
[c
] * (c
* c
);
189 if (stats
[c
] == 0 || stats
[c
] > stats
[c
-1] * 2) {
193 for (; c
< 256; c
++) {
194 errors
+= stats
[c
] * (c
* c
);
196 errors
/= (pixels
* 3 - stats
[0]);
201 #define DEFINE_DETECT_FUNCTION(bpp) \
203 static unsigned int \
204 tight_detect_smooth_image##bpp(VncState *vs, int w, int h) { \
207 int max[3], shift[3]; \
210 unsigned int stats[256]; \
212 int sample, sum, left[3]; \
213 unsigned int errors; \
214 unsigned char *buf = vs->tight.tight.buffer; \
216 endian = ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) != \
217 (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG)); \
220 max[0] = vs->clientds.pf.rmax; \
221 max[1] = vs->clientds.pf.gmax; \
222 max[2] = vs->clientds.pf.bmax; \
223 shift[0] = vs->clientds.pf.rshift; \
224 shift[1] = vs->clientds.pf.gshift; \
225 shift[2] = vs->clientds.pf.bshift; \
227 memset(stats, 0, sizeof(stats)); \
230 while (y < h && x < w) { \
231 for (d = 0; d < h - y && \
232 d < w - x - VNC_TIGHT_DETECT_SUBROW_WIDTH; d++) { \
233 pix = ((uint##bpp##_t *)buf)[(y+d)*w+x+d]; \
235 pix = bswap##bpp(pix); \
237 for (c = 0; c < 3; c++) { \
238 left[c] = (int)(pix >> shift[c] & max[c]); \
240 for (dx = 1; dx <= VNC_TIGHT_DETECT_SUBROW_WIDTH; \
242 pix = ((uint##bpp##_t *)buf)[(y+d)*w+x+d+dx]; \
244 pix = bswap##bpp(pix); \
247 for (c = 0; c < 3; c++) { \
248 sample = (int)(pix >> shift[c] & max[c]); \
249 sum += abs(sample - left[c]); \
268 if ((stats[0] + stats[1]) * 100 / pixels >= 90) { \
273 for (c = 1; c < 8; c++) { \
274 errors += stats[c] * (c * c); \
275 if (stats[c] == 0 || stats[c] > stats[c-1] * 2) { \
279 for (; c < 256; c++) { \
280 errors += stats[c] * (c * c); \
282 errors /= (pixels - stats[0]); \
287 DEFINE_DETECT_FUNCTION(16)
288 DEFINE_DETECT_FUNCTION(32)
291 tight_detect_smooth_image(VncState
*vs
, int w
, int h
)
294 int compression
= vs
->tight
.compression
;
295 int quality
= vs
->tight
.quality
;
297 if (!vs
->vd
->lossy
) {
301 if (ds_get_bytes_per_pixel(vs
->ds
) == 1 ||
302 vs
->clientds
.pf
.bytes_per_pixel
== 1 ||
303 w
< VNC_TIGHT_DETECT_MIN_WIDTH
|| h
< VNC_TIGHT_DETECT_MIN_HEIGHT
) {
307 if (vs
->tight
.quality
!= (uint8_t)-1) {
308 if (w
* h
< VNC_TIGHT_JPEG_MIN_RECT_SIZE
) {
312 if (w
* h
< tight_conf
[compression
].gradient_min_rect_size
) {
317 if (vs
->clientds
.pf
.bytes_per_pixel
== 4) {
318 if (vs
->tight
.pixel24
) {
319 errors
= tight_detect_smooth_image24(vs
, w
, h
);
320 if (vs
->tight
.quality
!= (uint8_t)-1) {
321 return (errors
< tight_conf
[quality
].jpeg_threshold24
);
323 return (errors
< tight_conf
[compression
].gradient_threshold24
);
325 errors
= tight_detect_smooth_image32(vs
, w
, h
);
328 errors
= tight_detect_smooth_image16(vs
, w
, h
);
331 return (errors
< tight_conf
[quality
].jpeg_threshold
);
333 return (errors
< tight_conf
[compression
].gradient_threshold
);
337 * Code to determine how many different colors used in rectangle.
339 #define DEFINE_FILL_PALETTE_FUNCTION(bpp) \
342 tight_fill_palette##bpp(VncState *vs, int x, int y, \
343 int max, size_t count, \
344 uint32_t *bg, uint32_t *fg, \
345 VncPalette **palette) { \
346 uint##bpp##_t *data; \
347 uint##bpp##_t c0, c1, ci; \
350 data = (uint##bpp##_t *)vs->tight.tight.buffer; \
354 while (i < count && data[i] == c0) \
368 for (i++; i < count; i++) { \
372 } else if (ci == c1) { \
379 *bg = (uint32_t)c0; \
380 *fg = (uint32_t)c1; \
382 *bg = (uint32_t)c1; \
383 *fg = (uint32_t)c0; \
392 *palette = palette_new(max, bpp); \
393 palette_put(*palette, c0); \
394 palette_put(*palette, c1); \
395 palette_put(*palette, ci); \
397 for (i++; i < count; i++) { \
398 if (data[i] == ci) { \
402 if (!palette_put(*palette, (uint32_t)ci)) { \
408 return palette_size(*palette); \
411 DEFINE_FILL_PALETTE_FUNCTION(8)
412 DEFINE_FILL_PALETTE_FUNCTION(16)
413 DEFINE_FILL_PALETTE_FUNCTION(32)
415 static int tight_fill_palette(VncState
*vs
, int x
, int y
,
416 size_t count
, uint32_t *bg
, uint32_t *fg
,
417 VncPalette
**palette
)
421 max
= count
/ tight_conf
[vs
->tight
.compression
].idx_max_colors_divisor
;
423 count
>= tight_conf
[vs
->tight
.compression
].mono_min_rect_size
) {
430 switch(vs
->clientds
.pf
.bytes_per_pixel
) {
432 return tight_fill_palette32(vs
, x
, y
, max
, count
, bg
, fg
, palette
);
434 return tight_fill_palette16(vs
, x
, y
, max
, count
, bg
, fg
, palette
);
437 return tight_fill_palette8(vs
, x
, y
, max
, count
, bg
, fg
, palette
);
443 * Converting truecolor samples into palette indices.
445 #define DEFINE_IDX_ENCODE_FUNCTION(bpp) \
448 tight_encode_indexed_rect##bpp(uint8_t *buf, int count, \
449 VncPalette *palette) { \
450 uint##bpp##_t *src; \
455 src = (uint##bpp##_t *) buf; \
457 for (i = 0; i < count; i++) { \
461 while (i < count && *src == rgb) { \
464 idx = palette_idx(palette, rgb); \
466 * Should never happen, but don't break everything \
467 * if it does, use the first color instead \
469 if (idx == (uint8_t)-1) { \
479 DEFINE_IDX_ENCODE_FUNCTION(16)
480 DEFINE_IDX_ENCODE_FUNCTION(32)
482 #define DEFINE_MONO_ENCODE_FUNCTION(bpp) \
485 tight_encode_mono_rect##bpp(uint8_t *buf, int w, int h, \
486 uint##bpp##_t bg, uint##bpp##_t fg) { \
487 uint##bpp##_t *ptr; \
488 unsigned int value, mask; \
492 ptr = (uint##bpp##_t *) buf; \
493 aligned_width = w - w % 8; \
495 for (y = 0; y < h; y++) { \
496 for (x = 0; x < aligned_width; x += 8) { \
497 for (bg_bits = 0; bg_bits < 8; bg_bits++) { \
498 if (*ptr++ != bg) { \
502 if (bg_bits == 8) { \
506 mask = 0x80 >> bg_bits; \
508 for (bg_bits++; bg_bits < 8; bg_bits++) { \
510 if (*ptr++ != bg) { \
514 *buf++ = (uint8_t)value; \
523 for (; x < w; x++) { \
524 if (*ptr++ != bg) { \
529 *buf++ = (uint8_t)value; \
533 DEFINE_MONO_ENCODE_FUNCTION(8)
534 DEFINE_MONO_ENCODE_FUNCTION(16)
535 DEFINE_MONO_ENCODE_FUNCTION(32)
538 * ``Gradient'' filter for 24-bit color samples.
539 * Should be called only when redMax, greenMax and blueMax are 255.
540 * Color components assumed to be byte-aligned.
544 tight_filter_gradient24(VncState
*vs
, uint8_t *buf
, int w
, int h
)
550 int here
[3], upper
[3], left
[3], upperleft
[3];
554 buf32
= (uint32_t *)buf
;
555 memset(vs
->tight
.gradient
.buffer
, 0, w
* 3 * sizeof(int));
557 if ((vs
->clientds
.flags
& QEMU_BIG_ENDIAN_FLAG
) ==
558 (vs
->ds
->surface
->flags
& QEMU_BIG_ENDIAN_FLAG
)) {
559 shift
[0] = vs
->clientds
.pf
.rshift
;
560 shift
[1] = vs
->clientds
.pf
.gshift
;
561 shift
[2] = vs
->clientds
.pf
.bshift
;
563 shift
[0] = 24 - vs
->clientds
.pf
.rshift
;
564 shift
[1] = 24 - vs
->clientds
.pf
.gshift
;
565 shift
[2] = 24 - vs
->clientds
.pf
.bshift
;
568 for (y
= 0; y
< h
; y
++) {
569 for (c
= 0; c
< 3; c
++) {
573 prev
= (int *)vs
->tight
.gradient
.buffer
;
574 for (x
= 0; x
< w
; x
++) {
576 for (c
= 0; c
< 3; c
++) {
577 upperleft
[c
] = upper
[c
];
580 here
[c
] = (int)(pix32
>> shift
[c
] & 0xFF);
583 prediction
= left
[c
] + upper
[c
] - upperleft
[c
];
584 if (prediction
< 0) {
586 } else if (prediction
> 0xFF) {
589 *buf
++ = (char)(here
[c
] - prediction
);
597 * ``Gradient'' filter for other color depths.
600 #define DEFINE_GRADIENT_FILTER_FUNCTION(bpp) \
603 tight_filter_gradient##bpp(VncState *vs, uint##bpp##_t *buf, \
605 uint##bpp##_t pix, diff; \
608 int max[3], shift[3]; \
609 int here[3], upper[3], left[3], upperleft[3]; \
613 memset (vs->tight.gradient.buffer, 0, w * 3 * sizeof(int)); \
615 endian = ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) != \
616 (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG)); \
618 max[0] = vs->clientds.pf.rmax; \
619 max[1] = vs->clientds.pf.gmax; \
620 max[2] = vs->clientds.pf.bmax; \
621 shift[0] = vs->clientds.pf.rshift; \
622 shift[1] = vs->clientds.pf.gshift; \
623 shift[2] = vs->clientds.pf.bshift; \
625 for (y = 0; y < h; y++) { \
626 for (c = 0; c < 3; c++) { \
630 prev = (int *)vs->tight.gradient.buffer; \
631 for (x = 0; x < w; x++) { \
634 pix = bswap##bpp(pix); \
637 for (c = 0; c < 3; c++) { \
638 upperleft[c] = upper[c]; \
641 here[c] = (int)(pix >> shift[c] & max[c]); \
644 prediction = left[c] + upper[c] - upperleft[c]; \
645 if (prediction < 0) { \
647 } else if (prediction > max[c]) { \
648 prediction = max[c]; \
650 diff |= ((here[c] - prediction) & max[c]) \
654 diff = bswap##bpp(diff); \
661 DEFINE_GRADIENT_FILTER_FUNCTION(16)
662 DEFINE_GRADIENT_FILTER_FUNCTION(32)
665 * Check if a rectangle is all of the same color. If needSameColor is
666 * set to non-zero, then also check that its color equals to the
667 * *colorPtr value. The result is 1 if the test is successful, and in
668 * that case new color will be stored in *colorPtr.
671 #define DEFINE_CHECK_SOLID_FUNCTION(bpp) \
674 check_solid_tile##bpp(VncState *vs, int x, int y, int w, int h, \
675 uint32_t* color, bool samecolor) \
677 VncDisplay *vd = vs->vd; \
678 uint##bpp##_t *fbptr; \
682 fbptr = (uint##bpp##_t *) \
683 (vd->server->data + y * ds_get_linesize(vs->ds) + \
684 x * ds_get_bytes_per_pixel(vs->ds)); \
687 if (samecolor && (uint32_t)c != *color) { \
691 for (dy = 0; dy < h; dy++) { \
692 for (dx = 0; dx < w; dx++) { \
693 if (c != fbptr[dx]) { \
697 fbptr = (uint##bpp##_t *) \
698 ((uint8_t *)fbptr + ds_get_linesize(vs->ds)); \
701 *color = (uint32_t)c; \
705 DEFINE_CHECK_SOLID_FUNCTION(32)
706 DEFINE_CHECK_SOLID_FUNCTION(16)
707 DEFINE_CHECK_SOLID_FUNCTION(8)
709 static bool check_solid_tile(VncState
*vs
, int x
, int y
, int w
, int h
,
710 uint32_t* color
, bool samecolor
)
712 VncDisplay
*vd
= vs
->vd
;
714 switch(vd
->server
->pf
.bytes_per_pixel
) {
716 return check_solid_tile32(vs
, x
, y
, w
, h
, color
, samecolor
);
718 return check_solid_tile16(vs
, x
, y
, w
, h
, color
, samecolor
);
720 return check_solid_tile8(vs
, x
, y
, w
, h
, color
, samecolor
);
724 static void find_best_solid_area(VncState
*vs
, int x
, int y
, int w
, int h
,
725 uint32_t color
, int *w_ptr
, int *h_ptr
)
729 int w_best
= 0, h_best
= 0;
733 for (dy
= y
; dy
< y
+ h
; dy
+= VNC_TIGHT_MAX_SPLIT_TILE_SIZE
) {
735 dh
= MIN(VNC_TIGHT_MAX_SPLIT_TILE_SIZE
, y
+ h
- dy
);
736 dw
= MIN(VNC_TIGHT_MAX_SPLIT_TILE_SIZE
, w_prev
);
738 if (!check_solid_tile(vs
, x
, dy
, dw
, dh
, &color
, true)) {
742 for (dx
= x
+ dw
; dx
< x
+ w_prev
;) {
743 dw
= MIN(VNC_TIGHT_MAX_SPLIT_TILE_SIZE
, x
+ w_prev
- dx
);
745 if (!check_solid_tile(vs
, dx
, dy
, dw
, dh
, &color
, true)) {
752 if (w_prev
* (dy
+ dh
- y
) > w_best
* h_best
) {
754 h_best
= dy
+ dh
- y
;
762 static void extend_solid_area(VncState
*vs
, int x
, int y
, int w
, int h
,
763 uint32_t color
, int *x_ptr
, int *y_ptr
,
764 int *w_ptr
, int *h_ptr
)
768 /* Try to extend the area upwards. */
769 for ( cy
= *y_ptr
- 1;
770 cy
>= y
&& check_solid_tile(vs
, *x_ptr
, cy
, *w_ptr
, 1, &color
, true);
772 *h_ptr
+= *y_ptr
- (cy
+ 1);
776 for ( cy
= *y_ptr
+ *h_ptr
;
778 check_solid_tile(vs
, *x_ptr
, cy
, *w_ptr
, 1, &color
, true);
780 *h_ptr
+= cy
- (*y_ptr
+ *h_ptr
);
782 /* ... to the left. */
783 for ( cx
= *x_ptr
- 1;
784 cx
>= x
&& check_solid_tile(vs
, cx
, *y_ptr
, 1, *h_ptr
, &color
, true);
786 *w_ptr
+= *x_ptr
- (cx
+ 1);
789 /* ... to the right. */
790 for ( cx
= *x_ptr
+ *w_ptr
;
792 check_solid_tile(vs
, cx
, *y_ptr
, 1, *h_ptr
, &color
, true);
794 *w_ptr
+= cx
- (*x_ptr
+ *w_ptr
);
797 static int tight_init_stream(VncState
*vs
, int stream_id
,
798 int level
, int strategy
)
800 z_streamp zstream
= &vs
->tight
.stream
[stream_id
];
802 if (zstream
->opaque
== NULL
) {
805 VNC_DEBUG("VNC: TIGHT: initializing zlib stream %d\n", stream_id
);
806 VNC_DEBUG("VNC: TIGHT: opaque = %p | vs = %p\n", zstream
->opaque
, vs
);
807 zstream
->zalloc
= vnc_zlib_zalloc
;
808 zstream
->zfree
= vnc_zlib_zfree
;
810 err
= deflateInit2(zstream
, level
, Z_DEFLATED
, MAX_WBITS
,
811 MAX_MEM_LEVEL
, strategy
);
814 fprintf(stderr
, "VNC: error initializing zlib\n");
818 vs
->tight
.levels
[stream_id
] = level
;
819 zstream
->opaque
= vs
;
822 if (vs
->tight
.levels
[stream_id
] != level
) {
823 if (deflateParams(zstream
, level
, strategy
) != Z_OK
) {
826 vs
->tight
.levels
[stream_id
] = level
;
831 static void tight_send_compact_size(VncState
*vs
, size_t len
)
835 char buf
[3] = {0, 0, 0};
837 buf
[bytes
++] = len
& 0x7F;
839 buf
[bytes
-1] |= 0x80;
840 buf
[bytes
++] = (len
>> 7) & 0x7F;
842 buf
[bytes
-1] |= 0x80;
843 buf
[bytes
++] = (len
>> 14) & 0xFF;
846 for (lpc
= 0; lpc
< bytes
; lpc
++) {
847 vnc_write_u8(vs
, buf
[lpc
]);
851 static int tight_compress_data(VncState
*vs
, int stream_id
, size_t bytes
,
852 int level
, int strategy
)
854 z_streamp zstream
= &vs
->tight
.stream
[stream_id
];
857 if (bytes
< VNC_TIGHT_MIN_TO_COMPRESS
) {
858 vnc_write(vs
, vs
->tight
.tight
.buffer
, vs
->tight
.tight
.offset
);
862 if (tight_init_stream(vs
, stream_id
, level
, strategy
)) {
866 /* reserve memory in output buffer */
867 buffer_reserve(&vs
->tight
.zlib
, bytes
+ 64);
870 zstream
->next_in
= vs
->tight
.tight
.buffer
;
871 zstream
->avail_in
= vs
->tight
.tight
.offset
;
872 zstream
->next_out
= vs
->tight
.zlib
.buffer
+ vs
->tight
.zlib
.offset
;
873 zstream
->avail_out
= vs
->tight
.zlib
.capacity
- vs
->tight
.zlib
.offset
;
874 previous_out
= zstream
->avail_out
;
875 zstream
->data_type
= Z_BINARY
;
878 if (deflate(zstream
, Z_SYNC_FLUSH
) != Z_OK
) {
879 fprintf(stderr
, "VNC: error during tight compression\n");
883 vs
->tight
.zlib
.offset
= vs
->tight
.zlib
.capacity
- zstream
->avail_out
;
884 /* ...how much data has actually been produced by deflate() */
885 bytes
= previous_out
- zstream
->avail_out
;
887 tight_send_compact_size(vs
, bytes
);
888 vnc_write(vs
, vs
->tight
.zlib
.buffer
, bytes
);
890 buffer_reset(&vs
->tight
.zlib
);
896 * Subencoding implementations.
898 static void tight_pack24(VncState
*vs
, uint8_t *buf
, size_t count
, size_t *ret
)
902 int rshift
, gshift
, bshift
;
904 buf32
= (uint32_t *)buf
;
906 if ((vs
->clientds
.flags
& QEMU_BIG_ENDIAN_FLAG
) ==
907 (vs
->ds
->surface
->flags
& QEMU_BIG_ENDIAN_FLAG
)) {
908 rshift
= vs
->clientds
.pf
.rshift
;
909 gshift
= vs
->clientds
.pf
.gshift
;
910 bshift
= vs
->clientds
.pf
.bshift
;
912 rshift
= 24 - vs
->clientds
.pf
.rshift
;
913 gshift
= 24 - vs
->clientds
.pf
.gshift
;
914 bshift
= 24 - vs
->clientds
.pf
.bshift
;
923 *buf
++ = (char)(pix
>> rshift
);
924 *buf
++ = (char)(pix
>> gshift
);
925 *buf
++ = (char)(pix
>> bshift
);
929 static int send_full_color_rect(VncState
*vs
, int x
, int y
, int w
, int h
)
934 #ifdef CONFIG_VNC_PNG
935 if (tight_can_send_png_rect(vs
, w
, h
)) {
936 return send_png_rect(vs
, x
, y
, w
, h
, NULL
);
940 vnc_write_u8(vs
, stream
<< 4); /* no flushing, no filter */
942 if (vs
->tight
.pixel24
) {
943 tight_pack24(vs
, vs
->tight
.tight
.buffer
, w
* h
, &vs
->tight
.tight
.offset
);
946 bytes
= vs
->clientds
.pf
.bytes_per_pixel
;
949 bytes
= tight_compress_data(vs
, stream
, w
* h
* bytes
,
950 tight_conf
[vs
->tight
.compression
].raw_zlib_level
,
956 static int send_solid_rect(VncState
*vs
)
960 vnc_write_u8(vs
, VNC_TIGHT_FILL
<< 4); /* no flushing, no filter */
962 if (vs
->tight
.pixel24
) {
963 tight_pack24(vs
, vs
->tight
.tight
.buffer
, 1, &vs
->tight
.tight
.offset
);
966 bytes
= vs
->clientds
.pf
.bytes_per_pixel
;
969 vnc_write(vs
, vs
->tight
.tight
.buffer
, bytes
);
973 static int send_mono_rect(VncState
*vs
, int x
, int y
,
974 int w
, int h
, uint32_t bg
, uint32_t fg
)
978 int level
= tight_conf
[vs
->tight
.compression
].mono_zlib_level
;
980 #ifdef CONFIG_VNC_PNG
981 if (tight_can_send_png_rect(vs
, w
, h
)) {
983 int bpp
= vs
->clientds
.pf
.bytes_per_pixel
* 8;
984 VncPalette
*palette
= palette_new(2, bpp
);
986 palette_put(palette
, bg
);
987 palette_put(palette
, fg
);
988 ret
= send_png_rect(vs
, x
, y
, w
, h
, palette
);
989 palette_destroy(palette
);
994 bytes
= ((w
+ 7) / 8) * h
;
996 vnc_write_u8(vs
, (stream
| VNC_TIGHT_EXPLICIT_FILTER
) << 4);
997 vnc_write_u8(vs
, VNC_TIGHT_FILTER_PALETTE
);
1000 switch(vs
->clientds
.pf
.bytes_per_pixel
) {
1003 uint32_t buf
[2] = {bg
, fg
};
1004 size_t ret
= sizeof (buf
);
1006 if (vs
->tight
.pixel24
) {
1007 tight_pack24(vs
, (unsigned char*)buf
, 2, &ret
);
1009 vnc_write(vs
, buf
, ret
);
1011 tight_encode_mono_rect32(vs
->tight
.tight
.buffer
, w
, h
, bg
, fg
);
1015 vnc_write(vs
, &bg
, 2);
1016 vnc_write(vs
, &fg
, 2);
1017 tight_encode_mono_rect16(vs
->tight
.tight
.buffer
, w
, h
, bg
, fg
);
1020 vnc_write_u8(vs
, bg
);
1021 vnc_write_u8(vs
, fg
);
1022 tight_encode_mono_rect8(vs
->tight
.tight
.buffer
, w
, h
, bg
, fg
);
1025 vs
->tight
.tight
.offset
= bytes
;
1027 bytes
= tight_compress_data(vs
, stream
, bytes
, level
, Z_DEFAULT_STRATEGY
);
1028 return (bytes
>= 0);
1031 struct palette_cb_priv
{
1034 #ifdef CONFIG_VNC_PNG
1035 png_colorp png_palette
;
1039 static void write_palette(int idx
, uint32_t color
, void *opaque
)
1041 struct palette_cb_priv
*priv
= opaque
;
1042 VncState
*vs
= priv
->vs
;
1043 uint32_t bytes
= vs
->clientds
.pf
.bytes_per_pixel
;
1046 ((uint32_t*)priv
->header
)[idx
] = color
;
1048 ((uint16_t*)priv
->header
)[idx
] = color
;
1052 static bool send_gradient_rect(VncState
*vs
, int x
, int y
, int w
, int h
)
1055 int level
= tight_conf
[vs
->tight
.compression
].gradient_zlib_level
;
1058 if (vs
->clientds
.pf
.bytes_per_pixel
== 1)
1059 return send_full_color_rect(vs
, x
, y
, w
, h
);
1061 vnc_write_u8(vs
, (stream
| VNC_TIGHT_EXPLICIT_FILTER
) << 4);
1062 vnc_write_u8(vs
, VNC_TIGHT_FILTER_GRADIENT
);
1064 buffer_reserve(&vs
->tight
.gradient
, w
* 3 * sizeof (int));
1066 if (vs
->tight
.pixel24
) {
1067 tight_filter_gradient24(vs
, vs
->tight
.tight
.buffer
, w
, h
);
1069 } else if (vs
->clientds
.pf
.bytes_per_pixel
== 4) {
1070 tight_filter_gradient32(vs
, (uint32_t *)vs
->tight
.tight
.buffer
, w
, h
);
1073 tight_filter_gradient16(vs
, (uint16_t *)vs
->tight
.tight
.buffer
, w
, h
);
1077 buffer_reset(&vs
->tight
.gradient
);
1079 bytes
= w
* h
* bytes
;
1080 vs
->tight
.tight
.offset
= bytes
;
1082 bytes
= tight_compress_data(vs
, stream
, bytes
,
1084 return (bytes
>= 0);
1087 static int send_palette_rect(VncState
*vs
, int x
, int y
,
1088 int w
, int h
, VncPalette
*palette
)
1091 int level
= tight_conf
[vs
->tight
.compression
].idx_zlib_level
;
1095 #ifdef CONFIG_VNC_PNG
1096 if (tight_can_send_png_rect(vs
, w
, h
)) {
1097 return send_png_rect(vs
, x
, y
, w
, h
, palette
);
1101 colors
= palette_size(palette
);
1103 vnc_write_u8(vs
, (stream
| VNC_TIGHT_EXPLICIT_FILTER
) << 4);
1104 vnc_write_u8(vs
, VNC_TIGHT_FILTER_PALETTE
);
1105 vnc_write_u8(vs
, colors
- 1);
1107 switch(vs
->clientds
.pf
.bytes_per_pixel
) {
1110 size_t old_offset
, offset
;
1111 uint32_t header
[palette_size(palette
)];
1112 struct palette_cb_priv priv
= { vs
, (uint8_t *)header
};
1114 old_offset
= vs
->output
.offset
;
1115 palette_iter(palette
, write_palette
, &priv
);
1116 vnc_write(vs
, header
, sizeof(header
));
1118 if (vs
->tight
.pixel24
) {
1119 tight_pack24(vs
, vs
->output
.buffer
+ old_offset
, colors
, &offset
);
1120 vs
->output
.offset
= old_offset
+ offset
;
1123 tight_encode_indexed_rect32(vs
->tight
.tight
.buffer
, w
* h
, palette
);
1128 uint16_t header
[palette_size(palette
)];
1129 struct palette_cb_priv priv
= { vs
, (uint8_t *)header
};
1131 palette_iter(palette
, write_palette
, &priv
);
1132 vnc_write(vs
, header
, sizeof(header
));
1133 tight_encode_indexed_rect16(vs
->tight
.tight
.buffer
, w
* h
, palette
);
1137 return -1; /* No palette for 8bits colors */
1141 vs
->tight
.tight
.offset
= bytes
;
1143 bytes
= tight_compress_data(vs
, stream
, bytes
,
1144 level
, Z_DEFAULT_STRATEGY
);
1145 return (bytes
>= 0);
1148 #if defined(CONFIG_VNC_JPEG) || defined(CONFIG_VNC_PNG)
1149 static void rgb_prepare_row24(VncState
*vs
, uint8_t *dst
, int x
, int y
,
1152 VncDisplay
*vd
= vs
->vd
;
1156 fbptr
= (uint32_t *)(vd
->server
->data
+ y
* ds_get_linesize(vs
->ds
) +
1157 x
* ds_get_bytes_per_pixel(vs
->ds
));
1161 *dst
++ = (uint8_t)(pix
>> vs
->ds
->surface
->pf
.rshift
);
1162 *dst
++ = (uint8_t)(pix
>> vs
->ds
->surface
->pf
.gshift
);
1163 *dst
++ = (uint8_t)(pix
>> vs
->ds
->surface
->pf
.bshift
);
1167 #define DEFINE_RGB_GET_ROW_FUNCTION(bpp) \
1170 rgb_prepare_row##bpp(VncState *vs, uint8_t *dst, \
1171 int x, int y, int count) \
1173 VncDisplay *vd = vs->vd; \
1174 uint##bpp##_t *fbptr; \
1175 uint##bpp##_t pix; \
1178 fbptr = (uint##bpp##_t *) \
1179 (vd->server->data + y * ds_get_linesize(vs->ds) + \
1180 x * ds_get_bytes_per_pixel(vs->ds)); \
1185 r = (int)((pix >> vs->ds->surface->pf.rshift) \
1186 & vs->ds->surface->pf.rmax); \
1187 g = (int)((pix >> vs->ds->surface->pf.gshift) \
1188 & vs->ds->surface->pf.gmax); \
1189 b = (int)((pix >> vs->ds->surface->pf.bshift) \
1190 & vs->ds->surface->pf.bmax); \
1192 *dst++ = (uint8_t)((r * 255 + vs->ds->surface->pf.rmax / 2) \
1193 / vs->ds->surface->pf.rmax); \
1194 *dst++ = (uint8_t)((g * 255 + vs->ds->surface->pf.gmax / 2) \
1195 / vs->ds->surface->pf.gmax); \
1196 *dst++ = (uint8_t)((b * 255 + vs->ds->surface->pf.bmax / 2) \
1197 / vs->ds->surface->pf.bmax); \
1201 DEFINE_RGB_GET_ROW_FUNCTION(16)
1202 DEFINE_RGB_GET_ROW_FUNCTION(32)
1204 static void rgb_prepare_row(VncState
*vs
, uint8_t *dst
, int x
, int y
,
1207 if (ds_get_bytes_per_pixel(vs
->ds
) == 4) {
1208 if (vs
->ds
->surface
->pf
.rmax
== 0xFF &&
1209 vs
->ds
->surface
->pf
.gmax
== 0xFF &&
1210 vs
->ds
->surface
->pf
.bmax
== 0xFF) {
1211 rgb_prepare_row24(vs
, dst
, x
, y
, count
);
1213 rgb_prepare_row32(vs
, dst
, x
, y
, count
);
1216 rgb_prepare_row16(vs
, dst
, x
, y
, count
);
1219 #endif /* CONFIG_VNC_JPEG or CONFIG_VNC_PNG */
1222 * JPEG compression stuff.
1224 #ifdef CONFIG_VNC_JPEG
1226 * Destination manager implementation for JPEG library.
1229 /* This is called once per encoding */
1230 static void jpeg_init_destination(j_compress_ptr cinfo
)
1232 VncState
*vs
= cinfo
->client_data
;
1233 Buffer
*buffer
= &vs
->tight
.jpeg
;
1235 cinfo
->dest
->next_output_byte
= (JOCTET
*)buffer
->buffer
+ buffer
->offset
;
1236 cinfo
->dest
->free_in_buffer
= (size_t)(buffer
->capacity
- buffer
->offset
);
1239 /* This is called when we ran out of buffer (shouldn't happen!) */
1240 static boolean
jpeg_empty_output_buffer(j_compress_ptr cinfo
)
1242 VncState
*vs
= cinfo
->client_data
;
1243 Buffer
*buffer
= &vs
->tight
.jpeg
;
1245 buffer
->offset
= buffer
->capacity
;
1246 buffer_reserve(buffer
, 2048);
1247 jpeg_init_destination(cinfo
);
1251 /* This is called when we are done processing data */
1252 static void jpeg_term_destination(j_compress_ptr cinfo
)
1254 VncState
*vs
= cinfo
->client_data
;
1255 Buffer
*buffer
= &vs
->tight
.jpeg
;
1257 buffer
->offset
= buffer
->capacity
- cinfo
->dest
->free_in_buffer
;
1260 static int send_jpeg_rect(VncState
*vs
, int x
, int y
, int w
, int h
, int quality
)
1262 struct jpeg_compress_struct cinfo
;
1263 struct jpeg_error_mgr jerr
;
1264 struct jpeg_destination_mgr manager
;
1269 if (ds_get_bytes_per_pixel(vs
->ds
) == 1)
1270 return send_full_color_rect(vs
, x
, y
, w
, h
);
1272 buffer_reserve(&vs
->tight
.jpeg
, 2048);
1274 cinfo
.err
= jpeg_std_error(&jerr
);
1275 jpeg_create_compress(&cinfo
);
1277 cinfo
.client_data
= vs
;
1278 cinfo
.image_width
= w
;
1279 cinfo
.image_height
= h
;
1280 cinfo
.input_components
= 3;
1281 cinfo
.in_color_space
= JCS_RGB
;
1283 jpeg_set_defaults(&cinfo
);
1284 jpeg_set_quality(&cinfo
, quality
, true);
1286 manager
.init_destination
= jpeg_init_destination
;
1287 manager
.empty_output_buffer
= jpeg_empty_output_buffer
;
1288 manager
.term_destination
= jpeg_term_destination
;
1289 cinfo
.dest
= &manager
;
1291 jpeg_start_compress(&cinfo
, true);
1293 buf
= qemu_malloc(w
* 3);
1295 for (dy
= 0; dy
< h
; dy
++) {
1296 rgb_prepare_row(vs
, buf
, x
, y
+ dy
, w
);
1297 jpeg_write_scanlines(&cinfo
, row
, 1);
1301 jpeg_finish_compress(&cinfo
);
1302 jpeg_destroy_compress(&cinfo
);
1304 vnc_write_u8(vs
, VNC_TIGHT_JPEG
<< 4);
1306 tight_send_compact_size(vs
, vs
->tight
.jpeg
.offset
);
1307 vnc_write(vs
, vs
->tight
.jpeg
.buffer
, vs
->tight
.jpeg
.offset
);
1308 buffer_reset(&vs
->tight
.jpeg
);
1312 #endif /* CONFIG_VNC_JPEG */
1315 * PNG compression stuff.
1317 #ifdef CONFIG_VNC_PNG
1318 static void write_png_palette(int idx
, uint32_t pix
, void *opaque
)
1320 struct palette_cb_priv
*priv
= opaque
;
1321 VncState
*vs
= priv
->vs
;
1322 png_colorp color
= &priv
->png_palette
[idx
];
1324 if (vs
->tight
.pixel24
)
1326 color
->red
= (pix
>> vs
->clientds
.pf
.rshift
) & vs
->clientds
.pf
.rmax
;
1327 color
->green
= (pix
>> vs
->clientds
.pf
.gshift
) & vs
->clientds
.pf
.gmax
;
1328 color
->blue
= (pix
>> vs
->clientds
.pf
.bshift
) & vs
->clientds
.pf
.bmax
;
1332 int red
, green
, blue
;
1334 red
= (pix
>> vs
->clientds
.pf
.rshift
) & vs
->clientds
.pf
.rmax
;
1335 green
= (pix
>> vs
->clientds
.pf
.gshift
) & vs
->clientds
.pf
.gmax
;
1336 blue
= (pix
>> vs
->clientds
.pf
.bshift
) & vs
->clientds
.pf
.bmax
;
1337 color
->red
= ((red
* 255 + vs
->clientds
.pf
.rmax
/ 2) /
1338 vs
->clientds
.pf
.rmax
);
1339 color
->green
= ((green
* 255 + vs
->clientds
.pf
.gmax
/ 2) /
1340 vs
->clientds
.pf
.gmax
);
1341 color
->blue
= ((blue
* 255 + vs
->clientds
.pf
.bmax
/ 2) /
1342 vs
->clientds
.pf
.bmax
);
1346 static void png_write_data(png_structp png_ptr
, png_bytep data
,
1349 VncState
*vs
= png_get_io_ptr(png_ptr
);
1351 buffer_reserve(&vs
->tight
.png
, vs
->tight
.png
.offset
+ length
);
1352 memcpy(vs
->tight
.png
.buffer
+ vs
->tight
.png
.offset
, data
, length
);
1354 vs
->tight
.png
.offset
+= length
;
1357 static void png_flush_data(png_structp png_ptr
)
1361 static void *vnc_png_malloc(png_structp png_ptr
, png_size_t size
)
1363 return qemu_malloc(size
);
1366 static void vnc_png_free(png_structp png_ptr
, png_voidp ptr
)
1371 static int send_png_rect(VncState
*vs
, int x
, int y
, int w
, int h
,
1372 VncPalette
*palette
)
1374 png_byte color_type
;
1375 png_structp png_ptr
;
1377 png_colorp png_palette
= NULL
;
1378 int level
= tight_png_conf
[vs
->tight
.compression
].png_zlib_level
;
1379 int filters
= tight_png_conf
[vs
->tight
.compression
].png_filters
;
1383 png_ptr
= png_create_write_struct_2(PNG_LIBPNG_VER_STRING
, NULL
, NULL
, NULL
,
1384 NULL
, vnc_png_malloc
, vnc_png_free
);
1386 if (png_ptr
== NULL
)
1389 info_ptr
= png_create_info_struct(png_ptr
);
1391 if (info_ptr
== NULL
) {
1392 png_destroy_write_struct(&png_ptr
, NULL
);
1396 png_set_write_fn(png_ptr
, (void *) vs
, png_write_data
, png_flush_data
);
1397 png_set_compression_level(png_ptr
, level
);
1398 png_set_filter(png_ptr
, PNG_FILTER_TYPE_DEFAULT
, filters
);
1401 color_type
= PNG_COLOR_TYPE_PALETTE
;
1403 color_type
= PNG_COLOR_TYPE_RGB
;
1406 png_set_IHDR(png_ptr
, info_ptr
, w
, h
,
1407 8, color_type
, PNG_INTERLACE_NONE
,
1408 PNG_COMPRESSION_TYPE_DEFAULT
, PNG_FILTER_TYPE_DEFAULT
);
1410 if (color_type
== PNG_COLOR_TYPE_PALETTE
) {
1411 struct palette_cb_priv priv
;
1413 png_palette
= png_malloc(png_ptr
, sizeof(*png_palette
) *
1414 palette_size(palette
));
1417 priv
.png_palette
= png_palette
;
1418 palette_iter(palette
, write_png_palette
, &priv
);
1420 png_set_PLTE(png_ptr
, info_ptr
, png_palette
, palette_size(palette
));
1422 if (vs
->clientds
.pf
.bytes_per_pixel
== 4) {
1423 tight_encode_indexed_rect32(vs
->tight
.tight
.buffer
, w
* h
, palette
);
1425 tight_encode_indexed_rect16(vs
->tight
.tight
.buffer
, w
* h
, palette
);
1429 png_write_info(png_ptr
, info_ptr
);
1431 buffer_reserve(&vs
->tight
.png
, 2048);
1432 buf
= qemu_malloc(w
* 3);
1433 for (dy
= 0; dy
< h
; dy
++)
1435 if (color_type
== PNG_COLOR_TYPE_PALETTE
) {
1436 memcpy(buf
, vs
->tight
.tight
.buffer
+ (dy
* w
), w
);
1438 rgb_prepare_row(vs
, buf
, x
, y
+ dy
, w
);
1440 png_write_row(png_ptr
, buf
);
1444 png_write_end(png_ptr
, NULL
);
1446 if (color_type
== PNG_COLOR_TYPE_PALETTE
) {
1447 png_free(png_ptr
, png_palette
);
1450 png_destroy_write_struct(&png_ptr
, &info_ptr
);
1452 vnc_write_u8(vs
, VNC_TIGHT_PNG
<< 4);
1454 tight_send_compact_size(vs
, vs
->tight
.png
.offset
);
1455 vnc_write(vs
, vs
->tight
.png
.buffer
, vs
->tight
.png
.offset
);
1456 buffer_reset(&vs
->tight
.png
);
1459 #endif /* CONFIG_VNC_PNG */
1461 static void vnc_tight_start(VncState
*vs
)
1463 buffer_reset(&vs
->tight
.tight
);
1465 // make the output buffer be the zlib buffer, so we can compress it later
1466 vs
->tight
.tmp
= vs
->output
;
1467 vs
->output
= vs
->tight
.tight
;
1470 static void vnc_tight_stop(VncState
*vs
)
1472 // switch back to normal output/zlib buffers
1473 vs
->tight
.tight
= vs
->output
;
1474 vs
->output
= vs
->tight
.tmp
;
1477 static int send_sub_rect_nojpeg(VncState
*vs
, int x
, int y
, int w
, int h
,
1478 int bg
, int fg
, int colors
, VncPalette
*palette
)
1483 if (tight_detect_smooth_image(vs
, w
, h
)) {
1484 ret
= send_gradient_rect(vs
, x
, y
, w
, h
);
1486 ret
= send_full_color_rect(vs
, x
, y
, w
, h
);
1488 } else if (colors
== 1) {
1489 ret
= send_solid_rect(vs
);
1490 } else if (colors
== 2) {
1491 ret
= send_mono_rect(vs
, x
, y
, w
, h
, bg
, fg
);
1492 } else if (colors
<= 256) {
1493 ret
= send_palette_rect(vs
, x
, y
, w
, h
, palette
);
1500 #ifdef CONFIG_VNC_JPEG
1501 static int send_sub_rect_jpeg(VncState
*vs
, int x
, int y
, int w
, int h
,
1502 int bg
, int fg
, int colors
,
1503 VncPalette
*palette
, bool force
)
1508 if (force
|| (tight_jpeg_conf
[vs
->tight
.quality
].jpeg_full
&&
1509 tight_detect_smooth_image(vs
, w
, h
))) {
1510 int quality
= tight_conf
[vs
->tight
.quality
].jpeg_quality
;
1512 ret
= send_jpeg_rect(vs
, x
, y
, w
, h
, quality
);
1514 ret
= send_full_color_rect(vs
, x
, y
, w
, h
);
1516 } else if (colors
== 1) {
1517 ret
= send_solid_rect(vs
);
1518 } else if (colors
== 2) {
1519 ret
= send_mono_rect(vs
, x
, y
, w
, h
, bg
, fg
);
1520 } else if (colors
<= 256) {
1521 if (force
|| (colors
> 96 &&
1522 tight_jpeg_conf
[vs
->tight
.quality
].jpeg_idx
&&
1523 tight_detect_smooth_image(vs
, w
, h
))) {
1524 int quality
= tight_conf
[vs
->tight
.quality
].jpeg_quality
;
1526 ret
= send_jpeg_rect(vs
, x
, y
, w
, h
, quality
);
1528 ret
= send_palette_rect(vs
, x
, y
, w
, h
, palette
);
1537 static int send_sub_rect(VncState
*vs
, int x
, int y
, int w
, int h
)
1539 VncPalette
*palette
= NULL
;
1540 uint32_t bg
= 0, fg
= 0;
1543 #ifdef CONFIG_VNC_JPEG
1544 bool force_jpeg
= false;
1545 bool allow_jpeg
= true;
1548 vnc_framebuffer_update(vs
, x
, y
, w
, h
, vs
->tight
.type
);
1550 vnc_tight_start(vs
);
1551 vnc_raw_send_framebuffer_update(vs
, x
, y
, w
, h
);
1554 #ifdef CONFIG_VNC_JPEG
1555 if (!vs
->vd
->non_adaptive
&& vs
->tight
.quality
!= (uint8_t)-1) {
1556 double freq
= vnc_update_freq(vs
, x
, y
, w
, h
);
1558 if (freq
< tight_jpeg_conf
[vs
->tight
.quality
].jpeg_freq_min
) {
1561 if (freq
>= tight_jpeg_conf
[vs
->tight
.quality
].jpeg_freq_threshold
) {
1563 vnc_sent_lossy_rect(vs
, x
, y
, w
, h
);
1568 colors
= tight_fill_palette(vs
, x
, y
, w
* h
, &fg
, &bg
, &palette
);
1570 #ifdef CONFIG_VNC_JPEG
1571 if (allow_jpeg
&& vs
->tight
.quality
!= (uint8_t)-1) {
1572 ret
= send_sub_rect_jpeg(vs
, x
, y
, w
, h
, bg
, fg
, colors
, palette
,
1575 ret
= send_sub_rect_nojpeg(vs
, x
, y
, w
, h
, bg
, fg
, colors
, palette
);
1578 ret
= send_sub_rect_nojpeg(vs
, x
, y
, w
, h
, bg
, fg
, colors
, palette
);
1581 palette_destroy(palette
);
1585 static int send_sub_rect_solid(VncState
*vs
, int x
, int y
, int w
, int h
)
1587 vnc_framebuffer_update(vs
, x
, y
, w
, h
, vs
->tight
.type
);
1589 vnc_tight_start(vs
);
1590 vnc_raw_send_framebuffer_update(vs
, x
, y
, w
, h
);
1593 return send_solid_rect(vs
);
1596 static int send_rect_simple(VncState
*vs
, int x
, int y
, int w
, int h
,
1599 int max_size
, max_width
;
1600 int max_sub_width
, max_sub_height
;
1605 max_size
= tight_conf
[vs
->tight
.compression
].max_rect_size
;
1606 max_width
= tight_conf
[vs
->tight
.compression
].max_rect_width
;
1608 if (split
&& (w
> max_width
|| w
* h
> max_size
)) {
1609 max_sub_width
= (w
> max_width
) ? max_width
: w
;
1610 max_sub_height
= max_size
/ max_sub_width
;
1612 for (dy
= 0; dy
< h
; dy
+= max_sub_height
) {
1613 for (dx
= 0; dx
< w
; dx
+= max_width
) {
1614 rw
= MIN(max_sub_width
, w
- dx
);
1615 rh
= MIN(max_sub_height
, h
- dy
);
1616 n
+= send_sub_rect(vs
, x
+dx
, y
+dy
, rw
, rh
);
1620 n
+= send_sub_rect(vs
, x
, y
, w
, h
);
1626 static int find_large_solid_color_rect(VncState
*vs
, int x
, int y
,
1627 int w
, int h
, int max_rows
)
1632 /* Try to find large solid-color areas and send them separately. */
1634 for (dy
= y
; dy
< y
+ h
; dy
+= VNC_TIGHT_MAX_SPLIT_TILE_SIZE
) {
1636 /* If a rectangle becomes too large, send its upper part now. */
1638 if (dy
- y
>= max_rows
) {
1639 n
+= send_rect_simple(vs
, x
, y
, w
, max_rows
, true);
1644 dh
= MIN(VNC_TIGHT_MAX_SPLIT_TILE_SIZE
, (y
+ h
- dy
));
1646 for (dx
= x
; dx
< x
+ w
; dx
+= VNC_TIGHT_MAX_SPLIT_TILE_SIZE
) {
1647 uint32_t color_value
;
1648 int x_best
, y_best
, w_best
, h_best
;
1650 dw
= MIN(VNC_TIGHT_MAX_SPLIT_TILE_SIZE
, (x
+ w
- dx
));
1652 if (!check_solid_tile(vs
, dx
, dy
, dw
, dh
, &color_value
, false)) {
1656 /* Get dimensions of solid-color area. */
1658 find_best_solid_area(vs
, dx
, dy
, w
- (dx
- x
), h
- (dy
- y
),
1659 color_value
, &w_best
, &h_best
);
1661 /* Make sure a solid rectangle is large enough
1662 (or the whole rectangle is of the same color). */
1664 if (w_best
* h_best
!= w
* h
&&
1665 w_best
* h_best
< VNC_TIGHT_MIN_SOLID_SUBRECT_SIZE
) {
1669 /* Try to extend solid rectangle to maximum size. */
1671 x_best
= dx
; y_best
= dy
;
1672 extend_solid_area(vs
, x
, y
, w
, h
, color_value
,
1673 &x_best
, &y_best
, &w_best
, &h_best
);
1675 /* Send rectangles at top and left to solid-color area. */
1678 n
+= send_rect_simple(vs
, x
, y
, w
, y_best
-y
, true);
1681 n
+= tight_send_framebuffer_update(vs
, x
, y_best
,
1685 /* Send solid-color rectangle. */
1686 n
+= send_sub_rect_solid(vs
, x_best
, y_best
, w_best
, h_best
);
1688 /* Send remaining rectangles (at right and bottom). */
1690 if (x_best
+ w_best
!= x
+ w
) {
1691 n
+= tight_send_framebuffer_update(vs
, x_best
+w_best
,
1693 w
-(x_best
-x
)-w_best
,
1696 if (y_best
+ h_best
!= y
+ h
) {
1697 n
+= tight_send_framebuffer_update(vs
, x
, y_best
+h_best
,
1698 w
, h
-(y_best
-y
)-h_best
);
1701 /* Return after all recursive calls are done. */
1705 return n
+ send_rect_simple(vs
, x
, y
, w
, h
, true);
1708 static int tight_send_framebuffer_update(VncState
*vs
, int x
, int y
,
1713 if (vs
->clientds
.pf
.bytes_per_pixel
== 4 && vs
->clientds
.pf
.rmax
== 0xFF &&
1714 vs
->clientds
.pf
.bmax
== 0xFF && vs
->clientds
.pf
.gmax
== 0xFF) {
1715 vs
->tight
.pixel24
= true;
1717 vs
->tight
.pixel24
= false;
1720 #ifdef CONFIG_VNC_JPEG
1721 if (vs
->tight
.quality
!= (uint8_t)-1) {
1722 double freq
= vnc_update_freq(vs
, x
, y
, w
, h
);
1724 if (freq
> tight_jpeg_conf
[vs
->tight
.quality
].jpeg_freq_threshold
) {
1725 return send_rect_simple(vs
, x
, y
, w
, h
, false);
1730 if (w
* h
< VNC_TIGHT_MIN_SPLIT_RECT_SIZE
) {
1731 return send_rect_simple(vs
, x
, y
, w
, h
, true);
1734 /* Calculate maximum number of rows in one non-solid rectangle. */
1736 max_rows
= tight_conf
[vs
->tight
.compression
].max_rect_size
;
1737 max_rows
/= MIN(tight_conf
[vs
->tight
.compression
].max_rect_width
, w
);
1739 return find_large_solid_color_rect(vs
, x
, y
, w
, h
, max_rows
);
1742 int vnc_tight_send_framebuffer_update(VncState
*vs
, int x
, int y
,
1745 vs
->tight
.type
= VNC_ENCODING_TIGHT
;
1746 return tight_send_framebuffer_update(vs
, x
, y
, w
, h
);
1749 int vnc_tight_png_send_framebuffer_update(VncState
*vs
, int x
, int y
,
1752 vs
->tight
.type
= VNC_ENCODING_TIGHT_PNG
;
1753 return tight_send_framebuffer_update(vs
, x
, y
, w
, h
);
1756 void vnc_tight_clear(VncState
*vs
)
1759 for (i
=0; i
<ARRAY_SIZE(vs
->tight
.stream
); i
++) {
1760 if (vs
->tight
.stream
[i
].opaque
) {
1761 deflateEnd(&vs
->tight
.stream
[i
]);
1765 buffer_free(&vs
->tight
.tight
);
1766 buffer_free(&vs
->tight
.zlib
);
1767 buffer_free(&vs
->tight
.gradient
);
1768 #ifdef CONFIG_VNC_JPEG
1769 buffer_free(&vs
->tight
.jpeg
);
1771 #ifdef CONFIG_VNC_PNG
1772 buffer_free(&vs
->tight
.png
);