![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vnc-enc-tight.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / ui|
Return to vnc-enc-tight.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / ui |
1.1 root 1: /*
2: * QEMU VNC display driver: tight encoding
3: *
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.
7: *
8: * Copyright (C) 2010 Corentin Chary <[email protected]>
9: *
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:
16: *
17: * The above copyright notice and this permission notice shall be included in
18: * all copies or substantial portions of the Software.
19: *
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
26: * THE SOFTWARE.
27: */
28:
29: #include "config-host.h"
30:
31: #ifdef CONFIG_VNC_PNG
32: #include <png.h>
33: #endif
34: #ifdef CONFIG_VNC_JPEG
35: #include <stdio.h>
36: #include <jpeglib.h>
37: #endif
38:
39: #include "qemu-common.h"
40:
41: #include "bswap.h"
42: #include "qint.h"
43: #include "vnc.h"
44: #include "vnc-enc-tight.h"
45: #include "vnc-palette.h"
46:
47: /* Compression level stuff. The following array contains various
48: encoder parameters for each of 10 compression levels (0..9).
49: Last three parameters correspond to JPEG quality levels (0..9). */
50:
51: static const struct {
52: int max_rect_size, max_rect_width;
53: int mono_min_rect_size, gradient_min_rect_size;
54: int idx_zlib_level, mono_zlib_level, raw_zlib_level, gradient_zlib_level;
55: int gradient_threshold, gradient_threshold24;
56: int idx_max_colors_divisor;
57: int jpeg_quality, jpeg_threshold, jpeg_threshold24;
58: } tight_conf[] = {
59: { 512, 32, 6, 65536, 0, 0, 0, 0, 0, 0, 4, 5, 10000, 23000 },
60: { 2048, 128, 6, 65536, 1, 1, 1, 0, 0, 0, 8, 10, 8000, 18000 },
61: { 6144, 256, 8, 65536, 3, 3, 2, 0, 0, 0, 24, 15, 6500, 15000 },
62: { 10240, 1024, 12, 65536, 5, 5, 3, 0, 0, 0, 32, 25, 5000, 12000 },
63: { 16384, 2048, 12, 65536, 6, 6, 4, 0, 0, 0, 32, 37, 4000, 10000 },
64: { 32768, 2048, 12, 4096, 7, 7, 5, 4, 150, 380, 32, 50, 3000, 8000 },
65: { 65536, 2048, 16, 4096, 7, 7, 6, 4, 170, 420, 48, 60, 2000, 5000 },
66: { 65536, 2048, 16, 4096, 8, 8, 7, 5, 180, 450, 64, 70, 1000, 2500 },
67: { 65536, 2048, 32, 8192, 9, 9, 8, 6, 190, 475, 64, 75, 500, 1200 },
68: { 65536, 2048, 32, 8192, 9, 9, 9, 6, 200, 500, 96, 80, 200, 500 }
69: };
70:
71:
72: static int tight_send_framebuffer_update(VncState *vs, int x, int y,
73: int w, int h);
74:
75: #ifdef CONFIG_VNC_PNG
76: static const struct {
77: int png_zlib_level, png_filters;
78: } tight_png_conf[] = {
79: { 0, PNG_NO_FILTERS },
80: { 1, PNG_NO_FILTERS },
81: { 2, PNG_NO_FILTERS },
82: { 3, PNG_NO_FILTERS },
83: { 4, PNG_NO_FILTERS },
84: { 5, PNG_ALL_FILTERS },
85: { 6, PNG_ALL_FILTERS },
86: { 7, PNG_ALL_FILTERS },
87: { 8, PNG_ALL_FILTERS },
88: { 9, PNG_ALL_FILTERS },
89: };
90:
91: static int send_png_rect(VncState *vs, int x, int y, int w, int h,
92: VncPalette *palette);
93:
94: static bool tight_can_send_png_rect(VncState *vs, int w, int h)
95: {
96: if (vs->tight.type != VNC_ENCODING_TIGHT_PNG) {
97: return false;
98: }
99:
100: if (ds_get_bytes_per_pixel(vs->ds) == 1 ||
101: vs->clientds.pf.bytes_per_pixel == 1) {
102: return false;
103: }
104:
105: return true;
106: }
107: #endif
108:
109: /*
110: * Code to guess if given rectangle is suitable for smooth image
111: * compression (by applying "gradient" filter or JPEG coder).
112: */
113:
114: static uint
115: tight_detect_smooth_image24(VncState *vs, int w, int h)
116: {
117: int off;
118: int x, y, d, dx;
119: uint c;
120: uint stats[256];
121: int pixels = 0;
122: int pix, left[3];
123: uint errors;
124: unsigned char *buf = vs->tight.tight.buffer;
125:
126: /*
127: * If client is big-endian, color samples begin from the second
128: * byte (offset 1) of a 32-bit pixel value.
129: */
130: off = !!(vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG);
131:
132: memset(stats, 0, sizeof (stats));
133:
134: for (y = 0, x = 0; y < h && x < w;) {
135: for (d = 0; d < h - y && d < w - x - VNC_TIGHT_DETECT_SUBROW_WIDTH;
136: d++) {
137: for (c = 0; c < 3; c++) {
138: left[c] = buf[((y+d)*w+x+d)*4+off+c] & 0xFF;
139: }
140: for (dx = 1; dx <= VNC_TIGHT_DETECT_SUBROW_WIDTH; dx++) {
141: for (c = 0; c < 3; c++) {
142: pix = buf[((y+d)*w+x+d+dx)*4+off+c] & 0xFF;
143: stats[abs(pix - left[c])]++;
144: left[c] = pix;
145: }
146: pixels++;
147: }
148: }
149: if (w > h) {
150: x += h;
151: y = 0;
152: } else {
153: x = 0;
154: y += w;
155: }
156: }
157:
158: /* 95% smooth or more ... */
159: if (stats[0] * 33 / pixels >= 95) {
160: return 0;
161: }
162:
163: errors = 0;
164: for (c = 1; c < 8; c++) {
165: errors += stats[c] * (c * c);
166: if (stats[c] == 0 || stats[c] > stats[c-1] * 2) {
167: return 0;
168: }
169: }
170: for (; c < 256; c++) {
171: errors += stats[c] * (c * c);
172: }
173: errors /= (pixels * 3 - stats[0]);
174:
175: return errors;
176: }
177:
178: #define DEFINE_DETECT_FUNCTION(bpp) \
179: \
180: static uint \
181: tight_detect_smooth_image##bpp(VncState *vs, int w, int h) { \
182: bool endian; \
183: uint##bpp##_t pix; \
184: int max[3], shift[3]; \
185: int x, y, d, dx; \
186: uint c; \
187: uint stats[256]; \
188: int pixels = 0; \
189: int sample, sum, left[3]; \
190: uint errors; \
191: unsigned char *buf = vs->tight.tight.buffer; \
192: \
193: endian = ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) != \
194: (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG)); \
195: \
196: \
197: max[0] = vs->clientds.pf.rmax; \
198: max[1] = vs->clientds.pf.gmax; \
199: max[2] = vs->clientds.pf.bmax; \
200: shift[0] = vs->clientds.pf.rshift; \
201: shift[1] = vs->clientds.pf.gshift; \
202: shift[2] = vs->clientds.pf.bshift; \
203: \
204: memset(stats, 0, sizeof(stats)); \
205: \
206: y = 0, x = 0; \
207: while (y < h && x < w) { \
208: for (d = 0; d < h - y && \
209: d < w - x - VNC_TIGHT_DETECT_SUBROW_WIDTH; d++) { \
210: pix = ((uint##bpp##_t *)buf)[(y+d)*w+x+d]; \
211: if (endian) { \
212: pix = bswap_##bpp(pix); \
213: } \
214: for (c = 0; c < 3; c++) { \
215: left[c] = (int)(pix >> shift[c] & max[c]); \
216: } \
217: for (dx = 1; dx <= VNC_TIGHT_DETECT_SUBROW_WIDTH; \
218: dx++) { \
219: pix = ((uint##bpp##_t *)buf)[(y+d)*w+x+d+dx]; \
220: if (endian) { \
221: pix = bswap_##bpp(pix); \
222: } \
223: sum = 0; \
224: for (c = 0; c < 3; c++) { \
225: sample = (int)(pix >> shift[c] & max[c]); \
226: sum += abs(sample - left[c]); \
227: left[c] = sample; \
228: } \
229: if (sum > 255) { \
230: sum = 255; \
231: } \
232: stats[sum]++; \
233: pixels++; \
234: } \
235: } \
236: if (w > h) { \
237: x += h; \
238: y = 0; \
239: } else { \
240: x = 0; \
241: y += w; \
242: } \
243: } \
244: \
245: if ((stats[0] + stats[1]) * 100 / pixels >= 90) { \
246: return 0; \
247: } \
248: \
249: errors = 0; \
250: for (c = 1; c < 8; c++) { \
251: errors += stats[c] * (c * c); \
252: if (stats[c] == 0 || stats[c] > stats[c-1] * 2) { \
253: return 0; \
254: } \
255: } \
256: for (; c < 256; c++) { \
257: errors += stats[c] * (c * c); \
258: } \
259: errors /= (pixels - stats[0]); \
260: \
261: return errors; \
262: }
263:
264: DEFINE_DETECT_FUNCTION(16)
265: DEFINE_DETECT_FUNCTION(32)
266:
267: static int
268: tight_detect_smooth_image(VncState *vs, int w, int h)
269: {
270: uint errors;
271: int compression = vs->tight.compression;
272: int quality = vs->tight.quality;
273:
274: if (!vs->vd->lossy) {
275: return 0;
276: }
277:
278: if (ds_get_bytes_per_pixel(vs->ds) == 1 ||
279: vs->clientds.pf.bytes_per_pixel == 1 ||
280: w < VNC_TIGHT_DETECT_MIN_WIDTH || h < VNC_TIGHT_DETECT_MIN_HEIGHT) {
281: return 0;
282: }
283:
284: if (vs->tight.quality != -1) {
285: if (w * h < VNC_TIGHT_JPEG_MIN_RECT_SIZE) {
286: return 0;
287: }
288: } else {
289: if (w * h < tight_conf[compression].gradient_min_rect_size) {
290: return 0;
291: }
292: }
293:
294: if (vs->clientds.pf.bytes_per_pixel == 4) {
295: if (vs->tight.pixel24) {
296: errors = tight_detect_smooth_image24(vs, w, h);
297: if (vs->tight.quality != -1) {
298: return (errors < tight_conf[quality].jpeg_threshold24);
299: }
300: return (errors < tight_conf[compression].gradient_threshold24);
301: } else {
302: errors = tight_detect_smooth_image32(vs, w, h);
303: }
304: } else {
305: errors = tight_detect_smooth_image16(vs, w, h);
306: }
307: if (quality != -1) {
308: return (errors < tight_conf[quality].jpeg_threshold);
309: }
310: return (errors < tight_conf[compression].gradient_threshold);
311: }
312:
313: /*
314: * Code to determine how many different colors used in rectangle.
315: */
316: #define DEFINE_FILL_PALETTE_FUNCTION(bpp) \
317: \
318: static int \
319: tight_fill_palette##bpp(VncState *vs, int x, int y, \
320: int max, size_t count, \
321: uint32_t *bg, uint32_t *fg, \
322: VncPalette **palette) { \
323: uint##bpp##_t *data; \
324: uint##bpp##_t c0, c1, ci; \
325: int i, n0, n1; \
326: \
327: data = (uint##bpp##_t *)vs->tight.tight.buffer; \
328: \
329: c0 = data[0]; \
330: i = 1; \
331: while (i < count && data[i] == c0) \
332: i++; \
333: if (i >= count) { \
334: *bg = *fg = c0; \
335: return 1; \
336: } \
337: \
338: if (max < 2) { \
339: return 0; \
340: } \
341: \
342: n0 = i; \
343: c1 = data[i]; \
344: n1 = 0; \
345: for (i++; i < count; i++) { \
346: ci = data[i]; \
347: if (ci == c0) { \
348: n0++; \
349: } else if (ci == c1) { \
350: n1++; \
351: } else \
352: break; \
353: } \
354: if (i >= count) { \
355: if (n0 > n1) { \
356: *bg = (uint32_t)c0; \
357: *fg = (uint32_t)c1; \
358: } else { \
359: *bg = (uint32_t)c1; \
360: *fg = (uint32_t)c0; \
361: } \
362: return 2; \
363: } \
364: \
365: if (max == 2) { \
366: return 0; \
367: } \
368: \
369: *palette = palette_new(max, bpp); \
370: palette_put(*palette, c0); \
371: palette_put(*palette, c1); \
372: palette_put(*palette, ci); \
373: \
374: for (i++; i < count; i++) { \
375: if (data[i] == ci) { \
376: continue; \
377: } else { \
378: ci = data[i]; \
379: if (!palette_put(*palette, (uint32_t)ci)) { \
380: return 0; \
381: } \
382: } \
383: } \
384: \
385: return palette_size(*palette); \
386: }
387:
388: DEFINE_FILL_PALETTE_FUNCTION(8)
389: DEFINE_FILL_PALETTE_FUNCTION(16)
390: DEFINE_FILL_PALETTE_FUNCTION(32)
391:
392: static int tight_fill_palette(VncState *vs, int x, int y,
393: size_t count, uint32_t *bg, uint32_t *fg,
394: VncPalette **palette)
395: {
396: int max;
397:
398: max = count / tight_conf[vs->tight.compression].idx_max_colors_divisor;
399: if (max < 2 &&
400: count >= tight_conf[vs->tight.compression].mono_min_rect_size) {
401: max = 2;
402: }
403: if (max >= 256) {
404: max = 256;
405: }
406:
407: switch(vs->clientds.pf.bytes_per_pixel) {
408: case 4:
409: return tight_fill_palette32(vs, x, y, max, count, bg, fg, palette);
410: case 2:
411: return tight_fill_palette16(vs, x, y, max, count, bg, fg, palette);
412: default:
413: max = 2;
414: return tight_fill_palette8(vs, x, y, max, count, bg, fg, palette);
415: }
416: return 0;
417: }
418:
419: /*
420: * Converting truecolor samples into palette indices.
421: */
422: #define DEFINE_IDX_ENCODE_FUNCTION(bpp) \
423: \
424: static void \
425: tight_encode_indexed_rect##bpp(uint8_t *buf, int count, \
426: VncPalette *palette) { \
427: uint##bpp##_t *src; \
428: uint##bpp##_t rgb; \
429: int i, rep; \
430: uint8_t idx; \
431: \
432: src = (uint##bpp##_t *) buf; \
433: \
434: for (i = 0; i < count; i++) { \
435: \
436: rgb = *src++; \
437: rep = 0; \
438: while (i < count && *src == rgb) { \
439: rep++, src++, i++; \
440: } \
441: idx = palette_idx(palette, rgb); \
442: /* \
443: * Should never happen, but don't break everything \
444: * if it does, use the first color instead \
445: */ \
446: if (idx == -1) { \
447: idx = 0; \
448: } \
449: while (rep >= 0) { \
450: *buf++ = idx; \
451: rep--; \
452: } \
453: } \
454: }
455:
456: DEFINE_IDX_ENCODE_FUNCTION(16)
457: DEFINE_IDX_ENCODE_FUNCTION(32)
458:
459: #define DEFINE_MONO_ENCODE_FUNCTION(bpp) \
460: \
461: static void \
462: tight_encode_mono_rect##bpp(uint8_t *buf, int w, int h, \
463: uint##bpp##_t bg, uint##bpp##_t fg) { \
464: uint##bpp##_t *ptr; \
465: unsigned int value, mask; \
466: int aligned_width; \
467: int x, y, bg_bits; \
468: \
469: ptr = (uint##bpp##_t *) buf; \
470: aligned_width = w - w % 8; \
471: \
472: for (y = 0; y < h; y++) { \
473: for (x = 0; x < aligned_width; x += 8) { \
474: for (bg_bits = 0; bg_bits < 8; bg_bits++) { \
475: if (*ptr++ != bg) { \
476: break; \
477: } \
478: } \
479: if (bg_bits == 8) { \
480: *buf++ = 0; \
481: continue; \
482: } \
483: mask = 0x80 >> bg_bits; \
484: value = mask; \
485: for (bg_bits++; bg_bits < 8; bg_bits++) { \
486: mask >>= 1; \
487: if (*ptr++ != bg) { \
488: value |= mask; \
489: } \
490: } \
491: *buf++ = (uint8_t)value; \
492: } \
493: \
494: mask = 0x80; \
495: value = 0; \
496: if (x >= w) { \
497: continue; \
498: } \
499: \
500: for (; x < w; x++) { \
501: if (*ptr++ != bg) { \
502: value |= mask; \
503: } \
504: mask >>= 1; \
505: } \
506: *buf++ = (uint8_t)value; \
507: } \
508: }
509:
510: DEFINE_MONO_ENCODE_FUNCTION(8)
511: DEFINE_MONO_ENCODE_FUNCTION(16)
512: DEFINE_MONO_ENCODE_FUNCTION(32)
513:
514: /*
515: * ``Gradient'' filter for 24-bit color samples.
516: * Should be called only when redMax, greenMax and blueMax are 255.
517: * Color components assumed to be byte-aligned.
518: */
519:
520: static void
521: tight_filter_gradient24(VncState *vs, uint8_t *buf, int w, int h)
522: {
523: uint32_t *buf32;
524: uint32_t pix32;
525: int shift[3];
526: int *prev;
527: int here[3], upper[3], left[3], upperleft[3];
528: int prediction;
529: int x, y, c;
530:
531: buf32 = (uint32_t *)buf;
532: memset(vs->tight.gradient.buffer, 0, w * 3 * sizeof(int));
533:
534: if ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) ==
535: (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG)) {
536: shift[0] = vs->clientds.pf.rshift;
537: shift[1] = vs->clientds.pf.gshift;
538: shift[2] = vs->clientds.pf.bshift;
539: } else {
540: shift[0] = 24 - vs->clientds.pf.rshift;
541: shift[1] = 24 - vs->clientds.pf.gshift;
542: shift[2] = 24 - vs->clientds.pf.bshift;
543: }
544:
545: for (y = 0; y < h; y++) {
546: for (c = 0; c < 3; c++) {
547: upper[c] = 0;
548: here[c] = 0;
549: }
550: prev = (int *)vs->tight.gradient.buffer;
551: for (x = 0; x < w; x++) {
552: pix32 = *buf32++;
553: for (c = 0; c < 3; c++) {
554: upperleft[c] = upper[c];
555: left[c] = here[c];
556: upper[c] = *prev;
557: here[c] = (int)(pix32 >> shift[c] & 0xFF);
558: *prev++ = here[c];
559:
560: prediction = left[c] + upper[c] - upperleft[c];
561: if (prediction < 0) {
562: prediction = 0;
563: } else if (prediction > 0xFF) {
564: prediction = 0xFF;
565: }
566: *buf++ = (char)(here[c] - prediction);
567: }
568: }
569: }
570: }
571:
572:
573: /*
574: * ``Gradient'' filter for other color depths.
575: */
576:
577: #define DEFINE_GRADIENT_FILTER_FUNCTION(bpp) \
578: \
579: static void \
580: tight_filter_gradient##bpp(VncState *vs, uint##bpp##_t *buf, \
581: int w, int h) { \
582: uint##bpp##_t pix, diff; \
583: bool endian; \
584: int *prev; \
585: int max[3], shift[3]; \
586: int here[3], upper[3], left[3], upperleft[3]; \
587: int prediction; \
588: int x, y, c; \
589: \
590: memset (vs->tight.gradient.buffer, 0, w * 3 * sizeof(int)); \
591: \
592: endian = ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) != \
593: (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG)); \
594: \
595: max[0] = vs->clientds.pf.rmax; \
596: max[1] = vs->clientds.pf.gmax; \
597: max[2] = vs->clientds.pf.bmax; \
598: shift[0] = vs->clientds.pf.rshift; \
599: shift[1] = vs->clientds.pf.gshift; \
600: shift[2] = vs->clientds.pf.bshift; \
601: \
602: for (y = 0; y < h; y++) { \
603: for (c = 0; c < 3; c++) { \
604: upper[c] = 0; \
605: here[c] = 0; \
606: } \
607: prev = (int *)vs->tight.gradient.buffer; \
608: for (x = 0; x < w; x++) { \
609: pix = *buf; \
610: if (endian) { \
611: pix = bswap_##bpp(pix); \
612: } \
613: diff = 0; \
614: for (c = 0; c < 3; c++) { \
615: upperleft[c] = upper[c]; \
616: left[c] = here[c]; \
617: upper[c] = *prev; \
618: here[c] = (int)(pix >> shift[c] & max[c]); \
619: *prev++ = here[c]; \
620: \
621: prediction = left[c] + upper[c] - upperleft[c]; \
622: if (prediction < 0) { \
623: prediction = 0; \
624: } else if (prediction > max[c]) { \
625: prediction = max[c]; \
626: } \
627: diff |= ((here[c] - prediction) & max[c]) \
628: << shift[c]; \
629: } \
630: if (endian) { \
631: diff = bswap_##bpp(diff); \
632: } \
633: *buf++ = diff; \
634: } \
635: } \
636: }
637:
638: DEFINE_GRADIENT_FILTER_FUNCTION(16)
639: DEFINE_GRADIENT_FILTER_FUNCTION(32)
640:
641: /*
642: * Check if a rectangle is all of the same color. If needSameColor is
643: * set to non-zero, then also check that its color equals to the
644: * *colorPtr value. The result is 1 if the test is successfull, and in
645: * that case new color will be stored in *colorPtr.
646: */
647:
648: #define DEFINE_CHECK_SOLID_FUNCTION(bpp) \
649: \
650: static bool \
651: check_solid_tile##bpp(VncState *vs, int x, int y, int w, int h, \
652: uint32_t* color, bool samecolor) \
653: { \
654: VncDisplay *vd = vs->vd; \
655: uint##bpp##_t *fbptr; \
656: uint##bpp##_t c; \
657: int dx, dy; \
658: \
659: fbptr = (uint##bpp##_t *) \
660: (vd->server->data + y * ds_get_linesize(vs->ds) + \
661: x * ds_get_bytes_per_pixel(vs->ds)); \
662: \
663: c = *fbptr; \
664: if (samecolor && (uint32_t)c != *color) { \
665: return false; \
666: } \
667: \
668: for (dy = 0; dy < h; dy++) { \
669: for (dx = 0; dx < w; dx++) { \
670: if (c != fbptr[dx]) { \
671: return false; \
672: } \
673: } \
674: fbptr = (uint##bpp##_t *) \
675: ((uint8_t *)fbptr + ds_get_linesize(vs->ds)); \
676: } \
677: \
678: *color = (uint32_t)c; \
679: return true; \
680: }
681:
682: DEFINE_CHECK_SOLID_FUNCTION(32)
683: DEFINE_CHECK_SOLID_FUNCTION(16)
684: DEFINE_CHECK_SOLID_FUNCTION(8)
685:
686: static bool check_solid_tile(VncState *vs, int x, int y, int w, int h,
687: uint32_t* color, bool samecolor)
688: {
689: VncDisplay *vd = vs->vd;
690:
691: switch(vd->server->pf.bytes_per_pixel) {
692: case 4:
693: return check_solid_tile32(vs, x, y, w, h, color, samecolor);
694: case 2:
695: return check_solid_tile16(vs, x, y, w, h, color, samecolor);
696: default:
697: return check_solid_tile8(vs, x, y, w, h, color, samecolor);
698: }
699: }
700:
701: static void find_best_solid_area(VncState *vs, int x, int y, int w, int h,
702: uint32_t color, int *w_ptr, int *h_ptr)
703: {
704: int dx, dy, dw, dh;
705: int w_prev;
706: int w_best = 0, h_best = 0;
707:
708: w_prev = w;
709:
710: for (dy = y; dy < y + h; dy += VNC_TIGHT_MAX_SPLIT_TILE_SIZE) {
711:
712: dh = MIN(VNC_TIGHT_MAX_SPLIT_TILE_SIZE, y + h - dy);
713: dw = MIN(VNC_TIGHT_MAX_SPLIT_TILE_SIZE, w_prev);
714:
715: if (!check_solid_tile(vs, x, dy, dw, dh, &color, true)) {
716: break;
717: }
718:
719: for (dx = x + dw; dx < x + w_prev;) {
720: dw = MIN(VNC_TIGHT_MAX_SPLIT_TILE_SIZE, x + w_prev - dx);
721:
722: if (!check_solid_tile(vs, dx, dy, dw, dh, &color, true)) {
723: break;
724: }
725: dx += dw;
726: }
727:
728: w_prev = dx - x;
729: if (w_prev * (dy + dh - y) > w_best * h_best) {
730: w_best = w_prev;
731: h_best = dy + dh - y;
732: }
733: }
734:
735: *w_ptr = w_best;
736: *h_ptr = h_best;
737: }
738:
739: static void extend_solid_area(VncState *vs, int x, int y, int w, int h,
740: uint32_t color, int *x_ptr, int *y_ptr,
741: int *w_ptr, int *h_ptr)
742: {
743: int cx, cy;
744:
745: /* Try to extend the area upwards. */
746: for ( cy = *y_ptr - 1;
747: cy >= y && check_solid_tile(vs, *x_ptr, cy, *w_ptr, 1, &color, true);
748: cy-- );
749: *h_ptr += *y_ptr - (cy + 1);
750: *y_ptr = cy + 1;
751:
752: /* ... downwards. */
753: for ( cy = *y_ptr + *h_ptr;
754: cy < y + h &&
755: check_solid_tile(vs, *x_ptr, cy, *w_ptr, 1, &color, true);
756: cy++ );
757: *h_ptr += cy - (*y_ptr + *h_ptr);
758:
759: /* ... to the left. */
760: for ( cx = *x_ptr - 1;
761: cx >= x && check_solid_tile(vs, cx, *y_ptr, 1, *h_ptr, &color, true);
762: cx-- );
763: *w_ptr += *x_ptr - (cx + 1);
764: *x_ptr = cx + 1;
765:
766: /* ... to the right. */
767: for ( cx = *x_ptr + *w_ptr;
768: cx < x + w &&
769: check_solid_tile(vs, cx, *y_ptr, 1, *h_ptr, &color, true);
770: cx++ );
771: *w_ptr += cx - (*x_ptr + *w_ptr);
772: }
773:
774: static int tight_init_stream(VncState *vs, int stream_id,
775: int level, int strategy)
776: {
777: z_streamp zstream = &vs->tight.stream[stream_id];
778:
779: if (zstream->opaque == NULL) {
780: int err;
781:
782: VNC_DEBUG("VNC: TIGHT: initializing zlib stream %d\n", stream_id);
783: VNC_DEBUG("VNC: TIGHT: opaque = %p | vs = %p\n", zstream->opaque, vs);
784: zstream->zalloc = vnc_zlib_zalloc;
785: zstream->zfree = vnc_zlib_zfree;
786:
787: err = deflateInit2(zstream, level, Z_DEFLATED, MAX_WBITS,
788: MAX_MEM_LEVEL, strategy);
789:
790: if (err != Z_OK) {
791: fprintf(stderr, "VNC: error initializing zlib\n");
792: return -1;
793: }
794:
795: vs->tight.levels[stream_id] = level;
796: zstream->opaque = vs;
797: }
798:
799: if (vs->tight.levels[stream_id] != level) {
800: if (deflateParams(zstream, level, strategy) != Z_OK) {
801: return -1;
802: }
803: vs->tight.levels[stream_id] = level;
804: }
805: return 0;
806: }
807:
808: static void tight_send_compact_size(VncState *vs, size_t len)
809: {
810: int lpc = 0;
811: int bytes = 0;
812: char buf[3] = {0, 0, 0};
813:
814: buf[bytes++] = len & 0x7F;
815: if (len > 0x7F) {
816: buf[bytes-1] |= 0x80;
817: buf[bytes++] = (len >> 7) & 0x7F;
818: if (len > 0x3FFF) {
819: buf[bytes-1] |= 0x80;
820: buf[bytes++] = (len >> 14) & 0xFF;
821: }
822: }
823: for (lpc = 0; lpc < bytes; lpc++) {
824: vnc_write_u8(vs, buf[lpc]);
825: }
826: }
827:
828: static int tight_compress_data(VncState *vs, int stream_id, size_t bytes,
829: int level, int strategy)
830: {
831: z_streamp zstream = &vs->tight.stream[stream_id];
832: int previous_out;
833:
834: if (bytes < VNC_TIGHT_MIN_TO_COMPRESS) {
835: vnc_write(vs, vs->tight.tight.buffer, vs->tight.tight.offset);
836: return bytes;
837: }
838:
839: if (tight_init_stream(vs, stream_id, level, strategy)) {
840: return -1;
841: }
842:
843: /* reserve memory in output buffer */
844: buffer_reserve(&vs->tight.zlib, bytes + 64);
845:
846: /* set pointers */
847: zstream->next_in = vs->tight.tight.buffer;
848: zstream->avail_in = vs->tight.tight.offset;
849: zstream->next_out = vs->tight.zlib.buffer + vs->tight.zlib.offset;
850: zstream->avail_out = vs->tight.zlib.capacity - vs->tight.zlib.offset;
851: zstream->data_type = Z_BINARY;
852: previous_out = zstream->total_out;
853:
854: /* start encoding */
855: if (deflate(zstream, Z_SYNC_FLUSH) != Z_OK) {
856: fprintf(stderr, "VNC: error during tight compression\n");
857: return -1;
858: }
859:
860: vs->tight.zlib.offset = vs->tight.zlib.capacity - zstream->avail_out;
861: bytes = zstream->total_out - previous_out;
862:
863: tight_send_compact_size(vs, bytes);
864: vnc_write(vs, vs->tight.zlib.buffer, bytes);
865:
866: buffer_reset(&vs->tight.zlib);
867:
868: return bytes;
869: }
870:
871: /*
872: * Subencoding implementations.
873: */
874: static void tight_pack24(VncState *vs, uint8_t *buf, size_t count, size_t *ret)
875: {
876: uint32_t *buf32;
877: uint32_t pix;
878: int rshift, gshift, bshift;
879:
880: buf32 = (uint32_t *)buf;
881:
882: if ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) ==
883: (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG)) {
884: rshift = vs->clientds.pf.rshift;
885: gshift = vs->clientds.pf.gshift;
886: bshift = vs->clientds.pf.bshift;
887: } else {
888: rshift = 24 - vs->clientds.pf.rshift;
889: gshift = 24 - vs->clientds.pf.gshift;
890: bshift = 24 - vs->clientds.pf.bshift;
891: }
892:
893: if (ret) {
894: *ret = count * 3;
895: }
896:
897: while (count--) {
898: pix = *buf32++;
899: *buf++ = (char)(pix >> rshift);
900: *buf++ = (char)(pix >> gshift);
901: *buf++ = (char)(pix >> bshift);
902: }
903: }
904:
905: static int send_full_color_rect(VncState *vs, int x, int y, int w, int h)
906: {
907: int stream = 0;
908: size_t bytes;
909:
910: #ifdef CONFIG_VNC_PNG
911: if (tight_can_send_png_rect(vs, w, h)) {
912: return send_png_rect(vs, x, y, w, h, NULL);
913: }
914: #endif
915:
916: vnc_write_u8(vs, stream << 4); /* no flushing, no filter */
917:
918: if (vs->tight.pixel24) {
919: tight_pack24(vs, vs->tight.tight.buffer, w * h, &vs->tight.tight.offset);
920: bytes = 3;
921: } else {
922: bytes = vs->clientds.pf.bytes_per_pixel;
923: }
924:
925: bytes = tight_compress_data(vs, stream, w * h * bytes,
926: tight_conf[vs->tight.compression].raw_zlib_level,
927: Z_DEFAULT_STRATEGY);
928:
929: return (bytes >= 0);
930: }
931:
932: static int send_solid_rect(VncState *vs)
933: {
934: size_t bytes;
935:
936: vnc_write_u8(vs, VNC_TIGHT_FILL << 4); /* no flushing, no filter */
937:
938: if (vs->tight.pixel24) {
939: tight_pack24(vs, vs->tight.tight.buffer, 1, &vs->tight.tight.offset);
940: bytes = 3;
941: } else {
942: bytes = vs->clientds.pf.bytes_per_pixel;
943: }
944:
945: vnc_write(vs, vs->tight.tight.buffer, bytes);
946: return 1;
947: }
948:
949: static int send_mono_rect(VncState *vs, int x, int y,
950: int w, int h, uint32_t bg, uint32_t fg)
951: {
952: size_t bytes;
953: int stream = 1;
954: int level = tight_conf[vs->tight.compression].mono_zlib_level;
955:
956: #ifdef CONFIG_VNC_PNG
957: if (tight_can_send_png_rect(vs, w, h)) {
958: int ret;
959: int bpp = vs->clientds.pf.bytes_per_pixel * 8;
960: VncPalette *palette = palette_new(2, bpp);
961:
962: palette_put(palette, bg);
963: palette_put(palette, fg);
964: ret = send_png_rect(vs, x, y, w, h, palette);
965: palette_destroy(palette);
966: return ret;
967: }
968: #endif
969:
970: bytes = ((w + 7) / 8) * h;
971:
972: vnc_write_u8(vs, (stream | VNC_TIGHT_EXPLICIT_FILTER) << 4);
973: vnc_write_u8(vs, VNC_TIGHT_FILTER_PALETTE);
974: vnc_write_u8(vs, 1);
975:
976: switch(vs->clientds.pf.bytes_per_pixel) {
977: case 4:
978: {
979: uint32_t buf[2] = {bg, fg};
980: size_t ret = sizeof (buf);
981:
982: if (vs->tight.pixel24) {
983: tight_pack24(vs, (unsigned char*)buf, 2, &ret);
984: }
985: vnc_write(vs, buf, ret);
986:
987: tight_encode_mono_rect32(vs->tight.tight.buffer, w, h, bg, fg);
988: break;
989: }
990: case 2:
991: vnc_write(vs, &bg, 2);
992: vnc_write(vs, &fg, 2);
993: tight_encode_mono_rect16(vs->tight.tight.buffer, w, h, bg, fg);
994: break;
995: default:
996: vnc_write_u8(vs, bg);
997: vnc_write_u8(vs, fg);
998: tight_encode_mono_rect8(vs->tight.tight.buffer, w, h, bg, fg);
999: break;
1000: }
1001: vs->tight.tight.offset = bytes;
1002:
1003: bytes = tight_compress_data(vs, stream, bytes, level, Z_DEFAULT_STRATEGY);
1004: return (bytes >= 0);
1005: }
1006:
1007: struct palette_cb_priv {
1008: VncState *vs;
1009: uint8_t *header;
1010: #ifdef CONFIG_VNC_PNG
1011: png_colorp png_palette;
1012: #endif
1013: };
1014:
1015: static void write_palette(int idx, uint32_t color, void *opaque)
1016: {
1017: struct palette_cb_priv *priv = opaque;
1018: VncState *vs = priv->vs;
1019: uint32_t bytes = vs->clientds.pf.bytes_per_pixel;
1020:
1021: if (bytes == 4) {
1022: ((uint32_t*)priv->header)[idx] = color;
1023: } else {
1024: ((uint16_t*)priv->header)[idx] = color;
1025: }
1026: }
1027:
1028: static bool send_gradient_rect(VncState *vs, int x, int y, int w, int h)
1029: {
1030: int stream = 3;
1031: int level = tight_conf[vs->tight.compression].gradient_zlib_level;
1032: size_t bytes;
1033:
1034: if (vs->clientds.pf.bytes_per_pixel == 1)
1035: return send_full_color_rect(vs, x, y, w, h);
1036:
1037: vnc_write_u8(vs, (stream | VNC_TIGHT_EXPLICIT_FILTER) << 4);
1038: vnc_write_u8(vs, VNC_TIGHT_FILTER_GRADIENT);
1039:
1040: buffer_reserve(&vs->tight.gradient, w * 3 * sizeof (int));
1041:
1042: if (vs->tight.pixel24) {
1043: tight_filter_gradient24(vs, vs->tight.tight.buffer, w, h);
1044: bytes = 3;
1045: } else if (vs->clientds.pf.bytes_per_pixel == 4) {
1046: tight_filter_gradient32(vs, (uint32_t *)vs->tight.tight.buffer, w, h);
1047: bytes = 4;
1048: } else {
1049: tight_filter_gradient16(vs, (uint16_t *)vs->tight.tight.buffer, w, h);
1050: bytes = 2;
1051: }
1052:
1053: buffer_reset(&vs->tight.gradient);
1054:
1055: bytes = w * h * bytes;
1056: vs->tight.tight.offset = bytes;
1057:
1058: bytes = tight_compress_data(vs, stream, bytes,
1059: level, Z_FILTERED);
1060: return (bytes >= 0);
1061: }
1062:
1063: static int send_palette_rect(VncState *vs, int x, int y,
1064: int w, int h, VncPalette *palette)
1065: {
1066: int stream = 2;
1067: int level = tight_conf[vs->tight.compression].idx_zlib_level;
1068: int colors;
1069: size_t bytes;
1070:
1071: #ifdef CONFIG_VNC_PNG
1072: if (tight_can_send_png_rect(vs, w, h)) {
1073: return send_png_rect(vs, x, y, w, h, palette);
1074: }
1075: #endif
1076:
1077: colors = palette_size(palette);
1078:
1079: vnc_write_u8(vs, (stream | VNC_TIGHT_EXPLICIT_FILTER) << 4);
1080: vnc_write_u8(vs, VNC_TIGHT_FILTER_PALETTE);
1081: vnc_write_u8(vs, colors - 1);
1082:
1083: switch(vs->clientds.pf.bytes_per_pixel) {
1084: case 4:
1085: {
1086: size_t old_offset, offset;
1087: uint32_t header[palette_size(palette)];
1088: struct palette_cb_priv priv = { vs, (uint8_t *)header };
1089:
1090: old_offset = vs->output.offset;
1091: palette_iter(palette, write_palette, &priv);
1092: vnc_write(vs, header, sizeof(header));
1093:
1094: if (vs->tight.pixel24) {
1095: tight_pack24(vs, vs->output.buffer + old_offset, colors, &offset);
1096: vs->output.offset = old_offset + offset;
1097: }
1098:
1099: tight_encode_indexed_rect32(vs->tight.tight.buffer, w * h, palette);
1100: break;
1101: }
1102: case 2:
1103: {
1104: uint16_t header[palette_size(palette)];
1105: struct palette_cb_priv priv = { vs, (uint8_t *)header };
1106:
1107: palette_iter(palette, write_palette, &priv);
1108: vnc_write(vs, header, sizeof(header));
1109: tight_encode_indexed_rect16(vs->tight.tight.buffer, w * h, palette);
1110: break;
1111: }
1112: default:
1113: return -1; /* No palette for 8bits colors */
1114: break;
1115: }
1116: bytes = w * h;
1117: vs->tight.tight.offset = bytes;
1118:
1119: bytes = tight_compress_data(vs, stream, bytes,
1120: level, Z_DEFAULT_STRATEGY);
1121: return (bytes >= 0);
1122: }
1123:
1124: #if defined(CONFIG_VNC_JPEG) || defined(CONFIG_VNC_PNG)
1125: static void rgb_prepare_row24(VncState *vs, uint8_t *dst, int x, int y,
1126: int count)
1127: {
1128: VncDisplay *vd = vs->vd;
1129: uint32_t *fbptr;
1130: uint32_t pix;
1131:
1132: fbptr = (uint32_t *)(vd->server->data + y * ds_get_linesize(vs->ds) +
1133: x * ds_get_bytes_per_pixel(vs->ds));
1134:
1135: while (count--) {
1136: pix = *fbptr++;
1137: *dst++ = (uint8_t)(pix >> vs->ds->surface->pf.rshift);
1138: *dst++ = (uint8_t)(pix >> vs->ds->surface->pf.gshift);
1139: *dst++ = (uint8_t)(pix >> vs->ds->surface->pf.bshift);
1140: }
1141: }
1142:
1143: #define DEFINE_RGB_GET_ROW_FUNCTION(bpp) \
1144: \
1145: static void \
1146: rgb_prepare_row##bpp(VncState *vs, uint8_t *dst, \
1147: int x, int y, int count) \
1148: { \
1149: VncDisplay *vd = vs->vd; \
1150: uint##bpp##_t *fbptr; \
1151: uint##bpp##_t pix; \
1152: int r, g, b; \
1153: \
1154: fbptr = (uint##bpp##_t *) \
1155: (vd->server->data + y * ds_get_linesize(vs->ds) + \
1156: x * ds_get_bytes_per_pixel(vs->ds)); \
1157: \
1158: while (count--) { \
1159: pix = *fbptr++; \
1160: \
1161: r = (int)((pix >> vs->ds->surface->pf.rshift) \
1162: & vs->ds->surface->pf.rmax); \
1163: g = (int)((pix >> vs->ds->surface->pf.gshift) \
1164: & vs->ds->surface->pf.gmax); \
1165: b = (int)((pix >> vs->ds->surface->pf.bshift) \
1166: & vs->ds->surface->pf.bmax); \
1167: \
1168: *dst++ = (uint8_t)((r * 255 + vs->ds->surface->pf.rmax / 2) \
1169: / vs->ds->surface->pf.rmax); \
1170: *dst++ = (uint8_t)((g * 255 + vs->ds->surface->pf.gmax / 2) \
1171: / vs->ds->surface->pf.gmax); \
1172: *dst++ = (uint8_t)((b * 255 + vs->ds->surface->pf.bmax / 2) \
1173: / vs->ds->surface->pf.bmax); \
1174: } \
1175: }
1176:
1177: DEFINE_RGB_GET_ROW_FUNCTION(16)
1178: DEFINE_RGB_GET_ROW_FUNCTION(32)
1179:
1180: static void rgb_prepare_row(VncState *vs, uint8_t *dst, int x, int y,
1181: int count)
1182: {
1183: if (ds_get_bytes_per_pixel(vs->ds) == 4) {
1184: if (vs->ds->surface->pf.rmax == 0xFF &&
1185: vs->ds->surface->pf.gmax == 0xFF &&
1186: vs->ds->surface->pf.bmax == 0xFF) {
1187: rgb_prepare_row24(vs, dst, x, y, count);
1188: } else {
1189: rgb_prepare_row32(vs, dst, x, y, count);
1190: }
1191: } else {
1192: rgb_prepare_row16(vs, dst, x, y, count);
1193: }
1194: }
1195: #endif /* CONFIG_VNC_JPEG or CONFIG_VNC_PNG */
1196:
1197: /*
1198: * JPEG compression stuff.
1199: */
1200: #ifdef CONFIG_VNC_JPEG
1201: /*
1202: * Destination manager implementation for JPEG library.
1203: */
1204:
1205: /* This is called once per encoding */
1206: static void jpeg_init_destination(j_compress_ptr cinfo)
1207: {
1208: VncState *vs = cinfo->client_data;
1209: Buffer *buffer = &vs->tight.jpeg;
1210:
1211: cinfo->dest->next_output_byte = (JOCTET *)buffer->buffer + buffer->offset;
1212: cinfo->dest->free_in_buffer = (size_t)(buffer->capacity - buffer->offset);
1213: }
1214:
1215: /* This is called when we ran out of buffer (shouldn't happen!) */
1216: static boolean jpeg_empty_output_buffer(j_compress_ptr cinfo)
1217: {
1218: VncState *vs = cinfo->client_data;
1219: Buffer *buffer = &vs->tight.jpeg;
1220:
1221: buffer->offset = buffer->capacity;
1222: buffer_reserve(buffer, 2048);
1223: jpeg_init_destination(cinfo);
1224: return TRUE;
1225: }
1226:
1227: /* This is called when we are done processing data */
1228: static void jpeg_term_destination(j_compress_ptr cinfo)
1229: {
1230: VncState *vs = cinfo->client_data;
1231: Buffer *buffer = &vs->tight.jpeg;
1232:
1233: buffer->offset = buffer->capacity - cinfo->dest->free_in_buffer;
1234: }
1235:
1236: static int send_jpeg_rect(VncState *vs, int x, int y, int w, int h, int quality)
1237: {
1238: struct jpeg_compress_struct cinfo;
1239: struct jpeg_error_mgr jerr;
1240: struct jpeg_destination_mgr manager;
1241: JSAMPROW row[1];
1242: uint8_t *buf;
1243: int dy;
1244:
1245: if (ds_get_bytes_per_pixel(vs->ds) == 1)
1246: return send_full_color_rect(vs, x, y, w, h);
1247:
1248: buffer_reserve(&vs->tight.jpeg, 2048);
1249:
1250: cinfo.err = jpeg_std_error(&jerr);
1251: jpeg_create_compress(&cinfo);
1252:
1253: cinfo.client_data = vs;
1254: cinfo.image_width = w;
1255: cinfo.image_height = h;
1256: cinfo.input_components = 3;
1257: cinfo.in_color_space = JCS_RGB;
1258:
1259: jpeg_set_defaults(&cinfo);
1260: jpeg_set_quality(&cinfo, quality, true);
1261:
1262: manager.init_destination = jpeg_init_destination;
1263: manager.empty_output_buffer = jpeg_empty_output_buffer;
1264: manager.term_destination = jpeg_term_destination;
1265: cinfo.dest = &manager;
1266:
1267: jpeg_start_compress(&cinfo, true);
1268:
1269: buf = qemu_malloc(w * 3);
1270: row[0] = buf;
1271: for (dy = 0; dy < h; dy++) {
1272: rgb_prepare_row(vs, buf, x, y + dy, w);
1273: jpeg_write_scanlines(&cinfo, row, 1);
1274: }
1275: qemu_free(buf);
1276:
1277: jpeg_finish_compress(&cinfo);
1278: jpeg_destroy_compress(&cinfo);
1279:
1280: vnc_write_u8(vs, VNC_TIGHT_JPEG << 4);
1281:
1282: tight_send_compact_size(vs, vs->tight.jpeg.offset);
1283: vnc_write(vs, vs->tight.jpeg.buffer, vs->tight.jpeg.offset);
1284: buffer_reset(&vs->tight.jpeg);
1285:
1286: return 1;
1287: }
1288: #endif /* CONFIG_VNC_JPEG */
1289:
1290: /*
1291: * PNG compression stuff.
1292: */
1293: #ifdef CONFIG_VNC_PNG
1294: static void write_png_palette(int idx, uint32_t pix, void *opaque)
1295: {
1296: struct palette_cb_priv *priv = opaque;
1297: VncState *vs = priv->vs;
1298: png_colorp color = &priv->png_palette[idx];
1299:
1300: if (vs->tight.pixel24)
1301: {
1302: color->red = (pix >> vs->clientds.pf.rshift) & vs->clientds.pf.rmax;
1303: color->green = (pix >> vs->clientds.pf.gshift) & vs->clientds.pf.gmax;
1304: color->blue = (pix >> vs->clientds.pf.bshift) & vs->clientds.pf.bmax;
1305: }
1306: else
1307: {
1308: int red, green, blue;
1309:
1310: red = (pix >> vs->clientds.pf.rshift) & vs->clientds.pf.rmax;
1311: green = (pix >> vs->clientds.pf.gshift) & vs->clientds.pf.gmax;
1312: blue = (pix >> vs->clientds.pf.bshift) & vs->clientds.pf.bmax;
1313: color->red = ((red * 255 + vs->clientds.pf.rmax / 2) /
1314: vs->clientds.pf.rmax);
1315: color->green = ((green * 255 + vs->clientds.pf.gmax / 2) /
1316: vs->clientds.pf.gmax);
1317: color->blue = ((blue * 255 + vs->clientds.pf.bmax / 2) /
1318: vs->clientds.pf.bmax);
1319: }
1320: }
1321:
1322: static void png_write_data(png_structp png_ptr, png_bytep data,
1323: png_size_t length)
1324: {
1325: VncState *vs = png_get_io_ptr(png_ptr);
1326:
1327: buffer_reserve(&vs->tight.png, vs->tight.png.offset + length);
1328: memcpy(vs->tight.png.buffer + vs->tight.png.offset, data, length);
1329:
1330: vs->tight.png.offset += length;
1331: }
1332:
1333: static void png_flush_data(png_structp png_ptr)
1334: {
1335: }
1336:
1337: static void *vnc_png_malloc(png_structp png_ptr, png_size_t size)
1338: {
1339: return qemu_malloc(size);
1340: }
1341:
1342: static void vnc_png_free(png_structp png_ptr, png_voidp ptr)
1343: {
1344: qemu_free(ptr);
1345: }
1346:
1347: static int send_png_rect(VncState *vs, int x, int y, int w, int h,
1348: VncPalette *palette)
1349: {
1350: png_byte color_type;
1351: png_structp png_ptr;
1352: png_infop info_ptr;
1353: png_colorp png_palette = NULL;
1354: size_t offset;
1355: int level = tight_png_conf[vs->tight.compression].png_zlib_level;
1356: int filters = tight_png_conf[vs->tight.compression].png_filters;
1357: uint8_t *buf;
1358: int dy;
1359:
1360: png_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL,
1361: NULL, vnc_png_malloc, vnc_png_free);
1362:
1363: if (png_ptr == NULL)
1364: return -1;
1365:
1366: info_ptr = png_create_info_struct(png_ptr);
1367:
1368: if (info_ptr == NULL) {
1369: png_destroy_write_struct(&png_ptr, NULL);
1370: return -1;
1371: }
1372:
1373: png_set_write_fn(png_ptr, (void *) vs, png_write_data, png_flush_data);
1374: png_set_compression_level(png_ptr, level);
1375: png_set_filter(png_ptr, PNG_FILTER_TYPE_DEFAULT, filters);
1376:
1377: if (palette) {
1378: color_type = PNG_COLOR_TYPE_PALETTE;
1379: } else {
1380: color_type = PNG_COLOR_TYPE_RGB;
1381: }
1382:
1383: png_set_IHDR(png_ptr, info_ptr, w, h,
1384: 8, color_type, PNG_INTERLACE_NONE,
1385: PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
1386:
1387: if (color_type == PNG_COLOR_TYPE_PALETTE) {
1388: struct palette_cb_priv priv;
1389:
1390: png_palette = png_malloc(png_ptr, sizeof(*png_palette) *
1391: palette_size(palette));
1392:
1393: priv.vs = vs;
1394: priv.png_palette = png_palette;
1395: palette_iter(palette, write_png_palette, &priv);
1396:
1397: png_set_PLTE(png_ptr, info_ptr, png_palette, palette_size(palette));
1398:
1399: offset = vs->tight.tight.offset;
1400: if (vs->clientds.pf.bytes_per_pixel == 4) {
1401: tight_encode_indexed_rect32(vs->tight.tight.buffer, w * h, palette);
1402: } else {
1403: tight_encode_indexed_rect16(vs->tight.tight.buffer, w * h, palette);
1404: }
1405: }
1406:
1407: png_write_info(png_ptr, info_ptr);
1408:
1409: buffer_reserve(&vs->tight.png, 2048);
1410: buf = qemu_malloc(w * 3);
1411: for (dy = 0; dy < h; dy++)
1412: {
1413: if (color_type == PNG_COLOR_TYPE_PALETTE) {
1414: memcpy(buf, vs->tight.tight.buffer + (dy * w), w);
1415: } else {
1416: rgb_prepare_row(vs, buf, x, y + dy, w);
1417: }
1418: png_write_row(png_ptr, buf);
1419: }
1420: qemu_free(buf);
1421:
1422: png_write_end(png_ptr, NULL);
1423:
1424: if (color_type == PNG_COLOR_TYPE_PALETTE) {
1425: png_free(png_ptr, png_palette);
1426: }
1427:
1428: png_destroy_write_struct(&png_ptr, &info_ptr);
1429:
1430: vnc_write_u8(vs, VNC_TIGHT_PNG << 4);
1431:
1432: tight_send_compact_size(vs, vs->tight.png.offset);
1433: vnc_write(vs, vs->tight.png.buffer, vs->tight.png.offset);
1434: buffer_reset(&vs->tight.png);
1435: return 1;
1436: }
1437: #endif /* CONFIG_VNC_PNG */
1438:
1439: static void vnc_tight_start(VncState *vs)
1440: {
1441: buffer_reset(&vs->tight.tight);
1442:
1443: // make the output buffer be the zlib buffer, so we can compress it later
1444: vs->tight.tmp = vs->output;
1445: vs->output = vs->tight.tight;
1446: }
1447:
1448: static void vnc_tight_stop(VncState *vs)
1449: {
1450: // switch back to normal output/zlib buffers
1451: vs->tight.tight = vs->output;
1452: vs->output = vs->tight.tmp;
1453: }
1454:
1455: static int send_sub_rect_nojpeg(VncState *vs, int x, int y, int w, int h,
1456: int bg, int fg, int colors, VncPalette *palette)
1457: {
1458: int ret;
1459:
1460: if (colors == 0) {
1461: if (tight_detect_smooth_image(vs, w, h)) {
1462: ret = send_gradient_rect(vs, x, y, w, h);
1463: } else {
1464: ret = send_full_color_rect(vs, x, y, w, h);
1465: }
1466: } else if (colors == 1) {
1467: ret = send_solid_rect(vs);
1468: } else if (colors == 2) {
1469: ret = send_mono_rect(vs, x, y, w, h, bg, fg);
1470: } else if (colors <= 256) {
1471: ret = send_palette_rect(vs, x, y, w, h, palette);
1472: }
1473: return ret;
1474: }
1475:
1476: #ifdef CONFIG_VNC_JPEG
1477: static int send_sub_rect_jpeg(VncState *vs, int x, int y, int w, int h,
1478: int bg, int fg, int colors,
1479: VncPalette *palette)
1480: {
1481: int ret;
1482:
1483: if (colors == 0) {
1484: if (tight_detect_smooth_image(vs, w, h)) {
1485: int quality = tight_conf[vs->tight.quality].jpeg_quality;
1486:
1487: ret = send_jpeg_rect(vs, x, y, w, h, quality);
1488: } else {
1489: ret = send_full_color_rect(vs, x, y, w, h);
1490: }
1491: } else if (colors == 1) {
1492: ret = send_solid_rect(vs);
1493: } else if (colors == 2) {
1494: ret = send_mono_rect(vs, x, y, w, h, bg, fg);
1495: } else if (colors <= 256) {
1496: if (colors > 96 &&
1497: tight_detect_smooth_image(vs, w, h)) {
1498: int quality = tight_conf[vs->tight.quality].jpeg_quality;
1499:
1500: ret = send_jpeg_rect(vs, x, y, w, h, quality);
1501: } else {
1502: ret = send_palette_rect(vs, x, y, w, h, palette);
1503: }
1504: }
1505: return ret;
1506: }
1507: #endif
1508:
1509: static int send_sub_rect(VncState *vs, int x, int y, int w, int h)
1510: {
1511: VncPalette *palette = NULL;
1512: uint32_t bg = 0, fg = 0;
1513: int colors;
1514: int ret = 0;
1515:
1516: vnc_framebuffer_update(vs, x, y, w, h, vs->tight.type);
1517:
1518: vnc_tight_start(vs);
1519: vnc_raw_send_framebuffer_update(vs, x, y, w, h);
1520: vnc_tight_stop(vs);
1521:
1522: colors = tight_fill_palette(vs, x, y, w * h, &fg, &bg, &palette);
1523:
1524: #ifdef CONFIG_VNC_JPEG
1525: if (vs->tight.quality != -1) {
1526: ret = send_sub_rect_jpeg(vs, x, y, w, h, bg, fg, colors, palette);
1527: } else {
1528: ret = send_sub_rect_nojpeg(vs, x, y, w, h, bg, fg, colors, palette);
1529: }
1530: #else
1531: ret = send_sub_rect_nojpeg(vs, x, y, w, h, bg, fg, colors, palette);
1532: #endif
1533:
1534: palette_destroy(palette);
1535: return ret;
1536: }
1537:
1538: static int send_sub_rect_solid(VncState *vs, int x, int y, int w, int h)
1539: {
1540: vnc_framebuffer_update(vs, x, y, w, h, vs->tight.type);
1541:
1542: vnc_tight_start(vs);
1543: vnc_raw_send_framebuffer_update(vs, x, y, w, h);
1544: vnc_tight_stop(vs);
1545:
1546: return send_solid_rect(vs);
1547: }
1548:
1549: static int send_rect_simple(VncState *vs, int x, int y, int w, int h)
1550: {
1551: int max_size, max_width;
1552: int max_sub_width, max_sub_height;
1553: int dx, dy;
1554: int rw, rh;
1555: int n = 0;
1556:
1557: max_size = tight_conf[vs->tight.compression].max_rect_size;
1558: max_width = tight_conf[vs->tight.compression].max_rect_width;
1559:
1560: if (w > max_width || w * h > max_size) {
1561: max_sub_width = (w > max_width) ? max_width : w;
1562: max_sub_height = max_size / max_sub_width;
1563:
1564: for (dy = 0; dy < h; dy += max_sub_height) {
1565: for (dx = 0; dx < w; dx += max_width) {
1566: rw = MIN(max_sub_width, w - dx);
1567: rh = MIN(max_sub_height, h - dy);
1568: n += send_sub_rect(vs, x+dx, y+dy, rw, rh);
1569: }
1570: }
1571: } else {
1572: n += send_sub_rect(vs, x, y, w, h);
1573: }
1574:
1575: return n;
1576: }
1577:
1578: static int find_large_solid_color_rect(VncState *vs, int x, int y,
1579: int w, int h, int max_rows)
1580: {
1581: int dx, dy, dw, dh;
1582: int n = 0;
1583:
1584: /* Try to find large solid-color areas and send them separately. */
1585:
1586: for (dy = y; dy < y + h; dy += VNC_TIGHT_MAX_SPLIT_TILE_SIZE) {
1587:
1588: /* If a rectangle becomes too large, send its upper part now. */
1589:
1590: if (dy - y >= max_rows) {
1591: n += send_rect_simple(vs, x, y, w, max_rows);
1592: y += max_rows;
1593: h -= max_rows;
1594: }
1595:
1596: dh = MIN(VNC_TIGHT_MAX_SPLIT_TILE_SIZE, (y + h - dy));
1597:
1598: for (dx = x; dx < x + w; dx += VNC_TIGHT_MAX_SPLIT_TILE_SIZE) {
1599: uint32_t color_value;
1600: int x_best, y_best, w_best, h_best;
1601:
1602: dw = MIN(VNC_TIGHT_MAX_SPLIT_TILE_SIZE, (x + w - dx));
1603:
1604: if (!check_solid_tile(vs, dx, dy, dw, dh, &color_value, false)) {
1605: continue ;
1606: }
1607:
1608: /* Get dimensions of solid-color area. */
1609:
1610: find_best_solid_area(vs, dx, dy, w - (dx - x), h - (dy - y),
1611: color_value, &w_best, &h_best);
1612:
1613: /* Make sure a solid rectangle is large enough
1614: (or the whole rectangle is of the same color). */
1615:
1616: if (w_best * h_best != w * h &&
1617: w_best * h_best < VNC_TIGHT_MIN_SOLID_SUBRECT_SIZE) {
1618: continue;
1619: }
1620:
1621: /* Try to extend solid rectangle to maximum size. */
1622:
1623: x_best = dx; y_best = dy;
1624: extend_solid_area(vs, x, y, w, h, color_value,
1625: &x_best, &y_best, &w_best, &h_best);
1626:
1627: /* Send rectangles at top and left to solid-color area. */
1628:
1629: if (y_best != y) {
1630: n += send_rect_simple(vs, x, y, w, y_best-y);
1631: }
1632: if (x_best != x) {
1633: n += tight_send_framebuffer_update(vs, x, y_best,
1634: x_best-x, h_best);
1635: }
1636:
1637: /* Send solid-color rectangle. */
1638: n += send_sub_rect_solid(vs, x_best, y_best, w_best, h_best);
1639:
1640: /* Send remaining rectangles (at right and bottom). */
1641:
1642: if (x_best + w_best != x + w) {
1643: n += tight_send_framebuffer_update(vs, x_best+w_best,
1644: y_best,
1645: w-(x_best-x)-w_best,
1646: h_best);
1647: }
1648: if (y_best + h_best != y + h) {
1649: n += tight_send_framebuffer_update(vs, x, y_best+h_best,
1650: w, h-(y_best-y)-h_best);
1651: }
1652:
1653: /* Return after all recursive calls are done. */
1654: return n;
1655: }
1656: }
1657: return n + send_rect_simple(vs, x, y, w, h);
1658: }
1659:
1660: static int tight_send_framebuffer_update(VncState *vs, int x, int y,
1661: int w, int h)
1662: {
1663: int max_rows;
1664:
1665: if (vs->clientds.pf.bytes_per_pixel == 4 && vs->clientds.pf.rmax == 0xFF &&
1666: vs->clientds.pf.bmax == 0xFF && vs->clientds.pf.gmax == 0xFF) {
1667: vs->tight.pixel24 = true;
1668: } else {
1669: vs->tight.pixel24 = false;
1670: }
1671:
1672: if (w * h < VNC_TIGHT_MIN_SPLIT_RECT_SIZE)
1673: return send_rect_simple(vs, x, y, w, h);
1674:
1675: /* Calculate maximum number of rows in one non-solid rectangle. */
1676:
1677: max_rows = tight_conf[vs->tight.compression].max_rect_size;
1678: max_rows /= MIN(tight_conf[vs->tight.compression].max_rect_width, w);
1679:
1680: return find_large_solid_color_rect(vs, x, y, w, h, max_rows);
1681: }
1682:
1683: int vnc_tight_send_framebuffer_update(VncState *vs, int x, int y,
1684: int w, int h)
1685: {
1686: vs->tight.type = VNC_ENCODING_TIGHT;
1687: return tight_send_framebuffer_update(vs, x, y, w, h);
1688: }
1689:
1690: int vnc_tight_png_send_framebuffer_update(VncState *vs, int x, int y,
1691: int w, int h)
1692: {
1693: vs->tight.type = VNC_ENCODING_TIGHT_PNG;
1694: return tight_send_framebuffer_update(vs, x, y, w, h);
1695: }
1696:
1697: void vnc_tight_clear(VncState *vs)
1698: {
1699: int i;
1700: for (i=0; i<ARRAY_SIZE(vs->tight.stream); i++) {
1701: if (vs->tight.stream[i].opaque) {
1702: deflateEnd(&vs->tight.stream[i]);
1703: }
1704: }
1705:
1706: buffer_free(&vs->tight.tight);
1707: buffer_free(&vs->tight.zlib);
1708: buffer_free(&vs->tight.gradient);
1709: #ifdef CONFIG_VNC_JPEG
1710: buffer_free(&vs->tight.jpeg);
1711: #endif
1712: #ifdef CONFIG_VNC_PNG
1713: buffer_free(&vs->tight.png);
1714: #endif
1715: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.