1 /* 2 * Copyright (C) 2000 Tridia Corporation. All Rights Reserved. 3 * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved. 4 * 5 * This is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This software is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this software; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 18 * USA. 19 */ 20 21 /* 22 * ultrazip.c - handle ultrazip encoding. 23 * 24 * This file shouldn't be compiled directly. It is included multiple times by 25 * rfbproto.c, each time with a different definition of the macro BPP. For 26 * each value of BPP, this file defines a function which handles an zlib 27 * encoded rectangle with BPP bits per pixel. 28 */ 29 30 #define HandleUltraZipBPP CONCAT2E(HandleUltraZip,BPP) 31 #define HandleUltraBPP CONCAT2E(HandleUltra,BPP) 32 #define CARDBPP CONCAT3E(uint,BPP,_t) 33 34 static rfbBool 35 HandleUltraBPP (rfbClient* client, int rx, int ry, int rw, int rh) 36 { 37 rfbZlibHeader hdr; 38 int toRead=0; 39 int inflateResult=0; 40 lzo_uint uncompressedBytes = (( rw * rh ) * ( BPP / 8 )); 41 42 if (!ReadFromRFBServer(client, (char *)&hdr, sz_rfbZlibHeader)) 43 return FALSE; 44 45 toRead = rfbClientSwap32IfLE(hdr.nBytes); 46 if (toRead==0) return TRUE; 47 48 if (uncompressedBytes==0) 49 { 50 rfbClientLog("ultra error: rectangle has 0 uncomressed bytes ((%dw * %dh) * (%d / 8))\n", rw, rh, BPP); 51 return FALSE; 52 } 53 54 /* First make sure we have a large enough raw buffer to hold the 55 * decompressed data. In practice, with a fixed BPP, fixed frame 56 * buffer size and the first update containing the entire frame 57 * buffer, this buffer allocation should only happen once, on the 58 * first update. 59 */ 60 if ( client->raw_buffer_size < (int)uncompressedBytes) { 61 if ( client->raw_buffer != NULL ) { 62 free( client->raw_buffer ); 63 } 64 client->raw_buffer_size = uncompressedBytes; 65 /* buffer needs to be aligned on 4-byte boundaries */ 66 if ((client->raw_buffer_size % 4)!=0) 67 client->raw_buffer_size += (4-(client->raw_buffer_size % 4)); 68 client->raw_buffer = (char*) malloc( client->raw_buffer_size ); 69 } 70 71 /* allocate enough space to store the incoming compressed packet */ 72 if ( client->ultra_buffer_size < toRead ) { 73 if ( client->ultra_buffer != NULL ) { 74 free( client->ultra_buffer ); 75 } 76 client->ultra_buffer_size = toRead; 77 /* buffer needs to be aligned on 4-byte boundaries */ 78 if ((client->ultra_buffer_size % 4)!=0) 79 client->ultra_buffer_size += (4-(client->ultra_buffer_size % 4)); 80 client->ultra_buffer = (char*) malloc( client->ultra_buffer_size ); 81 } 82 83 /* Fill the buffer, obtaining data from the server. */ 84 if (!ReadFromRFBServer(client, client->ultra_buffer, toRead)) 85 return FALSE; 86 87 /* uncompress the data */ 88 uncompressedBytes = client->raw_buffer_size; 89 inflateResult = lzo1x_decompress( 90 (lzo_byte *)client->ultra_buffer, toRead, 91 (lzo_byte *)client->raw_buffer, (lzo_uintp) &uncompressedBytes, 92 NULL); 93 94 95 if ((rw * rh * (BPP / 8)) != uncompressedBytes) 96 rfbClientLog("Ultra decompressed too little (%d < %d)", (rw * rh * (BPP / 8)), uncompressedBytes); 97 98 /* Put the uncompressed contents of the update on the screen. */ 99 if ( inflateResult == LZO_E_OK ) 100 { 101 CopyRectangle(client, (unsigned char *)client->raw_buffer, rx, ry, rw, rh); 102 } 103 else 104 { 105 rfbClientLog("ultra decompress returned error: %d\n", 106 inflateResult); 107 return FALSE; 108 } 109 return TRUE; 110 } 111 112 113 /* UltraZip is like rre in that it is composed of subrects */ 114 static rfbBool 115 HandleUltraZipBPP (rfbClient* client, int rx, int ry, int rw, int rh) 116 { 117 rfbZlibHeader hdr; 118 int i=0; 119 int toRead=0; 120 int inflateResult=0; 121 unsigned char *ptr=NULL; 122 lzo_uint uncompressedBytes = ry + (rw * 65535); 123 unsigned int numCacheRects = rx; 124 125 if (!ReadFromRFBServer(client, (char *)&hdr, sz_rfbZlibHeader)) 126 return FALSE; 127 128 toRead = rfbClientSwap32IfLE(hdr.nBytes); 129 130 if (toRead==0) return TRUE; 131 132 if (uncompressedBytes==0) 133 { 134 rfbClientLog("ultrazip error: rectangle has 0 uncomressed bytes (%dy + (%dw * 65535)) (%d rectangles)\n", ry, rw, rx); 135 return FALSE; 136 } 137 138 /* First make sure we have a large enough raw buffer to hold the 139 * decompressed data. In practice, with a fixed BPP, fixed frame 140 * buffer size and the first update containing the entire frame 141 * buffer, this buffer allocation should only happen once, on the 142 * first update. 143 */ 144 if ( client->raw_buffer_size < (int)(uncompressedBytes + 500)) { 145 if ( client->raw_buffer != NULL ) { 146 free( client->raw_buffer ); 147 } 148 client->raw_buffer_size = uncompressedBytes + 500; 149 /* buffer needs to be aligned on 4-byte boundaries */ 150 if ((client->raw_buffer_size % 4)!=0) 151 client->raw_buffer_size += (4-(client->raw_buffer_size % 4)); 152 client->raw_buffer = (char*) malloc( client->raw_buffer_size ); 153 } 154 155 156 /* allocate enough space to store the incoming compressed packet */ 157 if ( client->ultra_buffer_size < toRead ) { 158 if ( client->ultra_buffer != NULL ) { 159 free( client->ultra_buffer ); 160 } 161 client->ultra_buffer_size = toRead; 162 client->ultra_buffer = (char*) malloc( client->ultra_buffer_size ); 163 } 164 165 /* Fill the buffer, obtaining data from the server. */ 166 if (!ReadFromRFBServer(client, client->ultra_buffer, toRead)) 167 return FALSE; 168 169 /* uncompress the data */ 170 uncompressedBytes = client->raw_buffer_size; 171 inflateResult = lzo1x_decompress( 172 (lzo_byte *)client->ultra_buffer, toRead, 173 (lzo_byte *)client->raw_buffer, &uncompressedBytes, NULL); 174 if ( inflateResult != LZO_E_OK ) 175 { 176 rfbClientLog("ultra decompress returned error: %d\n", 177 inflateResult); 178 return FALSE; 179 } 180 181 /* Put the uncompressed contents of the update on the screen. */ 182 ptr = (unsigned char *)client->raw_buffer; 183 for (i=0; i<numCacheRects; i++) 184 { 185 unsigned short sx, sy, sw, sh; 186 unsigned int se; 187 188 memcpy((char *)&sx, ptr, 2); ptr += 2; 189 memcpy((char *)&sy, ptr, 2); ptr += 2; 190 memcpy((char *)&sw, ptr, 2); ptr += 2; 191 memcpy((char *)&sh, ptr, 2); ptr += 2; 192 memcpy((char *)&se, ptr, 4); ptr += 4; 193 194 sx = rfbClientSwap16IfLE(sx); 195 sy = rfbClientSwap16IfLE(sy); 196 sw = rfbClientSwap16IfLE(sw); 197 sh = rfbClientSwap16IfLE(sh); 198 se = rfbClientSwap32IfLE(se); 199 200 if (se == rfbEncodingRaw) 201 { 202 CopyRectangle(client, (unsigned char *)ptr, sx, sy, sw, sh); 203 ptr += ((sw * sh) * (BPP / 8)); 204 } 205 } 206 207 return TRUE; 208 } 209 210 #undef CARDBPP 211
