src/lib/doslib/ext/faad/bits.h

   1 /*
   2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
   3 ** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
   4 **
   5 ** This program is free software; you can redistribute it and/or modify
   6 ** it under the terms of the GNU General Public License as published by
   7 ** the Free Software Foundation; either version 2 of the License, or
   8 ** (at your option) any later version.
   9 **
  10 ** This program is distributed in the hope that it will be useful,
  11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 ** GNU General Public License for more details.
  14 **
  15 ** You should have received a copy of the GNU General Public License
  16 ** along with this program; if not, write to the Free Software
  17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18 **
  19 ** Any non-GPL usage of this software or parts of this software is strictly
  20 ** forbidden.
  21 **
  22 ** The "appropriate copyright message" mentioned in section 2c of the GPLv2
  23 ** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"
  24 **
  25 ** Commercial non-GPL licensing of this software is possible.
  26 ** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
  27 **
  28 ** $Id: bits.h,v 1.45 2007/11/01 12:33:29 menno Exp $
  29 **/
  30
  31 #ifndef __BITS_H__
  32 #define __BITS_H__
  33
  34 #ifdef __cplusplus
  35 extern "C" {
  36 #endif
  37
  38 #include "analysis.h"
  39 #ifdef ANALYSIS
  40 #include <stdio.h>
  41 #endif
  42
  43 #define BYTE_NUMBIT     8
  44 #define BYTE_NUMBIT_LD  3
  45 //#define bit2byte(a) ((a+7)/BYTE_NUMBIT)
  46 #define bit2byte(a) ((a+7)>>BYTE_NUMBIT_LD)
  47
  48 typedef struct _bitfile
  49 {
  50     /* bit input */
  51     uint32_t bufa;
  52     uint32_t bufb;
  53     uint32_t bits_left;
  54     uint32_t buffer_size; /* size of the buffer in bytes */
  55     uint32_t bytes_left;
  56     uint8_t error;
  57     uint32_t *tail;
  58     uint32_t *start;
  59     const void *buffer;
  60 } bitfile;
  61
  62
  63 #if 0
  64 static uint32_t const bitmask[] = {
  65     0x0, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF,
  66     0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF,
  67     0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF,
  68     0x7FFFFF, 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF,
  69     0xFFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF
  70     /* added bitmask 32, correct?!?!?! */
  71     , 0xFFFFFFFF
  72 };
  73 #endif
  74
  75 void faad_initbits(bitfile *ld, const void *buffer, const uint32_t buffer_size);
  76 void faad_endbits(bitfile *ld);
  77 void faad_initbits_rev(bitfile *ld, void *buffer,
  78                        uint32_t bits_in_buffer);
  79 uint8_t faad_byte_align(bitfile *ld);
  80 uint32_t faad_get_processed_bits(bitfile *ld);
  81 void faad_flushbits_ex(bitfile *ld, uint32_t bits);
  82 void faad_rewindbits(bitfile *ld);
  83 void faad_resetbits(bitfile *ld, int bits);
  84 uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits
  85                        DEBUGDEC);
  86 #ifdef DRM
  87 void *faad_origbitbuffer(bitfile *ld);
  88 uint32_t faad_origbitbuffer_size(bitfile *ld);
  89 #endif
  90
  91 /* circumvent memory alignment errors on ARM */
  92 static INLINE uint32_t getdword(void *mem)
  93 {
  94     uint32_t tmp;
  95 #ifndef ARCH_IS_BIG_ENDIAN
  96     ((uint8_t*)&tmp)[0] = ((uint8_t*)mem)[3];
  97     ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[2];
  98     ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[1];
  99     ((uint8_t*)&tmp)[3] = ((uint8_t*)mem)[0];
 100 #else
 101     ((uint8_t*)&tmp)[0] = ((uint8_t*)mem)[0];
 102     ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[1];
 103     ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[2];
 104     ((uint8_t*)&tmp)[3] = ((uint8_t*)mem)[3];
 105 #endif
 106
 107     return tmp;
 108 }
 109
 110 /* reads only n bytes from the stream instead of the standard 4 */
 111 static /*INLINE*/ uint32_t getdword_n(void *mem, int n)
 112 {
 113     uint32_t tmp = 0;
 114 #ifndef ARCH_IS_BIG_ENDIAN
 115     switch (n)
 116     {
 117     case 3:
 118         ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[2];
 119     case 2:
 120         ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[1];
 121     case 1:
 122         ((uint8_t*)&tmp)[3] = ((uint8_t*)mem)[0];
 123     default:
 124         break;
 125     }
 126 #else
 127     switch (n)
 128     {
 129     case 3:
 130         ((uint8_t*)&tmp)[2] = ((uint8_t*)mem)[2];
 131     case 2:
 132         ((uint8_t*)&tmp)[1] = ((uint8_t*)mem)[1];
 133     case 1:
 134         ((uint8_t*)&tmp)[0] = ((uint8_t*)mem)[0];
 135     default:
 136         break;
 137     }
 138 #endif
 139
 140     return tmp;
 141 }
 142
 143 static INLINE uint32_t faad_showbits(bitfile *ld, uint32_t bits)
 144 {
 145     if (bits <= ld->bits_left)
 146     {
 147         //return (ld->bufa >> (ld->bits_left - bits)) & bitmask[bits];
 148         return (ld->bufa << (32 - ld->bits_left)) >> (32 - bits);
 149     }
 150
 151     bits -= ld->bits_left;
 152     //return ((ld->bufa & bitmask[ld->bits_left]) << bits) | (ld->bufb >> (32 - bits));
 153     return ((ld->bufa & ((1<<ld->bits_left)-1)) << bits) | (ld->bufb >> (32 - bits));
 154 }
 155
 156 static INLINE void faad_flushbits(bitfile *ld, uint32_t bits)
 157 {
 158     /* do nothing if error */
 159     if (ld->error != 0)
 160         return;
 161
 162     if (bits < ld->bits_left)
 163     {
 164         ld->bits_left -= bits;
 165     } else {
 166         faad_flushbits_ex(ld, bits);
 167     }
 168 }
 169
 170 /* return next n bits (right adjusted) */
 171 static /*INLINE*/ uint32_t faad_getbits(bitfile *ld, uint32_t n DEBUGDEC)
 172 {
 173     uint32_t ret;
 174
 175     if (n == 0)
 176         return 0;
 177
 178     ret = faad_showbits(ld, n);
 179     faad_flushbits(ld, n);
 180
 181 #ifdef ANALYSIS
 182     if (print)
 183         fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg);
 184 #endif
 185
 186     return ret;
 187 }
 188
 189 static INLINE uint8_t faad_get1bit(bitfile *ld DEBUGDEC)
 190 {
 191     uint8_t r;
 192
 193     if (ld->bits_left > 0)
 194     {
 195         ld->bits_left--;
 196         r = (uint8_t)((ld->bufa >> ld->bits_left) & 1);
 197         return r;
 198     }
 199
 200     /* bits_left == 0 */
 201 #if 0
 202     r = (uint8_t)(ld->bufb >> 31);
 203     faad_flushbits_ex(ld, 1);
 204 #else
 205     r = (uint8_t)faad_getbits(ld, 1);
 206 #endif
 207     return r;
 208 }
 209
 210 /* reversed bitreading routines */
 211 static INLINE uint32_t faad_showbits_rev(bitfile *ld, uint32_t bits)
 212 {
 213     uint8_t i;
 214     uint32_t B = 0;
 215
 216     if (bits <= ld->bits_left)
 217     {
 218         for (i = 0; i < bits; i++)
 219         {
 220             if (ld->bufa & (1 << (i + (32 - ld->bits_left))))
 221                 B |= (1 << (bits - i - 1));
 222         }
 223         return B;
 224     } else {
 225         for (i = 0; i < ld->bits_left; i++)
 226         {
 227             if (ld->bufa & (1 << (i + (32 - ld->bits_left))))
 228                 B |= (1 << (bits - i - 1));
 229         }
 230         for (i = 0; i < bits - ld->bits_left; i++)
 231         {
 232             if (ld->bufb & (1 << (i + (32-ld->bits_left))))
 233                 B |= (1 << (bits - ld->bits_left - i - 1));
 234         }
 235         return B;
 236     }
 237 }
 238
 239 static INLINE void faad_flushbits_rev(bitfile *ld, uint32_t bits)
 240 {
 241     /* do nothing if error */
 242     if (ld->error != 0)
 243         return;
 244
 245     if (bits < ld->bits_left)
 246     {
 247         ld->bits_left -= bits;
 248     } else {
 249         uint32_t tmp;
 250
 251         ld->bufa = ld->bufb;
 252         tmp = getdword(ld->start);
 253         ld->bufb = tmp;
 254         ld->start--;
 255         ld->bits_left += (32 - bits);
 256
 257         if (ld->bytes_left < 4)
 258         {
 259             ld->error = 1;
 260             ld->bytes_left = 0;
 261         } else {
 262             ld->bytes_left -= 4;
 263         }
 264 //        if (ld->bytes_left == 0)
 265 //            ld->no_more_reading = 1;
 266     }
 267 }
 268
 269 static /*INLINE*/ uint32_t faad_getbits_rev(bitfile *ld, uint32_t n
 270                                         DEBUGDEC)
 271 {
 272     uint32_t ret;
 273
 274     if (n == 0)
 275         return 0;
 276
 277     ret = faad_showbits_rev(ld, n);
 278     faad_flushbits_rev(ld, n);
 279
 280 #ifdef ANALYSIS
 281     if (print)
 282         fprintf(stdout, "%4d %2d bits, val: %4d, variable: %d %s\n", dbg_count++, n, ret, var, dbg);
 283 #endif
 284
 285     return ret;
 286 }
 287
 288 #ifdef DRM
 289 /* CRC lookup table for G8 polynome in DRM standard */
 290 static const uint8_t crc_table_G8[256] = {
 291     0x0, 0x1d, 0x3a, 0x27, 0x74, 0x69, 0x4e, 0x53,
 292     0xe8, 0xf5, 0xd2, 0xcf, 0x9c, 0x81, 0xa6, 0xbb,
 293     0xcd, 0xd0, 0xf7, 0xea, 0xb9, 0xa4, 0x83, 0x9e,
 294     0x25, 0x38, 0x1f, 0x2, 0x51, 0x4c, 0x6b, 0x76,
 295     0x87, 0x9a, 0xbd, 0xa0, 0xf3, 0xee, 0xc9, 0xd4,
 296     0x6f, 0x72, 0x55, 0x48, 0x1b, 0x6, 0x21, 0x3c,
 297     0x4a, 0x57, 0x70, 0x6d, 0x3e, 0x23, 0x4, 0x19,
 298     0xa2, 0xbf, 0x98, 0x85, 0xd6, 0xcb, 0xec, 0xf1,
 299     0x13, 0xe, 0x29, 0x34, 0x67, 0x7a, 0x5d, 0x40,
 300     0xfb, 0xe6, 0xc1, 0xdc, 0x8f, 0x92, 0xb5, 0xa8,
 301     0xde, 0xc3, 0xe4, 0xf9, 0xaa, 0xb7, 0x90, 0x8d,
 302     0x36, 0x2b, 0xc, 0x11, 0x42, 0x5f, 0x78, 0x65,
 303     0x94, 0x89, 0xae, 0xb3, 0xe0, 0xfd, 0xda, 0xc7,
 304     0x7c, 0x61, 0x46, 0x5b, 0x8, 0x15, 0x32, 0x2f,
 305     0x59, 0x44, 0x63, 0x7e, 0x2d, 0x30, 0x17, 0xa,
 306     0xb1, 0xac, 0x8b, 0x96, 0xc5, 0xd8, 0xff, 0xe2,
 307     0x26, 0x3b, 0x1c, 0x1, 0x52, 0x4f, 0x68, 0x75,
 308     0xce, 0xd3, 0xf4, 0xe9, 0xba, 0xa7, 0x80, 0x9d,
 309     0xeb, 0xf6, 0xd1, 0xcc, 0x9f, 0x82, 0xa5, 0xb8,
 310     0x3, 0x1e, 0x39, 0x24, 0x77, 0x6a, 0x4d, 0x50,
 311     0xa1, 0xbc, 0x9b, 0x86, 0xd5, 0xc8, 0xef, 0xf2,
 312     0x49, 0x54, 0x73, 0x6e, 0x3d, 0x20, 0x7, 0x1a,
 313     0x6c, 0x71, 0x56, 0x4b, 0x18, 0x5, 0x22, 0x3f,
 314     0x84, 0x99, 0xbe, 0xa3, 0xf0, 0xed, 0xca, 0xd7,
 315     0x35, 0x28, 0xf, 0x12, 0x41, 0x5c, 0x7b, 0x66,
 316     0xdd, 0xc0, 0xe7, 0xfa, 0xa9, 0xb4, 0x93, 0x8e,
 317     0xf8, 0xe5, 0xc2, 0xdf, 0x8c, 0x91, 0xb6, 0xab,
 318     0x10, 0xd, 0x2a, 0x37, 0x64, 0x79, 0x5e, 0x43,
 319     0xb2, 0xaf, 0x88, 0x95, 0xc6, 0xdb, 0xfc, 0xe1,
 320     0x5a, 0x47, 0x60, 0x7d, 0x2e, 0x33, 0x14, 0x9,
 321     0x7f, 0x62, 0x45, 0x58, 0xb, 0x16, 0x31, 0x2c,
 322     0x97, 0x8a, 0xad, 0xb0, 0xe3, 0xfe, 0xd9, 0xc4,
 323 };
 324
 325 static uint8_t faad_check_CRC(bitfile *ld, uint16_t len)
 326 {
 327     int bytes, rem;
 328     unsigned int CRC;
 329     unsigned int r=255;  /* Initialize to all ones */
 330
 331     /* CRC polynome used x^8 + x^4 + x^3 + x^2 +1 */
 332 #define GPOLY 0435
 333
 334     faad_rewindbits(ld);
 335
 336     CRC = (unsigned int) ~faad_getbits(ld, 8
 337         DEBUGVAR(1,999,"faad_check_CRC(): CRC")) & 0xFF;          /* CRC is stored inverted */
 338
 339     bytes = len >> 3;
 340     rem = len & 0x7;
 341
 342     for (; bytes > 0; bytes--)
 343     {
 344         r = crc_table_G8[( r ^ faad_getbits(ld, 8 DEBUGVAR(1,998,"")) ) & 0xFF];
 345     }
 346     for (; rem > 0; rem--)
 347     {
 348         r = ( (r << 1) ^ (( ( faad_get1bit(ld
 349             DEBUGVAR(1,998,""))  & 1) ^ ((r >> 7) & 1)) * GPOLY )) & 0xFF;
 350     }
 351
 352     if (r != CRC)
 353   //  if (0)
 354     {
 355         return 28;
 356     } else {
 357         return 0;
 358     }
 359 }
 360
 361 static uint8_t tabFlipbits[256] = {
 362     0,128,64,192,32,160,96,224,16,144,80,208,48,176,112,240,
 363     8,136,72,200,40,168,104,232,24,152,88,216,56,184,120,248,
 364     4,132,68,196,36,164,100,228,20,148,84,212,52,180,116,244,
 365     12,140,76,204,44,172,108,236,28,156,92,220,60,188,124,252,
 366     2,130,66,194,34,162,98,226,18,146,82,210,50,178,114,242,
 367     10,138,74,202,42,170,106,234,26,154,90,218,58,186,122,250,
 368     6,134,70,198,38,166,102,230,22,150,86,214,54,182,118,246,
 369     14,142,78,206,46,174,110,238,30,158,94,222,62,190,126,254,
 370     1,129,65,193,33,161,97,225,17,145,81,209,49,177,113,241,
 371     9,137,73,201,41,169,105,233,25,153,89,217,57,185,121,249,
 372     5,133,69,197,37,165,101,229,21,149,85,213,53,181,117,245,
 373     13,141,77,205,45,173,109,237,29,157,93,221,61,189,125,253,
 374     3,131,67,195,35,163,99,227,19,147,83,211,51,179,115,243,
 375     11,139,75,203,43,171,107,235,27,155,91,219,59,187,123,251,
 376     7,135,71,199,39,167,103,231,23,151,87,215,55,183,119,247,
 377     15,143,79,207,47,175,111,239,31,159,95,223,63,191,127,255
 378 };
 379 #endif
 380
 381 #ifdef ERROR_RESILIENCE
 382
 383 /* Modified bit reading functions for HCR */
 384
 385 typedef struct
 386 {
 387     /* bit input */
 388     uint32_t bufa;
 389     uint32_t bufb;
 390     int8_t len;
 391 } bits_t;
 392
 393
 394 static INLINE uint32_t showbits_hcr(bits_t *ld, uint8_t bits)
 395 {
 396     if (bits == 0) return 0;
 397     if (ld->len <= 32)
 398     {
 399         /* huffman_spectral_data_2 needs to read more than may be available, bits maybe
 400            > ld->len, deliver 0 than */
 401         if (ld->len >= bits)
 402             return ((ld->bufa >> (ld->len - bits)) & (0xFFFFFFFF >> (32 - bits)));
 403         else
 404             return ((ld->bufa << (bits - ld->len)) & (0xFFFFFFFF >> (32 - bits)));
 405     } else {
 406         if ((ld->len - bits) < 32)
 407         {
 408             return ( (ld->bufb & (0xFFFFFFFF >> (64 - ld->len))) << (bits - ld->len + 32)) |
 409                 (ld->bufa >> (ld->len - bits));
 410         } else {
 411             return ((ld->bufb >> (ld->len - bits - 32)) & (0xFFFFFFFF >> (32 - bits)));
 412         }
 413     }
 414 }
 415
 416 /* return 1 if position is outside of buffer, 0 otherwise */
 417 static INLINE int8_t flushbits_hcr( bits_t *ld, uint8_t bits)
 418 {
 419     ld->len -= bits;
 420
 421     if (ld->len <0)
 422     {
 423         ld->len = 0;
 424         return 1;
 425     } else {
 426         return 0;
 427     }
 428 }
 429
 430 static INLINE int8_t getbits_hcr(bits_t *ld, uint8_t n, uint32_t *result)
 431 {
 432     *result = showbits_hcr(ld, n);
 433     return flushbits_hcr(ld, n);
 434 }
 435
 436 static INLINE int8_t get1bit_hcr(bits_t *ld, uint8_t *result)
 437 {
 438     uint32_t res;
 439     int8_t ret;
 440
 441     ret = getbits_hcr(ld, 1, &res);
 442     *result = (int8_t)(res & 1);
 443     return ret;
 444 }
 445
 446 #endif
 447
 448
 449 #ifdef __cplusplus
 450 }
 451 #endif
 452 #endif