163 lines
4.7 KiB
C
163 lines
4.7 KiB
C
/*
|
|
* Copyright (C) 2000 Tridia Corporation. All Rights Reserved.
|
|
* Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
|
|
*
|
|
* This is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This software is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this software; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
* USA.
|
|
*/
|
|
|
|
#ifdef LIBVNCSERVER_HAVE_LIBZ
|
|
|
|
/*
|
|
* zlib.c - handle zlib encoding.
|
|
*
|
|
* This file shouldn't be compiled directly. It is included multiple times by
|
|
* rfbproto.c, each time with a different definition of the macro BPP. For
|
|
* each value of BPP, this file defines a function which handles an zlib
|
|
* encoded rectangle with BPP bits per pixel.
|
|
*/
|
|
|
|
#define HandleZlibBPP CONCAT2E(HandleZlib,BPP)
|
|
#define CARDBPP CONCAT3E(uint,BPP,_t)
|
|
|
|
static rfbBool
|
|
HandleZlibBPP (rfbClient* client, int rx, int ry, int rw, int rh)
|
|
{
|
|
rfbZlibHeader hdr;
|
|
int remaining;
|
|
int inflateResult;
|
|
int toRead;
|
|
|
|
/* First make sure we have a large enough raw buffer to hold the
|
|
* decompressed data. In practice, with a fixed BPP, fixed frame
|
|
* buffer size and the first update containing the entire frame
|
|
* buffer, this buffer allocation should only happen once, on the
|
|
* first update.
|
|
*/
|
|
if ( client->raw_buffer_size < (( rw * rh ) * ( BPP / 8 ))) {
|
|
|
|
if ( client->raw_buffer != NULL ) {
|
|
|
|
free( client->raw_buffer );
|
|
|
|
}
|
|
|
|
client->raw_buffer_size = (( rw * rh ) * ( BPP / 8 ));
|
|
client->raw_buffer = (char*) malloc( client->raw_buffer_size );
|
|
|
|
}
|
|
|
|
if (!ReadFromRFBServer(client, (char *)&hdr, sz_rfbZlibHeader))
|
|
return FALSE;
|
|
|
|
remaining = rfbClientSwap32IfLE(hdr.nBytes);
|
|
|
|
/* Need to initialize the decompressor state. */
|
|
client->decompStream.next_in = ( Bytef * )client->buffer;
|
|
client->decompStream.avail_in = 0;
|
|
client->decompStream.next_out = ( Bytef * )client->raw_buffer;
|
|
client->decompStream.avail_out = client->raw_buffer_size;
|
|
client->decompStream.data_type = Z_BINARY;
|
|
|
|
/* Initialize the decompression stream structures on the first invocation. */
|
|
if ( client->decompStreamInited == FALSE ) {
|
|
|
|
inflateResult = inflateInit( &client->decompStream );
|
|
|
|
if ( inflateResult != Z_OK ) {
|
|
rfbClientLog(
|
|
"inflateInit returned error: %d, msg: %s\n",
|
|
inflateResult,
|
|
client->decompStream.msg);
|
|
return FALSE;
|
|
}
|
|
|
|
client->decompStreamInited = TRUE;
|
|
|
|
}
|
|
|
|
inflateResult = Z_OK;
|
|
|
|
/* Process buffer full of data until no more to process, or
|
|
* some type of inflater error, or Z_STREAM_END.
|
|
*/
|
|
while (( remaining > 0 ) &&
|
|
( inflateResult == Z_OK )) {
|
|
|
|
if ( remaining > RFB_BUFFER_SIZE ) {
|
|
toRead = RFB_BUFFER_SIZE;
|
|
}
|
|
else {
|
|
toRead = remaining;
|
|
}
|
|
|
|
/* Fill the buffer, obtaining data from the server. */
|
|
if (!ReadFromRFBServer(client, client->buffer,toRead))
|
|
return FALSE;
|
|
|
|
client->decompStream.next_in = ( Bytef * )client->buffer;
|
|
client->decompStream.avail_in = toRead;
|
|
|
|
/* Need to uncompress buffer full. */
|
|
inflateResult = inflate( &client->decompStream, Z_SYNC_FLUSH );
|
|
|
|
/* We never supply a dictionary for compression. */
|
|
if ( inflateResult == Z_NEED_DICT ) {
|
|
rfbClientLog("zlib inflate needs a dictionary!\n");
|
|
return FALSE;
|
|
}
|
|
if ( inflateResult < 0 ) {
|
|
rfbClientLog(
|
|
"zlib inflate returned error: %d, msg: %s\n",
|
|
inflateResult,
|
|
client->decompStream.msg);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Result buffer allocated to be at least large enough. We should
|
|
* never run out of space!
|
|
*/
|
|
if (( client->decompStream.avail_in > 0 ) &&
|
|
( client->decompStream.avail_out <= 0 )) {
|
|
rfbClientLog("zlib inflate ran out of space!\n");
|
|
return FALSE;
|
|
}
|
|
|
|
remaining -= toRead;
|
|
|
|
} /* while ( remaining > 0 ) */
|
|
|
|
if ( inflateResult == Z_OK ) {
|
|
|
|
/* Put the uncompressed contents of the update on the screen. */
|
|
CopyRectangle(client, (uint8_t *)client->raw_buffer, rx, ry, rw, rh);
|
|
}
|
|
else {
|
|
|
|
rfbClientLog(
|
|
"zlib inflate returned error: %d, msg: %s\n",
|
|
inflateResult,
|
|
client->decompStream.msg);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#undef CARDBPP
|
|
|
|
#endif
|