lib/bitio.c

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