git.sesse.net Git - vlc/blob - src/ac3_decoder/ac3_mantissa.c

   1 /*****************************************************************************
   2  * ac3_mantissa.c: ac3 mantissa computation
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  *
   6  * Authors:
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  21  *****************************************************************************/
  22 #include "defs.h"
  23
  24 #include <stdio.h>                                           /* "intf_msg.h" */
  25
  26 #include "common.h"
  27
  28 #include "ac3_decoder.h"
  29 #include "ac3_internal.h"
  30 #include "ac3_bit_stream.h"
  31
  32 #include "intf_msg.h"
  33
  34 #define Q0 ((-2 << 15) / 3.0)
  35 #define Q1 (0)
  36 #define Q2 ((2 << 15) / 3.0)
  37 static float q_1_0[ 32 ] = { Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0,
  38                              Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1,
  39                              Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2,
  40                              0, 0, 0, 0, 0 };
  41 static float q_1_1[ 32 ] = { Q0, Q0, Q0, Q1, Q1, Q1, Q2, Q2, Q2,
  42                              Q0, Q0, Q0, Q1, Q1, Q1, Q2, Q2, Q2,
  43                              Q0, Q0, Q0, Q1, Q1, Q1, Q2, Q2, Q2,
  44                              0, 0, 0, 0, 0 };
  45 static float q_1_2[ 32 ] = { Q0, Q1, Q2, Q0, Q1, Q2, Q0, Q1, Q2,
  46                              Q0, Q1, Q2, Q0, Q1, Q2, Q0, Q1, Q2,
  47                              Q0, Q1, Q2, Q0, Q1, Q2, Q0, Q1, Q2,
  48                              0, 0, 0, 0, 0 };
  49 #undef Q0
  50 #undef Q1
  51 #undef Q2
  52
  53 #define Q0 ((-4 << 15) / 5.0)
  54 #define Q1 ((-2 << 15) / 5.0)
  55 #define Q2 (0)
  56 #define Q3 ((2 << 15) / 5.0)
  57 #define Q4 ((4 << 15) / 5.0)
  58 static float q_2_0[ 128 ] =
  59   { 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,
  60     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,
  61     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,
  62     Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,
  63     Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,
  64      0, 0, 0 };
  65 static float q_2_1[ 128 ] =
  66   { 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,
  67     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,
  68     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,
  69     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,
  70     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,
  71      0, 0, 0 };
  72 static float q_2_2[ 128 ] =
  73   { 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,
  74     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,
  75     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,
  76     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,
  77     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,
  78      0, 0, 0 };
  79 #undef Q0
  80 #undef Q1
  81 #undef Q2
  82 #undef Q3
  83 #undef Q4
  84
  85 #define Q0 ((-10 << 15) / 11.0)
  86 #define Q1 ((-8 << 15) / 11.0)
  87 #define Q2 ((-6 << 15) / 11.0)
  88 #define Q3 ((-4 << 15) / 11.0)
  89 #define Q4 ((-2 << 15) / 11.0)
  90 #define Q5 (0)
  91 #define Q6 ((2 << 15) / 11.0)
  92 #define Q7 ((4 << 15) / 11.0)
  93 #define Q8 ((6 << 15) / 11.0)
  94 #define Q9 ((8 << 15) / 11.0)
  95 #define QA ((10 << 15) / 11.0)
  96 static float q_4_0[ 128 ] = { Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0,
  97                               Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1,
  98                               Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2,
  99                               Q3, Q3, Q3, Q3, Q3, Q3, Q3, Q3, Q3, Q3, Q3,
 100                               Q4, Q4, Q4, Q4, Q4, Q4, Q4, Q4, Q4, Q4, Q4,
 101                               Q5, Q5, Q5, Q5, Q5, Q5, Q5, Q5, Q5, Q5, Q5,
 102                               Q6, Q6, Q6, Q6, Q6, Q6, Q6, Q6, Q6, Q6, Q6,
 103                               Q7, Q7, Q7, Q7, Q7, Q7, Q7, Q7, Q7, Q7, Q7,
 104                               Q8, Q8, Q8, Q8, Q8, Q8, Q8, Q8, Q8, Q8, Q8,
 105                               Q9, Q9, Q9, Q9, Q9, Q9, Q9, Q9, Q9, Q9, Q9,
 106                               QA, QA, QA, QA, QA, QA, QA, QA, QA, QA, QA,
 107                                0,  0,  0,  0,  0,  0,  0};
 108 static float q_4_1[ 128 ] = { Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 109                               Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 110                               Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 111                               Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 112                               Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 113                               Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 114                               Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 115                               Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 116                               Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 117                               Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 118                               Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
 119                                0,  0,  0,  0,  0,  0,  0};
 120 #undef Q0
 121 #undef Q1
 122 #undef Q2
 123 #undef Q3
 124 #undef Q4
 125 #undef Q5
 126 #undef Q6
 127 #undef Q7
 128 #undef Q8
 129 #undef Q9
 130 #undef QA
 131
 132 /* Lookup tables of 0.16 two's complement quantization values */
 133
 134 static float q_3[8] = { (-6 << 15)/7.0, (-4 << 15)/7.0, (-2 << 15)/7.0,
 135                           0           , (2 << 15)/7.0, (4 << 15)/7.0,
 136                         (6 << 15)/7.0, 0 };
 137
 138 static float q_5[16] = { (-14 << 15)/15.0, (-12 << 15)/15.0, (-10 << 15)/15.0,
 139                          (-8 << 15)/15.0, (-6 << 15)/15.0, (-4 << 15)/15.0,
 140                          (-2 << 15)/15.0,    0            ,  (2 << 15)/15.0,
 141                           (4 << 15)/15.0,  (6 << 15)/15.0,  (8 << 15)/15.0,
 142                          (10 << 15)/15.0, (12 << 15)/15.0, (14 << 15)/15.0,
 143                          0 };
 144
 145 /* These store the persistent state of the packed mantissas */
 146 static float q_1[2];
 147 static float q_2[2];
 148 static float q_4[1];
 149 static s32 q_1_pointer;
 150 static s32 q_2_pointer;
 151 static s32 q_4_pointer;
 152
 153 /* Conversion from bap to number of bits in the mantissas
 154  * zeros account for cases 0,1,2,4 which are special cased */
 155 static u16 qnttztab[16] = { 0, 0, 0, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16};
 156
 157 static float exp_lut[ 25 ] =
 158 {
 159     6.10351562500000000000000000e-05,
 160     3.05175781250000000000000000e-05,
 161     1.52587890625000000000000000e-05,
 162     7.62939453125000000000000000e-06,
 163     3.81469726562500000000000000e-06,
 164     1.90734863281250000000000000e-06,
 165     9.53674316406250000000000000e-07,
 166     4.76837158203125000000000000e-07,
 167     2.38418579101562500000000000e-07,
 168     1.19209289550781250000000000e-07,
 169     5.96046447753906250000000000e-08,
 170     2.98023223876953125000000000e-08,
 171     1.49011611938476562500000000e-08,
 172     7.45058059692382812500000000e-09,
 173     3.72529029846191406250000000e-09,
 174     1.86264514923095703125000000e-09,
 175     9.31322574615478515625000000e-10,
 176     4.65661287307739257812500000e-10,
 177     2.32830643653869628906250000e-10,
 178     1.16415321826934814453125000e-10,
 179     5.82076609134674072265625000e-11,
 180     2.91038304567337036132812500e-11,
 181     1.45519152283668518066406250e-11,
 182     7.27595761418342590332031250e-12,
 183     3.63797880709171295166015625e-12,
 184 };
 185
 186 /* Fetch an unpacked, left justified, and properly biased/dithered mantissa value */
 187 static __inline__ float float_get (ac3dec_t * p_ac3dec, u16 bap, u16 exp)
 188 {
 189     u32 group_code;
 190
 191     /* If the bap is 0-5 then we have special cases to take care of */
 192     switch (bap) {
 193     case 0:
 194         return (0);     /* FIXME dither */
 195
 196     case 1:
 197         if (q_1_pointer >= 0) {
 198             return (q_1[q_1_pointer--] * exp_lut[exp]);
 199         }
 200
 201         NeedBits (&(p_ac3dec->bit_stream), 5);
 202         group_code = p_ac3dec->bit_stream.buffer >> (32 - 5);
 203         DumpBits (&(p_ac3dec->bit_stream), 5);
 204         if (group_code >= 27) {
 205             intf_ErrMsg ( "ac3dec error: invalid mantissa" );
 206         }
 207
 208         q_1[ 1 ] = q_1_1[ group_code ];
 209         q_1[ 0 ] = q_1_2[ group_code ];
 210
 211         q_1_pointer = 1;
 212
 213         return (q_1_0[group_code] * exp_lut[exp]);
 214
 215     case 2:
 216         if (q_2_pointer >= 0) {
 217             return (q_2[q_2_pointer--] * exp_lut[exp]);
 218         }
 219         NeedBits (&(p_ac3dec->bit_stream), 7);
 220         group_code = p_ac3dec->bit_stream.buffer >> (32 - 7);
 221         DumpBits (&(p_ac3dec->bit_stream), 7);
 222
 223         if (group_code >= 125) {
 224             intf_ErrMsg ( "ac3dec error: invalid mantissa" );
 225         }
 226
 227         q_2[ 1 ] = q_2_1[ group_code ];
 228         q_2[ 0 ] = q_2_2[ group_code ];
 229
 230         q_2_pointer = 1;
 231
 232         return (q_2_0[ group_code ] * exp_lut[exp]);
 233
 234     case 3:
 235         NeedBits (&(p_ac3dec->bit_stream), 3);
 236         group_code = p_ac3dec->bit_stream.buffer >> (32 - 3);
 237         DumpBits (&(p_ac3dec->bit_stream), 3);
 238
 239         if (group_code >= 7) {
 240             intf_ErrMsg ( "ac3dec error: invalid mantissa" );
 241         }
 242
 243         return (q_3[group_code] * exp_lut[exp]);
 244
 245     case 4:
 246         if (q_4_pointer >= 0) {
 247             return (q_4[q_4_pointer--] * exp_lut[exp]);
 248         }
 249         NeedBits (&(p_ac3dec->bit_stream), 7);
 250         group_code = p_ac3dec->bit_stream.buffer >> (32 - 7);
 251         DumpBits (&(p_ac3dec->bit_stream), 7);
 252
 253         if (group_code >= 121) {
 254             intf_ErrMsg ( "ac3dec error: invalid mantissa" );
 255         }
 256
 257         q_4[ 0 ] = q_4_1[ group_code ];
 258
 259         q_4_pointer = 0;
 260
 261         return (q_4_0[ group_code ] * exp_lut[exp]);
 262
 263     case 5:
 264         NeedBits (&(p_ac3dec->bit_stream), 4);
 265         group_code = p_ac3dec->bit_stream.buffer >> (32 - 4);
 266         DumpBits (&(p_ac3dec->bit_stream), 4);
 267
 268         if (group_code >= 15) {
 269             intf_ErrMsg ( "ac3dec error: invalid mantissa" );
 270         }
 271
 272         return (q_5[group_code] * exp_lut[exp]);
 273
 274     default:
 275         NeedBits (&(p_ac3dec->bit_stream), qnttztab[bap]);
 276         group_code = (((s32)(p_ac3dec->bit_stream.buffer)) >> (32 - qnttztab[bap])) << (16 - qnttztab[bap]);
 277         DumpBits (&(p_ac3dec->bit_stream), qnttztab[bap]);
 278
 279         return (((s32)group_code) * exp_lut[exp]);
 280     }
 281 }
 282
 283 static __inline__ void uncouple_channel (ac3dec_t * p_ac3dec, u32 ch)
 284 {
 285     u32 bnd = 0;
 286     u32 i,j;
 287     float cpl_coord = 0;
 288     u32 cpl_exp_tmp;
 289     u32 cpl_mant_tmp;
 290
 291     for (i = p_ac3dec->audblk.cplstrtmant; i < p_ac3dec->audblk.cplendmant;) {
 292         if (!p_ac3dec->audblk.cplbndstrc[bnd]) {
 293             cpl_exp_tmp = p_ac3dec->audblk.cplcoexp[ch][bnd] + 3 * p_ac3dec->audblk.mstrcplco[ch];
 294             if (p_ac3dec->audblk.cplcoexp[ch][bnd] == 15)
 295                 cpl_mant_tmp = (p_ac3dec->audblk.cplcomant[ch][bnd]) << 12;
 296             else
 297                 cpl_mant_tmp = ((0x10) | p_ac3dec->audblk.cplcomant[ch][bnd]) << 11;
 298
 299             cpl_coord = ((s16)cpl_mant_tmp) * exp_lut[cpl_exp_tmp];
 300         }
 301         bnd++;
 302
 303         for (j=0;j < 12; j++) {
 304             p_ac3dec->coeffs.fbw[ch][i]  = cpl_coord * p_ac3dec->audblk.cplfbw[i];
 305             i++;
 306         }
 307     }
 308 }
 309
 310 void mantissa_unpack (ac3dec_t * p_ac3dec)
 311 {
 312     int i, j;
 313
 314     q_1_pointer = -1;
 315     q_2_pointer = -1;
 316     q_4_pointer = -1;
 317
 318     if (p_ac3dec->audblk.cplinu) {
 319         /* 1 */
 320         for (i = 0; !p_ac3dec->audblk.chincpl[i]; i++) {
 321             for (j = 0; j < p_ac3dec->audblk.endmant[i]; j++) {
 322                 p_ac3dec->coeffs.fbw[i][j] = float_get (p_ac3dec, p_ac3dec->audblk.fbw_bap[i][j], p_ac3dec->audblk.fbw_exp[i][j]);
 323             }
 324         }
 325
 326         /* 2 */
 327         for (j = 0; j < p_ac3dec->audblk.endmant[i]; j++) {
 328             p_ac3dec->coeffs.fbw[i][j] = float_get (p_ac3dec, p_ac3dec->audblk.fbw_bap[i][j], p_ac3dec->audblk.fbw_exp[i][j]);
 329         }
 330         for (j = p_ac3dec->audblk.cplstrtmant; j < p_ac3dec->audblk.cplendmant; j++) {
 331             p_ac3dec->audblk.cplfbw[j] = float_get (p_ac3dec, p_ac3dec->audblk.cpl_bap[j], p_ac3dec->audblk.cpl_exp[j]);
 332         }
 333         uncouple_channel (p_ac3dec, i);
 334
 335         /* 3 */
 336         for (i++; i < p_ac3dec->bsi.nfchans; i++) {
 337             for (j = 0; j < p_ac3dec->audblk.endmant[i]; j++) {
 338                 p_ac3dec->coeffs.fbw[i][j] = float_get (p_ac3dec, p_ac3dec->audblk.fbw_bap[i][j], p_ac3dec->audblk.fbw_exp[i][j]);
 339             }
 340             if (p_ac3dec->audblk.chincpl[i]) {
 341                 uncouple_channel (p_ac3dec, i);
 342             }
 343         }
 344     } else {
 345         for (i = 0; i < p_ac3dec->bsi.nfchans; i++) {
 346             for (j = 0; j < p_ac3dec->audblk.endmant[i]; j++) {
 347                 p_ac3dec->coeffs.fbw[i][j] = float_get (p_ac3dec, p_ac3dec->audblk.fbw_bap[i][j], p_ac3dec->audblk.fbw_exp[i][j]);
 348             }
 349         }
 350     }
 351
 352     if (p_ac3dec->bsi.lfeon) {
 353         /* There are always 7 mantissas for lfe, no dither for lfe */
 354         for (j = 0; j < 7; j++) {
 355             p_ac3dec->coeffs.lfe[j] = float_get (p_ac3dec, p_ac3dec->audblk.lfe_bap[j], p_ac3dec->audblk.lfe_exp[j]);
 356         }
 357     }
 358 }