git.sesse.net Git - vlc/blob - src/audio_decoder/adec_layer1.c

   1 /*****************************************************************************
   2  * adec_layer1.c: MPEG Layer I audio decoder
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  * $Id: adec_layer1.c,v 1.3 2001/03/21 13:42:34 sam Exp $
   6  *
   7  * Authors: Michel Kaempf <maxx@via.ecp.fr>
   8  *          Michel Lespinasse <walken@via.ecp.fr>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*
  26  * TODO :
  27  *
  28  * - optimiser les NeedBits() et les GetBits() du code là où c'est possible ;
  29  *
  30  */
  31
  32 #include "defs.h"
  33
  34 #include "config.h"
  35 #include "common.h"
  36 #include "threads.h"
  37 #include "mtime.h"
  38 #include "stream_control.h"
  39 #include "input_ext-dec.h"
  40
  41 #include "adec_generic.h"
  42 #include "audio_decoder.h"
  43 #include "adec_math.h"                                     /* DCT32(), PCM() */
  44
  45 #define NULL ((void *)0)
  46
  47 /**** wkn ****/
  48
  49 static float adec_scalefactor_table[64] =
  50 {   /* 2 ^ (1 - i/3) */
  51     2.0000000000000000, 1.5874010519681994, 1.2599210498948732,
  52     1.0000000000000000, 0.7937005259840998, 0.6299605249474366,
  53     0.5000000000000000, 0.3968502629920499, 0.3149802624737183,
  54     0.2500000000000000, 0.1984251314960249, 0.1574901312368591,
  55     0.1250000000000000, 0.0992125657480125, 0.0787450656184296,
  56     0.0625000000000000, 0.0496062828740062, 0.0393725328092148,
  57     0.0312500000000000, 0.0248031414370031, 0.0196862664046074,
  58     0.0156250000000000, 0.0124015707185016, 0.0098431332023037,
  59     0.0078125000000000, 0.0062007853592508, 0.0049215666011518,
  60     0.0039062500000000, 0.0031003926796254, 0.0024607833005759,
  61     0.0019531250000000, 0.0015501963398127, 0.0012303916502880,
  62     0.0009765625000000, 0.0007750981699063, 0.0006151958251440,
  63     0.0004882812500000, 0.0003875490849532, 0.0003075979125720,
  64     0.0002441406250000, 0.0001937745424766, 0.0001537989562860,
  65     0.0001220703125000, 0.0000968872712383, 0.0000768994781430,
  66     0.0000610351562500, 0.0000484436356191, 0.0000384497390715,
  67     0.0000305175781250, 0.0000242218178096, 0.0000192248695357,
  68     0.0000152587890625, 0.0000121109089048, 0.0000096124347679,
  69     0.0000076293945312, 0.0000060554544524, 0.0000048062173839,
  70     0.0000038146972656, 0.0000030277272262, 0.0000024031086920,
  71     0.0000019073486328, 0.0000015138636131, 0.0000012015543460,
  72     0.0000009536743164 /* last element is not in the standard... invalid ??? */
  73 };
  74
  75 static float adec_slope_table[15] =
  76 {
  77     0.6666666666666666, 0.2857142857142857, 0.1333333333333333,
  78     0.0645161290322581, 0.0317460317460317, 0.0157480314960630,
  79     0.0078431372549020, 0.0039138943248532, 0.0019550342130987,
  80     0.0009770395701026, 0.0004884004884005, 0.0002441704309608,
  81     0.0001220777635354, 0.0000610370189520, 0.0000305180437934
  82 };
  83
  84 static float adec_offset_table[15] =
  85 {
  86     -0.6666666666666666, -0.8571428571428571, -0.9333333333333333,
  87     -0.9677419354838710, -0.9841269841269841, -0.9921259842519685,
  88     -0.9960784313725490, -0.9980430528375733, -0.9990224828934506,
  89     -0.9995114802149487, -0.9997557997557998, -0.9998779147845196,
  90     -0.9999389611182323, -0.9999694814905240, -0.9999847409781033
  91 };
  92
  93 static u8 adec_layer1_allocation_table[15] =
  94 {
  95     0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
  96 };
  97
  98 static int adec_bound_table[4] = { 4, 8, 12, 16 };
  99
 100 int adec_layer1_mono( adec_thread_t * p_adec, s16 * buffer )
 101 {
 102     u8 allocation[32];
 103     float slope[32];
 104     float offset[32];
 105     float sample[32];
 106
 107     int i_sb;
 108     int s;
 109     int i_read_bits = 0;
 110
 111     /*
 112      * Parse the allocation tables
 113      */
 114
 115     for (i_sb = 0; i_sb < 32; i_sb += 2)
 116     {
 117         u8 tmp;
 118
 119         /* i_read_bits will be updated at the end of the loop */
 120         tmp = GetBits ( &p_adec->bit_stream, 8 );
 121
 122         if ( (tmp >> 4) > 14 )
 123         {
 124             return 1;
 125         }
 126
 127         allocation[i_sb] = adec_layer1_allocation_table [tmp >> 4];
 128
 129         if ((tmp & 15) > 14)
 130         {
 131             return 1;
 132         }
 133
 134         allocation[i_sb+1] = adec_layer1_allocation_table [tmp & 15];
 135     }
 136
 137     i_read_bits += 8 * 16; /* we did 16 iterations */
 138
 139     /*
 140      * Parse scalefactors
 141      */
 142
 143     for ( i_sb = 0; i_sb < 32; i_sb++ )
 144     {
 145         if ( allocation[i_sb] )
 146         {
 147             int index;
 148             float scalefactor;
 149
 150             index = GetBits( &p_adec->bit_stream, 6);
 151
 152             /* We also add the bits we'll take later in the sample parsing */
 153             i_read_bits += 6 + 12 * allocation[i_sb];
 154
 155             scalefactor = adec_scalefactor_table[index];
 156
 157             slope[i_sb] = adec_slope_table[allocation[i_sb]-2] * scalefactor;
 158             offset[i_sb] = adec_offset_table[allocation[i_sb]-2] * scalefactor;
 159         }
 160     }
 161
 162     /*
 163      * Parse samples
 164      */
 165
 166     for ( s = 0 ; s < 12; s++)
 167     {
 168         s16 * XXX_buf;
 169
 170         for (i_sb = 0; i_sb < 32; i_sb++)
 171         {
 172             if (!allocation[i_sb])
 173             {
 174                 sample[i_sb] = 0;
 175             }
 176             else
 177             {
 178                 int code;
 179
 180                 /* The bits were already counted in the scalefactors parsing */
 181                 code = GetBits( &p_adec->bit_stream, allocation[i_sb] );
 182
 183                 sample[i_sb] = slope[i_sb] * code + offset[i_sb];
 184             }
 185         }
 186
 187         DCT32 (sample, &p_adec->bank_0);
 188         XXX_buf = buffer;
 189         PCM (&p_adec->bank_0, &XXX_buf, 1);
 190         buffer += 32;
 191     }
 192
 193     p_adec->i_read_bits += i_read_bits;
 194
 195     return 0;
 196 }
 197
 198 int adec_layer1_stereo( adec_thread_t * p_adec, s16 * buffer )
 199 {
 200     u8 allocation_0[32], allocation_1[32];
 201     float slope_0[32], slope_1[32];
 202     float offset_0[32], offset_1[32];
 203     float sample_0[32], sample_1[32];
 204
 205     int bound;
 206     int i_sb;
 207     int s;
 208     int i_read_bits = 0;
 209
 210     /*
 211      * Calculate bound
 212      */
 213
 214     bound = 32;
 215     if ( (p_adec->header & 0xc0) == 0x40)
 216     {
 217         /* intensity stereo */
 218         int index;
 219         index = (p_adec->header >> 4) & 3;
 220         bound = adec_bound_table[index];
 221     }
 222
 223     /*
 224      * Parse allocation
 225      */
 226
 227     for (i_sb = 0; i_sb < bound; i_sb++)
 228     {
 229         u8 tmp;
 230         tmp = GetBits( &p_adec->bit_stream, 8 );
 231         if ((tmp >> 4) > 14)
 232         {
 233             return 1;
 234         }
 235         allocation_0[i_sb] = adec_layer1_allocation_table [tmp >> 4];
 236         if ((tmp & 15) > 14)
 237         {
 238             return 1;
 239         }
 240         allocation_1[i_sb] = adec_layer1_allocation_table [tmp & 15];
 241     }
 242
 243     for (; i_sb < 32; i_sb += 2)
 244     {
 245         u8 tmp;
 246         tmp = GetBits( &p_adec->bit_stream, 8 );
 247
 248         if ((tmp >> 4) > 14)
 249         {
 250             return 1;
 251         }
 252         allocation_0[i_sb] = allocation_1[i_sb]
 253             = adec_layer1_allocation_table [tmp >> 4];
 254
 255         if ((tmp & 15) > 14)
 256         {
 257             return 1;
 258         }
 259         allocation_0[i_sb+1] = allocation_1[i_sb+1]
 260             = adec_layer1_allocation_table [tmp & 15];
 261     }
 262
 263     i_read_bits += 4 * ( 32 + bound ); /* we read 8*bound and 4*(32-bound) */
 264
 265     /*
 266      * Parse scalefactors
 267      */
 268
 269     for ( i_sb = 0; i_sb < 32; i_sb++ )
 270     {
 271         if ( allocation_0[i_sb] )
 272         {
 273             int index;
 274             float scalefactor;
 275
 276             index = GetBits( &p_adec->bit_stream, 6 );
 277             i_read_bits += 6;
 278
 279             scalefactor = adec_scalefactor_table[index];
 280
 281             slope_0[i_sb] = adec_slope_table[allocation_0[i_sb]-2] * scalefactor;
 282             offset_0[i_sb] = adec_offset_table[allocation_0[i_sb]-2] * scalefactor;
 283         }
 284
 285         if (allocation_1[i_sb])
 286         {
 287             int index;
 288             float scalefactor;
 289
 290             index = GetBits( &p_adec->bit_stream, 6 );
 291             i_read_bits += 6;
 292
 293             scalefactor = adec_scalefactor_table[index];
 294
 295             slope_1[i_sb] = adec_slope_table[allocation_1[i_sb]-2] * scalefactor;
 296             offset_1[i_sb] = adec_offset_table[allocation_1[i_sb]-2] * scalefactor;
 297         }
 298     }
 299
 300     /* parse samples */
 301
 302     for (s = 0; s < 12; s++)
 303     {
 304         s16 * XXX_buf;
 305
 306         for (i_sb = 0; i_sb < bound; i_sb++)
 307         {
 308             if (!allocation_0[i_sb])
 309             {
 310                 sample_0[i_sb] = 0;
 311             }
 312             else
 313             {
 314                 int code;
 315
 316                 code = GetBits( &p_adec->bit_stream, allocation_0[i_sb] );
 317                 i_read_bits += allocation_0[i_sb];
 318
 319                 sample_0[i_sb] = slope_0[i_sb] * code + offset_0[i_sb];
 320             }
 321
 322             if ( !allocation_1[i_sb] )
 323             {
 324                 sample_1[i_sb] = 0;
 325             }
 326             else
 327             {
 328                 int code;
 329
 330                 code = GetBits( &p_adec->bit_stream, allocation_1[i_sb] );
 331                 i_read_bits += allocation_1[i_sb];
 332
 333                 sample_1[i_sb] = slope_1[i_sb] * code + offset_1[i_sb];
 334             }
 335         }
 336
 337         for (; i_sb < 32; i_sb++)
 338         {
 339             if (!allocation_0[i_sb])
 340             {
 341                 sample_0[i_sb] = 0;
 342                 sample_1[i_sb] = 0;
 343             }
 344             else
 345             {
 346                 int code;
 347
 348                 code = GetBits( &p_adec->bit_stream, allocation_0[i_sb] );
 349                 i_read_bits += allocation_0[i_sb];
 350
 351                 sample_0[i_sb] = slope_0[i_sb] * code + offset_0[i_sb];
 352                 sample_1[i_sb] = slope_1[i_sb] * code + offset_1[i_sb];
 353             }
 354         }
 355
 356         DCT32 (sample_0, &p_adec->bank_0);
 357         XXX_buf = buffer;
 358         PCM (&p_adec->bank_0, &XXX_buf, 2);
 359         DCT32 (sample_1, &p_adec->bank_1);
 360         XXX_buf = buffer+1;
 361         PCM (&p_adec->bank_1, &XXX_buf, 2);
 362         buffer += 64;
 363     }
 364
 365     p_adec->i_read_bits += i_read_bits;
 366
 367     return 0;
 368 }
 369