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