/apps/desktop/libvncserver/zrleoutstream.c

http://ftk.googlecode.com/ · C · 275 lines · 202 code · 50 blank · 23 comment · 30 complexity · b1c783c16ed69fd47088a28eb6e3ee29 MD5 · raw 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. #include "zrleoutstream.h"
  21. #include <stdlib.h>
  22. #define ZRLE_IN_BUFFER_SIZE 16384
  23. #define ZRLE_OUT_BUFFER_SIZE 1024
  24. #undef ZRLE_DEBUG
  25. static rfbBool zrleBufferAlloc(zrleBuffer *buffer, int size)
  26. {
  27. buffer->ptr = buffer->start = malloc(size);
  28. if (buffer->start == NULL) {
  29. buffer->end = NULL;
  30. return FALSE;
  31. }
  32. buffer->end = buffer->start + size;
  33. return TRUE;
  34. }
  35. static void zrleBufferFree(zrleBuffer *buffer)
  36. {
  37. if (buffer->start)
  38. free(buffer->start);
  39. buffer->start = buffer->ptr = buffer->end = NULL;
  40. }
  41. static rfbBool zrleBufferGrow(zrleBuffer *buffer, int size)
  42. {
  43. int offset;
  44. size += buffer->end - buffer->start;
  45. offset = ZRLE_BUFFER_LENGTH (buffer);
  46. buffer->start = realloc(buffer->start, size);
  47. if (!buffer->start) {
  48. return FALSE;
  49. }
  50. buffer->end = buffer->start + size;
  51. buffer->ptr = buffer->start + offset;
  52. return TRUE;
  53. }
  54. zrleOutStream *zrleOutStreamNew(void)
  55. {
  56. zrleOutStream *os;
  57. os = malloc(sizeof(zrleOutStream));
  58. if (os == NULL)
  59. return NULL;
  60. if (!zrleBufferAlloc(&os->in, ZRLE_IN_BUFFER_SIZE)) {
  61. free(os);
  62. return NULL;
  63. }
  64. if (!zrleBufferAlloc(&os->out, ZRLE_OUT_BUFFER_SIZE)) {
  65. zrleBufferFree(&os->in);
  66. free(os);
  67. return NULL;
  68. }
  69. os->zs.zalloc = Z_NULL;
  70. os->zs.zfree = Z_NULL;
  71. os->zs.opaque = Z_NULL;
  72. if (deflateInit(&os->zs, Z_DEFAULT_COMPRESSION) != Z_OK) {
  73. zrleBufferFree(&os->in);
  74. free(os);
  75. return NULL;
  76. }
  77. return os;
  78. }
  79. void zrleOutStreamFree (zrleOutStream *os)
  80. {
  81. deflateEnd(&os->zs);
  82. zrleBufferFree(&os->in);
  83. zrleBufferFree(&os->out);
  84. free(os);
  85. }
  86. rfbBool zrleOutStreamFlush(zrleOutStream *os)
  87. {
  88. os->zs.next_in = os->in.start;
  89. os->zs.avail_in = ZRLE_BUFFER_LENGTH (&os->in);
  90. #ifdef ZRLE_DEBUG
  91. rfbLog("zrleOutStreamFlush: avail_in %d\n", os->zs.avail_in);
  92. #endif
  93. while (os->zs.avail_in != 0) {
  94. do {
  95. int ret;
  96. if (os->out.ptr >= os->out.end &&
  97. !zrleBufferGrow(&os->out, os->out.end - os->out.start)) {
  98. rfbLog("zrleOutStreamFlush: failed to grow output buffer\n");
  99. return FALSE;
  100. }
  101. os->zs.next_out = os->out.ptr;
  102. os->zs.avail_out = os->out.end - os->out.ptr;
  103. #ifdef ZRLE_DEBUG
  104. rfbLog("zrleOutStreamFlush: calling deflate, avail_in %d, avail_out %d\n",
  105. os->zs.avail_in, os->zs.avail_out);
  106. #endif
  107. if ((ret = deflate(&os->zs, Z_SYNC_FLUSH)) != Z_OK) {
  108. rfbLog("zrleOutStreamFlush: deflate failed with error code %d\n", ret);
  109. return FALSE;
  110. }
  111. #ifdef ZRLE_DEBUG
  112. rfbLog("zrleOutStreamFlush: after deflate: %d bytes\n",
  113. os->zs.next_out - os->out.ptr);
  114. #endif
  115. os->out.ptr = os->zs.next_out;
  116. } while (os->zs.avail_out == 0);
  117. }
  118. os->in.ptr = os->in.start;
  119. return TRUE;
  120. }
  121. static int zrleOutStreamOverrun(zrleOutStream *os,
  122. int size)
  123. {
  124. #ifdef ZRLE_DEBUG
  125. rfbLog("zrleOutStreamOverrun\n");
  126. #endif
  127. while (os->in.end - os->in.ptr < size && os->in.ptr > os->in.start) {
  128. os->zs.next_in = os->in.start;
  129. os->zs.avail_in = ZRLE_BUFFER_LENGTH (&os->in);
  130. do {
  131. int ret;
  132. if (os->out.ptr >= os->out.end &&
  133. !zrleBufferGrow(&os->out, os->out.end - os->out.start)) {
  134. rfbLog("zrleOutStreamOverrun: failed to grow output buffer\n");
  135. return FALSE;
  136. }
  137. os->zs.next_out = os->out.ptr;
  138. os->zs.avail_out = os->out.end - os->out.ptr;
  139. #ifdef ZRLE_DEBUG
  140. rfbLog("zrleOutStreamOverrun: calling deflate, avail_in %d, avail_out %d\n",
  141. os->zs.avail_in, os->zs.avail_out);
  142. #endif
  143. if ((ret = deflate(&os->zs, 0)) != Z_OK) {
  144. rfbLog("zrleOutStreamOverrun: deflate failed with error code %d\n", ret);
  145. return 0;
  146. }
  147. #ifdef ZRLE_DEBUG
  148. rfbLog("zrleOutStreamOverrun: after deflate: %d bytes\n",
  149. os->zs.next_out - os->out.ptr);
  150. #endif
  151. os->out.ptr = os->zs.next_out;
  152. } while (os->zs.avail_out == 0);
  153. /* output buffer not full */
  154. if (os->zs.avail_in == 0) {
  155. os->in.ptr = os->in.start;
  156. } else {
  157. /* but didn't consume all the data? try shifting what's left to the
  158. * start of the buffer.
  159. */
  160. rfbLog("zrleOutStreamOverrun: out buf not full, but in data not consumed\n");
  161. memmove(os->in.start, os->zs.next_in, os->in.ptr - os->zs.next_in);
  162. os->in.ptr -= os->zs.next_in - os->in.start;
  163. }
  164. }
  165. if (size > os->in.end - os->in.ptr)
  166. size = os->in.end - os->in.ptr;
  167. return size;
  168. }
  169. static int zrleOutStreamCheck(zrleOutStream *os, int size)
  170. {
  171. if (os->in.ptr + size > os->in.end) {
  172. return zrleOutStreamOverrun(os, size);
  173. }
  174. return size;
  175. }
  176. void zrleOutStreamWriteBytes(zrleOutStream *os,
  177. const zrle_U8 *data,
  178. int length)
  179. {
  180. const zrle_U8* dataEnd = data + length;
  181. while (data < dataEnd) {
  182. int n = zrleOutStreamCheck(os, dataEnd - data);
  183. memcpy(os->in.ptr, data, n);
  184. os->in.ptr += n;
  185. data += n;
  186. }
  187. }
  188. void zrleOutStreamWriteU8(zrleOutStream *os, zrle_U8 u)
  189. {
  190. zrleOutStreamCheck(os, 1);
  191. *os->in.ptr++ = u;
  192. }
  193. void zrleOutStreamWriteOpaque8(zrleOutStream *os, zrle_U8 u)
  194. {
  195. zrleOutStreamCheck(os, 1);
  196. *os->in.ptr++ = u;
  197. }
  198. void zrleOutStreamWriteOpaque16 (zrleOutStream *os, zrle_U16 u)
  199. {
  200. zrleOutStreamCheck(os, 2);
  201. *os->in.ptr++ = ((zrle_U8*)&u)[0];
  202. *os->in.ptr++ = ((zrle_U8*)&u)[1];
  203. }
  204. void zrleOutStreamWriteOpaque32 (zrleOutStream *os, zrle_U32 u)
  205. {
  206. zrleOutStreamCheck(os, 4);
  207. *os->in.ptr++ = ((zrle_U8*)&u)[0];
  208. *os->in.ptr++ = ((zrle_U8*)&u)[1];
  209. *os->in.ptr++ = ((zrle_U8*)&u)[2];
  210. *os->in.ptr++ = ((zrle_U8*)&u)[3];
  211. }
  212. void zrleOutStreamWriteOpaque24A(zrleOutStream *os, zrle_U32 u)
  213. {
  214. zrleOutStreamCheck(os, 3);
  215. *os->in.ptr++ = ((zrle_U8*)&u)[0];
  216. *os->in.ptr++ = ((zrle_U8*)&u)[1];
  217. *os->in.ptr++ = ((zrle_U8*)&u)[2];
  218. }
  219. void zrleOutStreamWriteOpaque24B(zrleOutStream *os, zrle_U32 u)
  220. {
  221. zrleOutStreamCheck(os, 3);
  222. *os->in.ptr++ = ((zrle_U8*)&u)[1];
  223. *os->in.ptr++ = ((zrle_U8*)&u)[2];
  224. *os->in.ptr++ = ((zrle_U8*)&u)[3];
  225. }