src/bitstream.c

   1 /*
   2  * bit stream routine
   3  *                     (C) 2008/03/09- yoya@awm.jp
   4  */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include "bitstream.h"
  10
  11 static void bitstream_clear(bitstream_t *bs);
  12
  13 bitstream_t *
  14 bitstream_open(void) {
  15     bitstream_t *bs = (bitstream_t *) calloc(sizeof(*bs), 1);
  16     bs->data = NULL;
  17     bs->data_len = 0;
  18     bs->data_alloc_len = 0;
  19     bs->byte_offset = 0;
  20     bs->bit_offset = 0;
  21     return bs;
  22 }
  23
  24 void
  25 bitstream_close(bitstream_t * bs) {
  26     if (bs->data) {
  27         free(bs->data);
  28         bs->data = NULL;
  29     }
  30     free(bs);
  31     return ;
  32 }
  33
  34 static void
  35 bitstream_clear(bitstream_t *bs) {
  36     if (bs->data) {
  37         free(bs->data);
  38         bs->data = NULL;
  39     }
  40     bs->data_len = 0;
  41     bs->data_alloc_len = 0;
  42     bs->byte_offset = 0;
  43     bs->bit_offset = 0;
  44     return ;
  45 }
  46
  47 int
  48 bitstream_realloc(bitstream_t *bs) {
  49     unsigned char *data;
  50     bs->data_alloc_len *= 2;
  51     if (bs->data_alloc_len < BITSTREAM_DATA_LEN_MIN) {
  52         bs->data_alloc_len = BITSTREAM_DATA_LEN_MIN;
  53     }
  54     data = (unsigned char *) realloc(bs->data, bs->data_alloc_len);
  55     if (! data) {
  56         fprintf(stderr, "bitstream_realloc: Can't realloc memory (%p, %lu)\n",
  57                 bs->data, bs->data_alloc_len);
  58         return 1;
  59     }
  60     bs->data = data;
  61     return 0;
  62 }
  63
  64 int
  65 bitstream_input(bitstream_t *bs, unsigned char *data,
  66                    unsigned long data_len) {
  67     bitstream_clear(bs);
  68     bs->data_alloc_len = data_len;
  69     bs->data = malloc(bs->data_alloc_len);
  70     if (bs->data == NULL) {
  71         fprintf(stderr, "bitstream_input: malloc failed\n");
  72         bs->data_alloc_len = 0;
  73         bs->data_len = 0;
  74         return 1;
  75     }
  76     memcpy(bs->data, data, data_len);
  77     bs->data_len = data_len;
  78     return 0;
  79 }
  80
  81 unsigned char *
  82 bitstream_steal(bitstream_t *bs, unsigned long *length) {
  83     unsigned char *data, *tmp;
  84     *length = 0;
  85     if (bs == NULL) {
  86         fprintf(stderr, "bitstream_steal: bs == NULL\n");
  87         return NULL;
  88     }
  89     data = bs->data;
  90     *length = bs->data_len;
  91     if ((tmp = realloc(data, *length)) == NULL) {
  92         fprintf(stderr, "bitstream_steal: Can't realloc\n");
  93         return NULL;
  94     }
  95     bs->data = NULL;
  96     bs->data_len = 0;
  97     bs->data_alloc_len = 0;
  98     return tmp;
  99 }
 100
 101 unsigned char *
 102 bitstream_output_sub(bitstream_t *bs, unsigned long offset, unsigned long length) {
 103     unsigned char *data;
 104     if (bs == NULL) {
 105         fprintf(stderr, "bitstream_output_sub: bs == NULL\n");
 106         return NULL;
 107     }
 108     if (bs->data_len < offset + length ) {
 109         fprintf(stderr, "bitstream_output_sub: bs->data_len(%lu) < offset(%lu)+length(%lu)\n",
 110                 bs->data_len, offset, length);
 111         return NULL;
 112     }
 113     data = malloc(length);
 114     if (data == NULL) {
 115         fprintf(stderr, "bitstream_output_sub: Can't malloc\n");
 116         return NULL;
 117     }
 118     memcpy(data, bs->data + offset, length);
 119     return data;
 120 }
 121
 122 /*
 123  * byte stream
 124  */
 125
 126 int
 127 bitstream_putbyte(bitstream_t *bs, int byte) {
 128     bitstream_align(bs);
 129     if (bs->data_len < bs->byte_offset ) {
 130         return 1;
 131     }
 132     if (bs->data_len == bs->byte_offset ) {
 133         if (bs->data_alloc_len <= bs->byte_offset ) {
 134             bitstream_realloc(bs);
 135         }
 136         bs->data_len ++;
 137     }
 138     byte &= 0xff;
 139     bs->data[bs->byte_offset] = (unsigned char) byte ;
 140     bs->byte_offset++;
 141     return 0;
 142 }
 143
 144 int
 145 bitstream_getbyte(bitstream_t *bs) {
 146     int byte;
 147     bitstream_align(bs);
 148     if (bs->data_len <= bs->byte_offset) {
 149         return -1; /* End of Stream */
 150     }
 151     byte = bs->data[bs->byte_offset] & 0xff;
 152     bs->byte_offset++;
 153     return byte;
 154 }
 155
 156 int
 157 bitstream_putstring(bitstream_t *bs,
 158                                unsigned char *data, signed long data_len) {
 159     bitstream_align(bs);
 160     if (bs->data_len < bs->byte_offset ) {
 161         return 1;
 162     }
 163     while(bs->data_alloc_len < bs->byte_offset + data_len) {
 164         bitstream_realloc(bs);
 165     }
 166     bs->data_len = bs->byte_offset + data_len;
 167     memcpy(bs->data + bs->byte_offset, data, data_len);
 168     bs->byte_offset += data_len;
 169     return 0;
 170 }
 171
 172 int
 173 bitstream_getstring(bitstream_t *bs,
 174                                unsigned char *data, signed long data_len) {
 175     bitstream_align(bs);
 176     if (bs->data_len < bs->byte_offset + data_len) {
 177         return -1; /* End of Stream */
 178     }
 179     memcpy(data, bs->data + bs->byte_offset, data_len);
 180     bs->byte_offset += data_len;
 181     return 0;
 182 }
 183
 184 unsigned char *
 185 bitstream_outputstring(bitstream_t *bs) {
 186     unsigned char *data;
 187     unsigned long data_len;
 188     bitstream_align(bs);
 189     data_len = strlen((char *) bs->data + bs->byte_offset);
 190     data_len += 1; // + '\0'
 191     if (bs->data_len < bs->byte_offset + data_len) {
 192         return NULL; /* End of Stream */
 193     }
 194     data = malloc(data_len);
 195     if (data == NULL) {
 196         fprintf(stderr, "bitstream_outputstring: can't malloc\n");
 197         return NULL;
 198     }
 199     memcpy(data, bs->data + bs->byte_offset, data_len);
 200     bs->byte_offset += data_len;
 201     return data;
 202 }
 203
 204 int
 205 bitstream_putbytesLE(bitstream_t *bs, unsigned long bytes, int byte_width) {
 206     int i;
 207     unsigned long byte;
 208     for (i=0 ; i < byte_width ; i++) {
 209         byte = bytes & 0xff;
 210         bitstream_putbyte(bs, byte);
 211         bytes >>= 8;
 212     }
 213     return 0;
 214 }
 215
 216 int
 217 bitstream_putbytesBE(bitstream_t *bs, unsigned long bytes, int byte_width) {
 218     int i;
 219     unsigned long byte;
 220     for (i=0 ; i < byte_width ; i++) {
 221         byte = bytes >> ( 8 * (byte_width - 1 - i));
 222         bitstream_putbyte(bs, byte & 0xff);
 223     }
 224     return 0;
 225 }
 226
 227 unsigned long
 228 bitstream_getbytesLE(bitstream_t *bs, int byte_width) {
 229     int i;
 230     unsigned long byte, bytes = 0;
 231     for (i=0 ; i < byte_width ; i++) {
 232         byte = bitstream_getbyte(bs);
 233         byte <<= 8 * i;
 234         bytes |= byte;
 235     }
 236     return bytes;
 237 }
 238
 239 unsigned long
 240 bitstream_getbytesBE(bitstream_t *bs, int byte_width) {
 241     int i;
 242     unsigned long byte, bytes = 0;
 243     for (i=0 ; i < byte_width ; i++) {
 244         bytes <<= 8;
 245         byte = bitstream_getbyte(bs);
 246         bytes |= byte;
 247     }
 248     return bytes;
 249 }
 250
 251 /*
 252  * bit stream
 253  */
 254
 255 int
 256 bitstream_putbit(bitstream_t *bs, int bit) {
 257     int byte;
 258     if (bs->data_len <= bs->byte_offset) {
 259 //        fprintf(stderr, "bs->data_len(%ld) <= bs->byte_offset(%ld)\n",
 260 //                bs->data_len, bs->byte_offset);
 261         if (bs->data_alloc_len <= bs->byte_offset) {
 262 //            fprintf(stderr, "bitstream_putbit: alloc_len=%lu\n", bs->data_alloc_len);
 263             bitstream_realloc(bs);
 264         }
 265         bs->data[bs->byte_offset] = 0;
 266         bs->data_len ++;
 267 // return 1;
 268     }
 269     bit &= 1;
 270     byte = bs->data[bs->byte_offset];
 271     byte |= bit << (7 - bs->bit_offset);
 272     bs->data[bs->byte_offset] = byte;
 273     bitstream_incrpos(bs, 0, 1);
 274     return 0;
 275 }
 276 int
 277 bitstream_getbit(bitstream_t *bs) {
 278     int bit, byte;
 279     if (bs->data_len <= bs->byte_offset) {
 280         fprintf(stderr, "bitstream_getbit: bs->data_len(%ld) <= bs->byte_offset(%ld)\n",
 281                 bs->data_len, bs->byte_offset);
 282         return -1; /* End of Stream */
 283     }
 284     byte = bs->data[bs->byte_offset];
 285     bit = byte >> (7 - bs->bit_offset);
 286     bitstream_incrpos(bs, 0, 1);
 287     return bit & 1;
 288 }
 289
 290 int
 291 bitstream_putbits(bitstream_t *bs, unsigned long bits, int bit_width) {
 292     int i, bit;
 293     for (i=0 ; i < bit_width ; i++) {
 294         bit = bits >> (bit_width - 1 - i);
 295         bit &= 1;
 296         bitstream_putbit(bs, bit);
 297     }
 298     return 0;
 299 }
 300
 301 int
 302 bitstream_putbits_signed(bitstream_t *bs, signed long bits, int bit_width) {
 303     if (bits < 0) {
 304         register signed long msb = 1 << (bit_width - 1);
 305         register signed long bitmask = (2 * msb) - 1;
 306         bits = (-bits  - 1) ^ bitmask;
 307     }
 308     return bitstream_putbits(bs, bits, bit_width);
 309 }
 310
 311 unsigned long
 312 bitstream_getbits(bitstream_t *bs, int bit_width) {
 313     int i;
 314     int bit;
 315     unsigned long bits = 0;
 316     for (i=0 ; i < bit_width ; i++) {
 317         bit = bitstream_getbit(bs);
 318         if (bit == -1) {
 319             return -1;
 320         }
 321         bits |= bit << (bit_width - 1 - i);
 322     }
 323     return bits;
 324 }
 325
 326 signed long
 327 bitstream_getbits_signed(bitstream_t *bs, int bit_width) {
 328     signed long bits = bitstream_getbits(bs, bit_width);
 329     register signed long msb =  bits & (1 << (bit_width - 1));
 330     if (msb) {
 331         register signed long bitmask = (2 * msb) - 1;
 332         bits = - (bits ^ bitmask) - 1;
 333     }
 334     return bits;
 335 }
 336
 337 void
 338 bitstream_align(bitstream_t *bs) {
 339     if (bs->bit_offset > 0) {
 340         bs->byte_offset++;
 341         bs->bit_offset = 0;
 342     }
 343 }
 344
 345 /*
 346  * stream seek
 347  */
 348
 349 int
 350 bitstream_incrpos(bitstream_t *bs, signed long byte_incr,
 351                   signed long bit_incr) {
 352     while (bit_incr < 0) {
 353         bit_incr += 8;
 354         byte_incr --;
 355     }
 356     bs->byte_offset += byte_incr;
 357     bs->bit_offset += bit_incr;
 358     while (bs->bit_offset >= 8) {
 359         bs->bit_offset -= 8;
 360         bs->byte_offset ++;
 361     }
 362     return 0;
 363 }
 364
 365 int
 366 bitstream_setpos(bitstream_t *bs, unsigned long byte_offset,
 367                      unsigned long bit_offset) {
 368     if (bs->data_len <= byte_offset ) {
 369         fprintf(stderr, "bitstream_setpos: bs->data_len(%ld) <= byte_offset(%ld)\n",
 370                 bs->data_len, byte_offset);
 371     }
 372     bs->byte_offset = byte_offset;
 373     bs->bit_offset = bit_offset;
 374     return 0;
 375 }
 376
 377 unsigned long
 378 bitstream_getbytepos(bitstream_t *bs) {
 379     return bs->byte_offset;
 380 }
 381
 382 unsigned long
 383 bitstream_getbitpos(bitstream_t *bs) {
 384     return bs->bit_offset;
 385 }
 386
 387 /*
 388  * stream info
 389  */
 390
 391 unsigned char *
 392 bitstream_buffer(bitstream_t *bs, unsigned long byte_offset) {
 393     return bs->data + byte_offset;
 394 }
 395
 396 unsigned long
 397 bitstream_length(bitstream_t *bs) {
 398     return bs->data_len;
 399 }
 400
 401 /*
 402  * utility
 403  */
 404
 405 signed long
 406 bitstream_unsigned2signed(unsigned long num, int size) {
 407     unsigned long sig_bit = 1 << (size - 1);
 408     if ((sig_bit & num) == 0) {
 409         return (signed long) num;
 410     } else {
 411         unsigned long mask = sig_bit - 1;
 412         return - ((num^mask) & mask) - 1;
 413     }
 414 }
 415
 416 unsigned long
 417 bitstream_signed2unsigned(signed long num, int size) { // XXX check me!
 418     if (0 <= num){
 419         return (unsigned long) num;
 420     } else {
 421         unsigned long sig_bit = 1 << (size - 1);
 422         unsigned long mask = sig_bit - 1;
 423         return - ((num^mask) & mask) - 1;
 424     }
 425 }
 426
 427 int
 428 bitstream_need_bits_unsigned(unsigned long n) {
 429     int i;
 430     for (i = 0 ; n ; i++) {
 431         n >>= 1;
 432     }
 433     return i;
 434 }
 435
 436 int
 437 bitstream_need_bits_signed(signed long n) {
 438     int i;
 439     int ret;
 440     if (n < -1) {
 441         n = -1 - n;
 442     }
 443     if (n >= 0) {
 444         for (i = 0 ; n ; i++) {
 445             n >>= 1;
 446         }
 447         ret = 1 + i;
 448         ;
 449     } else { // n == -1
 450         ret = 1;
 451     }
 452     return ret;
 453 }
 454
 455 /*
 456  * error handling
 457  */
 458
 459 int
 460 bitstream_iserror(bitstream_t *bs) {
 461     (void) bs;
 462     return 0;
 463 }
 464
 465 void
 466 bitstream_printerror(bitstream_t *bs) {
 467     (void) bs;
 468 }
 469
 470 /*
 471  * for debug
 472  */
 473
 474 void
 475 bitstream_hexdump(bitstream_t *bs, int length) {
 476     unsigned long i, j;
 477     for ( i = bs->byte_offset ; i < bs->byte_offset + length ; i++) {
 478         if ((i == bs->byte_offset) || (i%16) == 0) {
 479             printf("%08lu: ", i);
 480             if ((i%16) != 0) {
 481                 for( j = 0 ; j < (i%16) ; j++) {
 482                     printf("   ");
 483                 }
 484             }
 485         }
 486         printf("%02x ", bs->data[i] & 0xff);
 487         if ((i%16) == 7) {
 488             printf(" ");
 489         }
 490         if ((i%16) == 15) {
 491             printf("\n");
 492         }
 493     }
 494     if ((i%16) != 0) {
 495         printf("\n");
 496     }
 497 }
 498
 499 void
 500 bitstream_print(bitstream_t *bs) {
 501     printf("data=%p  data_len=%lu data_alloc_len=%lu\n",
 502            bs->data, bs->data_len, bs->data_alloc_len);
 503     printf("byte_offset=%lu  bit_offset=%lu\n",
 504            bs->byte_offset, bs->bit_offset);
 505 }