git.sesse.net Git - vlc/blob - contrib/src/a52/liba52-fixed.diff

   1 diff -ruN a52dec.orig/liba52.orig/a52_internal.h a52dec/liba52/a52_internal.h
   2 --- a52dec.orig/liba52/a52_internal.h   2002-07-28 03:52:06.000000000 +0200
   3 +++ a52dec/liba52/a52_internal.h        2008-07-23 14:03:02.000000000 +0200
   4 @@ -1,6 +1,6 @@
   5  /*
   6   * a52_internal.h
   7 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
   8 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
   9   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  10   *
  11   * This file is part of a52dec, a free ATSC A-52 stream decoder.
  12 @@ -37,24 +37,24 @@
  13      uint8_t halfrate;          /* halfrate factor */
  14      uint8_t acmod;             /* coded channels */
  15      uint8_t lfeon;             /* coded lfe channel */
  16 -    sample_t clev;             /* centre channel mix level */
  17 -    sample_t slev;             /* surround channels mix level */
  18 +    level_t clev;              /* centre channel mix level */
  19 +    level_t slev;              /* surround channels mix level */
  20
  21      int output;                        /* type of output */
  22 -    sample_t level;            /* output level */
  23 +    level_t level;             /* output level */
  24      sample_t bias;             /* output bias */
  25
  26      int dynrnge;               /* apply dynamic range */
  27 -    sample_t dynrng;           /* dynamic range */
  28 +    level_t dynrng;            /* dynamic range */
  29      void * dynrngdata;         /* dynamic range callback funtion and data */
  30 -    sample_t (* dynrngcall) (sample_t range, void * dynrngdata);
  31 +    level_t (* dynrngcall) (level_t range, void * dynrngdata);
  32
  33      uint8_t chincpl;           /* channel coupled */
  34      uint8_t phsflginu;         /* phase flags in use (stereo only) */
  35      uint8_t cplstrtmant;       /* coupling channel start mantissa */
  36      uint8_t cplendmant;                /* coupling channel end mantissa */
  37      uint32_t cplbndstrc;       /* coupling band structure */
  38 -    sample_t cplco[5][18];     /* coupling coordinates */
  39 +    level_t cplco[5][18];      /* coupling coordinates */
  40
  41      /* derived information */
  42      uint8_t cplstrtbnd;                /* coupling start band (for bit allocation) */
  43 @@ -107,14 +107,79 @@
  44                        int start, int end, int fastleak, int slowleak,
  45                        expbap_t * expbap);
  46
  47 -int a52_downmix_init (int input, int flags, sample_t * level,
  48 -                     sample_t clev, sample_t slev);
  49 -int a52_downmix_coeff (sample_t * coeff, int acmod, int output, sample_t level,
  50 -                      sample_t clev, sample_t slev);
  51 +int a52_downmix_init (int input, int flags, level_t * level,
  52 +                     level_t clev, level_t slev);
  53 +int a52_downmix_coeff (level_t * coeff, int acmod, int output, level_t level,
  54 +                      level_t clev, level_t slev);
  55  void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
  56 -                 sample_t clev, sample_t slev);
  57 +                 level_t clev, level_t slev);
  58  void a52_upmix (sample_t * samples, int acmod, int output);
  59
  60  void a52_imdct_init (uint32_t mm_accel);
  61  void a52_imdct_256 (sample_t * data, sample_t * delay, sample_t bias);
  62  void a52_imdct_512 (sample_t * data, sample_t * delay, sample_t bias);
  63 +
  64 +#define ROUND(x) ((int)((x) + ((x) > 0 ? 0.5 : -0.5)))
  65 +
  66 +#ifndef LIBA52_FIXED
  67 +
  68 +typedef sample_t quantizer_t;
  69 +#define SAMPLE(x) (x)
  70 +#define LEVEL(x) (x)
  71 +#define MUL(a,b) ((a) * (b))
  72 +#define MUL_L(a,b) ((a) * (b))
  73 +#define MUL_C(a,b) ((a) * (b))
  74 +#define DIV(a,b) ((a) / (b))
  75 +#define BIAS(x) ((x) + bias)
  76 +
  77 +#else /* LIBA52_FIXED */
  78 +
  79 +typedef int16_t quantizer_t;
  80 +#define SAMPLE(x) (sample_t)((x) * (1 << 30))
  81 +#define LEVEL(x) (level_t)((x) * (1 << 26))
  82 +
  83 +#if 0
  84 +#define MUL(a,b) ((int)(((int64_t)(a) * (b) + (1 << 29)) >> 30))
  85 +#define MUL_L(a,b) ((int)(((int64_t)(a) * (b) + (1 << 25)) >> 26))
  86 +#elif defined(CPU_COLDFIRE)
  87 +/* loses 1 bit of accuracy */
  88 +#define MUL(a, b) \
  89 +({ \
  90 +    int32_t t; \
  91 +    asm volatile ( \
  92 +        "mac.l %[A], %[B], %%acc0\n\t" \
  93 +        "movclr.l %%acc0, %[t]\n\t" \
  94 +        "asl.l #1, %[t]" \
  95 +        : [t] "=d" (t) \
  96 +        : [A] "r" ((a)), [B] "r" ((b))); \
  97 +    t; \
  98 +})
  99 +/* loses 5 bits of accuracy */
 100 +#define MUL_L(a, b) \
 101 +({ \
 102 +    int32_t t; \
 103 +    asm volatile ( \
 104 +        "mac.l %[A], %[B], %%acc0\n\t" \
 105 +        "movclr.l %%acc0, %[t]\n\t" \
 106 +        "asl.l #5, %[t]" \
 107 +        : [t] "=d" (t) \
 108 +        : [A] "r" ((a)), [B] "r" ((b))); \
 109 +    t; \
 110 +})
 111 +#elif 1
 112 +#define MUL(a,b) \
 113 +({ int32_t _ta=(a), _tb=(b), _tc; \
 114 +   _tc=(_ta & 0xffff)*(_tb >> 16)+(_ta >> 16)*(_tb & 0xffff); (int32_t)(((_tc >> 14))+ (((_ta >> 16)*(_tb >> 16)) << 2 )); })
 115 +#define MUL_L(a,b) \
 116 +({ int32_t _ta=(a), _tb=(b), _tc; \
 117 +   _tc=(_ta & 0xffff)*(_tb >> 16)+(_ta >> 16)*(_tb & 0xffff); (int32_t)((_tc >> 10) + (((_ta >> 16)*(_tb >> 16)) << 6)); })
 118 +#else
 119 +#define MUL(a,b) (((a) >> 15) * ((b) >> 15))
 120 +#define MUL_L(a,b) (((a) >> 13) * ((b) >> 13))
 121 +#endif
 122 +
 123 +#define MUL_C(a,b) MUL_L (a, LEVEL (b))
 124 +#define DIV(a,b) ((((int64_t)LEVEL (a)) << 26) / (b))
 125 +#define BIAS(x) ((x) + (bias*0))
 126 +
 127 +#endif
 128 diff -ruN a52dec.orig/liba52.orig/bit_allocate.c a52dec/liba52/bit_allocate.c
 129 --- a52dec.orig/liba52/bit_allocate.c   2002-02-19 07:20:20.000000000 +0100
 130 +++ a52dec/liba52/bit_allocate.c        2008-07-23 14:03:01.000000000 +0200
 131 @@ -1,6 +1,6 @@
 132  /*
 133   * bit_allocate.c
 134 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
 135 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
 136   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
 137   *
 138   * This file is part of a52dec, a free ATSC A-52 stream decoder.
 139 @@ -21,14 +21,14 @@
 140   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 141   */
 142
 143 -#include "config.h"
 144 +#include "config-a52.h"
 145
 146  #include <inttypes.h>
 147
 148  #include "a52.h"
 149  #include "a52_internal.h"
 150
 151 -static int hthtab[3][50] = {
 152 +static int hthtab[3][50] IDATA_ATTR = {
 153      {0x730, 0x730, 0x7c0, 0x800, 0x820, 0x840, 0x850, 0x850, 0x860, 0x860,
 154       0x860, 0x860, 0x860, 0x870, 0x870, 0x870, 0x880, 0x880, 0x890, 0x890,
 155       0x8a0, 0x8a0, 0x8b0, 0x8b0, 0x8c0, 0x8c0, 0x8d0, 0x8e0, 0x8f0, 0x900,
 156 @@ -46,7 +46,7 @@
 157       0x8d0, 0x8b0, 0x840, 0x7f0, 0x790, 0x760, 0x7a0, 0x7c0, 0x7b0, 0x720}
 158  };
 159
 160 -static int8_t baptab[305] = {
 161 +static int8_t baptab[305] IDATA_ATTR = {
 162      16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 163      16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 164      16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 165 @@ -71,11 +71,11 @@
 166       0,  0,  0,  0                                     /* 148 padding elems */
 167  };
 168
 169 -static int bndtab[30] = {21, 22,  23,  24,  25,  26,  27,  28,  31,  34,
 170 +static int bndtab[30] IDATA_ATTR = {21, 22,  23,  24,  25,  26,  27,  28,  31,  34,
 171                          37, 40,  43,  46,  49,  55,  61,  67,  73,  79,
 172                          85, 97, 109, 121, 133, 157, 181, 205, 229, 253};
 173
 174 -static int8_t latab[256] = {
 175 +static int8_t latab[256] IDATA_ATTR = {
 176      -64, -63, -62, -61, -60, -59, -58, -57, -56, -55, -54, -53,
 177      -52, -52, -51, -50, -49, -48, -47, -47, -46, -45, -44, -44,
 178      -43, -42, -41, -41, -40, -39, -38, -38, -37, -36, -36, -35,
 179 @@ -231,7 +231,7 @@
 180         int startband, endband;
 181
 182         startband = j;
 183 -       endband = ((bndtab-20)[i] < end) ? (bndtab-20)[i] : end;
 184 +       endband = (bndtab[i-20] < end) ? bndtab[i-20] : end;
 185         psd = 128 * exp[j++];
 186         while (j < endband) {
 187             int next, delta;
 188 diff -ruN a52dec.orig/liba52.orig/bitstream.c a52dec/liba52/bitstream.c
 189 --- a52dec.orig/liba52/bitstream.c      2002-07-28 03:52:06.000000000 +0200
 190 +++ a52dec/liba52/bitstream.c   2008-07-23 14:03:01.000000000 +0200
 191 @@ -1,6 +1,6 @@
 192  /*
 193   * bitstream.c
 194 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
 195 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
 196   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
 197   *
 198   * This file is part of a52dec, a free ATSC A-52 stream decoder.
 199 @@ -21,7 +21,7 @@
 200   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 201   */
 202
 203 -#include "config.h"
 204 +#include "config-a52.h"
 205
 206  #include <inttypes.h>
 207
 208 @@ -38,7 +38,9 @@
 209      align = (long)buf & 3;
 210      state->buffer_start = (uint32_t *) (buf - align);
 211      state->bits_left = 0;
 212 +    state->current_word = 0;
 213      bitstream_get (state, align * 8);
 214 +    bitstream_get_2 (state, 0);        /* pretend function is used - keep gcc happy */
 215  }
 216
 217  static inline void bitstream_fill_current (a52_state_t * state)
 218 diff -ruN a52dec.orig/liba52.orig/bitstream.h a52dec/liba52/bitstream.h
 219 --- a52dec.orig/liba52/bitstream.h      2002-07-28 03:52:07.000000000 +0200
 220 +++ a52dec/liba52/bitstream.h   2008-07-23 14:03:02.000000000 +0200
 221 @@ -1,6 +1,6 @@
 222  /*
 223   * bitstream.h
 224 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
 225 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
 226   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
 227   *
 228   * This file is part of a52dec, a free ATSC A-52 stream decoder.
 229 @@ -21,29 +21,29 @@
 230   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 231   */
 232
 233 -/* (stolen from the kernel) */
 234 +//#define swab32(x) (betoh32(x))
 235  #ifdef WORDS_BIGENDIAN
 236
 237 -#      define swab32(x) (x)
 238 +#   define swab32(x) (x)
 239
 240  #else
 241
 242 -#      if 0 && defined (__i386__)
 243 +#   if defined (__i386__)
 244
 245 -#      define swab32(x) __i386_swab32(x)
 246 -       static inline const uint32_t __i386_swab32(uint32_t x)
 247 -       {
 248 -               __asm__("bswap %0" : "=r" (x) : "0" (x));
 249 -               return x;
 250 -       }
 251 +#   define swab32(x) __i386_swab32(x)
 252 +    static inline const uint32_t __i386_swab32(uint32_t x)
 253 +    {
 254 +        __asm__("bswap %0" : "=r" (x) : "0" (x));
 255 +        return x;
 256 +    }
 257
 258 -#      else
 259 +#   else
 260
 261 -#      define swab32(x)\
 262 +#   define swab32(x)\
 263  ((((uint8_t*)&x)[0] << 24) | (((uint8_t*)&x)[1] << 16) |  \
 264   (((uint8_t*)&x)[2] << 8)  | (((uint8_t*)&x)[3]))
 265
 266 -#      endif
 267 +#   endif
 268  #endif
 269
 270  void a52_bitstream_set_ptr (a52_state_t * state, uint8_t * buf);
 271 diff -ruN a52dec.orig/liba52.orig/config-a52.h a52dec/liba52/config-a52.h
 272 --- a52dec.orig/liba52/config-a52.h     1970-01-01 01:00:00.000000000 +0100
 273 +++ a52dec/liba52/config-a52.h  2008-07-23 14:03:01.000000000 +0200
 274 @@ -0,0 +1,26 @@
 275 +#define IDATA_ATTR
 276 +#define IBSS_ATTR
 277 +/* a52dec profiling */
 278 +/* #undef A52DEC_GPROF */
 279 +
 280 +/* Define to 1 if you have the `memalign' function. */
 281 +/* #undef HAVE_MEMALIGN 1 */
 282 +
 283 +/* liba52 djbfft support */
 284 +/* #undef LIBA52_DJBFFT */
 285 +
 286 +/* a52 sample precision */
 287 +/* #undef LIBA52_DOUBLE */
 288 +
 289 +/* use fixed-point arithmetic */
 290 +#define LIBA52_FIXED
 291 +
 292 +/* Define to 1 if your processor stores words with the most significant byte
 293 +   first (like Motorola and SPARC, unlike Intel and VAX). */
 294 +
 295 +/* Used in bitstream.h */
 296 +
 297 +#ifdef ROCKBOX_BIG_ENDIAN
 298 +#define WORDS_BIGENDIAN 1
 299 +#endif
 300 +
 301 diff -ruN a52dec.orig/liba52.orig/downmix.c a52dec/liba52/downmix.c
 302 --- a52dec.orig/liba52/downmix.c        2002-01-28 06:37:54.000000000 +0100
 303 +++ a52dec/liba52/downmix.c     2008-07-23 14:03:02.000000000 +0200
 304 @@ -1,6 +1,6 @@
 305  /*
 306   * downmix.c
 307 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
 308 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
 309   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
 310   *
 311   * This file is part of a52dec, a free ATSC A-52 stream decoder.
 312 @@ -21,7 +21,7 @@
 313   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 314   */
 315
 316 -#include "config.h"
 317 +#include "config-a52.h"
 318
 319  #include <string.h>
 320  #include <inttypes.h>
 321 @@ -31,8 +31,8 @@
 322
 323  #define CONVERT(acmod,output) (((output) << 3) + (acmod))
 324
 325 -int a52_downmix_init (int input, int flags, sample_t * level,
 326 -                     sample_t clev, sample_t slev)
 327 +int a52_downmix_init (int input, int flags, level_t * level,
 328 +                     level_t clev, level_t slev)
 329  {
 330      static uint8_t table[11][8] = {
 331         {A52_CHANNEL,   A52_DOLBY,      A52_STEREO,     A52_STEREO,
 332 @@ -66,94 +66,106 @@
 333
 334      output = table[output][input & 7];
 335
 336 -    if ((output == A52_STEREO) &&
 337 -       ((input == A52_DOLBY) || ((input == A52_3F) && (clev == LEVEL_3DB))))
 338 +    if (output == A52_STEREO &&
 339 +       (input == A52_DOLBY || (input == A52_3F && clev == LEVEL (LEVEL_3DB))))
 340         output = A52_DOLBY;
 341
 342 -    if (flags & A52_ADJUST_LEVEL)
 343 +    if (flags & A52_ADJUST_LEVEL) {
 344 +       level_t adjust;
 345 +
 346         switch (CONVERT (input & 7, output)) {
 347
 348         case CONVERT (A52_3F, A52_MONO):
 349 -           *level *= LEVEL_3DB / (1 + clev);
 350 +           adjust = DIV (LEVEL_3DB, LEVEL (1) + clev);
 351             break;
 352
 353         case CONVERT (A52_STEREO, A52_MONO):
 354         case CONVERT (A52_2F2R, A52_2F1R):
 355         case CONVERT (A52_3F2R, A52_3F1R):
 356         level_3db:
 357 -           *level *= LEVEL_3DB;
 358 +           adjust = LEVEL (LEVEL_3DB);
 359             break;
 360
 361         case CONVERT (A52_3F2R, A52_2F1R):
 362 -           if (clev < LEVEL_PLUS3DB - 1)
 363 +           if (clev < LEVEL (LEVEL_PLUS3DB - 1))
 364                 goto level_3db;
 365             /* break thru */
 366         case CONVERT (A52_3F, A52_STEREO):
 367         case CONVERT (A52_3F1R, A52_2F1R):
 368         case CONVERT (A52_3F1R, A52_2F2R):
 369         case CONVERT (A52_3F2R, A52_2F2R):
 370 -           *level /= 1 + clev;
 371 +           adjust = DIV (1, LEVEL (1) + clev);
 372             break;
 373
 374         case CONVERT (A52_2F1R, A52_MONO):
 375 -           *level *= LEVEL_PLUS3DB / (2 + slev);
 376 +           adjust = DIV (LEVEL_PLUS3DB, LEVEL (2) + slev);
 377             break;
 378
 379         case CONVERT (A52_2F1R, A52_STEREO):
 380         case CONVERT (A52_3F1R, A52_3F):
 381 -           *level /= 1 + slev * LEVEL_3DB;
 382 +           adjust = DIV (1, LEVEL (1) + MUL_C (slev, LEVEL_3DB));
 383             break;
 384
 385         case CONVERT (A52_3F1R, A52_MONO):
 386 -           *level *= LEVEL_3DB / (1 + clev + 0.5 * slev);
 387 +           adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + MUL_C (slev, 0.5));
 388             break;
 389
 390         case CONVERT (A52_3F1R, A52_STEREO):
 391 -           *level /= 1 + clev + slev * LEVEL_3DB;
 392 +           adjust = DIV (1, LEVEL (1) + clev + MUL_C (slev, LEVEL_3DB));
 393             break;
 394
 395         case CONVERT (A52_2F2R, A52_MONO):
 396 -           *level *= LEVEL_3DB / (1 + slev);
 397 +           adjust = DIV (LEVEL_3DB, LEVEL (1) + slev);
 398             break;
 399
 400         case CONVERT (A52_2F2R, A52_STEREO):
 401         case CONVERT (A52_3F2R, A52_3F):
 402 -           *level /= 1 + slev;
 403 +           adjust = DIV (1, LEVEL (1) + slev);
 404             break;
 405
 406         case CONVERT (A52_3F2R, A52_MONO):
 407 -           *level *= LEVEL_3DB / (1 + clev + slev);
 408 +           adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + slev);
 409             break;
 410
 411         case CONVERT (A52_3F2R, A52_STEREO):
 412 -           *level /= 1 + clev + slev;
 413 +           adjust = DIV (1, LEVEL (1) + clev + slev);
 414             break;
 415
 416         case CONVERT (A52_MONO, A52_DOLBY):
 417 -           *level *= LEVEL_PLUS3DB;
 418 +           adjust = LEVEL (LEVEL_PLUS3DB);
 419             break;
 420
 421         case CONVERT (A52_3F, A52_DOLBY):
 422         case CONVERT (A52_2F1R, A52_DOLBY):
 423 -           *level *= 1 / (1 + LEVEL_3DB);
 424 +           adjust = LEVEL (1 / (1 + LEVEL_3DB));
 425             break;
 426
 427         case CONVERT (A52_3F1R, A52_DOLBY):
 428         case CONVERT (A52_2F2R, A52_DOLBY):
 429 -           *level *= 1 / (1 + 2 * LEVEL_3DB);
 430 +           adjust = LEVEL (1 / (1 + 2 * LEVEL_3DB));
 431             break;
 432
 433         case CONVERT (A52_3F2R, A52_DOLBY):
 434 -           *level *= 1 / (1 + 3 * LEVEL_3DB);
 435 +           adjust = LEVEL (1 / (1 + 3 * LEVEL_3DB));
 436             break;
 437 +
 438 +       default:
 439 +           return output;
 440         }
 441
 442 +       *level = MUL_L (*level, adjust);
 443 +    }
 444 +
 445      return output;
 446  }
 447
 448 -int a52_downmix_coeff (sample_t * coeff, int acmod, int output, sample_t level,
 449 -                      sample_t clev, sample_t slev)
 450 +int a52_downmix_coeff (level_t * coeff, int acmod, int output, level_t level,
 451 +                      level_t clev, level_t slev)
 452  {
 453 +    level_t level_3db;
 454 +
 455 +    level_3db = MUL_C (level, LEVEL_3DB);
 456 +
 457      switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
 458
 459      case CONVERT (A52_CHANNEL, A52_CHANNEL):
 460 @@ -169,120 +181,138 @@
 461         return 0;
 462
 463      case CONVERT (A52_CHANNEL, A52_MONO):
 464 -       coeff[0] = coeff[1] = level * LEVEL_6DB;
 465 +       coeff[0] = coeff[1] = MUL_C (level, LEVEL_6DB);
 466         return 3;
 467
 468      case CONVERT (A52_STEREO, A52_MONO):
 469 -       coeff[0] = coeff[1] = level * LEVEL_3DB;
 470 +       coeff[0] = coeff[1] = level_3db;
 471         return 3;
 472
 473      case CONVERT (A52_3F, A52_MONO):
 474 -       coeff[0] = coeff[2] = level * LEVEL_3DB;
 475 -       coeff[1] = level * clev * LEVEL_PLUS3DB;
 476 +       coeff[0] = coeff[2] = level_3db;
 477 +       coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
 478         return 7;
 479
 480      case CONVERT (A52_2F1R, A52_MONO):
 481 -       coeff[0] = coeff[1] = level * LEVEL_3DB;
 482 -       coeff[2] = level * slev * LEVEL_3DB;
 483 +       coeff[0] = coeff[1] = level_3db;
 484 +       coeff[2] = MUL_L (level_3db, slev);
 485         return 7;
 486
 487      case CONVERT (A52_2F2R, A52_MONO):
 488 -       coeff[0] = coeff[1] = level * LEVEL_3DB;
 489 -       coeff[2] = coeff[3] = level * slev * LEVEL_3DB;
 490 +       coeff[0] = coeff[1] = level_3db;
 491 +       coeff[2] = coeff[3] = MUL_L (level_3db, slev);
 492         return 15;
 493
 494      case CONVERT (A52_3F1R, A52_MONO):
 495 -       coeff[0] = coeff[2] = level * LEVEL_3DB;
 496 -       coeff[1] = level * clev * LEVEL_PLUS3DB;
 497 -       coeff[3] = level * slev * LEVEL_3DB;
 498 +       coeff[0] = coeff[2] = level_3db;
 499 +       coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
 500 +       coeff[3] = MUL_L (level_3db, slev);
 501         return 15;
 502
 503      case CONVERT (A52_3F2R, A52_MONO):
 504 -       coeff[0] = coeff[2] = level * LEVEL_3DB;
 505 -       coeff[1] = level * clev * LEVEL_PLUS3DB;
 506 -       coeff[3] = coeff[4] = level * slev * LEVEL_3DB;
 507 +       coeff[0] = coeff[2] = level_3db;
 508 +       coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
 509 +       coeff[3] = coeff[4] = MUL_L (level_3db, slev);
 510         return 31;
 511
 512      case CONVERT (A52_MONO, A52_DOLBY):
 513 -       coeff[0] = level * LEVEL_3DB;
 514 +       coeff[0] = level_3db;
 515         return 0;
 516
 517      case CONVERT (A52_3F, A52_DOLBY):
 518 -       clev = LEVEL_3DB;
 519 +       coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
 520 +       coeff[1] = level_3db;
 521 +       return 7;
 522 +
 523      case CONVERT (A52_3F, A52_STEREO):
 524      case CONVERT (A52_3F1R, A52_2F1R):
 525      case CONVERT (A52_3F2R, A52_2F2R):
 526         coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
 527 -       coeff[1] = level * clev;
 528 +       coeff[1] = MUL_L (level, clev);
 529         return 7;
 530
 531      case CONVERT (A52_2F1R, A52_DOLBY):
 532 -       slev = 1;
 533 +       coeff[0] = coeff[1] = level;
 534 +       coeff[2] = level_3db;
 535 +       return 7;
 536 +
 537      case CONVERT (A52_2F1R, A52_STEREO):
 538         coeff[0] = coeff[1] = level;
 539 -       coeff[2] = level * slev * LEVEL_3DB;
 540 +       coeff[2] = MUL_L (level_3db, slev);
 541         return 7;
 542
 543      case CONVERT (A52_3F1R, A52_DOLBY):
 544 -       clev = LEVEL_3DB;
 545 -       slev = 1;
 546 +       coeff[0] = coeff[2] = level;
 547 +       coeff[1] = coeff[3] = level_3db;
 548 +       return 15;
 549 +
 550      case CONVERT (A52_3F1R, A52_STEREO):
 551         coeff[0] = coeff[2] = level;
 552 -       coeff[1] = level * clev;
 553 -       coeff[3] = level * slev * LEVEL_3DB;
 554 +       coeff[1] = MUL_L (level, clev);
 555 +       coeff[3] = MUL_L (level_3db, slev);
 556         return 15;
 557
 558      case CONVERT (A52_2F2R, A52_DOLBY):
 559 -       slev = LEVEL_3DB;
 560 +       coeff[0] = coeff[1] = level;
 561 +       coeff[2] = coeff[3] = level_3db;
 562 +       return 15;
 563 +
 564      case CONVERT (A52_2F2R, A52_STEREO):
 565         coeff[0] = coeff[1] = level;
 566 -       coeff[2] = coeff[3] = level * slev;
 567 +       coeff[2] = coeff[3] = MUL_L (level, slev);
 568         return 15;
 569
 570      case CONVERT (A52_3F2R, A52_DOLBY):
 571 -       clev = LEVEL_3DB;
 572 +       coeff[0] = coeff[2] = level;
 573 +       coeff[1] = coeff[3] = coeff[4] = level_3db;
 574 +       return 31;
 575 +
 576      case CONVERT (A52_3F2R, A52_2F1R):
 577 -       slev = LEVEL_3DB;
 578 +       coeff[0] = coeff[2] = level;
 579 +       coeff[1] = MUL_L (level, clev);
 580 +       coeff[3] = coeff[4] = level_3db;
 581 +       return 31;
 582 +
 583      case CONVERT (A52_3F2R, A52_STEREO):
 584         coeff[0] = coeff[2] = level;
 585 -       coeff[1] = level * clev;
 586 -       coeff[3] = coeff[4] = level * slev;
 587 +       coeff[1] = MUL_L (level, clev);
 588 +       coeff[3] = coeff[4] = MUL_L (level, slev);
 589         return 31;
 590
 591      case CONVERT (A52_3F1R, A52_3F):
 592         coeff[0] = coeff[1] = coeff[2] = level;
 593 -       coeff[3] = level * slev * LEVEL_3DB;
 594 +       coeff[3] = MUL_L (level_3db, slev);
 595         return 13;
 596
 597      case CONVERT (A52_3F2R, A52_3F):
 598         coeff[0] = coeff[1] = coeff[2] = level;
 599 -       coeff[3] = coeff[4] = level * slev;
 600 +       coeff[3] = coeff[4] = MUL_L (level, slev);
 601         return 29;
 602
 603      case CONVERT (A52_2F2R, A52_2F1R):
 604         coeff[0] = coeff[1] = level;
 605 -       coeff[2] = coeff[3] = level * LEVEL_3DB;
 606 +       coeff[2] = coeff[3] = level_3db;
 607         return 12;
 608
 609      case CONVERT (A52_3F2R, A52_3F1R):
 610         coeff[0] = coeff[1] = coeff[2] = level;
 611 -       coeff[3] = coeff[4] = level * LEVEL_3DB;
 612 +       coeff[3] = coeff[4] = level_3db;
 613         return 24;
 614
 615      case CONVERT (A52_2F1R, A52_2F2R):
 616         coeff[0] = coeff[1] = level;
 617 -       coeff[2] = level * LEVEL_3DB;
 618 +       coeff[2] = level_3db;
 619         return 0;
 620
 621      case CONVERT (A52_3F1R, A52_2F2R):
 622         coeff[0] = coeff[2] = level;
 623 -       coeff[1] = level * clev;
 624 -       coeff[3] = level * LEVEL_3DB;
 625 +       coeff[1] = MUL_L (level, clev);
 626 +       coeff[3] = level_3db;
 627         return 7;
 628
 629      case CONVERT (A52_3F1R, A52_3F2R):
 630         coeff[0] = coeff[1] = coeff[2] = level;
 631 -       coeff[3] = level * LEVEL_3DB;
 632 +       coeff[3] = level_3db;
 633         return 0;
 634
 635      case CONVERT (A52_CHANNEL, A52_CHANNEL1):
 636 @@ -304,7 +334,7 @@
 637      int i;
 638
 639      for (i = 0; i < 256; i++)
 640 -       dest[i] += src[i] + bias;
 641 +       dest[i] += BIAS (src[i]);
 642  }
 643
 644  static void mix3to1 (sample_t * samples, sample_t bias)
 645 @@ -312,7 +342,7 @@
 646      int i;
 647
 648      for (i = 0; i < 256; i++)
 649 -       samples[i] += samples[i + 256] + samples[i + 512] + bias;
 650 +       samples[i] += BIAS (samples[i + 256] + samples[i + 512]);
 651  }
 652
 653  static void mix4to1 (sample_t * samples, sample_t bias)
 654 @@ -320,8 +350,8 @@
 655      int i;
 656
 657      for (i = 0; i < 256; i++)
 658 -       samples[i] += (samples[i + 256] + samples[i + 512] +
 659 -                      samples[i + 768] + bias);
 660 +       samples[i] += BIAS (samples[i + 256] + samples[i + 512] +
 661 +                           samples[i + 768]);
 662  }
 663
 664  static void mix5to1 (sample_t * samples, sample_t bias)
 665 @@ -329,8 +359,8 @@
 666      int i;
 667
 668      for (i = 0; i < 256; i++)
 669 -       samples[i] += (samples[i + 256] + samples[i + 512] +
 670 -                      samples[i + 768] + samples[i + 1024] + bias);
 671 +       samples[i] += BIAS (samples[i + 256] + samples[i + 512] +
 672 +                           samples[i + 768] + samples[i + 1024]);
 673  }
 674
 675  static void mix3to2 (sample_t * samples, sample_t bias)
 676 @@ -339,7 +369,7 @@
 677      sample_t common;
 678
 679      for (i = 0; i < 256; i++) {
 680 -       common = samples[i + 256] + bias;
 681 +       common = BIAS (samples[i + 256]);
 682         samples[i] += common;
 683         samples[i + 256] = samples[i + 512] + common;
 684      }
 685 @@ -351,7 +381,7 @@
 686      sample_t common;
 687
 688      for (i = 0; i < 256; i++) {
 689 -       common = right[i + 256] + bias;
 690 +       common = BIAS (right[i + 256]);
 691         left[i] += common;
 692         right[i] += common;
 693      }
 694 @@ -364,8 +394,8 @@
 695
 696      for (i = 0; i < 256; i++) {
 697         surround = samples[i + 512];
 698 -       samples[i] += bias - surround;
 699 -       samples[i + 256] += bias + surround;
 700 +       samples[i] += BIAS (-surround);
 701 +       samples[i + 256] += BIAS (surround);
 702      }
 703  }
 704
 705 @@ -375,7 +405,7 @@
 706      sample_t common;
 707
 708      for (i = 0; i < 256; i++) {
 709 -       common = samples[i + 256] + samples[i + 768] + bias;
 710 +       common = BIAS (samples[i + 256] + samples[i + 768]);
 711         samples[i] += common;
 712         samples[i + 256] = samples[i + 512] + common;
 713      }
 714 @@ -387,7 +417,7 @@
 715      sample_t common, surround;
 716
 717      for (i = 0; i < 256; i++) {
 718 -       common = samples[i + 256] + bias;
 719 +       common = BIAS (samples[i + 256]);
 720         surround = samples[i + 768];
 721         samples[i] += common - surround;
 722         samples[i + 256] = samples[i + 512] + common + surround;
 723 @@ -401,8 +431,8 @@
 724
 725      for (i = 0; i < 256; i++) {
 726         surround = samples[i + 512] + samples[i + 768];
 727 -       samples[i] += bias - surround;
 728 -       samples[i + 256] += bias + surround;
 729 +       samples[i] += BIAS (-surround);
 730 +       samples[i + 256] += BIAS (surround);
 731      }
 732  }
 733
 734 @@ -412,7 +442,7 @@
 735      sample_t common;
 736
 737      for (i = 0; i < 256; i++) {
 738 -       common = samples[i + 256] + bias;
 739 +       common = BIAS (samples[i + 256]);
 740         samples[i] += common + samples[i + 768];
 741         samples[i + 256] = common + samples[i + 512] + samples[i + 1024];
 742      }
 743 @@ -424,7 +454,7 @@
 744      sample_t common, surround;
 745
 746      for (i = 0; i < 256; i++) {
 747 -       common = samples[i + 256] + bias;
 748 +       common = BIAS (samples[i + 256]);
 749         surround = samples[i + 768] + samples[i + 1024];
 750         samples[i] += common - surround;
 751         samples[i + 256] = samples[i + 512] + common + surround;
 752 @@ -436,7 +466,7 @@
 753      int i;
 754
 755      for (i = 0; i < 256; i++)
 756 -       dest[i] = src[i] + src[i + 256] + bias;
 757 +       dest[i] = BIAS (src[i] + src[i + 256]);
 758  }
 759
 760  static void zero (sample_t * samples)
 761 @@ -448,8 +478,11 @@
 762  }
 763
 764  void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
 765 -                 sample_t clev, sample_t slev)
 766 +                 level_t clev, level_t slev)
 767  {
 768 +    /* avoid compiler warning */
 769 +    (void)clev;
 770 +
 771      switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
 772
 773      case CONVERT (A52_CHANNEL, A52_CHANNEL2):
 774 @@ -583,7 +616,7 @@
 775         break;
 776
 777      case CONVERT (A52_3F1R, A52_3F2R):
 778 -       memcpy (samples + 1027, samples + 768, 256 * sizeof (sample_t));
 779 +       memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
 780         break;
 781      }
 782  }
 783 diff -ruN a52dec.orig/liba52.orig/imdct.c a52dec/liba52/imdct.c
 784 --- a52dec.orig/liba52/imdct.c  2002-07-28 03:52:07.000000000 +0200
 785 +++ a52dec/liba52/imdct.c       2008-07-23 14:03:01.000000000 +0200
 786 @@ -1,6 +1,6 @@
 787  /*
 788   * imdct.c
 789 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
 790 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
 791   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
 792   *
 793   * The ifft algorithms in this file have been largely inspired by Dan
 794 @@ -24,12 +24,13 @@
 795   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 796   */
 797
 798 -#include "config.h"
 799 +#include "config-a52.h"
 800
 801  #include <math.h>
 802  #include <stdio.h>
 803  #ifdef LIBA52_DJBFFT
 804  #include <fftc4.h>
 805 +#include <fftc8.h>
 806  #endif
 807  #ifndef M_PI
 808  #define M_PI 3.1415926535897932384626433832795029
 809 @@ -57,25 +58,26 @@
 810  };
 811
 812  /* Root values for IFFT */
 813 -static sample_t roots16[3];
 814 -static sample_t roots32[7];
 815 -static sample_t roots64[15];
 816 -static sample_t roots128[31];
 817 +//static sample_t roots16[3];
 818 +//static sample_t roots32[7];
 819 +//static sample_t roots64[15];
 820 +//static sample_t roots128[31];
 821
 822  /* Twiddle factors for IMDCT */
 823 -static complex_t pre1[128];
 824 -static complex_t post1[64];
 825 -static complex_t pre2[64];
 826 -static complex_t post2[32];
 827 +//static complex_t pre1[128];
 828 +//static complex_t post1[64];
 829 +//static complex_t pre2[64];
 830 +//static complex_t post2[32];
 831
 832 -static sample_t a52_imdct_window[256];
 833 +//static sample_t a52_imdct_window[256];
 834 +#include "imdct_lookups.h"
 835
 836  static void (* ifft128) (complex_t * buf);
 837  static void (* ifft64) (complex_t * buf);
 838
 839  static inline void ifft2 (complex_t * buf)
 840  {
 841 -    double r, i;
 842 +    sample_t r, i;
 843
 844      r = buf[0].real;
 845      i = buf[0].imag;
 846 @@ -87,7 +89,7 @@
 847
 848  static inline void ifft4 (complex_t * buf)
 849  {
 850 -    double tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
 851 +    sample_t tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
 852
 853      tmp1 = buf[0].real + buf[1].real;
 854      tmp2 = buf[3].real + buf[2].real;
 855 @@ -108,25 +110,37 @@
 856      buf[3].imag = tmp6 - tmp8;
 857  }
 858
 859 +/* basic radix-2 ifft butterfly */
 860 +
 861 +#define BUTTERFLY_0(t0,t1,W0,W1,d0,d1) do {    \
 862 +    t0 = MUL (W1, d1) + MUL (W0, d0);          \
 863 +    t1 = MUL (W0, d1) - MUL (W1, d0);          \
 864 +} while (0)
 865 +
 866 +/* radix-2 ifft butterfly with bias */
 867 +
 868 +#define BUTTERFLY_B(t0,t1,W0,W1,d0,d1) do {    \
 869 +    t0 = BIAS (MUL (d1, W1) + MUL (d0, W0));   \
 870 +    t1 = BIAS (MUL (d1, W0) - MUL (d0, W1));   \
 871 +} while (0)
 872 +
 873  /* the basic split-radix ifft butterfly */
 874
 875 -#define BUTTERFLY(a0,a1,a2,a3,wr,wi) do {      \
 876 -    tmp5 = a2.real * wr + a2.imag * wi;                \
 877 -    tmp6 = a2.imag * wr - a2.real * wi;                \
 878 -    tmp7 = a3.real * wr - a3.imag * wi;                \
 879 -    tmp8 = a3.imag * wr + a3.real * wi;                \
 880 -    tmp1 = tmp5 + tmp7;                                \
 881 -    tmp2 = tmp6 + tmp8;                                \
 882 -    tmp3 = tmp6 - tmp8;                                \
 883 -    tmp4 = tmp7 - tmp5;                                \
 884 -    a2.real = a0.real - tmp1;                  \
 885 -    a2.imag = a0.imag - tmp2;                  \
 886 -    a3.real = a1.real - tmp3;                  \
 887 -    a3.imag = a1.imag - tmp4;                  \
 888 -    a0.real += tmp1;                           \
 889 -    a0.imag += tmp2;                           \
 890 -    a1.real += tmp3;                           \
 891 -    a1.imag += tmp4;                           \
 892 +#define BUTTERFLY(a0,a1,a2,a3,wr,wi) do {              \
 893 +    BUTTERFLY_0 (tmp5, tmp6, wr, wi, a2.real, a2.imag);        \
 894 +    BUTTERFLY_0 (tmp8, tmp7, wr, wi, a3.imag, a3.real);        \
 895 +    tmp1 = tmp5 + tmp7;                                        \
 896 +    tmp2 = tmp6 + tmp8;                                        \
 897 +    tmp3 = tmp6 - tmp8;                                        \
 898 +    tmp4 = tmp7 - tmp5;                                        \
 899 +    a2.real = a0.real - tmp1;                          \
 900 +    a2.imag = a0.imag - tmp2;                          \
 901 +    a3.real = a1.real - tmp3;                          \
 902 +    a3.imag = a1.imag - tmp4;                          \
 903 +    a0.real += tmp1;                                   \
 904 +    a0.imag += tmp2;                                   \
 905 +    a1.real += tmp3;                                   \
 906 +    a1.imag += tmp4;                                   \
 907  } while (0)
 908
 909  /* split-radix ifft butterfly, specialized for wr=1 wi=0 */
 910 @@ -149,10 +163,10 @@
 911  /* split-radix ifft butterfly, specialized for wr=wi */
 912
 913  #define BUTTERFLY_HALF(a0,a1,a2,a3,w) do {     \
 914 -    tmp5 = (a2.real + a2.imag) * w;            \
 915 -    tmp6 = (a2.imag - a2.real) * w;            \
 916 -    tmp7 = (a3.real - a3.imag) * w;            \
 917 -    tmp8 = (a3.imag + a3.real) * w;            \
 918 +    tmp5 = MUL (a2.real + a2.imag, w);         \
 919 +    tmp6 = MUL (a2.imag - a2.real, w);         \
 920 +    tmp7 = MUL (a3.real - a3.imag, w);         \
 921 +    tmp8 = MUL (a3.imag + a3.real, w);         \
 922      tmp1 = tmp5 + tmp7;                                \
 923      tmp2 = tmp6 + tmp8;                                \
 924      tmp3 = tmp6 - tmp8;                                \
 925 @@ -169,7 +183,7 @@
 926
 927  static inline void ifft8 (complex_t * buf)
 928  {
 929 -    double tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
 930 +    sample_t tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
 931
 932      ifft4 (buf);
 933      ifft2 (buf + 4);
 934 @@ -183,7 +197,7 @@
 935      complex_t * buf1;
 936      complex_t * buf2;
 937      complex_t * buf3;
 938 -    double tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
 939 +    sample_t tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
 940      int i;
 941
 942      buf++;
 943 @@ -196,7 +210,8 @@
 944      i = n - 1;
 945
 946      do {
 947 -       BUTTERFLY (buf[0], buf1[0], buf2[0], buf3[0], weight[n], weight[2*i]);
 948 +       BUTTERFLY (buf[0], buf1[0], buf2[0], buf3[0],
 949 +                  weight[0], weight[2*i-n]);
 950         buf++;
 951         buf1++;
 952         buf2++;
 953 @@ -210,7 +225,7 @@
 954      ifft8 (buf);
 955      ifft4 (buf + 8);
 956      ifft4 (buf + 12);
 957 -    ifft_pass (buf, roots16 - 4, 4);
 958 +    ifft_pass (buf, roots16, 4);
 959  }
 960
 961  static void ifft32 (complex_t * buf)
 962 @@ -218,7 +233,7 @@
 963      ifft16 (buf);
 964      ifft8 (buf + 16);
 965      ifft8 (buf + 24);
 966 -    ifft_pass (buf, roots32 - 8, 8);
 967 +    ifft_pass (buf, roots32, 8);
 968  }
 969
 970  static void ifft64_c (complex_t * buf)
 971 @@ -226,7 +241,7 @@
 972      ifft32 (buf);
 973      ifft16 (buf + 32);
 974      ifft16 (buf + 48);
 975 -    ifft_pass (buf, roots64 - 16, 16);
 976 +    ifft_pass (buf, roots64, 16);
 977  }
 978
 979  static void ifft128_c (complex_t * buf)
 980 @@ -234,11 +249,11 @@
 981      ifft32 (buf);
 982      ifft16 (buf + 32);
 983      ifft16 (buf + 48);
 984 -    ifft_pass (buf, roots64 - 16, 16);
 985 +    ifft_pass (buf, roots64, 16);
 986
 987      ifft32 (buf + 64);
 988      ifft32 (buf + 96);
 989 -    ifft_pass (buf, roots128 - 32, 32);
 990 +    ifft_pass (buf, roots128, 32);
 991  }
 992
 993  void a52_imdct_512 (sample_t * data, sample_t * delay, sample_t bias)
 994 @@ -252,9 +267,7 @@
 995         k = fftorder[i];
 996         t_r = pre1[i].real;
 997         t_i = pre1[i].imag;
 998 -
 999 -       buf[i].real = t_i * data[255-k] + t_r * data[k];
1000 -       buf[i].imag = t_r * data[255-k] - t_i * data[k];
1001 +       BUTTERFLY_0 (buf[i].real, buf[i].imag, t_r, t_i, data[k], data[255-k]);
1002      }
1003
1004      ifft128 (buf);
1005 @@ -265,27 +278,22 @@
1006         /* y[n] = z[n] * (xcos1[n] + j * xsin1[n]) ; */
1007         t_r = post1[i].real;
1008         t_i = post1[i].imag;
1009 -
1010 -       a_r = t_r * buf[i].real     + t_i * buf[i].imag;
1011 -       a_i = t_i * buf[i].real     - t_r * buf[i].imag;
1012 -       b_r = t_i * buf[127-i].real + t_r * buf[127-i].imag;
1013 -       b_i = t_r * buf[127-i].real - t_i * buf[127-i].imag;
1014 +       BUTTERFLY_0 (a_r, a_i, t_i, t_r, buf[i].imag, buf[i].real);
1015 +       BUTTERFLY_0 (b_r, b_i, t_r, t_i, buf[127-i].imag, buf[127-i].real);
1016
1017         w_1 = window[2*i];
1018         w_2 = window[255-2*i];
1019 -       data[2*i]     = delay[2*i] * w_2 - a_r * w_1 + bias;
1020 -       data[255-2*i] = delay[2*i] * w_1 + a_r * w_2 + bias;
1021 +       BUTTERFLY_B (data[255-2*i], data[2*i], w_2, w_1, a_r, delay[2*i]);
1022         delay[2*i] = a_i;
1023
1024         w_1 = window[2*i+1];
1025         w_2 = window[254-2*i];
1026 -       data[2*i+1]   = delay[2*i+1] * w_2 + b_r * w_1 + bias;
1027 -       data[254-2*i] = delay[2*i+1] * w_1 - b_r * w_2 + bias;
1028 +       BUTTERFLY_B (data[2*i+1], data[254-2*i], w_1, w_2, b_r, delay[2*i+1]);
1029         delay[2*i+1] = b_i;
1030      }
1031  }
1032
1033 -void a52_imdct_256(sample_t * data, sample_t * delay, sample_t bias)
1034 +void a52_imdct_256 (sample_t * data, sample_t * delay, sample_t bias)
1035  {
1036      int i, k;
1037      sample_t t_r, t_i, a_r, a_i, b_r, b_i, c_r, c_i, d_r, d_i, w_1, w_2;
1038 @@ -297,12 +305,8 @@
1039         k = fftorder[i];
1040         t_r = pre2[i].real;
1041         t_i = pre2[i].imag;
1042 -
1043 -       buf1[i].real = t_i * data[254-k] + t_r * data[k];
1044 -       buf1[i].imag = t_r * data[254-k] - t_i * data[k];
1045 -
1046 -       buf2[i].real = t_i * data[255-k] + t_r * data[k+1];
1047 -       buf2[i].imag = t_r * data[255-k] - t_i * data[k+1];
1048 +       BUTTERFLY_0 (buf1[i].real, buf1[i].imag, t_r, t_i, data[k], data[254-k]);
1049 +       BUTTERFLY_0 (buf2[i].real, buf2[i].imag, t_r, t_i, data[k+1], data[255-k]);
1050      }
1051
1052      ifft64 (buf1);
1053 @@ -314,43 +318,34 @@
1054         /* y1[n] = z1[n] * (xcos2[n] + j * xs in2[n]) ; */
1055         t_r = post2[i].real;
1056         t_i = post2[i].imag;
1057 -
1058 -       a_r = t_r * buf1[i].real    + t_i * buf1[i].imag;
1059 -       a_i = t_i * buf1[i].real    - t_r * buf1[i].imag;
1060 -       b_r = t_i * buf1[63-i].real + t_r * buf1[63-i].imag;
1061 -       b_i = t_r * buf1[63-i].real - t_i * buf1[63-i].imag;
1062 -
1063 -       c_r = t_r * buf2[i].real    + t_i * buf2[i].imag;
1064 -       c_i = t_i * buf2[i].real    - t_r * buf2[i].imag;
1065 -       d_r = t_i * buf2[63-i].real + t_r * buf2[63-i].imag;
1066 -       d_i = t_r * buf2[63-i].real - t_i * buf2[63-i].imag;
1067 +       BUTTERFLY_0 (a_r, a_i, t_i, t_r, buf1[i].imag, buf1[i].real);
1068 +       BUTTERFLY_0 (b_r, b_i, t_r, t_i, buf1[63-i].imag, buf1[63-i].real);
1069 +       BUTTERFLY_0 (c_r, c_i, t_i, t_r, buf2[i].imag, buf2[i].real);
1070 +       BUTTERFLY_0 (d_r, d_i, t_r, t_i, buf2[63-i].imag, buf2[63-i].real);
1071
1072         w_1 = window[2*i];
1073         w_2 = window[255-2*i];
1074 -       data[2*i]     = delay[2*i] * w_2 - a_r * w_1 + bias;
1075 -       data[255-2*i] = delay[2*i] * w_1 + a_r * w_2 + bias;
1076 +       BUTTERFLY_B (data[255-2*i], data[2*i], w_2, w_1, a_r, delay[2*i]);
1077         delay[2*i] = c_i;
1078
1079         w_1 = window[128+2*i];
1080         w_2 = window[127-2*i];
1081 -       data[128+2*i] = delay[127-2*i] * w_2 + a_i * w_1 + bias;
1082 -       data[127-2*i] = delay[127-2*i] * w_1 - a_i * w_2 + bias;
1083 +       BUTTERFLY_B (data[128+2*i], data[127-2*i], w_1, w_2, a_i, delay[127-2*i]);
1084         delay[127-2*i] = c_r;
1085
1086         w_1 = window[2*i+1];
1087         w_2 = window[254-2*i];
1088 -       data[2*i+1]   = delay[2*i+1] * w_2 - b_i * w_1 + bias;
1089 -       data[254-2*i] = delay[2*i+1] * w_1 + b_i * w_2 + bias;
1090 +       BUTTERFLY_B (data[254-2*i], data[2*i+1], w_2, w_1, b_i, delay[2*i+1]);
1091         delay[2*i+1] = d_r;
1092
1093         w_1 = window[129+2*i];
1094         w_2 = window[126-2*i];
1095 -       data[129+2*i] = delay[126-2*i] * w_2 + b_r * w_1 + bias;
1096 -       data[126-2*i] = delay[126-2*i] * w_1 - b_r * w_2 + bias;
1097 +       BUTTERFLY_B (data[129+2*i], data[126-2*i], w_1, w_2, b_r, delay[126-2*i]);
1098         delay[126-2*i] = d_i;
1099      }
1100  }
1101
1102 +/*
1103  static double besselI0 (double x)
1104  {
1105      double bessel = 1;
1106 @@ -361,71 +356,121 @@
1107      while (--i);
1108      return bessel;
1109  }
1110 +*/
1111
1112  void a52_imdct_init (uint32_t mm_accel)
1113  {
1114 -    int i, k;
1115 +  (void)mm_accel;
1116 +/*    int i, k;
1117      double sum;
1118 +    double local_imdct_window[256];*/
1119
1120      /* compute imdct window - kaiser-bessel derived window, alpha = 5.0 */
1121 -    sum = 0;
1122 +    /*    sum = 0;
1123      for (i = 0; i < 256; i++) {
1124         sum += besselI0 (i * (256 - i) * (5 * M_PI / 256) * (5 * M_PI / 256));
1125 -       a52_imdct_window[i] = sum;
1126 +       local_imdct_window[i] = sum;
1127      }
1128      sum++;
1129 -    for (i = 0; i < 256; i++)
1130 -       a52_imdct_window[i] = sqrt (a52_imdct_window[i] / sum);
1131 +    */
1132 +    /*    for (i = 0; i < 256; i++)
1133 +       a52_imdct_window[i] = SAMPLE (sqrt (local_imdct_window[i] / sum));
1134 +
1135 +    printf("static sample_t a52_imdct_window[256]={");
1136 +    for (i=0;i<256;i++) {
1137 +      if ((i % 16)==0) { printf("\n"); }
1138 +      printf("%d,",a52_imdct_window[i]);
1139 +    }
1140 +    printf("\n}\n");
1141 +    */
1142 +
1143 +    /*    for (i = 0; i < 3; i++)
1144 +       roots16[i] = SAMPLE (cos ((M_PI / 8) * (i + 1)));
1145
1146 -    for (i = 0; i < 3; i++)
1147 -       roots16[i] = cos ((M_PI / 8) * (i + 1));
1148 +    printf("static sample_t roots16[3]={%d,%d,%d};\n\n",roots16[0],roots16[1],roots16[2]);
1149
1150      for (i = 0; i < 7; i++)
1151 -       roots32[i] = cos ((M_PI / 16) * (i + 1));
1152 +       roots32[i] = SAMPLE (cos ((M_PI / 16) * (i + 1)));
1153 +
1154 +    printf("static sample_t roots32[7]={");
1155 +    for (i=0;i<7;i++) { printf("%d%s",roots32[i],(i < 6 ? "," : "")); }
1156 +    printf("};\n");
1157
1158      for (i = 0; i < 15; i++)
1159 -       roots64[i] = cos ((M_PI / 32) * (i + 1));
1160 +       roots64[i] = SAMPLE (cos ((M_PI / 32) * (i + 1)));
1161 +
1162 +    printf("static sample_t roots64[15]={");
1163 +    for (i=0;i<15;i++) { printf("%d%s",roots64[i],(i < 14 ? "," : "")); }
1164 +    printf("};\n");
1165
1166      for (i = 0; i < 31; i++)
1167 -       roots128[i] = cos ((M_PI / 64) * (i + 1));
1168 +       roots128[i] = SAMPLE (cos ((M_PI / 64) * (i + 1)));
1169
1170 +    printf("static sample_t roots128[31]={");
1171 +    for (i=0;i<31;i++) { printf("%d%s",roots128[i],(i < 30 ? "," : "")); }
1172 +    printf("};\n");
1173 +    */
1174 +    /*
1175      for (i = 0; i < 64; i++) {
1176         k = fftorder[i] / 2 + 64;
1177 -       pre1[i].real = cos ((M_PI / 256) * (k - 0.25));
1178 -       pre1[i].imag = sin ((M_PI / 256) * (k - 0.25));
1179 +       pre1[i].real = SAMPLE (cos ((M_PI / 256) * (k - 0.25)));
1180 +       pre1[i].imag = SAMPLE (sin ((M_PI / 256) * (k - 0.25)));
1181      }
1182
1183      for (i = 64; i < 128; i++) {
1184         k = fftorder[i] / 2 + 64;
1185 -       pre1[i].real = -cos ((M_PI / 256) * (k - 0.25));
1186 -       pre1[i].imag = -sin ((M_PI / 256) * (k - 0.25));
1187 +       pre1[i].real = SAMPLE (-cos ((M_PI / 256) * (k - 0.25)));
1188 +       pre1[i].imag = SAMPLE (-sin ((M_PI / 256) * (k - 0.25)));
1189      }
1190
1191 +    printf("static complex_t pre1[128]={");
1192 +    for (i=0;i<128;i++) { printf("{%d,%d}%s",pre1[i].real,pre1[i].imag,(i < 127 ? "," : "")); }
1193 +    printf("};\n");
1194 +    */
1195 +    /*
1196      for (i = 0; i < 64; i++) {
1197 -       post1[i].real = cos ((M_PI / 256) * (i + 0.5));
1198 -       post1[i].imag = sin ((M_PI / 256) * (i + 0.5));
1199 +       post1[i].real = SAMPLE (cos ((M_PI / 256) * (i + 0.5)));
1200 +       post1[i].imag = SAMPLE (sin ((M_PI / 256) * (i + 0.5)));
1201      }
1202
1203 +    printf("static complex_t post1[64]={");
1204 +    for (i=0;i<64;i++) { printf("{%d,%d}%s",post1[i].real,post1[i].imag,(i < 63 ? "," : "")); }
1205 +    printf("};\n");
1206 +    */
1207 +
1208 +    /*
1209      for (i = 0; i < 64; i++) {
1210         k = fftorder[i] / 4;
1211 -       pre2[i].real = cos ((M_PI / 128) * (k - 0.25));
1212 -       pre2[i].imag = sin ((M_PI / 128) * (k - 0.25));
1213 +       pre2[i].real = SAMPLE (cos ((M_PI / 128) * (k - 0.25)));
1214 +       pre2[i].imag = SAMPLE (sin ((M_PI / 128) * (k - 0.25)));
1215      }
1216
1217 +    printf("static complex_t pre2[64]={");
1218 +    for (i=0;i<64;i++) { printf("{%d,%d}%s",pre2[i].real,pre2[i].imag,(i < 63 ? "," : "")); }
1219 +    printf("};\n");
1220 +
1221      for (i = 0; i < 32; i++) {
1222 -       post2[i].real = cos ((M_PI / 128) * (i + 0.5));
1223 -       post2[i].imag = sin ((M_PI / 128) * (i + 0.5));
1224 +       post2[i].real = SAMPLE (cos ((M_PI / 128) * (i + 0.5)));
1225 +       post2[i].imag = SAMPLE (sin ((M_PI / 128) * (i + 0.5)));
1226      }
1227
1228 +    printf("static complex_t post2[32]={");
1229 +    for (i=0;i<32;i++) { printf("{%d,%d}%s",post2[i].real,post2[i].imag,(i < 31 ? "," : "")); }
1230 +    printf("};\n");
1231 +    */
1232 +
1233  #ifdef LIBA52_DJBFFT
1234      if (mm_accel & MM_ACCEL_DJBFFT) {
1235 -       fprintf (stderr, "Using djbfft for IMDCT transform\n");
1236 +#ifndef LIBA52_DOUBLE
1237         ifft128 = (void (*) (complex_t *)) fftc4_un128;
1238         ifft64 = (void (*) (complex_t *)) fftc4_un64;
1239 +#else
1240 +       ifft128 = (void (*) (complex_t *)) fftc8_un128;
1241 +       ifft64 = (void (*) (complex_t *)) fftc8_un64;
1242 +#endif
1243      } else
1244  #endif
1245      {
1246 -       fprintf (stderr, "No accelerated IMDCT transform found\n");
1247         ifft128 = ifft128_c;
1248         ifft64 = ifft64_c;
1249      }
1250 diff -ruN a52dec.orig/liba52.orig/imdct_lookups.h a52dec/liba52/imdct_lookups.h
1251 --- a52dec.orig/liba52/imdct_lookups.h  1970-01-01 01:00:00.000000000 +0100
1252 +++ a52dec/liba52/imdct_lookups.h       2008-07-23 14:03:02.000000000 +0200
1253 @@ -0,0 +1,15 @@
1254 +static sample_t a52_imdct_window[256]IDATA_ATTR={
1255 +                                      146020,261886,393529,545197,719447,918478,1144416,1399394,1685589,2005234,2360623,2754115,3188134,3665170,4187773,4758556, 5380193,6055411,6786995,7577779,8430645,9348521,10334375,11391212,12522071,13730020,15018150,16389576,17847424,19394833,21034947,22770912, 24605865,26542938,28585242,30735872,32997891,35374332,37868188,40482408,43219889,46083473,49075937,52199993,55458273,58853331,62387636,66063559, 69883377,73849259,77963266,82227341,86643307,91212859,95937560,100818835,105857968,111056092,116414194,121933098,127613474,133455822,139460477,145627601, 151957182,158449029,165102772,171917855,178893540,186028900,193322822,200774000,208380940,216141958,224055176,232118527,240329753,248686407,257185854,265825270, 274601649,283511802,292552357,301719768,311010314,320420105,329945084,339581031,349323572,359168178,369110174,379144743,389266934,399471665,409753732,420107815, 430528483,441010205,451547355,462134219,472765003,483433845,494134818,504861939,515609181,526370480,537139740,547910849,558677680,569434108,580174011,590891284, 601579849,612233658,622846709,633413050,643926788,654382103,664773249,675094567,685340494,695505569,705584441,715571877,725462772,735252152,744935184,754507184, 763963620,773300119,782512477,791596659,800548807,809365245,818042484,826577226,834966364,843206992,851296404,859232096,867011771,874633340,882094922,889394844, 896531647,903504079,910311101,916951881,923425798,929732436,935871584,941843233,947647575,953284997,958756080,964061593,969202490,974179906,978995149,983649698, 988145195,992483442,996666390,1000696136,1004574919,1008305104,1011889185,1015329772,1018629583,1021791439,1024818257,1027713038,1030478862,1033118881,1035636308,1038034411, 1040316504,1042485942,1044546109,1046500412,1048352275,1050105129,1051762405,1053327531,1054803917,1056194958,1057504020,1058734435,1059889501,1060972468,1061986539,1062934861, 1063820523,1064646551,1065415903,1066131467,1066796055,1067412403,1067983168,1068510924,1068998160,1069447282,1069860607,1070240366,1070588702,1070907668,1071199230,1071465266, 1071707567,1071927836,1072127692,1072308670,1072472221,1072619716,1072752449,1072871635,1072978415,1073073858,1073158963,1073234663,1073301826,1073361257,1073413702,1073459852, 1073500344,1073535763,1073566646,1073593486,1073616731,1073636791,1073654036,1073668804,1073681398,1073692090,1073701126,1073708726,1073715084,1073720373,1073724748,1073728344, 1073731279,1073733657,1073735568,1073737090,1073738291,1073739229,1073739951,1073740500,1073740912,1073741214,1073741431,1073741582,1073741685,1073741751,1073741792,1073741814
1256 +};
1257 +
1258 +static sample_t roots16[3]IDATA_ATTR={992008094,759250124,410903206};
1259 +static sample_t roots32[7]IDATA_ATTR={1053110175,992008094,892783698,759250124,596538995,410903206,209476638};
1260 +static sample_t roots64[15]IDATA_ATTR={1068571463,1053110175,1027506861,992008094,946955747,892783698,830013654,759250124,681174602,596538995,506158392,410903206,311690798,209476638,105245103};
1261 +static sample_t roots128[31]IDATA_ATTR={1072448454,1068571463,1062120190,1053110175,1041563127,1027506861,1010975241,992008094,970651112,946955747,920979082,892783698,862437519,830013654,795590212,759250124,721080937,681174602,639627257,596538995,552013618,506158392,459083785,410903206,361732725,311690798,260897981,209476638,157550647,105245103,52686014};
1262 +
1263 +static complex_t pre1[128]IDATA_ATTR={{761575898,756917205},{3294193,1073736770},{413944710,990742792},{-407857834,993264059},{599275209,890949340},{-206244755,1053747885},{-593797166,894609652},{212706548,1052462554},{683717842,827919933},{-101966276,1068889322},{314841678,1026545772},{-503250790,948504162},{-678624950,832099562},{108522938,1068243547},{509061229,945398418},{-308536985,1028458279},{723518379,793374223},{-49395540,1072605046},{364832651,1009860703},{-456103709,972054993},{554836544,919281193},{-257701283,1042358649},{-636978326,864395809},{160808444,1061631832},{-718636707,797798713},{55975991,1072281769},{462059540,969238095},{-358629394,1012080264},{642270168,860471112},{-154291366,1062598550},{-549185496,922668301},{264092224,1040757801},{742770847,775379244},{-23057618,1073494224},{389505993,1000603111},{-432110916,982955574},{577229727,905387953},{-232042906,1048369016},{-615573145,879767700},{186813761,1057365652},{663193747,844449855},{-128167423,1066065014},{289554159,1033963197},{-526376678,935868098},{-698841306,815194659},{82274244,1070585098},{485706670,957606670},{-333683689,1020576650},{-737999227,779922204},{29644020,1073332537},{438134083,980285687},{-383359075,1002974238},{620959710,875974053},{-180322371,1058492015},{-571663505,908912724},{238471209,1046925492},{703830091,810891303},{-75703709,1071069770},{339939548,1018509994},{-479821763,960568883},{-657999815,848503239},{134706262,1065258526},{532109148,932620694},{-283204430,1035720404},{-752230014,-766205918},{9882456,-1073696345},{-401755603,-995747929},{420016001,-988184225},{-588296766,-898236282},{219160333,-1051137599},{604730690,-887255485},{-199775197,-1054993542},{-673506508,-836247862},{115075515,-1067557553},{-302220675,-1030332066},{514852501,-942257080},{688784992,-823709134},{-95405775,-1069494853},{-497421404,-951574195},{321134518,-1024594615},{-713727978,-802193167},{62554335,-1071918121},{-352412636,-1014261720},{467997975,-966384705},{-543513771,-926020671},{270473222,-1039117770},{647537829,-856514018},{-147768480,-1063525261},{728372812,-788919863},{-42813229,-1072887940},{-450130706,-974835294},{371022172,-1007603122},{-631662502,-868287963},{167319467,-1060625145},{560466703,-915859475},{-251300639,-1043920252},{747514502,-770807091},{-16470347,-1073615495},{-426071479,-985588453},{395638246,-998194311},{-610163404,-883528225},{193298118,-1056199480},{582774217,-901829094},{-225605866,-1049773069},{-693826210,-819467323},{88841682,-1070060119},{-327415267,-1022604883},{491573291,-954608403},{668362709,-840364678},{-121623758,-1066831367},{-520624390,-939080267},{295892987,-1032167062},{-733199822,-784435800},{36229307,-1073130440},{-377197724,-1005307605},{444140755,-977578893},{-566075760,-912403275},{244890534,-1045442552},{626322896,-872147426},{-173824191,-1059578527},{708792377,-806557418},{-69130323,-1071514117},{-473918791,-963494932},{346182609,-1016404991},{-652781111,-852524677},{141240030,-1064411930},{537821584,-929338177},{-276844037,-1037438616}};
1264 +
1265 +static complex_t post1[64]IDATA_ATTR={{1073721611,6588355},{1073559912,19764075},{1073236539,32936819},{1072751541,46104602},{1072104991,59265442},{1071296985,72417357},{1070327646,85558366},{1069197119,98686490},{1067905576,111799753},{1066453209,124896178},{1064840239,137973795},{1063066908,151030634},{1061133483,164064728},{1059040255,177074114},{1056787539,190056834},{1054375675,203010932},{1051805026,215934457},{1049075979,228825463},{1046188946,241682009},{1043144359,254502159},{1039942680,267283981},{1036584388,280025551},{1033069991,292724951},{1029400017,305380267},{1025575020,317989594},{1021595574,330551034},{1017462280,343062693},{1013175760,355522688},{1008736660,367929143},{1004145647,380280189},{999403414,392573967},{994510674,404808624},{989468165,416982318},{984276645,429093217},{978936897,441139495},{973449725,453119340},{967815955,465030947},{962036435,476872521},{956112036,488642280},{950043650,500338452},{943832191,511959274},{937478594,523502998},{930983817,534967883},{924348836,546352205},{917574653,557654248},{910662286,568872310},{903612776,580004702},{896427186,591049747},{889106597,602005783},{881652112,612871159},{874064853,623644238},{866345963,634323399},{858496605,644907034},{850517961,655393547},{842411231,665781361},{834177638,676068911},{825818420,686254647},{817334837,696337035},{808728167,706314558},{799999705,716185713},{791150766,725949012},{782182683,735602987},{773096806,745146182},{763894503,754577161}};
1266 +
1267 +static complex_t pre2[64]IDATA_ATTR={{1073721611,-6588355},{763894503,754577161},{994510674,404808624},{416982318,989468165},{1054375675,203010932},{602005783,889106597},{215934457,1051805026},{896427186,591049747},{1069197119,98686490},{686254647,825818420},{950043650,500338452},{317989594,1025575020},{111799753,1067905576},{834177638,676068911},{1029400017,305380267},{511959274,943832191},{1072751541,46104602},{725949012,791150766},{973449725,453119340},{367929143,1008736660},{1043144359,254502159},{557654248,917574653},{164064728,1061133483},{866345963,634323399},{59265442,1072104991},{799999705,716185713},{1013175760,355522688},{465030947,967815955},{1063066908,151030634},{644907034,858496605},{267283981,1039942680},{924348836,546352205},{1073559912,19764075},{745146182,773096806},{984276645,429093217},{392573967,999403414},{1049075979,228825463},{580004702,903612776},{190056834,1056787539},{881652112,612871159},{1066453209,124896178},{665781361,842411231},{937478594,523502998},{292724951,1033069991},{85558366,1070327646},{817334837,696337035},{1021595574,330551034},{488642280,956112036},{32936819,1073236539},{782182683,735602987},{1004145647,380280189},{441139495,978936897},{1059040255,177074114},{623644238,874064853},{241682009,1046188946},{910662286,568872310},{1071296985,72417357},{706314558,808728167},{962036435,476872521},{343062693,1017462280},{137973795,1064840239},{850517961,655393547},{1036584388,280025551},{534967883,930983817}};
1268 +static complex_t post2[32]IDATA_ATTR={{1073660973,13176463},{1073014239,39521454},{1071721163,65842639},{1069782521,92124162},{1067199482,118350193},{1063973603,144504935},{1060106825,170572632},{1055601479,196537583},{1050460278,222384146},{1044686318,248096754},{1038283079,273659918},{1031254417,299058239},{1023604566,324276418},{1015338134,349299266},{1006460100,374111709},{996975812,398698801},{986890983,423045731},{976211688,447137835},{964944359,470960600},{953095785,494499675},{940673100,517740882},{927683790,540670222},{914135677,563273882},{900036924,585538247},{885396022,607449906},{870221790,628995659},{854523369,650162530},{838310215,670937766},{821592095,691308855},{804379078,711263525},{786681534,730789756},{768510121,749875787}};
1269 diff -ruN a52dec.orig/liba52.orig/parse.c a52dec/liba52/parse.c
1270 --- a52dec.orig/liba52/parse.c  2002-07-28 03:52:07.000000000 +0200
1271 +++ a52dec/liba52/parse.c       2008-07-23 14:03:02.000000000 +0200
1272 @@ -1,6 +1,6 @@
1273  /*
1274   * parse.c
1275 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
1276 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
1277   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
1278   *
1279   * This file is part of a52dec, a free ATSC A-52 stream decoder.
1280 @@ -21,9 +21,8 @@
1281   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
1282   */
1283
1284 -#include "config.h"
1285 +#include "config-a52.h"
1286
1287 -#include <stdlib.h>
1288  #include <string.h>
1289  #include <inttypes.h>
1290
1291 @@ -32,7 +31,7 @@
1292  #include "bitstream.h"
1293  #include "tables.h"
1294
1295 -#ifdef HAVE_MEMALIGN
1296 +#if defined(HAVE_MEMALIGN) && !defined(__cplusplus)
1297  /* some systems have memalign() but no declaration for it */
1298  void * memalign (size_t align, size_t size);
1299  #else
1300 @@ -41,13 +40,16 @@
1301  #endif
1302
1303  typedef struct {
1304 -    sample_t q1[2];
1305 -    sample_t q2[2];
1306 -    sample_t q4;
1307 +    quantizer_t q1[2];
1308 +    quantizer_t q2[2];
1309 +    quantizer_t q4;
1310      int q1_ptr;
1311      int q2_ptr;
1312      int q4_ptr;
1313 -} quantizer_t;
1314 +} quantizer_set_t;
1315 +
1316 +static a52_state_t istate IBSS_ATTR;
1317 +static sample_t isamples[256*12] IBSS_ATTR;
1318
1319  static uint8_t halfrate[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3};
1320
1321 @@ -56,16 +58,25 @@
1322      a52_state_t * state;
1323      int i;
1324
1325 -    state = malloc (sizeof (a52_state_t));
1326 +    #if defined(CPU_COLDFIRE)
1327 +    coldfire_set_macsr(EMAC_FRACTIONAL | EMAC_ROUND | EMAC_SATURATE);
1328 +    #endif
1329 +    /*
1330 +      this needs to come back if we ever want two decoder instances
1331 +      simultenously. NOTE, you also need to remove comments in a52_free.
1332 +    state = (a52_state_t *) malloc (sizeof (a52_state_t));
1333      if (state == NULL)
1334         return NULL;
1335
1336 -    state->samples = memalign (16, 256 * 12 * sizeof (sample_t));
1337 +    state->samples = (sample_t *) memalign (16, 256 * 12 * sizeof (sample_t));
1338      if (state->samples == NULL) {
1339         free (state);
1340         return NULL;
1341      }
1342
1343 +    */
1344 +    state = &istate;
1345 +    state->samples = isamples;
1346      for (i = 0; i < 256 * 12; i++)
1347         state->samples[i] = 0;
1348
1349 @@ -129,10 +140,12 @@
1350  }
1351
1352  int a52_frame (a52_state_t * state, uint8_t * buf, int * flags,
1353 -              sample_t * level, sample_t bias)
1354 +              level_t * level, sample_t bias)
1355  {
1356 -    static sample_t clev[4] = {LEVEL_3DB, LEVEL_45DB, LEVEL_6DB, LEVEL_45DB};
1357 -    static sample_t slev[4] = {LEVEL_3DB, LEVEL_6DB, 0, LEVEL_6DB};
1358 +    static level_t clev[4] = { LEVEL (LEVEL_3DB), LEVEL (LEVEL_45DB),
1359 +                              LEVEL (LEVEL_6DB), LEVEL (LEVEL_45DB) };
1360 +    static level_t slev[4] = { LEVEL (LEVEL_3DB), LEVEL (LEVEL_6DB),
1361 +                              0,                 LEVEL (LEVEL_6DB) };
1362      int chaninfo;
1363      int acmod;
1364
1365 @@ -146,6 +159,8 @@
1366      if ((acmod == 2) && (bitstream_get (state, 2) == 2))       /* dsurmod */
1367         acmod = A52_DOLBY;
1368
1369 +    state->clev = state->slev = 0;
1370 +
1371      if ((acmod & 1) && (acmod != 1))
1372         state->clev = clev[bitstream_get (state, 2)];   /* cmixlev */
1373
1374 @@ -162,7 +177,7 @@
1375         state->output |= A52_LFE;
1376      *flags = state->output;
1377      /* the 2* compensates for differences in imdct */
1378 -    state->dynrng = state->level = 2 * *level;
1379 +    state->dynrng = state->level = MUL_C (*level, 2);
1380      state->bias = bias;
1381      state->dynrnge = 1;
1382      state->dynrngcall = NULL;
1383 @@ -201,7 +216,7 @@
1384  }
1385
1386  void a52_dynrng (a52_state_t * state,
1387 -                sample_t (* call) (sample_t, void *), void * data)
1388 +                level_t (* call) (level_t, void *), void * data)
1389  {
1390      state->dynrnge = 0;
1391      if (call) {
1392 @@ -311,20 +326,38 @@
1393
1394      state->lfsr_state = (uint16_t) nstate;
1395
1396 -    return nstate;
1397 +    return (3 * nstate) >> 2;
1398  }
1399
1400 +#ifndef LIBA52_FIXED
1401 +#define COEFF(c,t,l,s,e) (c) = (t) * (s)[e]
1402 +#else
1403 +#define COEFF(c,_t,_l,s,e) do {                                        \
1404 +    quantizer_t t = (_t);                                      \
1405 +    level_t l = (_l);                                          \
1406 +    int shift = e - 5;                                         \
1407 +    sample_t tmp = t * (l >> 16) + ((t * (l & 0xffff)) >> 16); \
1408 +    if (shift >= 0)                                            \
1409 +       (c) = tmp >> shift;                                     \
1410 +    else                                                       \
1411 +       (c) = tmp << -shift;                                    \
1412 +} while (0)
1413 +#endif
1414 +
1415  static void coeff_get (a52_state_t * state, sample_t * coeff,
1416 -                      expbap_t * expbap, quantizer_t * quantizer,
1417 -                      sample_t level, int dither, int end)
1418 +                      expbap_t * expbap, quantizer_set_t * quant,
1419 +                      level_t level, int dither, int end)
1420  {
1421      int i;
1422      uint8_t * exp;
1423      int8_t * bap;
1424 +
1425 +#ifndef LIBA52_FIXED
1426      sample_t factor[25];
1427
1428      for (i = 0; i <= 24; i++)
1429         factor[i] = scale_factor[i] * level;
1430 +#endif
1431
1432      exp = expbap->exp;
1433      bap = expbap->bap;
1434 @@ -336,7 +369,7 @@
1435         switch (bapi) {
1436         case 0:
1437             if (dither) {
1438 -               coeff[i] = dither_gen (state) * LEVEL_3DB * factor[exp[i]];
1439 +               COEFF (coeff[i], dither_gen (state), level, factor, exp[i]);
1440                 continue;
1441             } else {
1442                 coeff[i] = 0;
1443 @@ -344,76 +377,80 @@
1444             }
1445
1446         case -1:
1447 -           if (quantizer->q1_ptr >= 0) {
1448 -               coeff[i] = quantizer->q1[quantizer->q1_ptr--] * factor[exp[i]];
1449 +           if (quant->q1_ptr >= 0) {
1450 +               COEFF (coeff[i], quant->q1[quant->q1_ptr--], level,
1451 +                      factor, exp[i]);
1452                 continue;
1453             } else {
1454                 int code;
1455
1456                 code = bitstream_get (state, 5);
1457
1458 -               quantizer->q1_ptr = 1;
1459 -               quantizer->q1[0] = q_1_2[code];
1460 -               quantizer->q1[1] = q_1_1[code];
1461 -               coeff[i] = q_1_0[code] * factor[exp[i]];
1462 +               quant->q1_ptr = 1;
1463 +               quant->q1[0] = q_1_2[code];
1464 +               quant->q1[1] = q_1_1[code];
1465 +               COEFF (coeff[i], q_1_0[code], level, factor, exp[i]);
1466                 continue;
1467             }
1468
1469         case -2:
1470 -           if (quantizer->q2_ptr >= 0) {
1471 -               coeff[i] = quantizer->q2[quantizer->q2_ptr--] * factor[exp[i]];
1472 +           if (quant->q2_ptr >= 0) {
1473 +               COEFF (coeff[i], quant->q2[quant->q2_ptr--], level,
1474 +                      factor, exp[i]);
1475                 continue;
1476             } else {
1477                 int code;
1478
1479                 code = bitstream_get (state, 7);
1480
1481 -               quantizer->q2_ptr = 1;
1482 -               quantizer->q2[0] = q_2_2[code];
1483 -               quantizer->q2[1] = q_2_1[code];
1484 -               coeff[i] = q_2_0[code] * factor[exp[i]];
1485 +               quant->q2_ptr = 1;
1486 +               quant->q2[0] = q_2_2[code];
1487 +               quant->q2[1] = q_2_1[code];
1488 +               COEFF (coeff[i], q_2_0[code], level, factor, exp[i]);
1489                 continue;
1490             }
1491
1492         case 3:
1493 -           coeff[i] = q_3[bitstream_get (state, 3)] * factor[exp[i]];
1494 +           COEFF (coeff[i], q_3[bitstream_get (state, 3)], level,
1495 +                  factor, exp[i]);
1496             continue;
1497
1498         case -3:
1499 -           if (quantizer->q4_ptr == 0) {
1500 -               quantizer->q4_ptr = -1;
1501 -               coeff[i] = quantizer->q4 * factor[exp[i]];
1502 +           if (quant->q4_ptr == 0) {
1503 +               quant->q4_ptr = -1;
1504 +               COEFF (coeff[i], quant->q4, level, factor, exp[i]);
1505                 continue;
1506             } else {
1507                 int code;
1508
1509                 code = bitstream_get (state, 7);
1510
1511 -               quantizer->q4_ptr = 0;
1512 -               quantizer->q4 = q_4_1[code];
1513 -               coeff[i] = q_4_0[code] * factor[exp[i]];
1514 +               quant->q4_ptr = 0;
1515 +               quant->q4 = q_4_1[code];
1516 +               COEFF (coeff[i], q_4_0[code], level, factor, exp[i]);
1517                 continue;
1518             }
1519
1520         case 4:
1521 -           coeff[i] = q_5[bitstream_get (state, 4)] * factor[exp[i]];
1522 +           COEFF (coeff[i], q_5[bitstream_get (state, 4)], level,
1523 +                  factor, exp[i]);
1524             continue;
1525
1526         default:
1527 -           coeff[i] = ((bitstream_get_2 (state, bapi) << (16 - bapi)) *
1528 -                         factor[exp[i]]);
1529 +           COEFF (coeff[i], bitstream_get_2 (state, bapi) << (16 - bapi),
1530 +                  level, factor, exp[i]);
1531         }
1532      }
1533  }
1534
1535  static void coeff_get_coupling (a52_state_t * state, int nfchans,
1536 -                               sample_t * coeff, sample_t (* samples)[256],
1537 -                               quantizer_t * quantizer, uint8_t dithflag[5])
1538 +                               level_t * coeff, sample_t (* samples)[256],
1539 +                               quantizer_set_t * quant, uint8_t dithflag[5])
1540  {
1541      int cplbndstrc, bnd, i, i_end, ch;
1542      uint8_t * exp;
1543      int8_t * bap;
1544 -    sample_t cplco[5];
1545 +    level_t cplco[5];
1546
1547      exp = state->cpl_expbap.exp;
1548      bap = state->cpl_expbap.bap;
1549 @@ -428,22 +465,26 @@
1550         }
1551         cplbndstrc >>= 1;
1552         for (ch = 0; ch < nfchans; ch++)
1553 -           cplco[ch] = state->cplco[ch][bnd] * coeff[ch];
1554 +           cplco[ch] = MUL_L (state->cplco[ch][bnd], coeff[ch]);
1555         bnd++;
1556
1557         while (i < i_end) {
1558 -           sample_t cplcoeff;
1559 +           quantizer_t cplcoeff;
1560             int bapi;
1561
1562             bapi = bap[i];
1563             switch (bapi) {
1564             case 0:
1565 -               cplcoeff = LEVEL_3DB * scale_factor[exp[i]];
1566                 for (ch = 0; ch < nfchans; ch++)
1567                     if ((state->chincpl >> ch) & 1) {
1568                         if (dithflag[ch])
1569 -                           samples[ch][i] = (cplcoeff * cplco[ch] *
1570 -                                             dither_gen (state));
1571 +#ifndef LIBA52_FIXED
1572 +                           samples[ch][i] = (scale_factor[exp[i]] *
1573 +                                             cplco[ch] * dither_gen (state));
1574 +#else
1575 +                           COEFF (samples[ch][i], dither_gen (state),
1576 +                                  cplco[ch], scale_factor, exp[i]);
1577 +#endif
1578                         else
1579                             samples[ch][i] = 0;
1580                     }
1581 @@ -451,33 +492,33 @@
1582                 continue;
1583
1584             case -1:
1585 -               if (quantizer->q1_ptr >= 0) {
1586 -                   cplcoeff = quantizer->q1[quantizer->q1_ptr--];
1587 +               if (quant->q1_ptr >= 0) {
1588 +                   cplcoeff = quant->q1[quant->q1_ptr--];
1589                     break;
1590                 } else {
1591                     int code;
1592
1593                     code = bitstream_get (state, 5);
1594
1595 -                   quantizer->q1_ptr = 1;
1596 -                   quantizer->q1[0] = q_1_2[code];
1597 -                   quantizer->q1[1] = q_1_1[code];
1598 +                   quant->q1_ptr = 1;
1599 +                   quant->q1[0] = q_1_2[code];
1600 +                   quant->q1[1] = q_1_1[code];
1601                     cplcoeff = q_1_0[code];
1602                     break;
1603                 }
1604
1605             case -2:
1606 -               if (quantizer->q2_ptr >= 0) {
1607 -                   cplcoeff = quantizer->q2[quantizer->q2_ptr--];
1608 +               if (quant->q2_ptr >= 0) {
1609 +                   cplcoeff = quant->q2[quant->q2_ptr--];
1610                     break;
1611                 } else {
1612                     int code;
1613
1614                     code = bitstream_get (state, 7);
1615
1616 -                   quantizer->q2_ptr = 1;
1617 -                   quantizer->q2[0] = q_2_2[code];
1618 -                   quantizer->q2[1] = q_2_1[code];
1619 +                   quant->q2_ptr = 1;
1620 +                   quant->q2[0] = q_2_2[code];
1621 +                   quant->q2[1] = q_2_1[code];
1622                     cplcoeff = q_2_0[code];
1623                     break;
1624                 }
1625 @@ -487,17 +528,17 @@
1626                 break;
1627
1628             case -3:
1629 -               if (quantizer->q4_ptr == 0) {
1630 -                   quantizer->q4_ptr = -1;
1631 -                   cplcoeff = quantizer->q4;
1632 +               if (quant->q4_ptr == 0) {
1633 +                   quant->q4_ptr = -1;
1634 +                   cplcoeff = quant->q4;
1635                     break;
1636                 } else {
1637                     int code;
1638
1639                     code = bitstream_get (state, 7);
1640
1641 -                   quantizer->q4_ptr = 0;
1642 -                   quantizer->q4 = q_4_1[code];
1643 +                   quant->q4_ptr = 0;
1644 +                   quant->q4 = q_4_1[code];
1645                     cplcoeff = q_4_0[code];
1646                     break;
1647                 }
1648 @@ -509,11 +550,17 @@
1649             default:
1650                 cplcoeff = bitstream_get_2 (state, bapi) << (16 - bapi);
1651             }
1652 -
1653 +#ifndef LIBA52_FIXED
1654             cplcoeff *= scale_factor[exp[i]];
1655 +#endif
1656             for (ch = 0; ch < nfchans; ch++)
1657 -               if ((state->chincpl >> ch) & 1)
1658 +              if ((state->chincpl >> ch) & 1)
1659 +#ifndef LIBA52_FIXED
1660                     samples[ch][i] = cplcoeff * cplco[ch];
1661 +#else
1662 +                   COEFF (samples[ch][i], cplcoeff, cplco[ch],
1663 +                          scale_factor, exp[i]);
1664 +#endif
1665             i++;
1666         }
1667      }
1668 @@ -526,9 +573,9 @@
1669      int i, nfchans, chaninfo;
1670      uint8_t cplexpstr, chexpstr[5], lfeexpstr, do_bit_alloc, done_cpl;
1671      uint8_t blksw[5], dithflag[5];
1672 -    sample_t coeff[5];
1673 +    level_t coeff[5];
1674      int chanbias;
1675 -    quantizer_t quantizer;
1676 +    quantizer_set_t quant;
1677      sample_t * samples;
1678
1679      nfchans = nfchans_tbl[state->acmod];
1680 @@ -546,13 +593,17 @@
1681
1682             dynrng = bitstream_get_2 (state, 8);
1683             if (state->dynrnge) {
1684 -               sample_t range;
1685 +               level_t range;
1686
1687 +#if !defined(LIBA52_FIXED)
1688                 range = ((((dynrng & 0x1f) | 0x20) << 13) *
1689                          scale_factor[3 - (dynrng >> 5)]);
1690 +#else
1691 +               range = ((dynrng & 0x1f) | 0x20) << (21 + (dynrng >> 5));
1692 +#endif
1693                 if (state->dynrngcall)
1694                     range = state->dynrngcall (range, state->dynrngdata);
1695 -               state->dynrng = state->level * range;
1696 +               state->dynrng = MUL_L (state->level, range);
1697             }
1698         }
1699      } while (chaninfo--);
1700 @@ -611,8 +662,13 @@
1701                             cplcomant <<= 14;
1702                         else
1703                             cplcomant = (cplcomant | 0x10) << 13;
1704 +#ifndef LIBA52_FIXED
1705                         state->cplco[i][j] =
1706                             cplcomant * scale_factor[cplcoexp + mstrcplco];
1707 +#else
1708 +                       state->cplco[i][j] = (cplcomant << 11) >> (cplcoexp + mstrcplco);
1709 +#endif
1710 +
1711                     }
1712                 }
1713         if ((state->acmod == 2) && state->phsflginu && cplcoe)
1714 @@ -691,11 +747,11 @@
1715      }
1716
1717      if (bitstream_get (state, 1)) {    /* baie */
1718 -       do_bit_alloc = -1;
1719 +       do_bit_alloc = 127;
1720         state->bai = bitstream_get (state, 11);
1721      }
1722      if (bitstream_get (state, 1)) {    /* snroffste */
1723 -       do_bit_alloc = -1;
1724 +       do_bit_alloc = 127;
1725         state->csnroffst = bitstream_get (state, 6);
1726         if (state->chincpl)     /* cplinu */
1727             state->cplba.bai = bitstream_get (state, 7);
1728 @@ -711,7 +767,7 @@
1729      }
1730
1731      if (bitstream_get (state, 1)) {    /* deltbaie */
1732 -       do_bit_alloc = -1;
1733 +       do_bit_alloc = 127;
1734         if (state->chincpl)     /* cplinu */
1735             state->cplba.deltbae = bitstream_get (state, 2);
1736         for (i = 0; i < nfchans; i++)
1737 @@ -765,20 +821,20 @@
1738      chanbias = a52_downmix_coeff (coeff, state->acmod, state->output,
1739                                   state->dynrng, state->clev, state->slev);
1740
1741 -    quantizer.q1_ptr = quantizer.q2_ptr = quantizer.q4_ptr = -1;
1742 +    quant.q1_ptr = quant.q2_ptr = quant.q4_ptr = -1;
1743      done_cpl = 0;
1744
1745      for (i = 0; i < nfchans; i++) {
1746         int j;
1747
1748 -       coeff_get (state, samples + 256 * i, state->fbw_expbap +i, &quantizer,
1749 +       coeff_get (state, samples + 256 * i, state->fbw_expbap +i, &quant,
1750                    coeff[i], dithflag[i], state->endmant[i]);
1751
1752         if ((state->chincpl >> i) & 1) {
1753             if (!done_cpl) {
1754                 done_cpl = 1;
1755                 coeff_get_coupling (state, nfchans, coeff,
1756 -                                   (sample_t (*)[256])samples, &quantizer,
1757 +                                   (sample_t (*)[256])samples, &quant,
1758                                     dithflag);
1759             }
1760             j = state->cplendmant;
1761 @@ -821,14 +877,14 @@
1762
1763      if (state->lfeon) {
1764         if (state->output & A52_LFE) {
1765 -           coeff_get (state, samples - 256, &state->lfe_expbap, &quantizer,
1766 +           coeff_get (state, samples - 256, &state->lfe_expbap, &quant,
1767                        state->dynrng, 0, 7);
1768             for (i = 7; i < 256; i++)
1769                 (samples-256)[i] = 0;
1770             a52_imdct_512 (samples - 256, samples + 1536 - 256, state->bias);
1771         } else {
1772             /* just skip the LFE coefficients */
1773 -           coeff_get (state, samples + 1280, &state->lfe_expbap, &quantizer,
1774 +           coeff_get (state, samples + 1280, &state->lfe_expbap, &quant,
1775                        0, 0, 7);
1776         }
1777      }
1778 @@ -896,6 +952,9 @@
1779
1780  void a52_free (a52_state_t * state)
1781  {
1782 +    (void)state;
1783 +    /*
1784      free (state->samples);
1785      free (state);
1786 +    */
1787  }
1788 diff -ruN a52dec.orig/liba52.orig/tables.h a52dec/liba52/tables.h
1789 --- a52dec.orig/liba52/tables.h 2002-03-05 09:10:43.000000000 +0100
1790 +++ a52dec/liba52/tables.h      2008-07-23 14:03:01.000000000 +0200
1791 @@ -1,6 +1,6 @@
1792  /*
1793   * tables.h
1794 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
1795 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
1796   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
1797   *
1798   * This file is part of a52dec, a free ATSC A-52 stream decoder.
1799 @@ -46,42 +46,44 @@
1800      25,25,25
1801  };
1802
1803 -#define Q0 ((-2 << 15) / 3.0)
1804 -#define Q1 (0)
1805 -#define Q2 ((2 << 15) / 3.0)
1806 -
1807 -static const sample_t q_1_0[32] = {
1808 -    Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,
1809 -    Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,
1810 -    Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,
1811 -    0,0,0,0,0
1812 -};
1813 -
1814 -static const sample_t q_1_1[32] = {
1815 -    Q0,Q0,Q0,Q1,Q1,Q1,Q2,Q2,Q2,
1816 -    Q0,Q0,Q0,Q1,Q1,Q1,Q2,Q2,Q2,
1817 -    Q0,Q0,Q0,Q1,Q1,Q1,Q2,Q2,Q2,
1818 -    0,0,0,0,0
1819 -};
1820 -
1821 -static const sample_t q_1_2[32] = {
1822 -    Q0,Q1,Q2,Q0,Q1,Q2,Q0,Q1,Q2,
1823 -    Q0,Q1,Q2,Q0,Q1,Q2,Q0,Q1,Q2,
1824 -    Q0,Q1,Q2,Q0,Q1,Q2,Q0,Q1,Q2,
1825 -    0,0,0,0,0
1826 +#define Q(x) ROUND (32768.0 * x)
1827 +
1828 +#define Q0 Q (-2/3)
1829 +#define Q1 Q (0)
1830 +#define Q2 Q (2/3)
1831 +
1832 +static const quantizer_t q_1_0[32] = {
1833 +    Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0,
1834 +    Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1,
1835 +    Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2,
1836 +    0,  0,  0,  0,  0
1837 +};
1838 +
1839 +static const quantizer_t q_1_1[32] = {
1840 +    Q0, Q0, Q0, Q1, Q1, Q1, Q2, Q2, Q2,
1841 +    Q0, Q0, Q0, Q1, Q1, Q1, Q2, Q2, Q2,
1842 +    Q0, Q0, Q0, Q1, Q1, Q1, Q2, Q2, Q2,
1843 +    0,  0,  0,  0,  0
1844 +};
1845 +
1846 +static const quantizer_t q_1_2[32] = {
1847 +    Q0, Q1, Q2, Q0, Q1, Q2, Q0, Q1, Q2,
1848 +    Q0, Q1, Q2, Q0, Q1, Q2, Q0, Q1, Q2,
1849 +    Q0, Q1, Q2, Q0, Q1, Q2, Q0, Q1, Q2,
1850 +    0,  0,  0,  0,  0
1851  };
1852
1853  #undef Q0
1854  #undef Q1
1855  #undef Q2
1856
1857 -#define Q0 ((-4 << 15) / 5.0)
1858 -#define Q1 ((-2 << 15) / 5.0)
1859 -#define Q2 (0)
1860 -#define Q3 ((2 << 15) / 5.0)
1861 -#define Q4 ((4 << 15) / 5.0)
1862 +#define Q0 Q (-4/5)
1863 +#define Q1 Q (-2/5)
1864 +#define Q2 Q (0)
1865 +#define Q3 Q (2/5)
1866 +#define Q4 Q (4/5)
1867
1868 -static const sample_t q_2_0[128] = {
1869 +static const quantizer_t q_2_0[128] = {
1870      Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,
1871      Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,
1872      Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,
1873 @@ -90,7 +92,7 @@
1874      0,0,0
1875  };
1876
1877 -static const sample_t q_2_1[128] = {
1878 +static const quantizer_t q_2_1[128] = {
1879      Q0,Q0,Q0,Q0,Q0,Q1,Q1,Q1,Q1,Q1,Q2,Q2,Q2,Q2,Q2,Q3,Q3,Q3,Q3,Q3,Q4,Q4,Q4,Q4,Q4,
1880      Q0,Q0,Q0,Q0,Q0,Q1,Q1,Q1,Q1,Q1,Q2,Q2,Q2,Q2,Q2,Q3,Q3,Q3,Q3,Q3,Q4,Q4,Q4,Q4,Q4,
1881      Q0,Q0,Q0,Q0,Q0,Q1,Q1,Q1,Q1,Q1,Q2,Q2,Q2,Q2,Q2,Q3,Q3,Q3,Q3,Q3,Q4,Q4,Q4,Q4,Q4,
1882 @@ -99,7 +101,7 @@
1883      0,0,0
1884  };
1885
1886 -static const sample_t q_2_2[128] = {
1887 +static const quantizer_t q_2_2[128] = {
1888      Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,
1889      Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,
1890      Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,
1891 @@ -114,24 +116,23 @@
1892  #undef Q3
1893  #undef Q4
1894
1895 -static const sample_t q_3[8] = {
1896 -    (-6 << 15)/7.0, (-4 << 15)/7.0, (-2 << 15)/7.0, 0,
1897 -    ( 2 << 15)/7.0, ( 4 << 15)/7.0, ( 6 << 15)/7.0, 0
1898 -};
1899 -
1900 -#define Q0 ((-10 << 15) / 11.0)
1901 -#define Q1 ((-8 << 15) / 11.0)
1902 -#define Q2 ((-6 << 15) / 11.0)
1903 -#define Q3 ((-4 << 15) / 11.0)
1904 -#define Q4 ((-2 << 15) / 11.0)
1905 -#define Q5 (0)
1906 -#define Q6 ((2 << 15) / 11.0)
1907 -#define Q7 ((4 << 15) / 11.0)
1908 -#define Q8 ((6 << 15) / 11.0)
1909 -#define Q9 ((8 << 15) / 11.0)
1910 -#define QA ((10 << 15) / 11.0)
1911 +static const quantizer_t q_3[8] = {
1912 +    Q (-6/7), Q (-4/7), Q (-2/7), Q (0), Q (2/7), Q (4/7), Q (6/7), 0
1913 +};
1914 +
1915 +#define Q0 Q (-10/11)
1916 +#define Q1 Q (-8/11)
1917 +#define Q2 Q (-6/11)
1918 +#define Q3 Q (-4/11)
1919 +#define Q4 Q (-2/11)
1920 +#define Q5 Q (0)
1921 +#define Q6 Q (2/11)
1922 +#define Q7 Q (4/11)
1923 +#define Q8 Q (6/11)
1924 +#define Q9 Q (8/11)
1925 +#define QA Q (10/11)
1926
1927 -static const sample_t q_4_0[128] = {
1928 +static const quantizer_t q_4_0[128] = {
1929      Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0,
1930      Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1,
1931      Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2,
1932 @@ -146,7 +147,7 @@
1933      0,  0,  0,  0,  0,  0,  0
1934  };
1935
1936 -static const sample_t q_4_1[128] = {
1937 +static const quantizer_t q_4_1[128] = {
1938      Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
1939      Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
1940      Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
1941 @@ -173,15 +174,13 @@
1942  #undef Q9
1943  #undef QA
1944
1945 -static const sample_t q_5[16] = {
1946 -    (-14 << 15)/15.0,(-12 << 15)/15.0,(-10 << 15)/15.0,
1947 -    ( -8 << 15)/15.0,( -6 << 15)/15.0,( -4 << 15)/15.0,
1948 -    ( -2 << 15)/15.0,   0            ,(  2 << 15)/15.0,
1949 -    (  4 << 15)/15.0,(  6 << 15)/15.0,(  8 << 15)/15.0,
1950 -    ( 10 << 15)/15.0,( 12 << 15)/15.0,( 14 << 15)/15.0,
1951 -    0
1952 +static const quantizer_t q_5[16] = {
1953 +    Q (-14/15), Q (-12/15), Q (-10/15), Q (-8/15), Q (-6/15),
1954 +    Q (-4/15), Q (-2/15), Q (0), Q (2/15), Q (4/15),
1955 +    Q (6/15), Q (8/15), Q (10/15), Q (12/15), Q (14/15), 0
1956  };
1957
1958 +#ifndef LIBA52_FIXED
1959  static const sample_t scale_factor[25] = {
1960      0.000030517578125,
1961      0.0000152587890625,
1962 @@ -209,6 +208,7 @@
1963      0.00000000000363797880709171295166015625,
1964      0.000000000001818989403545856475830078125
1965  };
1966 +#endif
1967
1968  static const uint16_t dither_lut[256] = {
1969      0x0000, 0xa011, 0xe033, 0x4022, 0x6077, 0xc066, 0x8044, 0x2055,
1970 diff -ruN a52dec.orig/include.orig/a52.h a52dec/include/a52.h
1971 --- a52dec.orig/include/a52.h   2008-07-23 14:10:23.000000000 +0200
1972 +++ a52dec/include/a52.h        2008-07-23 14:10:36.000000000 +0200
1973 @@ -1,6 +1,6 @@
1974  /*
1975   * a52.h
1976 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
1977 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
1978   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
1979   *
1980   * This file is part of a52dec, a free ATSC A-52 stream decoder.
1981 @@ -24,10 +24,15 @@
1982  #ifndef A52_H
1983  #define A52_H
1984
1985 -#ifndef LIBA52_DOUBLE
1986 -typedef float sample_t;
1987 -#else
1988 +#if defined(LIBA52_FIXED)
1989 +typedef int32_t sample_t;
1990 +typedef int32_t level_t;
1991 +#elif defined(LIBA52_DOUBLE)
1992  typedef double sample_t;
1993 +typedef double level_t;
1994 +#else
1995 +typedef float sample_t;
1996 +typedef float level_t;
1997  #endif
1998
1999  typedef struct a52_state_s a52_state_t;
2000 @@ -53,9 +58,9 @@
2001  int a52_syncinfo (uint8_t * buf, int * flags,
2002                   int * sample_rate, int * bit_rate);
2003  int a52_frame (a52_state_t * state, uint8_t * buf, int * flags,
2004 -              sample_t * level, sample_t bias);
2005 +              level_t * level, sample_t bias);
2006  void a52_dynrng (a52_state_t * state,
2007 -                sample_t (* call) (sample_t, void *), void * data);
2008 +                level_t (* call) (level_t, void *), void * data);
2009  int a52_block (a52_state_t * state);
2010  void a52_free (a52_state_t * state);
2011
2012 diff -ruN a52dec.orig/include.orig/attributes.h a52dec/include/attributes.h
2013 --- a52dec.orig/include/attributes.h    2008-07-23 14:10:23.000000000 +0200
2014 +++ a52dec/include/attributes.h 2008-07-23 14:10:36.000000000 +0200
2015 @@ -1,6 +1,6 @@
2016  /*
2017   * attributes.h
2018 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
2019 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
2020   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
2021   *
2022   * This file is part of a52dec, a free ATSC A-52 stream decoder.
2023 @@ -27,3 +27,11 @@
2024  #else
2025  #define ATTR_ALIGN(align)
2026  #endif
2027 +
2028 +#ifdef HAVE_BUILTIN_EXPECT
2029 +#define likely(x) __builtin_expect ((x) != 0, 1)
2030 +#define unlikely(x) __builtin_expect ((x) != 0, 0)
2031 +#else
2032 +#define likely(x) (x)
2033 +#define unlikely(x) (x)
2034 +#endif
2035 diff -ruN a52dec.orig/include.orig/mm_accel.h a52dec/include/mm_accel.h
2036 --- a52dec.orig/include/mm_accel.h      2008-07-23 14:10:23.000000000 +0200
2037 +++ a52dec/include/mm_accel.h   2008-07-23 14:10:36.000000000 +0200
2038 @@ -1,6 +1,6 @@
2039  /*
2040   * mm_accel.h
2041 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
2042 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
2043   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
2044   *
2045   * This file is part of a52dec, a free ATSC A-52 stream decoder.
2046 diff -ruN a52dec.orig/include.orig/tendra.h a52dec/include/tendra.h
2047 --- a52dec.orig/include/tendra.h        2008-07-23 14:10:23.000000000 +0200
2048 +++ a52dec/include/tendra.h     2008-07-23 14:10:36.000000000 +0200
2049 @@ -1,6 +1,6 @@
2050  /*
2051   * tendra.h
2052 - * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
2053 + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
2054   * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
2055   *
2056   * This file is part of a52dec, a free ATSC A-52 stream decoder.