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         return 0;
 193     }
 194     if(!len)
 195         return 0;
 196
 197     z->zs.next_out = data;
 198     z->zs.avail_out = len;
 199
 200     while(1) {
 201         if(!z->zs.avail_in) {
 202             z->zs.avail_in = z->input->read(z->input, z->readbuffer, ZLIB_BUFFER_SIZE);
 203             z->zs.next_in = z->readbuffer;
 204         }
 205         if(z->zs.avail_in)
 206             ret = inflate(&z->zs, Z_NO_FLUSH);
 207         else
 208             ret = inflate(&z->zs, Z_FINISH);
 209
 210         if (ret != Z_OK &&
 211             ret != Z_STREAM_END) zlib_error(ret, "bitio:inflate_inflate", &z->zs);
 212
 213         if (ret == Z_STREAM_END) {
 214                 int pos = z->zs.next_out - (Bytef*)data;
 215                 ret = inflateEnd(&z->zs);
 216                 if (ret != Z_OK) zlib_error(ret, "bitio:inflate_end", &z->zs);
 217                 free(reader->internal);
 218                 reader->internal = 0;
 219                 reader->pos += pos;
 220                 return pos;
 221         }
 222         if(!z->zs.avail_out) {
 223             break;
 224         }
 225     }
 226     reader->pos += len;
 227     return len;
 228 #else
 229     fprintf(stderr, "Error: swftools was compiled without zlib support");
 230     exit(1);
 231 #endif
 232 }
 233 void reader_init_zlibinflate(struct reader_t*r, struct reader_t*input)
 234 {
 235 #ifdef HAVE_ZLIB
 236     struct zlibinflate_t*z;
 237     int ret;
 238     memset(r, 0, sizeof(struct reader_t));
 239     z = (struct zlibinflate_t*)malloc(sizeof(struct zlibinflate_t));
 240     memset(z, 0, sizeof(struct zlibinflate_t));
 241     r->internal = z;
 242     r->read = reader_zlibinflate;
 243     r->type = READER_TYPE_ZLIB;
 244     r->pos = 0;
 245     z->input = input;
 246     memset(&z->zs,0,sizeof(z_stream));
 247     z->zs.zalloc = Z_NULL;
 248     z->zs.zfree  = Z_NULL;
 249     z->zs.opaque = Z_NULL;
 250     ret = inflateInit(&z->zs);
 251     if (ret != Z_OK) zlib_error(ret, "bitio:inflate_init", &z->zs);
 252     reader_resetbits(r);
 253 #else
 254     fprintf(stderr, "Error: swftools was compiled without zlib support");
 255 #endif
 256 }
 257
 258 /* ---------------------------- zlibdeflate writer -------------------------- */
 259
 260 struct zlibdeflate_t
 261 {
 262 #ifdef HAVE_ZLIB
 263     z_stream zs;
 264     struct writer_t*output;
 265     unsigned char writebuffer[ZLIB_BUFFER_SIZE];
 266 #endif
 267 };
 268
 269 static int writer_zlibdeflate_write(struct writer_t*writer, void* data, int len)
 270 {
 271 #ifdef HAVE_ZLIB
 272     struct zlibdeflate_t*z = (struct zlibdeflate_t*)writer->internal;
 273     int ret;
 274     if(!z) {
 275         fprintf(stderr, "zlib not initialized!\n");
 276         return 0;
 277     }
 278     if(!len)
 279         return 0;
 280
 281     z->zs.next_in = data;
 282     z->zs.avail_in = len;
 283
 284     while(1) {
 285         ret = deflate(&z->zs, Z_NO_FLUSH);
 286
 287         if (ret != Z_OK) zlib_error(ret, "bitio:deflate_deflate", &z->zs);
 288
 289         if(z->zs.next_out != z->writebuffer) {
 290             z->output->write(z->output, z->writebuffer, z->zs.next_out - (Bytef*)z->writebuffer);
 291             z->zs.next_out = z->writebuffer;
 292             z->zs.avail_out = ZLIB_BUFFER_SIZE;
 293         }
 294
 295         if(!z->zs.avail_in) {
 296             break;
 297         }
 298     }
 299     writer->pos += len;
 300     return len;
 301 #else
 302     fprintf(stderr, "Error: swftools was compiled without zlib support");
 303     exit(1);
 304 #endif
 305 }
 306 static void writer_zlibdeflate_finish(struct writer_t*writer)
 307 {
 308 #ifdef HAVE_ZLIB
 309     struct zlibdeflate_t*z = (struct zlibdeflate_t*)writer->internal;
 310     struct writer_t*output;
 311     int ret;
 312     if(!z)
 313         return;
 314     output= z->output;
 315     while(1) {
 316         ret = deflate(&z->zs, Z_FINISH);
 317         if (ret != Z_OK &&
 318             ret != Z_STREAM_END) zlib_error(ret, "bitio:deflate_finish", &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 (ret == Z_STREAM_END) {
 327             break;
 328
 329         }
 330     }
 331     ret = deflateEnd(&z->zs);
 332     if (ret != Z_OK) zlib_error(ret, "bitio:deflate_end", &z->zs);
 333     free(writer->internal);
 334     writer->internal = 0;
 335     output->finish(output);
 336 #else
 337     fprintf(stderr, "Error: swftools was compiled without zlib support");
 338     exit(1);
 339 #endif
 340 }
 341 void writer_init_zlibdeflate(struct writer_t*w, struct writer_t*output)
 342 {
 343 #ifdef HAVE_ZLIB
 344     struct zlibdeflate_t*z;
 345     int ret;
 346     memset(w, 0, sizeof(struct writer_t));
 347     z = (struct zlibdeflate_t*)malloc(sizeof(struct zlibdeflate_t));
 348     memset(z, 0, sizeof(struct zlibdeflate_t));
 349     w->internal = z;
 350     w->write = writer_zlibdeflate_write;
 351     w->finish = writer_zlibdeflate_finish;
 352     w->type = WRITER_TYPE_ZLIB;
 353     w->pos = 0;
 354     z->output = output;
 355     memset(&z->zs,0,sizeof(z_stream));
 356     z->zs.zalloc = Z_NULL;
 357     z->zs.zfree  = Z_NULL;
 358     z->zs.opaque = Z_NULL;
 359     ret = deflateInit(&z->zs, 9);
 360     if (ret != Z_OK) zlib_error(ret, "bitio:deflate_init", &z->zs);
 361     w->bitpos = 0;
 362     w->mybyte = 0;
 363     z->zs.next_out = z->writebuffer;
 364     z->zs.avail_out = ZLIB_BUFFER_SIZE;
 365 #else
 366     fprintf(stderr, "Error: swftools was compiled without zlib support");
 367     exit(1);
 368 #endif
 369 }
 370
 371 /* ----------------------- bit handling routines -------------------------- */
 372
 373 void writer_writebit(struct writer_t*w, int bit)
 374 {
 375     if(w->bitpos==8)
 376     {
 377         w->write(w, &w->mybyte, 1);
 378         w->bitpos = 0;
 379         w->mybyte = 0;
 380     }
 381     if(bit&1)
 382         w->mybyte |= 1 << (7 - w->bitpos);
 383     w->bitpos ++;
 384 }
 385 void writer_writebits(struct writer_t*w, unsigned int data, int bits)
 386 {
 387     int t;
 388     for(t=0;t<bits;t++)
 389     {
 390         writer_writebit(w, (data >> (bits-t-1))&1);
 391     }
 392 }
 393 void writer_resetbits(struct writer_t*w)
 394 {
 395     if(w->bitpos)
 396         w->write(w, &w->mybyte, 1);
 397     w->bitpos = 0;
 398     w->mybyte = 0;
 399 }
 400
 401 unsigned int reader_readbit(struct reader_t*r)
 402 {
 403     if(r->bitpos==8)
 404     {
 405         r->bitpos=0;
 406         r->read(r, &r->mybyte, 1);
 407     }
 408     return (r->mybyte>>(7-r->bitpos++))&1;
 409 }
 410 unsigned int reader_readbits(struct reader_t*r, int num)
 411 {
 412     int t;
 413     int val = 0;
 414     for(t=0;t<num;t++)
 415     {
 416         val<<=1;
 417         val|=reader_readbit(r);
 418     }
 419     return val;
 420 }
 421 void reader_resetbits(struct reader_t*r)
 422 {
 423     r->mybyte = 0;
 424     r->bitpos = 8;
 425
 426 }
 427