![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vnc-enc-tight.h 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.h 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/rfb/rfbproto.h
5: * Copyright (C) 2005 Rohit Kumar, Johannes E. Schindelin
6: * Copyright (C) 2000-2002 Constantin Kaplinsky. All Rights Reserved.
7: * Copyright (C) 2000 Tridia Corporation. All Rights Reserved.
8: * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
9: *
10: *
11: * Permission is hereby granted, free of charge, to any person obtaining a copy
12: * of this software and associated documentation files (the "Software"), to deal
13: * in the Software without restriction, including without limitation the rights
14: * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15: * copies of the Software, and to permit persons to whom the Software is
16: * furnished to do so, subject to the following conditions:
17: *
18: * The above copyright notice and this permission notice shall be included in
19: * all copies or substantial portions of the Software.
20: *
21: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26: * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
27: * THE SOFTWARE.
28: */
29:
30: #ifndef VNC_ENCODING_TIGHT_H
31: #define VNC_ENCODING_TIGHT_H
32:
33: /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
34: * Tight Encoding.
35: *
36: *-- The first byte of each Tight-encoded rectangle is a "compression control
37: * byte". Its format is as follows (bit 0 is the least significant one):
38: *
39: * bit 0: if 1, then compression stream 0 should be reset;
40: * bit 1: if 1, then compression stream 1 should be reset;
41: * bit 2: if 1, then compression stream 2 should be reset;
42: * bit 3: if 1, then compression stream 3 should be reset;
43: * bits 7-4: if 1000 (0x08), then the compression type is "fill",
44: * if 1001 (0x09), then the compression type is "jpeg",
45: * if 1010 (0x0A), then the compression type is "png",
46: * if 0xxx, then the compression type is "basic",
47: * values greater than 1010 are not valid.
48: *
49: * If the compression type is "basic", then bits 6..4 of the
50: * compression control byte (those xxx in 0xxx) specify the following:
51: *
52: * bits 5-4: decimal representation is the index of a particular zlib
53: * stream which should be used for decompressing the data;
54: * bit 6: if 1, then a "filter id" byte is following this byte.
55: *
56: *-- The data that follows after the compression control byte described
57: * above depends on the compression type ("fill", "jpeg", "png" or "basic").
58: *
59: *-- If the compression type is "fill", then the only pixel value follows, in
60: * client pixel format (see NOTE 1). This value applies to all pixels of the
61: * rectangle.
62: *
63: *-- If the compression type is "jpeg" or "png", the following data stream
64: * looks like this:
65: *
66: * 1..3 bytes: data size (N) in compact representation;
67: * N bytes: JPEG or PNG image.
68: *
69: * Data size is compactly represented in one, two or three bytes, according
70: * to the following scheme:
71: *
72: * 0xxxxxxx (for values 0..127)
73: * 1xxxxxxx 0yyyyyyy (for values 128..16383)
74: * 1xxxxxxx 1yyyyyyy zzzzzzzz (for values 16384..4194303)
75: *
76: * Here each character denotes one bit, xxxxxxx are the least significant 7
77: * bits of the value (bits 0-6), yyyyyyy are bits 7-13, and zzzzzzzz are the
78: * most significant 8 bits (bits 14-21). For example, decimal value 10000
79: * should be represented as two bytes: binary 10010000 01001110, or
80: * hexadecimal 90 4E.
81: *
82: *-- If the compression type is "basic" and bit 6 of the compression control
83: * byte was set to 1, then the next (second) byte specifies "filter id" which
84: * tells the decoder what filter type was used by the encoder to pre-process
85: * pixel data before the compression. The "filter id" byte can be one of the
86: * following:
87: *
88: * 0: no filter ("copy" filter);
89: * 1: "palette" filter;
90: * 2: "gradient" filter.
91: *
92: *-- If bit 6 of the compression control byte is set to 0 (no "filter id"
93: * byte), or if the filter id is 0, then raw pixel values in the client
94: * format (see NOTE 1) will be compressed. See below details on the
95: * compression.
96: *
97: *-- The "gradient" filter pre-processes pixel data with a simple algorithm
98: * which converts each color component to a difference between a "predicted"
99: * intensity and the actual intensity. Such a technique does not affect
100: * uncompressed data size, but helps to compress photo-like images better.
101: * Pseudo-code for converting intensities to differences is the following:
102: *
103: * P[i,j] := V[i-1,j] + V[i,j-1] - V[i-1,j-1];
104: * if (P[i,j] < 0) then P[i,j] := 0;
105: * if (P[i,j] > MAX) then P[i,j] := MAX;
106: * D[i,j] := V[i,j] - P[i,j];
107: *
108: * Here V[i,j] is the intensity of a color component for a pixel at
109: * coordinates (i,j). MAX is the maximum value of intensity for a color
110: * component.
111: *
112: *-- The "palette" filter converts true-color pixel data to indexed colors
113: * and a palette which can consist of 2..256 colors. If the number of colors
114: * is 2, then each pixel is encoded in 1 bit, otherwise 8 bits is used to
115: * encode one pixel. 1-bit encoding is performed such way that the most
116: * significant bits correspond to the leftmost pixels, and each raw of pixels
117: * is aligned to the byte boundary. When "palette" filter is used, the
118: * palette is sent before the pixel data. The palette begins with an unsigned
119: * byte which value is the number of colors in the palette minus 1 (i.e. 1
120: * means 2 colors, 255 means 256 colors in the palette). Then follows the
121: * palette itself which consist of pixel values in client pixel format (see
122: * NOTE 1).
123: *
124: *-- The pixel data is compressed using the zlib library. But if the data
125: * size after applying the filter but before the compression is less then 12,
126: * then the data is sent as is, uncompressed. Four separate zlib streams
127: * (0..3) can be used and the decoder should read the actual stream id from
128: * the compression control byte (see NOTE 2).
129: *
130: * If the compression is not used, then the pixel data is sent as is,
131: * otherwise the data stream looks like this:
132: *
133: * 1..3 bytes: data size (N) in compact representation;
134: * N bytes: zlib-compressed data.
135: *
136: * Data size is compactly represented in one, two or three bytes, just like
137: * in the "jpeg" compression method (see above).
138: *
139: *-- NOTE 1. If the color depth is 24, and all three color components are
140: * 8-bit wide, then one pixel in Tight encoding is always represented by
141: * three bytes, where the first byte is red component, the second byte is
142: * green component, and the third byte is blue component of the pixel color
143: * value. This applies to colors in palettes as well.
144: *
145: *-- NOTE 2. The decoder must reset compression streams' states before
146: * decoding the rectangle, if some of bits 0,1,2,3 in the compression control
147: * byte are set to 1. Note that the decoder must reset zlib streams even if
148: * the compression type is "fill", "jpeg" or "png".
149: *
150: *-- NOTE 3. The "gradient" filter and "jpeg" compression may be used only
151: * when bits-per-pixel value is either 16 or 32, not 8.
152: *
153: *-- NOTE 4. The width of any Tight-encoded rectangle cannot exceed 2048
154: * pixels. If a rectangle is wider, it must be split into several rectangles
155: * and each one should be encoded separately.
156: *
157: */
158:
159: #define VNC_TIGHT_EXPLICIT_FILTER 0x04
160: #define VNC_TIGHT_FILL 0x08
161: #define VNC_TIGHT_JPEG 0x09
162: #define VNC_TIGHT_PNG 0x0A
163: #define VNC_TIGHT_MAX_SUBENCODING 0x0A
164:
165: /* Filters to improve compression efficiency */
166: #define VNC_TIGHT_FILTER_COPY 0x00
167: #define VNC_TIGHT_FILTER_PALETTE 0x01
168: #define VNC_TIGHT_FILTER_GRADIENT 0x02
169:
170: /* Note: The following constant should not be changed. */
171: #define VNC_TIGHT_MIN_TO_COMPRESS 12
172:
173: /* The parameters below may be adjusted. */
174: #define VNC_TIGHT_MIN_SPLIT_RECT_SIZE 4096
175: #define VNC_TIGHT_MIN_SOLID_SUBRECT_SIZE 2048
176: #define VNC_TIGHT_MAX_SPLIT_TILE_SIZE 16
177:
178: #define VNC_TIGHT_JPEG_MIN_RECT_SIZE 4096
179: #define VNC_TIGHT_DETECT_SUBROW_WIDTH 7
180: #define VNC_TIGHT_DETECT_MIN_WIDTH 8
181: #define VNC_TIGHT_DETECT_MIN_HEIGHT 8
182:
183: #endif /* VNC_ENCODING_TIGHT_H */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.