1 /* bitio.c
2 part of swftools
3 implementation of bitio.h.
4
5 Copyright (C) 2003 Matthias Kramm <kramm@quiss.org>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #ifdef HAVE_UNISTD_H
24 #include <unistd.h>
25 #endif
26 #ifdef HAVE_IO_H
27 #include <io.h>
28 #endif
29 #include <string.h>
30 #include <memory.h>
31 #define __USE_LARGEFILE64
32 #include <fcntl.h>
33 #include <errno.h>
34
35 #include "../config.h"
36
37 #ifdef HAVE_ZLIB
38 #include <zlib.h>
39 #define ZLIB_BUFFER_SIZE 16384
40 #endif
41 #include "./bitio.h"
42
43 /* ---------------------------- null reader ------------------------------- */
44
reader_nullread(reader_t * r,void * data,int len)45 static int reader_nullread(reader_t*r, void* data, int len)
46 {
47 memset(data, 0, len);
48 return len;
49 }
reader_nullread_dealloc(reader_t * r)50 static void reader_nullread_dealloc(reader_t*r)
51 {
52 memset(r, 0, sizeof(reader_t));
53 }
reader_nullseek(reader_t * r,int pos)54 static int reader_nullseek(reader_t*r, int pos)
55 {
56 return pos;
57 }
reader_init_nullreader(reader_t * r)58 void reader_init_nullreader(reader_t*r)
59 {
60 r->read = reader_nullread;
61 r->seek = reader_nullseek;
62 r->dealloc = reader_nullread_dealloc;
63 r->internal = 0;
64 r->type = READER_TYPE_NULL;
65 r->mybyte = 0;
66 r->bitpos = 8;
67 r->pos = 0;
68 }
69 /* ---------------------------- file reader ------------------------------- */
70
reader_fileread(reader_t * reader,void * data,int len)71 static int reader_fileread(reader_t*reader, void* data, int len)
72 {
73 int ret = read((int)reader->internal, data, len);
74 if(ret>=0)
75 reader->pos += ret;
76 return ret;
77 }
reader_fileread_dealloc(reader_t * r)78 static void reader_fileread_dealloc(reader_t*r)
79 {
80 if(r->type == READER_TYPE_FILE2) {
81 close((ptroff_t)r->internal);
82 }
83 memset(r, 0, sizeof(reader_t));
84 }
reader_fileread_seek(reader_t * r,int pos)85 static int reader_fileread_seek(reader_t*r, int pos)
86 {
87 return lseek((ptroff_t)r->internal, pos, SEEK_SET);
88 }
reader_init_filereader(reader_t * r,int handle)89 void reader_init_filereader(reader_t*r, int handle)
90 {
91 r->read = reader_fileread;
92 r->seek = reader_fileread_seek;
93 r->dealloc = reader_fileread_dealloc;
94 r->internal = (void*)handle;
95 r->type = READER_TYPE_FILE;
96 r->mybyte = 0;
97 r->bitpos = 8;
98 r->pos = 0;
99 }
reader_init_filereader2(reader_t * r,const char * filename)100 int reader_init_filereader2(reader_t*r, const char*filename)
101 {
102 #ifdef HAVE_OPEN64
103 int fi = open64
104 #else
105 int fi = open
106 #endif
107 (filename,
108 #ifdef O_BINARY
109 O_BINARY|
110 #endif
111 O_RDONLY);
112 reader_init_filereader(r, fi);
113 r->type = READER_TYPE_FILE2;
114 return fi;
115 }
116
117 /* ---------------------------- mem reader ------------------------------- */
118
119 typedef struct _memread
120 {
121 unsigned char*data;
122 int length;
123 } memread_t;
124
reader_memread(reader_t * reader,void * data,int len)125 static int reader_memread(reader_t*reader, void* data, int len)
126 {
127 memread_t*mr = (memread_t*)reader->internal;
128
129 if(mr->length - reader->pos < len) {
130 len = mr->length - reader->pos;
131 }
132 if(!len) return 0;
133 memcpy(data, &mr->data[reader->pos], len);
134 reader->pos += len;
135 return len;
136 }
reader_memseek(reader_t * reader,int pos)137 static int reader_memseek(reader_t*reader, int pos)
138 {
139 memread_t*mr = (memread_t*)reader->internal;
140 if(pos>=0 && pos<=mr->length) {
141 reader->pos = pos;
142 return pos;
143 } else {
144 return -1;
145 }
146 }
reader_memread_dealloc(reader_t * reader)147 static void reader_memread_dealloc(reader_t*reader)
148 {
149 if(reader->internal)
150 free(reader->internal);
151 memset(reader, 0, sizeof(reader_t));
152 }
reader_init_memreader(reader_t * r,void * newdata,int newlength)153 void reader_init_memreader(reader_t*r, void*newdata, int newlength)
154 {
155 memread_t*mr = (memread_t*)malloc(sizeof(memread_t));
156 mr->data = (unsigned char*)newdata;
157 mr->length = newlength;
158 r->read = reader_memread;
159 r->seek = reader_memseek;
160 r->dealloc = reader_memread_dealloc;
161 r->internal = (void*)mr;
162 r->type = READER_TYPE_MEM;
163 r->mybyte = 0;
164 r->bitpos = 8;
165 r->pos = 0;
166 }
167
168 /* ---------------------------- zzip reader ------------------------------ */
169 #ifdef HAVE_ZZIP
reader_zzip_read(reader_t * reader,void * data,int len)170 static int reader_zzip_read(reader_t*reader, void* data, int len)
171 {
172 return zzip_file_read((ZZIP_FILE*)reader->internal, data, len);
173 }
reader_zzip_dealloc(reader_t * reader)174 static void reader_zzip_dealloc(reader_t*reader)
175 {
176 memset(reader, 0, sizeof(reader_t));
177 }
reader_zzip_seek(reader_t * reader,int pos)178 static int reader_zzip_seek(reader_t*reader, int pos)
179 {
180 return zzip_seek((ZZIP_FILE*)reader->internal, pos, SEEK_SET);
181 }
reader_init_zzipreader(reader_t * r,ZZIP_FILE * z)182 void reader_init_zzipreader(reader_t*r,ZZIP_FILE*z)
183 {
184 r->read = reader_zzip_read;
185 r->seek = reader_zzip_seek;
186 r->dealloc = reader_zzip_dealloc;
187 r->internal = z;
188 r->type = READER_TYPE_ZZIP;
189 r->mybyte = 0;
190 r->bitpos = 8;
191 r->pos = 0;
192 }
193 #endif
194
195 /* ---------------------------- mem writer ------------------------------- */
196
197 typedef struct _memwrite
198 {
199 unsigned char*data;
200 int length;
201 } memwrite_t;
202
writer_memwrite_write(writer_t * w,void * data,int len)203 static int writer_memwrite_write(writer_t*w, void* data, int len)
204 {
205 memwrite_t*mw = (memwrite_t*)w->internal;
206 if(mw->length - w->pos > len) {
207 memcpy(&mw->data[w->pos], data, len);
208 w->pos += len;
209 return len;
210 } else {
211 memcpy(&mw->data[w->pos], data, mw->length - w->pos);
212 w->pos = mw->length;
213 return mw->length - w->pos;
214 }
215 }
writer_memwrite_finish(writer_t * w)216 static void writer_memwrite_finish(writer_t*w)
217 {
218 if(w->internal)
219 free(w->internal);
220 w->internal = 0;
221 }
dummy_flush(writer_t * w)222 static void dummy_flush(writer_t*w)
223 {
224 }
writer_init_memwriter(writer_t * w,void * data,int len)225 void writer_init_memwriter(writer_t*w, void*data, int len)
226 {
227 memwrite_t *mr;
228 mr = (memwrite_t*)malloc(sizeof(memwrite_t));
229 mr->data = (unsigned char *)data;
230 mr->length = len;
231 memset(w, 0, sizeof(writer_t));
232 w->write = writer_memwrite_write;
233 w->flush = dummy_flush;
234 w->finish = writer_memwrite_finish;
235 w->internal = (void*)mr;
236 w->type = WRITER_TYPE_MEM;
237 w->bitpos = 0;
238 w->mybyte = 0;
239 w->pos = 0;
240 }
241
242 /* ------------------------- growing mem writer ------------------------------- */
243
244 typedef struct _growmemwrite
245 {
246 unsigned char*data;
247 int length;
248 U32 grow;
249 } growmemwrite_t;
writer_growmemwrite_write(writer_t * w,void * data,int len)250 static int writer_growmemwrite_write(writer_t*w, void* data, int len)
251 {
252 growmemwrite_t*mw = (growmemwrite_t*)w->internal;
253 if(!mw->data) {
254 fprintf(stderr, "Illegal write operation: data already given away");
255 exit(1);
256 }
257 if(mw->length - w->pos < len) {
258 int newlength = mw->length;
259 while(newlength - w->pos < len) {
260 newlength += mw->grow;
261 }
262 #ifdef NO_REALLOC
263 unsigned char*newmem = (unsigned char*)malloc(newlength);
264 memcpy(newmem, mw->data, mw->length);
265 free(mw->data);
266 mw->data = newmem;
267 #else
268 mw->data = (unsigned char*)realloc(mw->data, newlength);
269 #endif
270 mw->length = newlength;
271 }
272 memcpy(&mw->data[w->pos], data, len);
273 w->pos += len;
274 return len;
275 }
writer_growmemwrite_finish(writer_t * w)276 static void writer_growmemwrite_finish(writer_t*w)
277 {
278 growmemwrite_t*mw = (growmemwrite_t*)w->internal;
279 if(mw->data) {
280 free(mw->data);mw->data = 0;
281 }
282 mw->length = 0;
283 free(w->internal);mw=0;
284 memset(w, 0, sizeof(writer_t));
285 }
writer_growmemwrite_memptr(writer_t * w,int * len)286 void* writer_growmemwrite_memptr(writer_t*w, int*len)
287 {
288 growmemwrite_t*mw = (growmemwrite_t*)w->internal;
289 if(len) {
290 *len = w->pos;
291 }
292 return mw->data;
293 }
writer_growmemwrite_getmem(writer_t * w)294 void* writer_growmemwrite_getmem(writer_t*w)
295 {
296 growmemwrite_t*mw = (growmemwrite_t*)w->internal;
297 void*ret = mw->data;
298 /* remove own reference so that neither write() nor finish() can free it.
299 It's property of the caller now.
300 */
301 mw->data = 0;
302 return ret;
303 }
writer_growmemwrite_reset(writer_t * w)304 void writer_growmemwrite_reset(writer_t*w)
305 {
306 growmemwrite_t*mw = (growmemwrite_t*)w->internal;
307 w->pos = 0;
308 w->bitpos = 0;
309 w->mybyte = 0;
310 }
writer_init_growingmemwriter(writer_t * w,U32 grow)311 void writer_init_growingmemwriter(writer_t*w, U32 grow)
312 {
313 growmemwrite_t *mw = (growmemwrite_t *)malloc(sizeof(growmemwrite_t));
314 mw->length = 4096;
315 mw->data = (unsigned char *)malloc(mw->length);
316 mw->grow = grow;
317 memset(w, 0, sizeof(writer_t));
318 w->write = writer_growmemwrite_write;
319 w->flush = dummy_flush;
320 w->finish = writer_growmemwrite_finish;
321 w->internal = (void*)mw;
322 w->type = WRITER_TYPE_GROWING_MEM;
323 w->bitpos = 0;
324 w->mybyte = 0;
325 w->pos = 0;
326 }
327
328 /* ---------------------------- file writer ------------------------------- */
329
330 typedef struct _filewrite
331 {
332 int handle;
333 char free_handle;
334 } filewrite_t;
335
writer_filewrite_write(writer_t * w,void * data,int len)336 static int writer_filewrite_write(writer_t*w, void* data, int len)
337 {
338 filewrite_t * fw= (filewrite_t*)w->internal;
339 w->pos += len;
340 int l = write(fw->handle, data, len);
341 if(l < len)
342 fprintf(stderr, "Error writing to file: %d/%d", l, len);
343 return l;
344 }
writer_filewrite_finish(writer_t * w)345 static void writer_filewrite_finish(writer_t*w)
346 {
347 filewrite_t *mr = (filewrite_t*)w->internal;
348 if(mr->free_handle)
349 close(mr->handle);
350 free(w->internal);
351 memset(w, 0, sizeof(writer_t));
352 }
writer_init_filewriter(writer_t * w,int handle)353 void writer_init_filewriter(writer_t*w, int handle)
354 {
355 filewrite_t *mr = (filewrite_t *)malloc(sizeof(filewrite_t));
356 mr->handle = handle;
357 mr->free_handle = 0;
358 memset(w, 0, sizeof(writer_t));
359 w->write = writer_filewrite_write;
360 w->finish = writer_filewrite_finish;
361 w->internal = mr;
362 w->type = WRITER_TYPE_FILE;
363 w->bitpos = 0;
364 w->mybyte = 0;
365 w->pos = 0;
366 }
writer_init_filewriter2(writer_t * w,char * filename)367 void writer_init_filewriter2(writer_t*w, char*filename)
368 {
369 #ifdef HAVE_OPEN64
370 int fi = open64
371 #else
372 int fi = open
373 #endif
374 (filename,
375 #ifdef O_BINARY
376 O_BINARY|
377 #endif
378 O_WRONLY|O_CREAT|O_TRUNC, 0644);
379 writer_init_filewriter(w, fi);
380 ((filewrite_t*)w->internal)->free_handle = 1;
381 }
382
383 /* ---------------------------- null writer ------------------------------- */
384
writer_nullwrite_write(writer_t * w,void * data,int len)385 static int writer_nullwrite_write(writer_t*w, void* data, int len)
386 {
387 w->pos += len;
388 return len;
389 }
writer_nullwrite_finish(writer_t * w)390 static void writer_nullwrite_finish(writer_t*w)
391 {
392 memset(w, 0, sizeof(writer_t));
393 }
writer_init_nullwriter(writer_t * w)394 void writer_init_nullwriter(writer_t*w)
395 {
396 memset(w, 0, sizeof(writer_t));
397 w->write = writer_nullwrite_write;
398 w->flush = dummy_flush;
399 w->finish = writer_nullwrite_finish;
400 w->internal = 0;
401 w->type = WRITER_TYPE_NULL;
402 w->bitpos = 0;
403 w->mybyte = 0;
404 w->pos = 0;
405 }
406 /* ---------------------------- zlibinflate reader -------------------------- */
407
408 typedef struct _zlibinflate
409 {
410 #ifdef HAVE_ZLIB
411 z_stream zs;
412 reader_t*input;
413 unsigned char readbuffer[ZLIB_BUFFER_SIZE];
414 #endif
415 } zlibinflate_t;
416
417 #ifdef HAVE_ZLIB
zlib_error(int ret,char * msg,z_stream * zs)418 static void zlib_error(int ret, char* msg, z_stream*zs)
419 {
420 fprintf(stderr, "%s: zlib error (%d): last zlib error: %s\n",
421 msg,
422 ret,
423 zs->msg?zs->msg:"unknown");
424 if(errno) perror("errno:");
425 exit(1);
426 }
427 #endif
428
reader_zlibinflate(reader_t * reader,void * data,int len)429 static int reader_zlibinflate(reader_t*reader, void* data, int len)
430 {
431 #ifdef HAVE_ZLIB
432 zlibinflate_t*z = (zlibinflate_t*)reader->internal;
433 int ret;
434 if(!z) {
435 return 0;
436 }
437 if(!len)
438 return 0;
439
440 z->zs.next_out = (Bytef *)data;
441 z->zs.avail_out = len;
442
443 while(1) {
444 if(!z->zs.avail_in) {
445 z->zs.avail_in = z->input->read(z->input, z->readbuffer, ZLIB_BUFFER_SIZE);
446 z->zs.next_in = z->readbuffer;
447 }
448 if(z->zs.avail_in)
449 ret = inflate(&z->zs, Z_NO_FLUSH);
450 else
451 ret = inflate(&z->zs, Z_FINISH);
452
453 if (ret != Z_OK &&
454 ret != Z_STREAM_END) zlib_error(ret, "bitio:inflate_inflate", &z->zs);
455
456 if (ret == Z_STREAM_END) {
457 int pos = z->zs.next_out - (Bytef*)data;
458 ret = inflateEnd(&z->zs);
459 if (ret != Z_OK) zlib_error(ret, "bitio:inflate_end", &z->zs);
460 free(reader->internal);
461 reader->internal = 0;
462 reader->pos += pos;
463 return pos;
464 }
465 if(!z->zs.avail_out) {
466 break;
467 }
468 }
469 reader->pos += len;
470 return len;
471 #else
472 fprintf(stderr, "Error: swftools was compiled without zlib support");
473 exit(1);
474 #endif
475 }
reader_zlibseek(reader_t * reader,int pos)476 static int reader_zlibseek(reader_t*reader, int pos)
477 {
478 fprintf(stderr, "Erro: seeking not supported for zlib streams");
479 return -1;
480 }
reader_zlibinflate_dealloc(reader_t * reader)481 static void reader_zlibinflate_dealloc(reader_t*reader)
482 {
483 #ifdef HAVE_ZLIB
484 zlibinflate_t*z = (zlibinflate_t*)reader->internal;
485 /* test whether read() already did basic deallocation */
486 if(reader->internal) {
487 inflateEnd(&z->zs);
488 free(reader->internal);
489 }
490 memset(reader, 0, sizeof(reader_t));
491 #endif
492 }
reader_init_zlibinflate(reader_t * r,reader_t * input)493 void reader_init_zlibinflate(reader_t*r, reader_t*input)
494 {
495 #ifdef HAVE_ZLIB
496 zlibinflate_t*z = (zlibinflate_t*)malloc(sizeof(zlibinflate_t));
497 memset(z, 0, sizeof(zlibinflate_t));
498 int ret;
499 memset(r, 0, sizeof(reader_t));
500 r->internal = z;
501 r->read = reader_zlibinflate;
502 r->seek = reader_zlibseek;
503 r->dealloc = reader_zlibinflate_dealloc;
504 r->type = READER_TYPE_ZLIB;
505 r->pos = 0;
506 z->input = input;
507 memset(&z->zs,0,sizeof(z_stream));
508 z->zs.zalloc = Z_NULL;
509 z->zs.zfree = Z_NULL;
510 z->zs.opaque = Z_NULL;
511 ret = inflateInit(&z->zs);
512 if (ret != Z_OK) zlib_error(ret, "bitio:inflate_init", &z->zs);
513 reader_resetbits(r);
514 #else
515 fprintf(stderr, "Error: swftools was compiled without zlib support");
516 exit(1);
517 #endif
518 }
519
520 /* ---------------------------- zlibdeflate writer -------------------------- */
521
522 typedef struct _zlibdeflate
523 {
524 #ifdef HAVE_ZLIB
525 z_stream zs;
526 writer_t*output;
527 unsigned char writebuffer[ZLIB_BUFFER_SIZE];
528 #endif
529 } zlibdeflate_t;
530
writer_zlibdeflate_write(writer_t * writer,void * data,int len)531 static int writer_zlibdeflate_write(writer_t*writer, void* data, int len)
532 {
533 #ifdef HAVE_ZLIB
534 zlibdeflate_t*z = (zlibdeflate_t*)writer->internal;
535 int ret;
536 if(writer->type != WRITER_TYPE_ZLIB) {
537 fprintf(stderr, "Wrong writer ID (writer not initialized?)\n");
538 return 0;
539 }
540 if(!z) {
541 fprintf(stderr, "zlib not initialized!\n");
542 return 0;
543 }
544 if(!len)
545 return 0;
546
547 z->zs.next_in = (Bytef *)data;
548 z->zs.avail_in = len;
549
550 while(1) {
551 ret = deflate(&z->zs, Z_NO_FLUSH);
552
553 if (ret != Z_OK) zlib_error(ret, "bitio:deflate_deflate", &z->zs);
554
555 if(z->zs.next_out != z->writebuffer) {
556 writer->pos += z->zs.next_out - (Bytef*)z->writebuffer;
557 z->output->write(z->output, z->writebuffer, z->zs.next_out - (Bytef*)z->writebuffer);
558 z->zs.next_out = z->writebuffer;
559 z->zs.avail_out = ZLIB_BUFFER_SIZE;
560 }
561
562 if(!z->zs.avail_in) {
563 break;
564 }
565 }
566 return len;
567 #else
568 fprintf(stderr, "Error: swftools was compiled without zlib support");
569 exit(1);
570 #endif
571 }
572
writer_zlibdeflate_flush(writer_t * writer)573 void writer_zlibdeflate_flush(writer_t*writer)
574 {
575 #ifdef HAVE_ZLIB
576 zlibdeflate_t*z = (zlibdeflate_t*)writer->internal;
577 int ret;
578 if(writer->type != WRITER_TYPE_ZLIB) {
579 fprintf(stderr, "Wrong writer ID (writer not initialized?)\n");
580 return;
581 }
582 if(!z) {
583 fprintf(stderr, "zlib not initialized!\n");
584 return;
585 }
586
587 z->zs.next_in = 0;
588 z->zs.avail_in = 0;
589 while(1) {
590 ret = deflate(&z->zs, Z_SYNC_FLUSH);
591 if (ret != Z_OK) zlib_error(ret, "bitio:deflate_flush", &z->zs);
592 if(z->zs.next_out != z->writebuffer) {
593 writer->pos += z->zs.next_out - (Bytef*)z->writebuffer;
594 z->output->write(z->output, z->writebuffer, z->zs.next_out - (Bytef*)z->writebuffer);
595 z->zs.next_out = z->writebuffer;
596 z->zs.avail_out = ZLIB_BUFFER_SIZE;
597 }
598 /* TODO: how will zlib let us know it needs more buffer space? */
599 break;
600 }
601 return;
602 #else
603 fprintf(stderr, "Error: swftools was compiled without zlib support");
604 exit(1);
605 #endif
606 }
607
writer_zlibdeflate_finish(writer_t * writer)608 static void writer_zlibdeflate_finish(writer_t*writer)
609 {
610 #ifdef HAVE_ZLIB
611 zlibdeflate_t*z = (zlibdeflate_t*)writer->internal;
612 writer_t*output;
613 int ret;
614 if(writer->type != WRITER_TYPE_ZLIB) {
615 fprintf(stderr, "Wrong writer ID (writer not initialized?)\n");
616 return;
617 }
618 if(!z)
619 return;
620 output= z->output;
621 while(1) {
622 ret = deflate(&z->zs, Z_FINISH);
623 if (ret != Z_OK &&
624 ret != Z_STREAM_END) zlib_error(ret, "bitio:deflate_finish", &z->zs);
625
626 if(z->zs.next_out != z->writebuffer) {
627 writer->pos += z->zs.next_out - (Bytef*)z->writebuffer;
628 z->output->write(z->output, z->writebuffer, z->zs.next_out - (Bytef*)z->writebuffer);
629 z->zs.next_out = z->writebuffer;
630 z->zs.avail_out = ZLIB_BUFFER_SIZE;
631 }
632
633 if (ret == Z_STREAM_END) {
634 break;
635
636 }
637 }
638 ret = deflateEnd(&z->zs);
639 if (ret != Z_OK) zlib_error(ret, "bitio:deflate_end", &z->zs);
640 free(writer->internal);
641 memset(writer, 0, sizeof(writer_t));
642 //output->finish(output);
643 #else
644 fprintf(stderr, "Error: swftools was compiled without zlib support");
645 exit(1);
646 #endif
647 }
writer_init_zlibdeflate(writer_t * w,writer_t * output)648 void writer_init_zlibdeflate(writer_t*w, writer_t*output)
649 {
650 #ifdef HAVE_ZLIB
651 zlibdeflate_t*z;
652 int ret;
653 memset(w, 0, sizeof(writer_t));
654 z = (zlibdeflate_t*)malloc(sizeof(zlibdeflate_t));
655 memset(z, 0, sizeof(zlibdeflate_t));
656 w->internal = z;
657 w->write = writer_zlibdeflate_write;
658 w->flush = writer_zlibdeflate_flush;
659 w->finish = writer_zlibdeflate_finish;
660 w->type = WRITER_TYPE_ZLIB;
661 w->pos = 0;
662 z->output = output;
663 memset(&z->zs,0,sizeof(z_stream));
664 z->zs.zalloc = Z_NULL;
665 z->zs.zfree = Z_NULL;
666 z->zs.opaque = Z_NULL;
667 ret = deflateInit(&z->zs, 9);
668 if (ret != Z_OK) zlib_error(ret, "bitio:deflate_init", &z->zs);
669 w->bitpos = 0;
670 w->mybyte = 0;
671 z->zs.next_out = z->writebuffer;
672 z->zs.avail_out = ZLIB_BUFFER_SIZE;
673 #else
674 fprintf(stderr, "Error: swftools was compiled without zlib support");
675 exit(1);
676 #endif
677 }
678
679 /* ----------------------- bit handling routines -------------------------- */
680
writer_writebit(writer_t * w,int bit)681 void writer_writebit(writer_t*w, int bit)
682 {
683 if(w->bitpos==8)
684 {
685 w->write(w, &w->mybyte, 1);
686 w->bitpos = 0;
687 w->mybyte = 0;
688 }
689 if(bit&1)
690 w->mybyte |= 1 << (7 - w->bitpos);
691 w->bitpos ++;
692 }
writer_writebits(writer_t * w,unsigned int data,int bits)693 void writer_writebits(writer_t*w, unsigned int data, int bits)
694 {
695 int t;
696 for(t=0;t<bits;t++)
697 {
698 writer_writebit(w, (data >> (bits-t-1))&1);
699 }
700 }
writer_resetbits(writer_t * w)701 void writer_resetbits(writer_t*w)
702 {
703 if(w->bitpos)
704 w->write(w, &w->mybyte, 1);
705 w->bitpos = 0;
706 w->mybyte = 0;
707 }
708
reader_readbit(reader_t * r)709 unsigned int reader_readbit(reader_t*r)
710 {
711 if(r->bitpos==8)
712 {
713 r->bitpos=0;
714 r->read(r, &r->mybyte, 1);
715 }
716 return (r->mybyte>>(7-r->bitpos++))&1;
717 }
reader_readbits(reader_t * r,int num)718 unsigned int reader_readbits(reader_t*r, int num)
719 {
720 int t;
721 int val = 0;
722 for(t=0;t<num;t++)
723 {
724 val<<=1;
725 val|=reader_readbit(r);
726 }
727 return val;
728 }
reader_resetbits(reader_t * r)729 void reader_resetbits(reader_t*r)
730 {
731 r->mybyte = 0;
732 r->bitpos = 8;
733
734 }
735
reader_readU8(reader_t * r)736 U8 reader_readU8(reader_t*r)
737 {
738 U8 b = 0;
739 if(r->read(r, &b, 1)<1) {
740 fprintf(stderr, "bitio.c:reader_readU8: Read over end of memory region\n");
741 }
742 return b;
743 }
reader_readS8(reader_t * r)744 S8 reader_readS8(reader_t*r)
745 {
746 S8 b = 0;
747 if(r->read(r, &b, 1)<1) {
748 fprintf(stderr, "bitio.c:reader_readU8: Read over end of memory region\n");
749 }
750 return b;
751 }
reader_readU16(reader_t * r)752 U16 reader_readU16(reader_t*r)
753 {
754 U8 b1=0,b2=0;
755 if(r->read(r, &b1, 1)<1) {
756 fprintf(stderr, "bitio.c:reader_readU16: Read over end of memory region\n");
757 }
758 if(r->read(r, &b2, 1)<1) {
759 fprintf(stderr, "bitio.c:reader_readU16: Read over end of memory region\n");
760 }
761 return b1|b2<<8;
762 }
reader_readU32(reader_t * r)763 U32 reader_readU32(reader_t*r)
764 {
765 U8 b1=0,b2=0,b3=0,b4=0;
766 if(r->read(r, &b1, 1)<1)
767 fprintf(stderr, "bitio.c:reader_readU32: Read over end of memory region\n");
768 if(r->read(r, &b2, 1)<1)
769 fprintf(stderr, "bitio.c:reader_readU32: Read over end of memory region\n");
770 if(r->read(r, &b3, 1)<1)
771 fprintf(stderr, "bitio.c:reader_readU32: Read over end of memory region\n");
772 if(r->read(r, &b4, 1)<1)
773 fprintf(stderr, "bitio.c:reader_readU32: Read over end of memory region\n");
774 return b1|b2<<8|b3<<16|b4<<24;
775 }
776
reader_readFloat(reader_t * r)777 float reader_readFloat(reader_t*r)
778 {
779 float f;
780 r->read(r, &f, 4);
781 return f;
782
783 U8 b1=0,b2=0,b3=0,b4=0;
784 r->read(r, &b1, 1);
785 r->read(r, &b2, 1);
786 r->read(r, &b3, 1);
787 r->read(r, &b4, 1);
788 U32 w = (b1|b2<<8|b3<<16|b4<<24);
789 return *(float*)&w;
790 }
reader_readDouble(reader_t * r)791 double reader_readDouble(reader_t*r)
792 {
793 double f;
794 r->read(r, &f, 8);
795 return f;
796
797 U8 b[8];
798 r->read(r, b, 8);
799 U64 w = ((U64)b[0]|(U64)b[1]<<8|(U64)b[2]<<16|(U64)b[3]<<24|(U64)b[4]<<32|(U64)b[5]<<40|(U64)b[6]<<48|(U64)b[7]<<56);
800 return *(double*)&w;
801 }
reader_readString(reader_t * r)802 char*reader_readString(reader_t*r)
803 {
804 writer_t g;
805 writer_init_growingmemwriter(&g, 16);
806 while(1) {
807 U8 b = reader_readU8(r);
808 writer_writeU8(&g, b);
809 if(!b)
810 break;
811 }
812 char*string = (char*)writer_growmemwrite_getmem(&g);
813 g.finish(&g);
814 return string;
815 }
read_compressed_uint(reader_t * r)816 unsigned int read_compressed_uint(reader_t*r)
817 {
818 unsigned int u = 0;
819 unsigned int b;
820 do {
821 b = reader_readU8(r);
822 u = u<<7|b&0x7f;
823 } while(b&0x80);
824 return u;
825 }
read_compressed_int(reader_t * r)826 int read_compressed_int(reader_t*r)
827 {
828 int i = 0;
829 int b;
830
831 b = reader_readS8(r);
832 i = b&0x7f;
833
834 if(b&0x40)
835 i|=0xffffff80; //sign extension
836
837 if(!(b&0x80))
838 return i;
839
840 do {
841 b = reader_readS8(r);
842 i = i<<7|b&0x7f;
843 } while(b&0x80);
844
845 return i;
846 }
847
848
writer_writeString(writer_t * w,const char * s)849 void writer_writeString(writer_t*w, const char*s)
850 {
851 int l = strlen(s);
852 char zero = 0;
853 w->write(w, (void*)s, l);
854 w->write(w, &zero, 1);
855 }
writer_writeU8(writer_t * w,unsigned char b)856 void writer_writeU8(writer_t*w, unsigned char b)
857 {
858 w->write(w, &b, 1);
859 }
writer_writeU16(writer_t * w,unsigned short v)860 void writer_writeU16(writer_t*w, unsigned short v)
861 {
862 unsigned char b1 = v;
863 unsigned char b2 = v>>8;
864 w->write(w, &b1, 1);
865 w->write(w, &b2, 1);
866 }
writer_writeU32(writer_t * w,unsigned long v)867 void writer_writeU32(writer_t*w, unsigned long v)
868 {
869 unsigned char b1 = v;
870 unsigned char b2 = v>>8;
871 unsigned char b3 = v>>16;
872 unsigned char b4 = v>>24;
873 w->write(w, &b1, 1);
874 w->write(w, &b2, 1);
875 w->write(w, &b3, 1);
876 w->write(w, &b4, 1);
877 }
writer_writeFloat(writer_t * w,float f)878 void writer_writeFloat(writer_t*w, float f)
879 {
880 w->write(w, &f, 4);
881 return;
882
883 unsigned v = *(unsigned*)&f;
884 unsigned char b1 = v;
885 unsigned char b2 = v>>8;
886 unsigned char b3 = v>>16;
887 unsigned char b4 = v>>24;
888 w->write(w, &b1, 1);
889 w->write(w, &b2, 1);
890 w->write(w, &b3, 1);
891 w->write(w, &b4, 1);
892 }
writer_writeDouble(writer_t * w,double f)893 void writer_writeDouble(writer_t*w, double f)
894 {
895 w->write(w, &f, 8);
896 return;
897
898 unsigned long long v = *(unsigned long long*)&f;
899 unsigned char b1 = v;
900 unsigned char b2 = v>>8;
901 unsigned char b3 = v>>16;
902 unsigned char b4 = v>>24;
903 unsigned char b5 = v>>32;
904 unsigned char b6 = v>>40;
905 unsigned char b7 = v>>48;
906 unsigned char b8 = v>>56;
907 w->write(w, &b1, 1);
908 w->write(w, &b2, 1);
909 w->write(w, &b3, 1);
910 w->write(w, &b4, 1);
911 w->write(w, &b5, 1);
912 w->write(w, &b6, 1);
913 w->write(w, &b7, 1);
914 w->write(w, &b8, 1);
915 }
write_compressed_uint(writer_t * w,unsigned int u)916 void write_compressed_uint(writer_t*w, unsigned int u)
917 {
918 if(u<0x80) {
919 writer_writeU8(w, u);
920 } else if(u<0x4000) {
921 writer_writeU8(w, u>>7|0x80);
922 writer_writeU8(w, u&0x7f);
923 } else if(u<0x200000) {
924 writer_writeU8(w, u>>14|0x80);
925 writer_writeU8(w, u>>7|0x80);
926 writer_writeU8(w, u&0x7f);
927 } else if(u<0x10000000) {
928 writer_writeU8(w, u>>21|0x80);
929 writer_writeU8(w, u>>14|0x80);
930 writer_writeU8(w, u>>7|0x80);
931 writer_writeU8(w, u&0x7f);
932 } else {
933 writer_writeU8(w, u>>28|0x80);
934 writer_writeU8(w, u>>21|0x80);
935 writer_writeU8(w, u>>14|0x80);
936 writer_writeU8(w, u>>7|0x80);
937 writer_writeU8(w, u&0x7f);
938 }
939 }
write_compressed_int(writer_t * w,int i)940 void write_compressed_int(writer_t*w, int i)
941 {
942 if(i>=-0x40 && i<0x40) {
943 writer_writeU8(w, i&0x7f);
944 } else if(i>=-0x2000 && i<0x2000) {
945 writer_writeU8(w, (i>>7)&0x7f|0x80);
946 writer_writeU8(w, i&0x7f);
947 } else if(i>=-0x100000 && i<0x100000) {
948 writer_writeU8(w, (i>>14)&0x7f|0x80);
949 writer_writeU8(w, (i>>7)&0x7f|0x80);
950 writer_writeU8(w, (i)&0x7f);
951 } else if(i>=-0x8000000 && i<0x8000000) {
952 writer_writeU8(w, (i>>21)&0x7f|0x80);
953 writer_writeU8(w, (i>>14)&0x7f|0x80);
954 writer_writeU8(w, (i>>7)&0x7f|0x80);
955 writer_writeU8(w, (i)&0x7f);
956 } else {
957 writer_writeU8(w, (i>>28)&0x7f|0x80);
958 writer_writeU8(w, (i>>21)&0x7f|0x80);
959 writer_writeU8(w, (i>>14)&0x7f|0x80);
960 writer_writeU8(w, (i>>7)&0x7f|0x80);
961 writer_writeU8(w, (i)&0x7f);
962 }
963 }
964