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