![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vnc-enc-zrle.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-zrle.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / ui |
1.1 root 1: /*
2: * QEMU VNC display driver: Zlib Run-length Encoding (ZRLE)
3: *
4: * From libvncserver/libvncserver/zrle.c
5: * Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
6: * Copyright (C) 2003 Sun Microsystems, Inc.
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 "vnc.h"
30: #include "vnc-enc-zrle.h"
31:
32: static const int bits_per_packed_pixel[] = {
33: 0, 1, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
34: };
35:
36:
37: static void vnc_zrle_start(VncState *vs)
38: {
39: buffer_reset(&vs->zrle.zrle);
40:
41: /* make the output buffer be the zlib buffer, so we can compress it later */
42: vs->zrle.tmp = vs->output;
43: vs->output = vs->zrle.zrle;
44: }
45:
46: static void vnc_zrle_stop(VncState *vs)
47: {
48: /* switch back to normal output/zlib buffers */
49: vs->zrle.zrle = vs->output;
50: vs->output = vs->zrle.tmp;
51: }
52:
53: static void *zrle_convert_fb(VncState *vs, int x, int y, int w, int h,
54: int bpp)
55: {
56: Buffer tmp;
57:
58: buffer_reset(&vs->zrle.fb);
59: buffer_reserve(&vs->zrle.fb, w * h * bpp + bpp);
60:
61: tmp = vs->output;
62: vs->output = vs->zrle.fb;
63:
64: vnc_raw_send_framebuffer_update(vs, x, y, w, h);
65:
66: vs->zrle.fb = vs->output;
67: vs->output = tmp;
68: return vs->zrle.fb.buffer;
69: }
70:
71: static int zrle_compress_data(VncState *vs, int level)
72: {
73: z_streamp zstream = &vs->zrle.stream;
74:
75: buffer_reset(&vs->zrle.zlib);
76:
77: if (zstream->opaque != vs) {
78: int err;
79:
80: zstream->zalloc = vnc_zlib_zalloc;
81: zstream->zfree = vnc_zlib_zfree;
82:
83: err = deflateInit2(zstream, level, Z_DEFLATED, MAX_WBITS,
84: MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);
85:
86: if (err != Z_OK) {
87: fprintf(stderr, "VNC: error initializing zlib\n");
88: return -1;
89: }
90:
91: zstream->opaque = vs;
92: }
93:
94: /* reserve memory in output buffer */
95: buffer_reserve(&vs->zrle.zlib, vs->zrle.zrle.offset + 64);
96:
97: /* set pointers */
98: zstream->next_in = vs->zrle.zrle.buffer;
99: zstream->avail_in = vs->zrle.zrle.offset;
100: zstream->next_out = vs->zrle.zlib.buffer + vs->zrle.zlib.offset;
101: zstream->avail_out = vs->zrle.zlib.capacity - vs->zrle.zlib.offset;
102: zstream->data_type = Z_BINARY;
103:
104: /* start encoding */
105: if (deflate(zstream, Z_SYNC_FLUSH) != Z_OK) {
106: fprintf(stderr, "VNC: error during zrle compression\n");
107: return -1;
108: }
109:
110: vs->zrle.zlib.offset = vs->zrle.zlib.capacity - zstream->avail_out;
111: return vs->zrle.zlib.offset;
112: }
113:
114: /* Try to work out whether to use RLE and/or a palette. We do this by
115: * estimating the number of bytes which will be generated and picking the
116: * method which results in the fewest bytes. Of course this may not result
117: * in the fewest bytes after compression... */
118: static void zrle_choose_palette_rle(VncState *vs, int w, int h,
119: VncPalette *palette, int bpp_out,
120: int runs, int single_pixels,
121: int zywrle_level,
122: bool *use_rle, bool *use_palette)
123: {
124: size_t estimated_bytes;
125: size_t plain_rle_bytes;
126:
127: *use_palette = *use_rle = false;
128:
129: estimated_bytes = w * h * (bpp_out / 8); /* start assuming raw */
130:
131: if (bpp_out != 8) {
132: if (zywrle_level > 0 && !(zywrle_level & 0x80))
133: estimated_bytes >>= zywrle_level;
134: }
135:
136: plain_rle_bytes = ((bpp_out / 8) + 1) * (runs + single_pixels);
137:
138: if (plain_rle_bytes < estimated_bytes) {
139: *use_rle = true;
140: estimated_bytes = plain_rle_bytes;
141: }
142:
143: if (palette_size(palette) < 128) {
144: int palette_rle_bytes;
145:
146: palette_rle_bytes = (bpp_out / 8) * palette_size(palette);
147: palette_rle_bytes += 2 * runs + single_pixels;
148:
149: if (palette_rle_bytes < estimated_bytes) {
150: *use_rle = true;
151: *use_palette = true;
152: estimated_bytes = palette_rle_bytes;
153: }
154:
155: if (palette_size(palette) < 17) {
156: int packed_bytes;
157:
158: packed_bytes = (bpp_out / 8) * palette_size(palette);
159: packed_bytes += w * h *
160: bits_per_packed_pixel[palette_size(palette)-1] / 8;
161:
162: if (packed_bytes < estimated_bytes) {
163: *use_rle = false;
164: *use_palette = true;
165: estimated_bytes = packed_bytes;
166: }
167: }
168: }
169: }
170:
171: static void zrle_write_u32(VncState *vs, uint32_t value)
172: {
173: vnc_write(vs, (uint8_t *)&value, 4);
174: }
175:
176: static void zrle_write_u24a(VncState *vs, uint32_t value)
177: {
178: vnc_write(vs, (uint8_t *)&value, 3);
179: }
180:
181: static void zrle_write_u24b(VncState *vs, uint32_t value)
182: {
183: vnc_write(vs, ((uint8_t *)&value) + 1, 3);
184: }
185:
186: static void zrle_write_u16(VncState *vs, uint16_t value)
187: {
188: vnc_write(vs, (uint8_t *)&value, 2);
189: }
190:
191: static void zrle_write_u8(VncState *vs, uint8_t value)
192: {
193: vnc_write_u8(vs, value);
194: }
195:
196: #define ENDIAN_LITTLE 0
197: #define ENDIAN_BIG 1
198: #define ENDIAN_NO 2
199:
200: #define ZRLE_BPP 8
201: #define ZYWRLE_ENDIAN ENDIAN_NO
202: #include "vnc-enc-zrle-template.c"
203: #undef ZRLE_BPP
204:
205: #define ZRLE_BPP 15
206: #undef ZYWRLE_ENDIAN
207: #define ZYWRLE_ENDIAN ENDIAN_LITTLE
208: #include "vnc-enc-zrle-template.c"
209:
210: #undef ZYWRLE_ENDIAN
211: #define ZYWRLE_ENDIAN ENDIAN_BIG
212: #include "vnc-enc-zrle-template.c"
213:
214: #undef ZRLE_BPP
215: #define ZRLE_BPP 16
216: #undef ZYWRLE_ENDIAN
217: #define ZYWRLE_ENDIAN ENDIAN_LITTLE
218: #include "vnc-enc-zrle-template.c"
219:
220: #undef ZYWRLE_ENDIAN
221: #define ZYWRLE_ENDIAN ENDIAN_BIG
222: #include "vnc-enc-zrle-template.c"
223:
224: #undef ZRLE_BPP
225: #define ZRLE_BPP 32
226: #undef ZYWRLE_ENDIAN
227: #define ZYWRLE_ENDIAN ENDIAN_LITTLE
228: #include "vnc-enc-zrle-template.c"
229:
230: #undef ZYWRLE_ENDIAN
231: #define ZYWRLE_ENDIAN ENDIAN_BIG
232: #include "vnc-enc-zrle-template.c"
233:
234: #define ZRLE_COMPACT_PIXEL 24a
235: #undef ZYWRLE_ENDIAN
236: #define ZYWRLE_ENDIAN ENDIAN_LITTLE
237: #include "vnc-enc-zrle-template.c"
238:
239: #undef ZYWRLE_ENDIAN
240: #define ZYWRLE_ENDIAN ENDIAN_BIG
241: #include "vnc-enc-zrle-template.c"
242:
243: #undef ZRLE_COMPACT_PIXEL
244: #define ZRLE_COMPACT_PIXEL 24b
245: #undef ZYWRLE_ENDIAN
246: #define ZYWRLE_ENDIAN ENDIAN_LITTLE
247: #include "vnc-enc-zrle-template.c"
248:
249: #undef ZYWRLE_ENDIAN
250: #define ZYWRLE_ENDIAN ENDIAN_BIG
251: #include "vnc-enc-zrle-template.c"
252: #undef ZRLE_COMPACT_PIXEL
253: #undef ZRLE_BPP
254:
255: static int zrle_send_framebuffer_update(VncState *vs, int x, int y,
256: int w, int h)
257: {
258: bool be = !!(vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG);
259: size_t bytes;
260: int zywrle_level;
261:
262: if (vs->zrle.type == VNC_ENCODING_ZYWRLE) {
263: if (!vs->vd->lossy || vs->tight.quality == (uint8_t)-1
264: || vs->tight.quality == 9) {
265: zywrle_level = 0;
266: vs->zrle.type = VNC_ENCODING_ZRLE;
267: } else if (vs->tight.quality < 3) {
268: zywrle_level = 3;
269: } else if (vs->tight.quality < 6) {
270: zywrle_level = 2;
271: } else {
272: zywrle_level = 1;
273: }
274: } else {
275: zywrle_level = 0;
276: }
277:
278: vnc_zrle_start(vs);
279:
280: switch(vs->clientds.pf.bytes_per_pixel) {
281: case 1:
282: zrle_encode_8ne(vs, x, y, w, h, zywrle_level);
283: break;
284:
285: case 2:
286: if (vs->clientds.pf.gmax > 0x1F) {
287: if (be) {
288: zrle_encode_16be(vs, x, y, w, h, zywrle_level);
289: } else {
290: zrle_encode_16le(vs, x, y, w, h, zywrle_level);
291: }
292: } else {
293: if (be) {
294: zrle_encode_15be(vs, x, y, w, h, zywrle_level);
295: } else {
296: zrle_encode_15le(vs, x, y, w, h, zywrle_level);
297: }
298: }
299: break;
300:
301: case 4:
302: {
303: bool fits_in_ls3bytes;
304: bool fits_in_ms3bytes;
305:
306: fits_in_ls3bytes =
307: ((vs->clientds.pf.rmax << vs->clientds.pf.rshift) < (1 << 24) &&
308: (vs->clientds.pf.gmax << vs->clientds.pf.gshift) < (1 << 24) &&
309: (vs->clientds.pf.bmax << vs->clientds.pf.bshift) < (1 << 24));
310:
311: fits_in_ms3bytes = (vs->clientds.pf.rshift > 7 &&
312: vs->clientds.pf.gshift > 7 &&
313: vs->clientds.pf.bshift > 7);
314:
315: if ((fits_in_ls3bytes && !be) || (fits_in_ms3bytes && be)) {
316: if (be) {
317: zrle_encode_24abe(vs, x, y, w, h, zywrle_level);
318: } else {
319: zrle_encode_24ale(vs, x, y, w, h, zywrle_level);
320: }
321: } else if ((fits_in_ls3bytes && be) || (fits_in_ms3bytes && !be)) {
322: if (be) {
323: zrle_encode_24bbe(vs, x, y, w, h, zywrle_level);
324: } else {
325: zrle_encode_24ble(vs, x, y, w, h, zywrle_level);
326: }
327: } else {
328: if (be) {
329: zrle_encode_32be(vs, x, y, w, h, zywrle_level);
330: } else {
331: zrle_encode_32le(vs, x, y, w, h, zywrle_level);
332: }
333: }
334: }
335: break;
336: }
337:
338: vnc_zrle_stop(vs);
339: bytes = zrle_compress_data(vs, Z_DEFAULT_COMPRESSION);
340: vnc_framebuffer_update(vs, x, y, w, h, vs->zrle.type);
341: vnc_write_u32(vs, bytes);
342: vnc_write(vs, vs->zrle.zlib.buffer, vs->zrle.zlib.offset);
343: return 1;
344: }
345:
346: int vnc_zrle_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
347: {
348: vs->zrle.type = VNC_ENCODING_ZRLE;
349: return zrle_send_framebuffer_update(vs, x, y, w, h);
350: }
351:
352: int vnc_zywrle_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
353: {
354: vs->zrle.type = VNC_ENCODING_ZYWRLE;
355: return zrle_send_framebuffer_update(vs, x, y, w, h);
356: }
357:
358: void vnc_zrle_clear(VncState *vs)
359: {
360: if (vs->zrle.stream.opaque) {
361: deflateEnd(&vs->zrle.stream);
362: }
363: buffer_free(&vs->zrle.zrle);
364: buffer_free(&vs->zrle.fb);
365: buffer_free(&vs->zrle.zlib);
366: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.