mirror of
https://github.com/xemu-project/xemu.git
synced 2024-11-23 19:49:43 +00:00
139c1837db
With Makefiles that have automatically generated dependencies, you
generated includes are set as dependencies of the Makefile, so that they
are built before everything else and they are available when first
building the .c files.
Alternatively you can use a fine-grained dependency, e.g.
target/arm/translate.o: target/arm/decode-neon-shared.inc.c
With Meson you have only one choice and it is a third option, namely
"build at the beginning of the corresponding target"; the way you
express it is to list the includes in the sources of that target.
The problem is that Meson decides if something is a source vs. a
generated include by looking at the extension: '.c', '.cc', '.m', '.C'
are sources, while everything else is considered an include---including
'.inc.c'.
Use '.c.inc' to avoid this, as it is consistent with our other convention
of using '.rst.inc' for included reStructuredText files. The editorconfig
file is adjusted.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
264 lines
7.0 KiB
C++
264 lines
7.0 KiB
C++
/*
|
|
* QEMU VNC display driver: Zlib Run-length Encoding (ZRLE)
|
|
*
|
|
* From libvncserver/libvncserver/zrleencodetemplate.c
|
|
* Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
|
|
* Copyright (C) 2003 Sun Microsystems, Inc.
|
|
*
|
|
* Copyright (C) 2010 Corentin Chary <corentin.chary@gmail.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*/
|
|
|
|
/*
|
|
* Before including this file, you must define a number of CPP macros.
|
|
*
|
|
* ZRLE_BPP should be 8, 16 or 32 depending on the bits per pixel.
|
|
*
|
|
* Note that the buf argument to ZRLE_ENCODE needs to be at least one pixel
|
|
* bigger than the largest tile of pixel data, since the ZRLE encoding
|
|
* algorithm writes to the position one past the end of the pixel data.
|
|
*/
|
|
|
|
|
|
#include "qemu/osdep.h"
|
|
|
|
#undef ZRLE_ENDIAN_SUFFIX
|
|
|
|
#if ZYWRLE_ENDIAN == ENDIAN_LITTLE
|
|
#define ZRLE_ENDIAN_SUFFIX le
|
|
#elif ZYWRLE_ENDIAN == ENDIAN_BIG
|
|
#define ZRLE_ENDIAN_SUFFIX be
|
|
#else
|
|
#define ZRLE_ENDIAN_SUFFIX ne
|
|
#endif
|
|
|
|
#ifndef ZRLE_CONCAT
|
|
#define ZRLE_CONCAT_I(a, b) a##b
|
|
#define ZRLE_CONCAT2(a, b) ZRLE_CONCAT_I(a, b)
|
|
#define ZRLE_CONCAT3(a, b, c) ZRLE_CONCAT2(a, ZRLE_CONCAT2(b, c))
|
|
#endif
|
|
|
|
#ifdef ZRLE_COMPACT_PIXEL
|
|
#define ZRLE_ENCODE_SUFFIX ZRLE_CONCAT2(ZRLE_COMPACT_PIXEL,ZRLE_ENDIAN_SUFFIX)
|
|
#define ZRLE_WRITE_SUFFIX ZRLE_COMPACT_PIXEL
|
|
#define ZRLE_PIXEL ZRLE_CONCAT3(uint,ZRLE_BPP,_t)
|
|
#define ZRLE_BPP_OUT 24
|
|
#elif ZRLE_BPP == 15
|
|
#define ZRLE_ENCODE_SUFFIX ZRLE_CONCAT2(ZRLE_BPP,ZRLE_ENDIAN_SUFFIX)
|
|
#define ZRLE_WRITE_SUFFIX 16
|
|
#define ZRLE_PIXEL uint16_t
|
|
#define ZRLE_BPP_OUT 16
|
|
#else
|
|
#define ZRLE_ENCODE_SUFFIX ZRLE_CONCAT2(ZRLE_BPP,ZRLE_ENDIAN_SUFFIX)
|
|
#define ZRLE_WRITE_SUFFIX ZRLE_BPP
|
|
#define ZRLE_BPP_OUT ZRLE_BPP
|
|
#define ZRLE_PIXEL ZRLE_CONCAT3(uint,ZRLE_BPP,_t)
|
|
#endif
|
|
|
|
#define ZRLE_WRITE_PIXEL ZRLE_CONCAT2(zrle_write_u, ZRLE_WRITE_SUFFIX)
|
|
#define ZRLE_ENCODE ZRLE_CONCAT2(zrle_encode_, ZRLE_ENCODE_SUFFIX)
|
|
#define ZRLE_ENCODE_TILE ZRLE_CONCAT2(zrle_encode_tile, ZRLE_ENCODE_SUFFIX)
|
|
#define ZRLE_WRITE_PALETTE ZRLE_CONCAT2(zrle_write_palette,ZRLE_ENCODE_SUFFIX)
|
|
|
|
static void ZRLE_ENCODE_TILE(VncState *vs, ZRLE_PIXEL *data, int w, int h,
|
|
int zywrle_level);
|
|
|
|
#if ZRLE_BPP != 8
|
|
#include "vnc-enc-zywrle-template.c"
|
|
#endif
|
|
|
|
|
|
static void ZRLE_ENCODE(VncState *vs, int x, int y, int w, int h,
|
|
int zywrle_level)
|
|
{
|
|
int ty;
|
|
|
|
for (ty = y; ty < y + h; ty += VNC_ZRLE_TILE_HEIGHT) {
|
|
|
|
int tx, th;
|
|
|
|
th = MIN(VNC_ZRLE_TILE_HEIGHT, y + h - ty);
|
|
|
|
for (tx = x; tx < x + w; tx += VNC_ZRLE_TILE_WIDTH) {
|
|
int tw;
|
|
ZRLE_PIXEL *buf;
|
|
|
|
tw = MIN(VNC_ZRLE_TILE_WIDTH, x + w - tx);
|
|
|
|
buf = zrle_convert_fb(vs, tx, ty, tw, th, ZRLE_BPP);
|
|
ZRLE_ENCODE_TILE(vs, buf, tw, th, zywrle_level);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ZRLE_ENCODE_TILE(VncState *vs, ZRLE_PIXEL *data, int w, int h,
|
|
int zywrle_level)
|
|
{
|
|
VncPalette *palette = &vs->zrle->palette;
|
|
|
|
int runs = 0;
|
|
int single_pixels = 0;
|
|
|
|
bool use_rle;
|
|
bool use_palette;
|
|
|
|
int i;
|
|
|
|
ZRLE_PIXEL *ptr = data;
|
|
ZRLE_PIXEL *end = ptr + h * w;
|
|
*end = ~*(end-1); /* one past the end is different so the while loop ends */
|
|
|
|
/* Real limit is 127 but we wan't a way to know if there is more than 127 */
|
|
palette_init(palette, 256, ZRLE_BPP);
|
|
|
|
while (ptr < end) {
|
|
ZRLE_PIXEL pix = *ptr;
|
|
if (*++ptr != pix) { /* FIXME */
|
|
single_pixels++;
|
|
} else {
|
|
while (*++ptr == pix) ;
|
|
runs++;
|
|
}
|
|
palette_put(palette, pix);
|
|
}
|
|
|
|
/* Solid tile is a special case */
|
|
|
|
if (palette_size(palette) == 1) {
|
|
bool found;
|
|
|
|
vnc_write_u8(vs, 1);
|
|
ZRLE_WRITE_PIXEL(vs, palette_color(palette, 0, &found));
|
|
return;
|
|
}
|
|
|
|
zrle_choose_palette_rle(vs, w, h, palette, ZRLE_BPP_OUT,
|
|
runs, single_pixels, zywrle_level,
|
|
&use_rle, &use_palette);
|
|
|
|
if (!use_palette) {
|
|
vnc_write_u8(vs, (use_rle ? 128 : 0));
|
|
} else {
|
|
uint32_t colors[VNC_PALETTE_MAX_SIZE];
|
|
size_t size = palette_size(palette);
|
|
|
|
vnc_write_u8(vs, (use_rle ? 128 : 0) | size);
|
|
palette_fill(palette, colors);
|
|
|
|
for (i = 0; i < size; i++) {
|
|
ZRLE_WRITE_PIXEL(vs, colors[i]);
|
|
}
|
|
}
|
|
|
|
if (use_rle) {
|
|
ZRLE_PIXEL *ptr = data;
|
|
ZRLE_PIXEL *end = ptr + w * h;
|
|
ZRLE_PIXEL *run_start;
|
|
ZRLE_PIXEL pix;
|
|
|
|
while (ptr < end) {
|
|
int len;
|
|
int index = 0;
|
|
|
|
run_start = ptr;
|
|
pix = *ptr++;
|
|
|
|
while (*ptr == pix && ptr < end) {
|
|
ptr++;
|
|
}
|
|
|
|
len = ptr - run_start;
|
|
|
|
if (use_palette)
|
|
index = palette_idx(palette, pix);
|
|
|
|
if (len <= 2 && use_palette) {
|
|
if (len == 2) {
|
|
vnc_write_u8(vs, index);
|
|
}
|
|
vnc_write_u8(vs, index);
|
|
continue;
|
|
}
|
|
if (use_palette) {
|
|
vnc_write_u8(vs, index | 128);
|
|
} else {
|
|
ZRLE_WRITE_PIXEL(vs, pix);
|
|
}
|
|
|
|
len -= 1;
|
|
|
|
while (len >= 255) {
|
|
vnc_write_u8(vs, 255);
|
|
len -= 255;
|
|
}
|
|
|
|
vnc_write_u8(vs, len);
|
|
}
|
|
} else if (use_palette) { /* no RLE */
|
|
int bppp;
|
|
ZRLE_PIXEL *ptr = data;
|
|
|
|
/* packed pixels */
|
|
|
|
assert (palette_size(palette) < 17);
|
|
|
|
bppp = bits_per_packed_pixel[palette_size(palette)-1];
|
|
|
|
for (i = 0; i < h; i++) {
|
|
uint8_t nbits = 0;
|
|
uint8_t byte = 0;
|
|
|
|
ZRLE_PIXEL *eol = ptr + w;
|
|
|
|
while (ptr < eol) {
|
|
ZRLE_PIXEL pix = *ptr++;
|
|
uint8_t index = palette_idx(palette, pix);
|
|
|
|
byte = (byte << bppp) | index;
|
|
nbits += bppp;
|
|
if (nbits >= 8) {
|
|
vnc_write_u8(vs, byte);
|
|
nbits = 0;
|
|
}
|
|
}
|
|
if (nbits > 0) {
|
|
byte <<= 8 - nbits;
|
|
vnc_write_u8(vs, byte);
|
|
}
|
|
}
|
|
} else {
|
|
|
|
/* raw */
|
|
|
|
#if ZRLE_BPP != 8
|
|
if (zywrle_level > 0 && !(zywrle_level & 0x80)) {
|
|
ZYWRLE_ANALYZE(data, data, w, h, w, zywrle_level, vs->zywrle.buf);
|
|
ZRLE_ENCODE_TILE(vs, data, w, h, zywrle_level | 0x80);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
#ifdef ZRLE_COMPACT_PIXEL
|
|
ZRLE_PIXEL *ptr;
|
|
|
|
for (ptr = data; ptr < data + w * h; ptr++) {
|
|
ZRLE_WRITE_PIXEL(vs, *ptr);
|
|
}
|
|
#else
|
|
vnc_write(vs, data, w * h * (ZRLE_BPP / 8));
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
#undef ZRLE_PIXEL
|
|
#undef ZRLE_WRITE_PIXEL
|
|
#undef ZRLE_ENCODE
|
|
#undef ZRLE_ENCODE_TILE
|
|
#undef ZYWRLE_ENCODE_TILE
|
|
#undef ZRLE_BPP_OUT
|
|
#undef ZRLE_WRITE_SUFFIX
|
|
#undef ZRLE_ENCODE_SUFFIX
|