LibVNCServer/LibVNCClient
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
zrleoutstream.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2002 RealVNC Ltd. All Rights Reserved.
3  * Copyright (C) 2003 Sun Microsystems, Inc.
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 #include "zrleoutstream.h"
22 #include <stdlib.h>
23 
24 #define ZRLE_IN_BUFFER_SIZE 16384
25 #define ZRLE_OUT_BUFFER_SIZE 1024
26 #undef ZRLE_DEBUG
27 
28 static rfbBool zrleBufferAlloc(zrleBuffer *buffer, int size)
29 {
30  buffer->ptr = buffer->start = malloc(size);
31  if (buffer->start == NULL) {
32  buffer->end = NULL;
33  return FALSE;
34  }
35 
36  buffer->end = buffer->start + size;
37 
38  return TRUE;
39 }
40 
41 static void zrleBufferFree(zrleBuffer *buffer)
42 {
43  if (buffer->start)
44  free(buffer->start);
45  buffer->start = buffer->ptr = buffer->end = NULL;
46 }
47 
48 static rfbBool zrleBufferGrow(zrleBuffer *buffer, int size)
49 {
50  int offset;
51 
52  size += buffer->end - buffer->start;
53  offset = ZRLE_BUFFER_LENGTH (buffer);
54 
55  buffer->start = realloc(buffer->start, size);
56  if (!buffer->start) {
57  return FALSE;
58  }
59 
60  buffer->end = buffer->start + size;
61  buffer->ptr = buffer->start + offset;
62 
63  return TRUE;
64 }
65 
67 {
68  zrleOutStream *os;
69 
70  os = malloc(sizeof(zrleOutStream));
71  if (os == NULL)
72  return NULL;
73 
74  if (!zrleBufferAlloc(&os->in, ZRLE_IN_BUFFER_SIZE)) {
75  free(os);
76  return NULL;
77  }
78 
79  if (!zrleBufferAlloc(&os->out, ZRLE_OUT_BUFFER_SIZE)) {
80  zrleBufferFree(&os->in);
81  free(os);
82  return NULL;
83  }
84 
85  os->zs.zalloc = Z_NULL;
86  os->zs.zfree = Z_NULL;
87  os->zs.opaque = Z_NULL;
88  if (deflateInit(&os->zs, Z_DEFAULT_COMPRESSION) != Z_OK) {
89  zrleBufferFree(&os->in);
90  free(os);
91  return NULL;
92  }
93 
94  return os;
95 }
96 
98 {
99  deflateEnd(&os->zs);
100  zrleBufferFree(&os->in);
101  zrleBufferFree(&os->out);
102  free(os);
103 }
104 
106 {
107  os->zs.next_in = os->in.start;
108  os->zs.avail_in = ZRLE_BUFFER_LENGTH (&os->in);
109 
110 #ifdef ZRLE_DEBUG
111  rfbLog("zrleOutStreamFlush: avail_in %d\n", os->zs.avail_in);
112 #endif
113 
114  while (os->zs.avail_in != 0) {
115  do {
116  int ret;
117 
118  if (os->out.ptr >= os->out.end &&
119  !zrleBufferGrow(&os->out, os->out.end - os->out.start)) {
120  rfbLog("zrleOutStreamFlush: failed to grow output buffer\n");
121  return FALSE;
122  }
123 
124  os->zs.next_out = os->out.ptr;
125  os->zs.avail_out = os->out.end - os->out.ptr;
126 
127 #ifdef ZRLE_DEBUG
128  rfbLog("zrleOutStreamFlush: calling deflate, avail_in %d, avail_out %d\n",
129  os->zs.avail_in, os->zs.avail_out);
130 #endif
131 
132  if ((ret = deflate(&os->zs, Z_SYNC_FLUSH)) != Z_OK) {
133  rfbLog("zrleOutStreamFlush: deflate failed with error code %d\n", ret);
134  return FALSE;
135  }
136 
137 #ifdef ZRLE_DEBUG
138  rfbLog("zrleOutStreamFlush: after deflate: %d bytes\n",
139  os->zs.next_out - os->out.ptr);
140 #endif
141 
142  os->out.ptr = os->zs.next_out;
143  } while (os->zs.avail_out == 0);
144  }
145 
146  os->in.ptr = os->in.start;
147 
148  return TRUE;
149 }
150 
151 static int zrleOutStreamOverrun(zrleOutStream *os,
152  int size)
153 {
154 #ifdef ZRLE_DEBUG
155  rfbLog("zrleOutStreamOverrun\n");
156 #endif
157 
158  while (os->in.end - os->in.ptr < size && os->in.ptr > os->in.start) {
159  os->zs.next_in = os->in.start;
160  os->zs.avail_in = ZRLE_BUFFER_LENGTH (&os->in);
161 
162  do {
163  int ret;
164 
165  if (os->out.ptr >= os->out.end &&
166  !zrleBufferGrow(&os->out, os->out.end - os->out.start)) {
167  rfbLog("zrleOutStreamOverrun: failed to grow output buffer\n");
168  return FALSE;
169  }
170 
171  os->zs.next_out = os->out.ptr;
172  os->zs.avail_out = os->out.end - os->out.ptr;
173 
174 #ifdef ZRLE_DEBUG
175  rfbLog("zrleOutStreamOverrun: calling deflate, avail_in %d, avail_out %d\n",
176  os->zs.avail_in, os->zs.avail_out);
177 #endif
178 
179  if ((ret = deflate(&os->zs, 0)) != Z_OK) {
180  rfbLog("zrleOutStreamOverrun: deflate failed with error code %d\n", ret);
181  return 0;
182  }
183 
184 #ifdef ZRLE_DEBUG
185  rfbLog("zrleOutStreamOverrun: after deflate: %d bytes\n",
186  os->zs.next_out - os->out.ptr);
187 #endif
188 
189  os->out.ptr = os->zs.next_out;
190  } while (os->zs.avail_out == 0);
191 
192  /* output buffer not full */
193 
194  if (os->zs.avail_in == 0) {
195  os->in.ptr = os->in.start;
196  } else {
197  /* but didn't consume all the data? try shifting what's left to the
198  * start of the buffer.
199  */
200  rfbLog("zrleOutStreamOverrun: out buf not full, but in data not consumed\n");
201  memmove(os->in.start, os->zs.next_in, os->in.ptr - os->zs.next_in);
202  os->in.ptr -= os->zs.next_in - os->in.start;
203  }
204  }
205 
206  if (size > os->in.end - os->in.ptr)
207  size = os->in.end - os->in.ptr;
208 
209  return size;
210 }
211 
212 static int zrleOutStreamCheck(zrleOutStream *os, int size)
213 {
214  if (os->in.ptr + size > os->in.end) {
215  return zrleOutStreamOverrun(os, size);
216  }
217  return size;
218 }
219 
221  const zrle_U8 *data,
222  int length)
223 {
224  const zrle_U8* dataEnd = data + length;
225  while (data < dataEnd) {
226  int n = zrleOutStreamCheck(os, dataEnd - data);
227  memcpy(os->in.ptr, data, n);
228  os->in.ptr += n;
229  data += n;
230  }
231 }
232 
234 {
235  zrleOutStreamCheck(os, 1);
236  *os->in.ptr++ = u;
237 }
238 
240 {
241  zrleOutStreamCheck(os, 1);
242  *os->in.ptr++ = u;
243 }
244 
246 {
247  zrleOutStreamCheck(os, 2);
248  *os->in.ptr++ = ((zrle_U8*)&u)[0];
249  *os->in.ptr++ = ((zrle_U8*)&u)[1];
250 }
251 
253 {
254  zrleOutStreamCheck(os, 4);
255  *os->in.ptr++ = ((zrle_U8*)&u)[0];
256  *os->in.ptr++ = ((zrle_U8*)&u)[1];
257  *os->in.ptr++ = ((zrle_U8*)&u)[2];
258  *os->in.ptr++ = ((zrle_U8*)&u)[3];
259 }
260 
262 {
263  zrleOutStreamCheck(os, 3);
264  *os->in.ptr++ = ((zrle_U8*)&u)[0];
265  *os->in.ptr++ = ((zrle_U8*)&u)[1];
266  *os->in.ptr++ = ((zrle_U8*)&u)[2];
267 }
268 
270 {
271  zrleOutStreamCheck(os, 3);
272  *os->in.ptr++ = ((zrle_U8*)&u)[1];
273  *os->in.ptr++ = ((zrle_U8*)&u)[2];
274  *os->in.ptr++ = ((zrle_U8*)&u)[3];
275 }