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