← Back to branch summary

~ahs3/+junk/cq-qemu

« back to all changes in this revision

Viewing changes to ui/vnc-enc-zrle.c

  • Committer: Al Stone
  • Date: 2012-02-09 01:17:20 UTC
  • Revision ID: albert.stone@canonical.com-20120209011720-tztl7ik3qayz80p4
first commit to bzr for qemu

Show diffs side-by-side

added added

removed removed

Lines of Context:
ui/vnc-enc-zrle.c
 
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 <corentin.chary@gmail.com>
 
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
}