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 #include <unistd.h>
  24 #include <memory.h>
  25 #include <fcntl.h>
  26
  27 #include "../config.h"
  28
  29 #ifdef HAVE_ZLIB
  30 #include <zlib.h>
  31 #define ZLIB_BUFFER_SIZE 16384
  32 #endif
  33 #include "./bitio.h"
  34
  35 /* ---------------------------- file reader ------------------------------- */
  36
  37 static int reader_fileread(struct reader_t*reader, void* data, int len)
  38 {
  39     int ret = read((int)reader->internal, data, len);
  40     if(ret>=0)
  41         reader->pos += ret;
  42     return ret;
  43 }
  44 void reader_init_filereader(struct reader_t*r, int handle)
  45 {
  46     r->read = reader_fileread;
  47     r->internal = (void*)handle;
  48     r->type = READER_TYPE_FILE;
  49     r->mybyte = 0;
  50     r->bitpos = 8;
  51     r->pos = 0;
  52 }
  53
  54 /* ---------------------------- mem reader ------------------------------- */
  55
  56 struct memread_t
  57 {
  58     unsigned char*data;
  59     int length;
  60 };
  61 static int reader_memread(struct reader_t*reader, void* data, int len)
  62 {
  63     struct memread_t*mr = (struct memread_t*)reader->internal;
  64
  65     if(mr->length - reader->pos > len) {
  66         memcpy(data, &mr->data[reader->pos], len);
  67         reader->pos += len;
  68         return len;
  69     } else {
  70         memcpy(data, &mr->data[reader->pos], mr->length - reader->pos);
  71         reader->pos = mr->length;
  72         return mr->length - reader->pos;
  73     }
  74 }
  75 void reader_init_memreader(struct reader_t*r, void*newdata, int newlength)
  76 {
  77     struct memread_t*mr = malloc(sizeof(struct memread_t));
  78     mr->data = newdata;
  79     mr->length = newlength;
  80     r->read = reader_memread;
  81     r->internal = (void*)mr;
  82     r->type = READER_TYPE_MEM;
  83     r->mybyte = 0;
  84     r->bitpos = 8;
  85     r->pos = 0;
  86 }
  87
  88 /* ---------------------------- mem writer ------------------------------- */
  89
  90 struct memwrite_t
  91 {
  92     unsigned char*data;
  93     int length;
  94 };
  95
  96 static int writer_memwrite_write(struct writer_t*w, void* data, int len)
  97 {
  98     struct memread_t*mw = (struct memread_t*)w->internal;
  99     if(mw->length - w->pos > len) {
 100         memcpy(&mw->data[w->pos], data, len);
 101         w->pos += len;
 102         return len;
 103     } else {
 104         memcpy(&mw->data[w->pos], data, mw->length - w->pos);
 105         w->pos = mw->length;
 106         return mw->length - w->pos;
 107     }
 108 }
 109 static void writer_memwrite_finish(struct writer_t*w)
 110 {
 111     free(w->internal);
 112 }
 113 void writer_init_memwriter(struct writer_t*w, void*data, int len)
 114 {
 115     struct memwrite_t *mr;
 116     mr = malloc(sizeof(struct memwrite_t));
 117     mr->data = data;
 118     mr->length = len;
 119     memset(w, 0, sizeof(struct writer_t));
 120     w->write = writer_memwrite_write;
 121     w->finish = writer_memwrite_finish;
 122     w->internal = (void*)mr;
 123     w->type = WRITER_TYPE_FILE;
 124     w->bitpos = 0;
 125     w->mybyte = 0;
 126     w->pos = 0;
 127 }
 128
 129 /* ---------------------------- file writer ------------------------------- */
 130
 131 struct filewrite_t
 132 {
 133     int handle;
 134     char free_handle;
 135 };
 136
 137 static int writer_filewrite_write(struct writer_t*w, void* data, int len)
 138 {
 139     struct filewrite_t * fw= (struct filewrite_t*)w->internal;
 140     return write(fw->handle, data, len);
 141 }
 142 static void writer_filewrite_finish(struct writer_t*w)
 143 {
 144     struct filewrite_t *mr = (struct filewrite_t*)w->internal;
 145     if(mr->free_handle)
 146         close(mr->handle);
 147     free(mr);
 148 }
 149 void writer_init_filewriter(struct writer_t*w, int handle)
 150 {
 151     struct filewrite_t *mr = malloc(sizeof(struct filewrite_t));
 152     mr->handle = handle;
 153     mr->free_handle = 0;
 154     memset(w, 0, sizeof(struct writer_t));
 155     w->write = writer_filewrite_write;
 156     w->finish = writer_filewrite_finish;
 157     w->internal = mr;
 158     w->type = WRITER_TYPE_FILE;
 159     w->bitpos = 0;
 160     w->mybyte = 0;
 161     w->pos = 0;
 162 }
 163 void writer_init_filewriter2(struct writer_t*w, char*filename)
 164 {
 165     int fi = open("movie.swf",
 166 #ifdef O_BINARY
 167             O_BINARY|
 168 #endif
 169             O_WRONLY|O_CREAT|O_TRUNC, 0644);
 170     writer_init_filewriter(w, fi);
 171     ((struct filewrite_t*)w->internal)->free_handle = 1;
 172 }
 173
 174 /* ---------------------------- null writer ------------------------------- */
 175
 176 static int writer_nullwrite_write(struct writer_t*w, void* data, int len)
 177 {
 178     return len;
 179 }
 180 static void writer_nullwrite_finish(struct writer_t*w)
 181 {
 182 }
 183 void writer_init_nullwriter(struct writer_t*w)
 184 {
 185     memset(w, 0, sizeof(struct writer_t));
 186     w->write = writer_nullwrite_write;
 187     w->finish = writer_nullwrite_finish;
 188     w->internal = 0;
 189     w->type = WRITER_TYPE_NULL;
 190     w->bitpos = 0;
 191     w->mybyte = 0;
 192     w->pos = 0;
 193 }
 194 /* ---------------------------- zlibinflate writer -------------------------- */
 195
 196 struct zlibinflate_t
 197 {
 198 #ifdef HAVE_ZLIB
 199     z_stream zs;
 200     struct reader_t*input;
 201     unsigned char readbuffer[ZLIB_BUFFER_SIZE];
 202 #endif
 203 };
 204
 205 #ifdef HAVE_ZLIB
 206 static void zlib_error(int ret, char* msg, z_stream*zs)
 207 {
 208     fprintf(stderr, "%s: zlib error (%d): last zlib error: %s\n",
 209           msg,
 210           ret,
 211           zs->msg?zs->msg:"unknown");
 212     perror("errno:");
 213     exit(1);
 214 }
 215 #endif
 216
 217 static int reader_zlibinflate(struct reader_t*reader, void* data, int len)
 218 {
 219 #ifdef HAVE_ZLIB
 220     struct zlibinflate_t*z = (struct zlibinflate_t*)reader->internal;
 221     int ret;
 222     if(!z) {
 223         return 0;
 224     }
 225     if(!len)
 226         return 0;
 227
 228     z->zs.next_out = data;
 229     z->zs.avail_out = len;
 230
 231     while(1) {
 232         if(!z->zs.avail_in) {
 233             z->zs.avail_in = z->input->read(z->input, z->readbuffer, ZLIB_BUFFER_SIZE);
 234             z->zs.next_in = z->readbuffer;
 235         }
 236         if(z->zs.avail_in)
 237             ret = inflate(&z->zs, Z_NO_FLUSH);
 238         else
 239             ret = inflate(&z->zs, Z_FINISH);
 240
 241         if (ret != Z_OK &&
 242             ret != Z_STREAM_END) zlib_error(ret, "bitio:inflate_inflate", &z->zs);
 243
 244         if (ret == Z_STREAM_END) {
 245                 int pos = z->zs.next_out - (Bytef*)data;
 246                 ret = inflateEnd(&z->zs);
 247                 if (ret != Z_OK) zlib_error(ret, "bitio:inflate_end", &z->zs);
 248                 free(reader->internal);
 249                 reader->internal = 0;
 250                 reader->pos += pos;
 251                 return pos;
 252         }
 253         if(!z->zs.avail_out) {
 254             break;
 255         }
 256     }
 257     reader->pos += len;
 258     return len;
 259 #else
 260     fprintf(stderr, "Error: swftools was compiled without zlib support");
 261     exit(1);
 262 #endif
 263 }
 264 void reader_init_zlibinflate(struct reader_t*r, struct reader_t*input)
 265 {
 266 #ifdef HAVE_ZLIB
 267     struct zlibinflate_t*z;
 268     int ret;
 269     memset(r, 0, sizeof(struct reader_t));
 270     z = (struct zlibinflate_t*)malloc(sizeof(struct zlibinflate_t));
 271     memset(z, 0, sizeof(struct zlibinflate_t));
 272     r->internal = z;
 273     r->read = reader_zlibinflate;
 274     r->type = READER_TYPE_ZLIB;
 275     r->pos = 0;
 276     z->input = input;
 277     memset(&z->zs,0,sizeof(z_stream));
 278     z->zs.zalloc = Z_NULL;
 279     z->zs.zfree  = Z_NULL;
 280     z->zs.opaque = Z_NULL;
 281     ret = inflateInit(&z->zs);
 282     if (ret != Z_OK) zlib_error(ret, "bitio:inflate_init", &z->zs);
 283     reader_resetbits(r);
 284 #else
 285     fprintf(stderr, "Error: swftools was compiled without zlib support");
 286 #endif
 287 }
 288
 289 /* ---------------------------- zlibdeflate writer -------------------------- */
 290
 291 struct zlibdeflate_t
 292 {
 293 #ifdef HAVE_ZLIB
 294     z_stream zs;
 295     struct writer_t*output;
 296     unsigned char writebuffer[ZLIB_BUFFER_SIZE];
 297 #endif
 298 };
 299
 300 static int writer_zlibdeflate_write(struct writer_t*writer, void* data, int len)
 301 {
 302 #ifdef HAVE_ZLIB
 303     struct zlibdeflate_t*z = (struct zlibdeflate_t*)writer->internal;
 304     int ret;
 305     if(!z) {
 306         fprintf(stderr, "zlib not initialized!\n");
 307         return 0;
 308     }
 309     if(!len)
 310         return 0;
 311
 312     z->zs.next_in = data;
 313     z->zs.avail_in = len;
 314
 315     while(1) {
 316         ret = deflate(&z->zs, Z_NO_FLUSH);
 317
 318         if (ret != Z_OK) zlib_error(ret, "bitio:deflate_deflate", &z->zs);
 319
 320         if(z->zs.next_out != z->writebuffer) {
 321             z->output->write(z->output, z->writebuffer, z->zs.next_out - (Bytef*)z->writebuffer);
 322             z->zs.next_out = z->writebuffer;
 323             z->zs.avail_out = ZLIB_BUFFER_SIZE;
 324         }
 325
 326         if(!z->zs.avail_in) {
 327             break;
 328         }
 329     }
 330     writer->pos += len;
 331     return len;
 332 #else
 333     fprintf(stderr, "Error: swftools was compiled without zlib support");
 334     exit(1);
 335 #endif
 336 }
 337 static void writer_zlibdeflate_finish(struct writer_t*writer)
 338 {
 339 #ifdef HAVE_ZLIB
 340     struct zlibdeflate_t*z = (struct zlibdeflate_t*)writer->internal;
 341     struct writer_t*output;
 342     int ret;
 343     if(!z)
 344         return;
 345     output= z->output;
 346     while(1) {
 347         ret = deflate(&z->zs, Z_FINISH);
 348         if (ret != Z_OK &&
 349             ret != Z_STREAM_END) zlib_error(ret, "bitio:deflate_finish", &z->zs);
 350
 351         if(z->zs.next_out != z->writebuffer) {
 352             z->output->write(z->output, z->writebuffer, z->zs.next_out - (Bytef*)z->writebuffer);
 353             z->zs.next_out = z->writebuffer;
 354             z->zs.avail_out = ZLIB_BUFFER_SIZE;
 355         }
 356
 357         if (ret == Z_STREAM_END) {
 358             break;
 359
 360         }
 361     }
 362     ret = deflateEnd(&z->zs);
 363     if (ret != Z_OK) zlib_error(ret, "bitio:deflate_end", &z->zs);
 364     free(writer->internal);
 365     writer->internal = 0;
 366     output->finish(output);
 367 #else
 368     fprintf(stderr, "Error: swftools was compiled without zlib support");
 369     exit(1);
 370 #endif
 371 }
 372 void writer_init_zlibdeflate(struct writer_t*w, struct writer_t*output)
 373 {
 374 #ifdef HAVE_ZLIB
 375     struct zlibdeflate_t*z;
 376     int ret;
 377     memset(w, 0, sizeof(struct writer_t));
 378     z = (struct zlibdeflate_t*)malloc(sizeof(struct zlibdeflate_t));
 379     memset(z, 0, sizeof(struct zlibdeflate_t));
 380     w->internal = z;
 381     w->write = writer_zlibdeflate_write;
 382     w->finish = writer_zlibdeflate_finish;
 383     w->type = WRITER_TYPE_ZLIB;
 384     w->pos = 0;
 385     z->output = output;
 386     memset(&z->zs,0,sizeof(z_stream));
 387     z->zs.zalloc = Z_NULL;
 388     z->zs.zfree  = Z_NULL;
 389     z->zs.opaque = Z_NULL;
 390     ret = deflateInit(&z->zs, 9);
 391     if (ret != Z_OK) zlib_error(ret, "bitio:deflate_init", &z->zs);
 392     w->bitpos = 0;
 393     w->mybyte = 0;
 394     z->zs.next_out = z->writebuffer;
 395     z->zs.avail_out = ZLIB_BUFFER_SIZE;
 396 #else
 397     fprintf(stderr, "Error: swftools was compiled without zlib support");
 398     exit(1);
 399 #endif
 400 }
 401
 402 /* ----------------------- bit handling routines -------------------------- */
 403
 404 void writer_writebit(struct writer_t*w, int bit)
 405 {
 406     if(w->bitpos==8)
 407     {
 408         w->write(w, &w->mybyte, 1);
 409         w->bitpos = 0;
 410         w->mybyte = 0;
 411     }
 412     if(bit&1)
 413         w->mybyte |= 1 << (7 - w->bitpos);
 414     w->bitpos ++;
 415 }
 416 void writer_writebits(struct writer_t*w, unsigned int data, int bits)
 417 {
 418     int t;
 419     for(t=0;t<bits;t++)
 420     {
 421         writer_writebit(w, (data >> (bits-t-1))&1);
 422     }
 423 }
 424 void writer_resetbits(struct writer_t*w)
 425 {
 426     if(w->bitpos)
 427         w->write(w, &w->mybyte, 1);
 428     w->bitpos = 0;
 429     w->mybyte = 0;
 430 }
 431
 432 unsigned int reader_readbit(struct reader_t*r)
 433 {
 434     if(r->bitpos==8)
 435     {
 436         r->bitpos=0;
 437         r->read(r, &r->mybyte, 1);
 438     }
 439     return (r->mybyte>>(7-r->bitpos++))&1;
 440 }
 441 unsigned int reader_readbits(struct reader_t*r, int num)
 442 {
 443     int t;
 444     int val = 0;
 445     for(t=0;t<num;t++)
 446     {
 447         val<<=1;
 448         val|=reader_readbit(r);
 449     }
 450     return val;
 451 }
 452 void reader_resetbits(struct reader_t*r)
 453 {
 454     r->mybyte = 0;
 455     r->bitpos = 8;
 456
 457 }
 458