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(writer->type != WRITER_TYPE_ZLIB) {
 307         fprintf(stderr, "Wrong writer ID (writer not initialized?)\n");
 308         return 0;
 309     }
 310     if(!z) {
 311         fprintf(stderr, "zlib not initialized!\n");
 312         return 0;
 313     }
 314     if(!len)
 315         return 0;
 316
 317     z->zs.next_in = data;
 318     z->zs.avail_in = len;
 319
 320     while(1) {
 321         ret = deflate(&z->zs, Z_NO_FLUSH);
 322
 323         if (ret != Z_OK) zlib_error(ret, "bitio:deflate_deflate", &z->zs);
 324
 325         if(z->zs.next_out != z->writebuffer) {
 326             z->output->write(z->output, z->writebuffer, z->zs.next_out - (Bytef*)z->writebuffer);
 327             z->zs.next_out = z->writebuffer;
 328             z->zs.avail_out = ZLIB_BUFFER_SIZE;
 329         }
 330
 331         if(!z->zs.avail_in) {
 332             break;
 333         }
 334     }
 335     writer->pos += len;
 336     return len;
 337 #else
 338     fprintf(stderr, "Error: swftools was compiled without zlib support");
 339     exit(1);
 340 #endif
 341 }
 342 static void writer_zlibdeflate_finish(struct writer_t*writer)
 343 {
 344 #ifdef HAVE_ZLIB
 345     struct zlibdeflate_t*z = (struct zlibdeflate_t*)writer->internal;
 346     struct writer_t*output;
 347     int ret;
 348     if(writer->type != WRITER_TYPE_ZLIB) {
 349         fprintf(stderr, "Wrong writer ID (writer not initialized?)\n");
 350         return;
 351     }
 352     if(!z)
 353         return;
 354     output= z->output;
 355     while(1) {
 356         ret = deflate(&z->zs, Z_FINISH);
 357         if (ret != Z_OK &&
 358             ret != Z_STREAM_END) zlib_error(ret, "bitio:deflate_finish", &z->zs);
 359
 360         if(z->zs.next_out != z->writebuffer) {
 361             z->output->write(z->output, z->writebuffer, z->zs.next_out - (Bytef*)z->writebuffer);
 362             z->zs.next_out = z->writebuffer;
 363             z->zs.avail_out = ZLIB_BUFFER_SIZE;
 364         }
 365
 366         if (ret == Z_STREAM_END) {
 367             break;
 368
 369         }
 370     }
 371     ret = deflateEnd(&z->zs);
 372     if (ret != Z_OK) zlib_error(ret, "bitio:deflate_end", &z->zs);
 373     free(writer->internal);
 374     writer->internal = 0;
 375     //output->finish(output);
 376 #else
 377     fprintf(stderr, "Error: swftools was compiled without zlib support");
 378     exit(1);
 379 #endif
 380 }
 381 void writer_init_zlibdeflate(struct writer_t*w, struct writer_t*output)
 382 {
 383 #ifdef HAVE_ZLIB
 384     struct zlibdeflate_t*z;
 385     int ret;
 386     memset(w, 0, sizeof(struct writer_t));
 387     z = (struct zlibdeflate_t*)malloc(sizeof(struct zlibdeflate_t));
 388     memset(z, 0, sizeof(struct zlibdeflate_t));
 389     w->internal = z;
 390     w->write = writer_zlibdeflate_write;
 391     w->finish = writer_zlibdeflate_finish;
 392     w->type = WRITER_TYPE_ZLIB;
 393     w->pos = 0;
 394     z->output = output;
 395     memset(&z->zs,0,sizeof(z_stream));
 396     z->zs.zalloc = Z_NULL;
 397     z->zs.zfree  = Z_NULL;
 398     z->zs.opaque = Z_NULL;
 399     ret = deflateInit(&z->zs, 9);
 400     if (ret != Z_OK) zlib_error(ret, "bitio:deflate_init", &z->zs);
 401     w->bitpos = 0;
 402     w->mybyte = 0;
 403     z->zs.next_out = z->writebuffer;
 404     z->zs.avail_out = ZLIB_BUFFER_SIZE;
 405 #else
 406     fprintf(stderr, "Error: swftools was compiled without zlib support");
 407     exit(1);
 408 #endif
 409 }
 410
 411 /* ----------------------- bit handling routines -------------------------- */
 412
 413 void writer_writebit(struct writer_t*w, int bit)
 414 {
 415     if(w->bitpos==8)
 416     {
 417         w->write(w, &w->mybyte, 1);
 418         w->bitpos = 0;
 419         w->mybyte = 0;
 420     }
 421     if(bit&1)
 422         w->mybyte |= 1 << (7 - w->bitpos);
 423     w->bitpos ++;
 424 }
 425 void writer_writebits(struct writer_t*w, unsigned int data, int bits)
 426 {
 427     int t;
 428     for(t=0;t<bits;t++)
 429     {
 430         writer_writebit(w, (data >> (bits-t-1))&1);
 431     }
 432 }
 433 void writer_resetbits(struct writer_t*w)
 434 {
 435     if(w->bitpos)
 436         w->write(w, &w->mybyte, 1);
 437     w->bitpos = 0;
 438     w->mybyte = 0;
 439 }
 440
 441 unsigned int reader_readbit(struct reader_t*r)
 442 {
 443     if(r->bitpos==8)
 444     {
 445         r->bitpos=0;
 446         r->read(r, &r->mybyte, 1);
 447     }
 448     return (r->mybyte>>(7-r->bitpos++))&1;
 449 }
 450 unsigned int reader_readbits(struct reader_t*r, int num)
 451 {
 452     int t;
 453     int val = 0;
 454     for(t=0;t<num;t++)
 455     {
 456         val<<=1;
 457         val|=reader_readbit(r);
 458     }
 459     return val;
 460 }
 461 void reader_resetbits(struct reader_t*r)
 462 {
 463     r->mybyte = 0;
 464     r->bitpos = 8;
 465
 466 }
 467