LibVNCServer/LibVNCClient
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ultra.c
Go to the documentation of this file.
1 /*
2  * ultra.c
3  *
4  * Routines to implement ultra based encoding (minilzo).
5  * ultrazip supports packed rectangles if the rects are tiny...
6  * This improves performance as lzo has more data to work with at once
7  * This is 'UltraZip' and is currently not implemented.
8  */
9 
10 #include <rfb/rfb.h>
11 #include "minilzo.h"
12 
13 /*
14  * cl->beforeEncBuf contains pixel data in the client's format.
15  * cl->afterEncBuf contains the lzo (deflated) encoding version.
16  * If the lzo compressed/encoded version is
17  * larger than the raw data or if it exceeds cl->afterEncBufSize then
18  * raw encoding is used instead.
19  */
20 
21 
22 /*
23  * rfbSendOneRectEncodingZlib - send a given rectangle using one Zlib
24  * rectangle encoding.
25  */
26 
27 #define MAX_WRKMEM ((LZO1X_1_MEM_COMPRESS) + (sizeof(lzo_align_t) - 1)) / sizeof(lzo_align_t)
28 
29 
30 void rfbFreeUltraData(rfbClientPtr cl) {
31  if (cl->compStreamInitedLZO) {
32  free(cl->lzoWrkMem);
33  cl->compStreamInitedLZO=FALSE;
34  }
35 }
36 
37 
38 static rfbBool
39 rfbSendOneRectEncodingUltra(rfbClientPtr cl,
40  int x,
41  int y,
42  int w,
43  int h)
44 {
46  rfbZlibHeader hdr;
47  int deflateResult;
48  int i;
49  char *fbptr = (cl->scaledScreen->frameBuffer + (cl->scaledScreen->paddedWidthInBytes * y)
50  + (x * (cl->scaledScreen->bitsPerPixel / 8)));
51 
52  int maxRawSize;
53  lzo_uint maxCompSize;
54 
55  maxRawSize = (w * h * (cl->format.bitsPerPixel / 8));
56 
57  if (cl->beforeEncBufSize < maxRawSize) {
58  cl->beforeEncBufSize = maxRawSize;
59  if (cl->beforeEncBuf == NULL)
60  cl->beforeEncBuf = (char *)malloc(cl->beforeEncBufSize);
61  else
62  cl->beforeEncBuf = (char *)realloc(cl->beforeEncBuf, cl->beforeEncBufSize);
63  }
64 
65  /*
66  * lzo requires output buffer to be slightly larger than the input
67  * buffer, in the worst case.
68  */
69  maxCompSize = (maxRawSize + maxRawSize / 16 + 64 + 3);
70 
71  if (cl->afterEncBufSize < (int)maxCompSize) {
72  cl->afterEncBufSize = maxCompSize;
73  if (cl->afterEncBuf == NULL)
74  cl->afterEncBuf = (char *)malloc(cl->afterEncBufSize);
75  else
76  cl->afterEncBuf = (char *)realloc(cl->afterEncBuf, cl->afterEncBufSize);
77  }
78 
79  /*
80  * Convert pixel data to client format.
81  */
82  (*cl->translateFn)(cl->translateLookupTable, &cl->screen->serverFormat,
83  &cl->format, fbptr, cl->beforeEncBuf,
84  cl->scaledScreen->paddedWidthInBytes, w, h);
85 
86  if ( cl->compStreamInitedLZO == FALSE ) {
87  cl->compStreamInitedLZO = TRUE;
88  /* Work-memory needed for compression. Allocate memory in units
89  * of `lzo_align_t' (instead of `char') to make sure it is properly aligned.
90  */
91  cl->lzoWrkMem = malloc(sizeof(lzo_align_t) * (((LZO1X_1_MEM_COMPRESS) + (sizeof(lzo_align_t) - 1)) / sizeof(lzo_align_t)));
92  }
93 
94  /* Perform the compression here. */
95  deflateResult = lzo1x_1_compress((unsigned char *)cl->beforeEncBuf, (lzo_uint)(w * h * (cl->format.bitsPerPixel / 8)), (unsigned char *)cl->afterEncBuf, &maxCompSize, cl->lzoWrkMem);
96  /* maxCompSize now contains the compressed size */
97 
98  /* Find the total size of the resulting compressed data. */
99  cl->afterEncBufLen = maxCompSize;
100 
101  if ( deflateResult != LZO_E_OK ) {
102  rfbErr("lzo deflation error: %d\n", deflateResult);
103  return FALSE;
104  }
105 
106  /* Update statics */
108 
110  > UPDATE_BUF_SIZE)
111  {
112  if (!rfbSendUpdateBuf(cl))
113  return FALSE;
114  }
115 
116  rect.r.x = Swap16IfLE(x);
117  rect.r.y = Swap16IfLE(y);
118  rect.r.w = Swap16IfLE(w);
119  rect.r.h = Swap16IfLE(h);
121 
122  memcpy(&cl->updateBuf[cl->ublen], (char *)&rect,
125 
126  hdr.nBytes = Swap32IfLE(cl->afterEncBufLen);
127 
128  memcpy(&cl->updateBuf[cl->ublen], (char *)&hdr, sz_rfbZlibHeader);
129  cl->ublen += sz_rfbZlibHeader;
130 
131  /* We might want to try sending the data directly... */
132  for (i = 0; i < cl->afterEncBufLen;) {
133 
134  int bytesToCopy = UPDATE_BUF_SIZE - cl->ublen;
135 
136  if (i + bytesToCopy > cl->afterEncBufLen) {
137  bytesToCopy = cl->afterEncBufLen - i;
138  }
139 
140  memcpy(&cl->updateBuf[cl->ublen], &cl->afterEncBuf[i], bytesToCopy);
141 
142  cl->ublen += bytesToCopy;
143  i += bytesToCopy;
144 
145  if (cl->ublen == UPDATE_BUF_SIZE) {
146  if (!rfbSendUpdateBuf(cl))
147  return FALSE;
148  }
149  }
150 
151  return TRUE;
152 
153 }
154 
155 /*
156  * rfbSendRectEncodingUltra - send a given rectangle using one or more
157  * LZO encoding rectangles.
158  */
159 
160 rfbBool
161 rfbSendRectEncodingUltra(rfbClientPtr cl,
162  int x,
163  int y,
164  int w,
165  int h)
166 {
167  int maxLines;
168  int linesRemaining;
169  rfbRectangle partialRect;
170 
171  partialRect.x = x;
172  partialRect.y = y;
173  partialRect.w = w;
174  partialRect.h = h;
175 
176  /* Determine maximum pixel/scan lines allowed per rectangle. */
177  maxLines = ( ULTRA_MAX_SIZE(w) / w );
178 
179  /* Initialize number of scan lines left to do. */
180  linesRemaining = h;
181 
182  /* Loop until all work is done. */
183  while ( linesRemaining > 0 ) {
184 
185  int linesToComp;
186 
187  if ( maxLines < linesRemaining )
188  linesToComp = maxLines;
189  else
190  linesToComp = linesRemaining;
191 
192  partialRect.h = linesToComp;
193 
194  /* Encode (compress) and send the next rectangle. */
195  if ( ! rfbSendOneRectEncodingUltra( cl,
196  partialRect.x,
197  partialRect.y,
198  partialRect.w,
199  partialRect.h )) {
200 
201  return FALSE;
202  }
203 
204  /* Technically, flushing the buffer here is not extrememly
205  * efficient. However, this improves the overall throughput
206  * of the system over very slow networks. By flushing
207  * the buffer with every maximum size lzo rectangle, we
208  * improve the pipelining usage of the server CPU, network,
209  * and viewer CPU components. Insuring that these components
210  * are working in parallel actually improves the performance
211  * seen by the user.
212  * Since, lzo is most useful for slow networks, this flush
213  * is appropriate for the desired behavior of the lzo encoding.
214  */
215  if (( cl->ublen > 0 ) &&
216  ( linesToComp == maxLines )) {
217  if (!rfbSendUpdateBuf(cl)) {
218 
219  return FALSE;
220  }
221  }
222 
223  /* Update remaining and incremental rectangle location. */
224  linesRemaining -= linesToComp;
225  partialRect.y += linesToComp;
226 
227  }
228 
229  return TRUE;
230 
231 }