• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  *  Copyright (C) 2000, 2001 Const Kaplinsky.  All Rights Reserved.
3  *
4  *  This is free software; you can redistribute it and/or modify
5  *  it under the terms of the GNU General Public License as published by
6  *  the Free Software Foundation; either version 2 of the License, or
7  *  (at your option) any later version.
8  *
9  *  This software is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *  GNU General Public License for more details.
13  *
14  *  You should have received a copy of the GNU General Public License
15  *  along with this software; if not, write to the Free Software
16  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
17  *  USA.
18  */
19 
20 #ifdef LIBVNCSERVER_HAVE_LIBZ
21 #ifdef LIBVNCSERVER_HAVE_LIBJPEG
22 
23 /*
24  * tight.c - handle ``tight'' encoding.
25  *
26  * This file shouldn't be compiled directly. It is included multiple
27  * times by rfbproto.c, each time with a different definition of the
28  * macro BPP. For each value of BPP, this file defines a function
29  * which handles a tight-encoded rectangle with BPP bits per pixel.
30  *
31  */
32 
33 #define TIGHT_MIN_TO_COMPRESS 12
34 
35 #define CARDBPP CONCAT3E(uint,BPP,_t)
36 #define filterPtrBPP CONCAT2E(filterPtr,BPP)
37 
38 #define HandleTightBPP CONCAT2E(HandleTight,BPP)
39 #define InitFilterCopyBPP CONCAT2E(InitFilterCopy,BPP)
40 #define InitFilterPaletteBPP CONCAT2E(InitFilterPalette,BPP)
41 #define InitFilterGradientBPP CONCAT2E(InitFilterGradient,BPP)
42 #define FilterCopyBPP CONCAT2E(FilterCopy,BPP)
43 #define FilterPaletteBPP CONCAT2E(FilterPalette,BPP)
44 #define FilterGradientBPP CONCAT2E(FilterGradient,BPP)
45 
46 #if BPP != 8
47 #define DecompressJpegRectBPP CONCAT2E(DecompressJpegRect,BPP)
48 #endif
49 
50 #ifndef RGB_TO_PIXEL
51 
52 #define RGB_TO_PIXEL(bpp,r,g,b)						\
53   (((CARD##bpp)(r) & client->format.redMax) << client->format.redShift |		\
54    ((CARD##bpp)(g) & client->format.greenMax) << client->format.greenShift |	\
55    ((CARD##bpp)(b) & client->format.blueMax) << client->format.blueShift)
56 
57 #define RGB24_TO_PIXEL(bpp,r,g,b)                                       \
58    ((((CARD##bpp)(r) & 0xFF) * client->format.redMax + 127) / 255             \
59     << client->format.redShift |                                              \
60     (((CARD##bpp)(g) & 0xFF) * client->format.greenMax + 127) / 255           \
61     << client->format.greenShift |                                            \
62     (((CARD##bpp)(b) & 0xFF) * client->format.blueMax + 127) / 255            \
63     << client->format.blueShift)
64 
65 #define RGB24_TO_PIXEL32(r,g,b)						\
66   (((uint32_t)(r) & 0xFF) << client->format.redShift |				\
67    ((uint32_t)(g) & 0xFF) << client->format.greenShift |			\
68    ((uint32_t)(b) & 0xFF) << client->format.blueShift)
69 
70 #endif
71 
72 /* Type declarations */
73 
74 typedef void (*filterPtrBPP)(rfbClient* client, int, CARDBPP *);
75 
76 /* Prototypes */
77 
78 static int InitFilterCopyBPP (rfbClient* client, int rw, int rh);
79 static int InitFilterPaletteBPP (rfbClient* client, int rw, int rh);
80 static int InitFilterGradientBPP (rfbClient* client, int rw, int rh);
81 static void FilterCopyBPP (rfbClient* client, int numRows, CARDBPP *destBuffer);
82 static void FilterPaletteBPP (rfbClient* client, int numRows, CARDBPP *destBuffer);
83 static void FilterGradientBPP (rfbClient* client, int numRows, CARDBPP *destBuffer);
84 
85 #if BPP != 8
86 static rfbBool DecompressJpegRectBPP(rfbClient* client, int x, int y, int w, int h);
87 #endif
88 
89 /* Definitions */
90 
91 static rfbBool
HandleTightBPP(rfbClient * client,int rx,int ry,int rw,int rh)92 HandleTightBPP (rfbClient* client, int rx, int ry, int rw, int rh)
93 {
94   CARDBPP fill_colour;
95   uint8_t comp_ctl;
96   uint8_t filter_id;
97   filterPtrBPP filterFn;
98   z_streamp zs;
99   char *buffer2;
100   int err, stream_id, compressedLen, bitsPixel;
101   int bufferSize, rowSize, numRows, portionLen, rowsProcessed, extraBytes;
102 
103   if (!ReadFromRFBServer(client, (char *)&comp_ctl, 1))
104     return FALSE;
105 
106   /* Flush zlib streams if we are told by the server to do so. */
107   for (stream_id = 0; stream_id < 4; stream_id++) {
108     if ((comp_ctl & 1) && client->zlibStreamActive[stream_id]) {
109       if (inflateEnd (&client->zlibStream[stream_id]) != Z_OK &&
110 	  client->zlibStream[stream_id].msg != NULL)
111 	rfbClientLog("inflateEnd: %s\n", client->zlibStream[stream_id].msg);
112       client->zlibStreamActive[stream_id] = FALSE;
113     }
114     comp_ctl >>= 1;
115   }
116 
117   /* Handle solid rectangles. */
118   if (comp_ctl == rfbTightFill) {
119 #if BPP == 32
120     if (client->format.depth == 24 && client->format.redMax == 0xFF &&
121 	client->format.greenMax == 0xFF && client->format.blueMax == 0xFF) {
122       if (!ReadFromRFBServer(client, client->buffer, 3))
123 	return FALSE;
124       fill_colour = RGB24_TO_PIXEL32(client->buffer[0], client->buffer[1], client->buffer[2]);
125     } else {
126       if (!ReadFromRFBServer(client, (char*)&fill_colour, sizeof(fill_colour)))
127 	return FALSE;
128     }
129 #else
130     if (!ReadFromRFBServer(client, (char*)&fill_colour, sizeof(fill_colour)))
131 	return FALSE;
132 #endif
133 
134     FillRectangle(client, rx, ry, rw, rh, fill_colour);
135 
136     return TRUE;
137   }
138 
139 #if BPP == 8
140   if (comp_ctl == rfbTightJpeg) {
141     rfbClientLog("Tight encoding: JPEG is not supported in 8 bpp mode.\n");
142     return FALSE;
143   }
144 #else
145   if (comp_ctl == rfbTightJpeg) {
146     return DecompressJpegRectBPP(client, rx, ry, rw, rh);
147   }
148 #endif
149 
150   /* Quit on unsupported subencoding value. */
151   if (comp_ctl > rfbTightMaxSubencoding) {
152     rfbClientLog("Tight encoding: bad subencoding value received.\n");
153     return FALSE;
154   }
155 
156   /*
157    * Here primary compression mode handling begins.
158    * Data was processed with optional filter + zlib compression.
159    */
160 
161   /* First, we should identify a filter to use. */
162   if ((comp_ctl & rfbTightExplicitFilter) != 0) {
163     if (!ReadFromRFBServer(client, (char*)&filter_id, 1))
164       return FALSE;
165 
166     switch (filter_id) {
167     case rfbTightFilterCopy:
168       filterFn = FilterCopyBPP;
169       bitsPixel = InitFilterCopyBPP(client, rw, rh);
170       break;
171     case rfbTightFilterPalette:
172       filterFn = FilterPaletteBPP;
173       bitsPixel = InitFilterPaletteBPP(client, rw, rh);
174       break;
175     case rfbTightFilterGradient:
176       filterFn = FilterGradientBPP;
177       bitsPixel = InitFilterGradientBPP(client, rw, rh);
178       break;
179     default:
180       rfbClientLog("Tight encoding: unknown filter code received.\n");
181       return FALSE;
182     }
183   } else {
184     filterFn = FilterCopyBPP;
185     bitsPixel = InitFilterCopyBPP(client, rw, rh);
186   }
187   if (bitsPixel == 0) {
188     rfbClientLog("Tight encoding: error receiving palette.\n");
189     return FALSE;
190   }
191 
192   /* Determine if the data should be decompressed or just copied. */
193   rowSize = (rw * bitsPixel + 7) / 8;
194   if (rh * rowSize < TIGHT_MIN_TO_COMPRESS) {
195     if (!ReadFromRFBServer(client, (char*)client->buffer, rh * rowSize))
196       return FALSE;
197 
198     buffer2 = &client->buffer[TIGHT_MIN_TO_COMPRESS * 4];
199     filterFn(client, rh, (CARDBPP *)buffer2);
200 
201     CopyRectangle(client, (uint8_t *)buffer2, rx, ry, rw, rh);
202 
203     return TRUE;
204   }
205 
206   /* Read the length (1..3 bytes) of compressed data following. */
207   compressedLen = (int)ReadCompactLen(client);
208   if (compressedLen <= 0) {
209     rfbClientLog("Incorrect data received from the server.\n");
210     return FALSE;
211   }
212 
213   /* Now let's initialize compression stream if needed. */
214   stream_id = comp_ctl & 0x03;
215   zs = &client->zlibStream[stream_id];
216   if (!client->zlibStreamActive[stream_id]) {
217     zs->zalloc = Z_NULL;
218     zs->zfree = Z_NULL;
219     zs->opaque = Z_NULL;
220     err = inflateInit(zs);
221     if (err != Z_OK) {
222       if (zs->msg != NULL)
223 	rfbClientLog("InflateInit error: %s.\n", zs->msg);
224       return FALSE;
225     }
226     client->zlibStreamActive[stream_id] = TRUE;
227   }
228 
229   /* Read, decode and draw actual pixel data in a loop. */
230 
231   bufferSize = RFB_BUFFER_SIZE * bitsPixel / (bitsPixel + BPP) & 0xFFFFFFFC;
232   buffer2 = &client->buffer[bufferSize];
233   if (rowSize > bufferSize) {
234     /* Should be impossible when RFB_BUFFER_SIZE >= 16384 */
235     rfbClientLog("Internal error: incorrect buffer size.\n");
236     return FALSE;
237   }
238 
239   rowsProcessed = 0;
240   extraBytes = 0;
241 
242   while (compressedLen > 0) {
243     if (compressedLen > ZLIB_BUFFER_SIZE)
244       portionLen = ZLIB_BUFFER_SIZE;
245     else
246       portionLen = compressedLen;
247 
248     if (!ReadFromRFBServer(client, (char*)client->zlib_buffer, portionLen))
249       return FALSE;
250 
251     compressedLen -= portionLen;
252 
253     zs->next_in = (Bytef *)client->zlib_buffer;
254     zs->avail_in = portionLen;
255 
256     do {
257       zs->next_out = (Bytef *)&client->buffer[extraBytes];
258       zs->avail_out = bufferSize - extraBytes;
259 
260       err = inflate(zs, Z_SYNC_FLUSH);
261       if (err == Z_BUF_ERROR)   /* Input exhausted -- no problem. */
262 	break;
263       if (err != Z_OK && err != Z_STREAM_END) {
264 	if (zs->msg != NULL) {
265 	  rfbClientLog("Inflate error: %s.\n", zs->msg);
266 	} else {
267 	  rfbClientLog("Inflate error: %d.\n", err);
268 	}
269 	return FALSE;
270       }
271 
272       numRows = (bufferSize - zs->avail_out) / rowSize;
273 
274       filterFn(client, numRows, (CARDBPP *)buffer2);
275 
276       extraBytes = bufferSize - zs->avail_out - numRows * rowSize;
277       if (extraBytes > 0)
278 	memcpy(client->buffer, &client->buffer[numRows * rowSize], extraBytes);
279 
280       CopyRectangle(client, (uint8_t *)buffer2, rx, ry+rowsProcessed, rw, numRows);
281 
282       rowsProcessed += numRows;
283     }
284     while (zs->avail_out == 0);
285   }
286 
287   if (rowsProcessed != rh) {
288     rfbClientLog("Incorrect number of scan lines after decompression.\n");
289     return FALSE;
290   }
291 
292   return TRUE;
293 }
294 
295 /*----------------------------------------------------------------------------
296  *
297  * Filter stuff.
298  *
299  */
300 
301 static int
InitFilterCopyBPP(rfbClient * client,int rw,int rh)302 InitFilterCopyBPP (rfbClient* client, int rw, int rh)
303 {
304   client->rectWidth = rw;
305 
306 #if BPP == 32
307   if (client->format.depth == 24 && client->format.redMax == 0xFF &&
308       client->format.greenMax == 0xFF && client->format.blueMax == 0xFF) {
309     client->cutZeros = TRUE;
310     return 24;
311   } else {
312     client->cutZeros = FALSE;
313   }
314 #endif
315 
316   return BPP;
317 }
318 
319 static void
FilterCopyBPP(rfbClient * client,int numRows,CARDBPP * dst)320 FilterCopyBPP (rfbClient* client, int numRows, CARDBPP *dst)
321 {
322 
323 #if BPP == 32
324   int x, y;
325 
326   if (client->cutZeros) {
327     for (y = 0; y < numRows; y++) {
328       for (x = 0; x < client->rectWidth; x++) {
329 	dst[y*client->rectWidth+x] =
330 	  RGB24_TO_PIXEL32(client->buffer[(y*client->rectWidth+x)*3],
331 			   client->buffer[(y*client->rectWidth+x)*3+1],
332 			   client->buffer[(y*client->rectWidth+x)*3+2]);
333       }
334     }
335     return;
336   }
337 #endif
338 
339   memcpy (dst, client->buffer, numRows * client->rectWidth * (BPP / 8));
340 }
341 
342 static int
InitFilterGradientBPP(rfbClient * client,int rw,int rh)343 InitFilterGradientBPP (rfbClient* client, int rw, int rh)
344 {
345   int bits;
346 
347   bits = InitFilterCopyBPP(client, rw, rh);
348   if (client->cutZeros)
349     memset(client->tightPrevRow, 0, rw * 3);
350   else
351     memset(client->tightPrevRow, 0, rw * 3 * sizeof(uint16_t));
352 
353   return bits;
354 }
355 
356 #if BPP == 32
357 
358 static void
FilterGradient24(rfbClient * client,int numRows,uint32_t * dst)359 FilterGradient24 (rfbClient* client, int numRows, uint32_t *dst)
360 {
361   int x, y, c;
362   uint8_t thisRow[2048*3];
363   uint8_t pix[3];
364   int est[3];
365 
366   for (y = 0; y < numRows; y++) {
367 
368     /* First pixel in a row */
369     for (c = 0; c < 3; c++) {
370       pix[c] = client->tightPrevRow[c] + client->buffer[y*client->rectWidth*3+c];
371       thisRow[c] = pix[c];
372     }
373     dst[y*client->rectWidth] = RGB24_TO_PIXEL32(pix[0], pix[1], pix[2]);
374 
375     /* Remaining pixels of a row */
376     for (x = 1; x < client->rectWidth; x++) {
377       for (c = 0; c < 3; c++) {
378 	est[c] = (int)client->tightPrevRow[x*3+c] + (int)pix[c] -
379 		 (int)client->tightPrevRow[(x-1)*3+c];
380 	if (est[c] > 0xFF) {
381 	  est[c] = 0xFF;
382 	} else if (est[c] < 0x00) {
383 	  est[c] = 0x00;
384 	}
385 	pix[c] = (uint8_t)est[c] + client->buffer[(y*client->rectWidth+x)*3+c];
386 	thisRow[x*3+c] = pix[c];
387       }
388       dst[y*client->rectWidth+x] = RGB24_TO_PIXEL32(pix[0], pix[1], pix[2]);
389     }
390 
391     memcpy(client->tightPrevRow, thisRow, client->rectWidth * 3);
392   }
393 }
394 
395 #endif
396 
397 static void
FilterGradientBPP(rfbClient * client,int numRows,CARDBPP * dst)398 FilterGradientBPP (rfbClient* client, int numRows, CARDBPP *dst)
399 {
400   int x, y, c;
401   CARDBPP *src = (CARDBPP *)client->buffer;
402   uint16_t *thatRow = (uint16_t *)client->tightPrevRow;
403   uint16_t thisRow[2048*3];
404   uint16_t pix[3];
405   uint16_t max[3];
406   int shift[3];
407   int est[3];
408 
409 #if BPP == 32
410   if (client->cutZeros) {
411     FilterGradient24(client, numRows, dst);
412     return;
413   }
414 #endif
415 
416   max[0] = client->format.redMax;
417   max[1] = client->format.greenMax;
418   max[2] = client->format.blueMax;
419 
420   shift[0] = client->format.redShift;
421   shift[1] = client->format.greenShift;
422   shift[2] = client->format.blueShift;
423 
424   for (y = 0; y < numRows; y++) {
425 
426     /* First pixel in a row */
427     for (c = 0; c < 3; c++) {
428       pix[c] = (uint16_t)(((src[y*client->rectWidth] >> shift[c]) + thatRow[c]) & max[c]);
429       thisRow[c] = pix[c];
430     }
431     dst[y*client->rectWidth] = RGB_TO_PIXEL(BPP, pix[0], pix[1], pix[2]);
432 
433     /* Remaining pixels of a row */
434     for (x = 1; x < client->rectWidth; x++) {
435       for (c = 0; c < 3; c++) {
436 	est[c] = (int)thatRow[x*3+c] + (int)pix[c] - (int)thatRow[(x-1)*3+c];
437 	if (est[c] > (int)max[c]) {
438 	  est[c] = (int)max[c];
439 	} else if (est[c] < 0) {
440 	  est[c] = 0;
441 	}
442 	pix[c] = (uint16_t)(((src[y*client->rectWidth+x] >> shift[c]) + est[c]) & max[c]);
443 	thisRow[x*3+c] = pix[c];
444       }
445       dst[y*client->rectWidth+x] = RGB_TO_PIXEL(BPP, pix[0], pix[1], pix[2]);
446     }
447     memcpy(thatRow, thisRow, client->rectWidth * 3 * sizeof(uint16_t));
448   }
449 }
450 
451 static int
InitFilterPaletteBPP(rfbClient * client,int rw,int rh)452 InitFilterPaletteBPP (rfbClient* client, int rw, int rh)
453 {
454   uint8_t numColors;
455 #if BPP == 32
456   int i;
457   CARDBPP *palette = (CARDBPP *)client->tightPalette;
458 #endif
459 
460   client->rectWidth = rw;
461 
462   if (!ReadFromRFBServer(client, (char*)&numColors, 1))
463     return 0;
464 
465   client->rectColors = (int)numColors;
466   if (++client->rectColors < 2)
467     return 0;
468 
469 #if BPP == 32
470   if (client->format.depth == 24 && client->format.redMax == 0xFF &&
471       client->format.greenMax == 0xFF && client->format.blueMax == 0xFF) {
472     if (!ReadFromRFBServer(client, (char*)&client->tightPalette, client->rectColors * 3))
473       return 0;
474     for (i = client->rectColors - 1; i >= 0; i--) {
475       palette[i] = RGB24_TO_PIXEL32(client->tightPalette[i*3],
476 				    client->tightPalette[i*3+1],
477 				    client->tightPalette[i*3+2]);
478     }
479     return (client->rectColors == 2) ? 1 : 8;
480   }
481 #endif
482 
483   if (!ReadFromRFBServer(client, (char*)&client->tightPalette, client->rectColors * (BPP / 8)))
484     return 0;
485 
486   return (client->rectColors == 2) ? 1 : 8;
487 }
488 
489 static void
FilterPaletteBPP(rfbClient * client,int numRows,CARDBPP * dst)490 FilterPaletteBPP (rfbClient* client, int numRows, CARDBPP *dst)
491 {
492   int x, y, b, w;
493   uint8_t *src = (uint8_t *)client->buffer;
494   CARDBPP *palette = (CARDBPP *)client->tightPalette;
495 
496   if (client->rectColors == 2) {
497     w = (client->rectWidth + 7) / 8;
498     for (y = 0; y < numRows; y++) {
499       for (x = 0; x < client->rectWidth / 8; x++) {
500 	for (b = 7; b >= 0; b--)
501 	  dst[y*client->rectWidth+x*8+7-b] = palette[src[y*w+x] >> b & 1];
502       }
503       for (b = 7; b >= 8 - client->rectWidth % 8; b--) {
504 	dst[y*client->rectWidth+x*8+7-b] = palette[src[y*w+x] >> b & 1];
505       }
506     }
507   } else {
508     for (y = 0; y < numRows; y++)
509       for (x = 0; x < client->rectWidth; x++)
510 	dst[y*client->rectWidth+x] = palette[(int)src[y*client->rectWidth+x]];
511   }
512 }
513 
514 #if BPP != 8
515 
516 /*----------------------------------------------------------------------------
517  *
518  * JPEG decompression.
519  *
520  */
521 
522 static rfbBool
DecompressJpegRectBPP(rfbClient * client,int x,int y,int w,int h)523 DecompressJpegRectBPP(rfbClient* client, int x, int y, int w, int h)
524 {
525   struct jpeg_decompress_struct cinfo;
526   struct jpeg_error_mgr jerr;
527   int compressedLen;
528   uint8_t *compressedData;
529   CARDBPP *pixelPtr;
530   JSAMPROW rowPointer[1];
531   int dx, dy;
532 
533   compressedLen = (int)ReadCompactLen(client);
534   if (compressedLen <= 0) {
535     rfbClientLog("Incorrect data received from the server.\n");
536     return FALSE;
537   }
538 
539   compressedData = malloc(compressedLen);
540   if (compressedData == NULL) {
541     rfbClientLog("Memory allocation error.\n");
542     return FALSE;
543   }
544 
545   if (!ReadFromRFBServer(client, (char*)compressedData, compressedLen)) {
546     free(compressedData);
547     return FALSE;
548   }
549 
550   cinfo.err = jpeg_std_error(&jerr);
551   cinfo.client_data = client;
552   jpeg_create_decompress(&cinfo);
553 
554   JpegSetSrcManager(&cinfo, compressedData, compressedLen);
555 
556   jpeg_read_header(&cinfo, TRUE);
557   cinfo.out_color_space = JCS_RGB;
558 
559   jpeg_start_decompress(&cinfo);
560   if (cinfo.output_width != w || cinfo.output_height != h ||
561       cinfo.output_components != 3) {
562     rfbClientLog("Tight Encoding: Wrong JPEG data received.\n");
563     jpeg_destroy_decompress(&cinfo);
564     free(compressedData);
565     return FALSE;
566   }
567 
568   rowPointer[0] = (JSAMPROW)client->buffer;
569   dy = 0;
570   while (cinfo.output_scanline < cinfo.output_height) {
571     jpeg_read_scanlines(&cinfo, rowPointer, 1);
572     if (client->jpegError) {
573       break;
574     }
575     pixelPtr = (CARDBPP *)&client->buffer[RFB_BUFFER_SIZE / 2];
576     for (dx = 0; dx < w; dx++) {
577       *pixelPtr++ =
578 	RGB24_TO_PIXEL(BPP, client->buffer[dx*3], client->buffer[dx*3+1], client->buffer[dx*3+2]);
579     }
580     CopyRectangle(client, (uint8_t *)&client->buffer[RFB_BUFFER_SIZE / 2], x, y + dy, w, 1);
581     dy++;
582   }
583 
584   if (!client->jpegError)
585     jpeg_finish_decompress(&cinfo);
586 
587   jpeg_destroy_decompress(&cinfo);
588   free(compressedData);
589 
590   return !client->jpegError;
591 }
592 
593 #else
594 
595 static long
ReadCompactLen(rfbClient * client)596 ReadCompactLen (rfbClient* client)
597 {
598   long len;
599   uint8_t b;
600 
601   if (!ReadFromRFBServer(client, (char *)&b, 1))
602     return -1;
603   len = (int)b & 0x7F;
604   if (b & 0x80) {
605     if (!ReadFromRFBServer(client, (char *)&b, 1))
606       return -1;
607     len |= ((int)b & 0x7F) << 7;
608     if (b & 0x80) {
609       if (!ReadFromRFBServer(client, (char *)&b, 1))
610 	return -1;
611       len |= ((int)b & 0xFF) << 14;
612     }
613   }
614   return len;
615 }
616 
617 /*
618  * JPEG source manager functions for JPEG decompression in Tight decoder.
619  */
620 
621 static void
JpegInitSource(j_decompress_ptr cinfo)622 JpegInitSource(j_decompress_ptr cinfo)
623 {
624   rfbClient* client=(rfbClient*)cinfo->client_data;
625   client->jpegError = FALSE;
626 }
627 
628 static boolean
JpegFillInputBuffer(j_decompress_ptr cinfo)629 JpegFillInputBuffer(j_decompress_ptr cinfo)
630 {
631   rfbClient* client=(rfbClient*)cinfo->client_data;
632   client->jpegError = TRUE;
633   client->jpegSrcManager->bytes_in_buffer = client->jpegBufferLen;
634   client->jpegSrcManager->next_input_byte = (JOCTET *)client->jpegBufferPtr;
635 
636   return TRUE;
637 }
638 
639 static void
JpegSkipInputData(j_decompress_ptr cinfo,long num_bytes)640 JpegSkipInputData(j_decompress_ptr cinfo, long num_bytes)
641 {
642   rfbClient* client=(rfbClient*)cinfo->client_data;
643   if (num_bytes < 0 || num_bytes > client->jpegSrcManager->bytes_in_buffer) {
644     client->jpegError = TRUE;
645     client->jpegSrcManager->bytes_in_buffer = client->jpegBufferLen;
646     client->jpegSrcManager->next_input_byte = (JOCTET *)client->jpegBufferPtr;
647   } else {
648     client->jpegSrcManager->next_input_byte += (size_t) num_bytes;
649     client->jpegSrcManager->bytes_in_buffer -= (size_t) num_bytes;
650   }
651 }
652 
653 static void
JpegTermSource(j_decompress_ptr cinfo)654 JpegTermSource(j_decompress_ptr cinfo)
655 {
656   /* nothing to do here. */
657 }
658 
659 static void
JpegSetSrcManager(j_decompress_ptr cinfo,uint8_t * compressedData,int compressedLen)660 JpegSetSrcManager(j_decompress_ptr cinfo,
661 		  uint8_t *compressedData,
662 		  int compressedLen)
663 {
664   rfbClient* client=(rfbClient*)cinfo->client_data;
665   client->jpegBufferPtr = compressedData;
666   client->jpegBufferLen = (size_t)compressedLen;
667 
668   if(client->jpegSrcManager == NULL)
669     client->jpegSrcManager = malloc(sizeof(struct jpeg_source_mgr));
670   client->jpegSrcManager->init_source = JpegInitSource;
671   client->jpegSrcManager->fill_input_buffer = JpegFillInputBuffer;
672   client->jpegSrcManager->skip_input_data = JpegSkipInputData;
673   client->jpegSrcManager->resync_to_restart = jpeg_resync_to_restart;
674   client->jpegSrcManager->term_source = JpegTermSource;
675   client->jpegSrcManager->next_input_byte = (JOCTET*)client->jpegBufferPtr;
676   client->jpegSrcManager->bytes_in_buffer = client->jpegBufferLen;
677 
678   cinfo->src = client->jpegSrcManager;
679 }
680 
681 #endif
682 
683 #undef CARDBPP
684 
685 /* LIBVNCSERVER_HAVE_LIBZ and LIBVNCSERVER_HAVE_LIBJPEG */
686 #endif
687 #endif
688 
689