lib/bitio.c

   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
  45 static int reader_nullread(reader_t*r, void* data, int len)
  46 {
  47     memset(data, 0, len);
  48     return len;
  49 }
  50 static void reader_nullread_dealloc(reader_t*r)
  51 {
  52     memset(r, 0, sizeof(reader_t));
  53 }
  54 static int reader_nullseek(reader_t*r, int pos)
  55 {
  56     return pos;
  57 }
  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
  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 }
  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 }
  85 static int reader_fileread_seek(reader_t*r, int pos)
  86 {
  87     return lseek((ptroff_t)r->internal, pos, SEEK_SET);
  88 }
  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 }
 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
 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 }
 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 }
 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 }
 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
 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 }
 174 static void reader_zzip_dealloc(reader_t*reader)
 175 {
 176     memset(reader, 0, sizeof(reader_t));
 177 }
 178 static int reader_zzip_seek(reader_t*reader, int pos)
 179 {
 180     return zzip_seek((ZZIP_FILE*)reader->internal, pos, SEEK_SET);
 181 }
 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
 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 }
 216 static void writer_memwrite_finish(writer_t*w)
 217 {
 218     if(w->internal)
 219         free(w->internal);
 220     w->internal = 0;
 221 }
 222 static void dummy_flush(writer_t*w)
 223 {
 224 }
 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;
 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 }
 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 }
 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 }
 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 }
 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 }
 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
 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 }
 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 }
 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 }
 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
 385 static int writer_nullwrite_write(writer_t*w, void* data, int len)
 386 {
 387     w->pos += len;
 388     return len;
 389 }
 390 static void writer_nullwrite_finish(writer_t*w)
 391 {
 392     memset(w, 0, sizeof(writer_t));
 393 }
 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
 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
 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 }
 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 }
 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 }
 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
 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
 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
 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 }
 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
 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 }
 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 }
 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
 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 }
 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 }
 729 void reader_resetbits(reader_t*r)
 730 {
 731     r->mybyte = 0;
 732     r->bitpos = 8;
 733
 734 }
 735
 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 }
 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 }
 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 }
 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
 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 }
 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 }
 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 }
 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 }
 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
 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 }
 856 void writer_writeU8(writer_t*w, unsigned char b)
 857 {
 858     w->write(w, &b, 1);
 859 }
 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 }
 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 }
 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 }
 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 }
 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 }
 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 }