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