LCOV - code coverage report
Current view: top level - libavcodec - mpegaudiodec_template.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 735 1055 69.7 %
Date: 2017-12-16 01:21:47 Functions: 23 31 74.2 %

          Line data    Source code
       1             : /*
       2             :  * MPEG Audio decoder
       3             :  * Copyright (c) 2001, 2002 Fabrice Bellard
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * MPEG Audio decoder
      25             :  */
      26             : 
      27             : #include "libavutil/attributes.h"
      28             : #include "libavutil/avassert.h"
      29             : #include "libavutil/channel_layout.h"
      30             : #include "libavutil/float_dsp.h"
      31             : #include "libavutil/libm.h"
      32             : #include "avcodec.h"
      33             : #include "get_bits.h"
      34             : #include "internal.h"
      35             : #include "mathops.h"
      36             : #include "mpegaudiodsp.h"
      37             : 
      38             : /*
      39             :  * TODO:
      40             :  *  - test lsf / mpeg25 extensively.
      41             :  */
      42             : 
      43             : #include "mpegaudio.h"
      44             : #include "mpegaudiodecheader.h"
      45             : 
      46             : #define BACKSTEP_SIZE 512
      47             : #define EXTRABYTES 24
      48             : #define LAST_BUF_SIZE 2 * BACKSTEP_SIZE + EXTRABYTES
      49             : 
      50             : /* layer 3 "granule" */
      51             : typedef struct GranuleDef {
      52             :     uint8_t scfsi;
      53             :     int part2_3_length;
      54             :     int big_values;
      55             :     int global_gain;
      56             :     int scalefac_compress;
      57             :     uint8_t block_type;
      58             :     uint8_t switch_point;
      59             :     int table_select[3];
      60             :     int subblock_gain[3];
      61             :     uint8_t scalefac_scale;
      62             :     uint8_t count1table_select;
      63             :     int region_size[3]; /* number of huffman codes in each region */
      64             :     int preflag;
      65             :     int short_start, long_end; /* long/short band indexes */
      66             :     uint8_t scale_factors[40];
      67             :     DECLARE_ALIGNED(16, INTFLOAT, sb_hybrid)[SBLIMIT * 18]; /* 576 samples */
      68             : } GranuleDef;
      69             : 
      70             : typedef struct MPADecodeContext {
      71             :     MPA_DECODE_HEADER
      72             :     uint8_t last_buf[LAST_BUF_SIZE];
      73             :     int last_buf_size;
      74             :     int extrasize;
      75             :     /* next header (used in free format parsing) */
      76             :     uint32_t free_format_next_header;
      77             :     GetBitContext gb;
      78             :     GetBitContext in_gb;
      79             :     DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
      80             :     int synth_buf_offset[MPA_MAX_CHANNELS];
      81             :     DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
      82             :     INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
      83             :     GranuleDef granules[2][2]; /* Used in Layer 3 */
      84             :     int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3
      85             :     int dither_state;
      86             :     int err_recognition;
      87             :     AVCodecContext* avctx;
      88             :     MPADSPContext mpadsp;
      89             :     AVFloatDSPContext *fdsp;
      90             :     AVFrame *frame;
      91             : } MPADecodeContext;
      92             : 
      93             : #define HEADER_SIZE 4
      94             : 
      95             : #include "mpegaudiodata.h"
      96             : #include "mpegaudiodectab.h"
      97             : 
      98             : /* vlc structure for decoding layer 3 huffman tables */
      99             : static VLC huff_vlc[16];
     100             : static VLC_TYPE huff_vlc_tables[
     101             :     0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
     102             :   142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
     103             :   ][2];
     104             : static const int huff_vlc_tables_sizes[16] = {
     105             :     0,  128,  128,  128,  130,  128,  154,  166,
     106             :   142,  204,  190,  170,  542,  460,  662,  414
     107             : };
     108             : static VLC huff_quad_vlc[2];
     109             : static VLC_TYPE  huff_quad_vlc_tables[128+16][2];
     110             : static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
     111             : /* computed from band_size_long */
     112             : static uint16_t band_index_long[9][23];
     113             : #include "mpegaudio_tablegen.h"
     114             : /* intensity stereo coef table */
     115             : static INTFLOAT is_table[2][16];
     116             : static INTFLOAT is_table_lsf[2][2][16];
     117             : static INTFLOAT csa_table[8][4];
     118             : 
     119             : static int16_t division_tab3[1<<6 ];
     120             : static int16_t division_tab5[1<<8 ];
     121             : static int16_t division_tab9[1<<11];
     122             : 
     123             : static int16_t * const division_tabs[4] = {
     124             :     division_tab3, division_tab5, NULL, division_tab9
     125             : };
     126             : 
     127             : /* lower 2 bits: modulo 3, higher bits: shift */
     128             : static uint16_t scale_factor_modshift[64];
     129             : /* [i][j]:  2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
     130             : static int32_t scale_factor_mult[15][3];
     131             : /* mult table for layer 2 group quantization */
     132             : 
     133             : #define SCALE_GEN(v) \
     134             : { FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }
     135             : 
     136             : static const int32_t scale_factor_mult2[3][3] = {
     137             :     SCALE_GEN(4.0 / 3.0), /* 3 steps */
     138             :     SCALE_GEN(4.0 / 5.0), /* 5 steps */
     139             :     SCALE_GEN(4.0 / 9.0), /* 9 steps */
     140             : };
     141             : 
     142             : /**
     143             :  * Convert region offsets to region sizes and truncate
     144             :  * size to big_values.
     145             :  */
     146        8114 : static void region_offset2size(GranuleDef *g)
     147             : {
     148        8114 :     int i, k, j = 0;
     149        8114 :     g->region_size[2] = 576 / 2;
     150       32456 :     for (i = 0; i < 3; i++) {
     151       24342 :         k = FFMIN(g->region_size[i], g->big_values);
     152       24342 :         g->region_size[i] = k - j;
     153       24342 :         j = k;
     154             :     }
     155        8114 : }
     156             : 
     157         843 : static void init_short_region(MPADecodeContext *s, GranuleDef *g)
     158             : {
     159         843 :     if (g->block_type == 2) {
     160         304 :         if (s->sample_rate_index != 8)
     161         304 :             g->region_size[0] = (36 / 2);
     162             :         else
     163           0 :             g->region_size[0] = (72 / 2);
     164             :     } else {
     165         539 :         if (s->sample_rate_index <= 2)
     166         538 :             g->region_size[0] = (36 / 2);
     167           1 :         else if (s->sample_rate_index != 8)
     168           1 :             g->region_size[0] = (54 / 2);
     169             :         else
     170           0 :             g->region_size[0] = (108 / 2);
     171             :     }
     172         843 :     g->region_size[1] = (576 / 2);
     173         843 : }
     174             : 
     175        7271 : static void init_long_region(MPADecodeContext *s, GranuleDef *g,
     176             :                              int ra1, int ra2)
     177             : {
     178             :     int l;
     179        7271 :     g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
     180             :     /* should not overflow */
     181        7271 :     l = FFMIN(ra1 + ra2 + 2, 22);
     182        7271 :     g->region_size[1] = band_index_long[s->sample_rate_index][      l] >> 1;
     183        7271 : }
     184             : 
     185        8114 : static void compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
     186             : {
     187        8114 :     if (g->block_type == 2) {
     188         304 :         if (g->switch_point) {
     189          13 :             if(s->sample_rate_index == 8)
     190           0 :                 avpriv_request_sample(s->avctx, "switch point in 8khz");
     191             :             /* if switched mode, we handle the 36 first samples as
     192             :                 long blocks.  For 8000Hz, we handle the 72 first
     193             :                 exponents as long blocks */
     194          13 :             if (s->sample_rate_index <= 2)
     195          13 :                 g->long_end = 8;
     196             :             else
     197           0 :                 g->long_end = 6;
     198             : 
     199          13 :             g->short_start = 3;
     200             :         } else {
     201         291 :             g->long_end    = 0;
     202         291 :             g->short_start = 0;
     203             :         }
     204             :     } else {
     205        7810 :         g->short_start = 13;
     206        7810 :         g->long_end    = 22;
     207             :     }
     208        8114 : }
     209             : 
     210             : /* layer 1 unscaling */
     211             : /* n = number of bits of the mantissa minus 1 */
     212     2223612 : static inline int l1_unscale(int n, int mant, int scale_factor)
     213             : {
     214             :     int shift, mod;
     215             :     int64_t val;
     216             : 
     217     2223612 :     shift   = scale_factor_modshift[scale_factor];
     218     2223612 :     mod     = shift & 3;
     219     2223612 :     shift >>= 2;
     220     2223612 :     val     = MUL64((int)(mant + (-1U << n) + 1), scale_factor_mult[n-1][mod]);
     221     2223612 :     shift  += n;
     222             :     /* NOTE: at this point, 1 <= shift >= 21 + 15 */
     223     2223612 :     return (int)((val + (1LL << (shift - 1))) >> shift);
     224             : }
     225             : 
     226      619416 : static inline int l2_unscale_group(int steps, int mant, int scale_factor)
     227             : {
     228             :     int shift, mod, val;
     229             : 
     230      619416 :     shift   = scale_factor_modshift[scale_factor];
     231      619416 :     mod     = shift & 3;
     232      619416 :     shift >>= 2;
     233             : 
     234      619416 :     val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
     235             :     /* NOTE: at this point, 0 <= shift <= 21 */
     236      619416 :     if (shift > 0)
     237      619416 :         val = (val + (1 << (shift - 1))) >> shift;
     238      619416 :     return val;
     239             : }
     240             : 
     241             : /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
     242       56735 : static inline int l3_unscale(int value, int exponent)
     243             : {
     244             :     unsigned int m;
     245             :     int e;
     246             : 
     247       56735 :     e  = table_4_3_exp  [4 * value + (exponent & 3)];
     248       56735 :     m  = table_4_3_value[4 * value + (exponent & 3)];
     249       56735 :     e -= exponent >> 2;
     250             : #ifdef DEBUG
     251             :     if(e < 1)
     252             :         av_log(NULL, AV_LOG_WARNING, "l3_unscale: e is %d\n", e);
     253             : #endif
     254       56735 :     if (e > (SUINT)31)
     255          10 :         return 0;
     256       56725 :     m = (m + ((1U << e)>>1)) >> e;
     257             : 
     258       56725 :     return m;
     259             : }
     260             : 
     261          65 : static av_cold void decode_init_static(void)
     262             : {
     263             :     int i, j, k;
     264             :     int offset;
     265             : 
     266             :     /* scale factors table for layer 1/2 */
     267        4225 :     for (i = 0; i < 64; i++) {
     268             :         int shift, mod;
     269             :         /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
     270        4160 :         shift = i / 3;
     271        4160 :         mod   = i % 3;
     272        4160 :         scale_factor_modshift[i] = mod | (shift << 2);
     273             :     }
     274             : 
     275             :     /* scale factor multiply for layer 1 */
     276        1040 :     for (i = 0; i < 15; i++) {
     277             :         int n, norm;
     278         975 :         n = i + 2;
     279         975 :         norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
     280         975 :         scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0          * 2.0), FRAC_BITS);
     281         975 :         scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
     282         975 :         scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
     283             :         ff_dlog(NULL, "%d: norm=%x s=%"PRIx32" %"PRIx32" %"PRIx32"\n", i,
     284             :                 (unsigned)norm,
     285             :                 scale_factor_mult[i][0],
     286             :                 scale_factor_mult[i][1],
     287             :                 scale_factor_mult[i][2]);
     288             :     }
     289             : 
     290          65 :     RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
     291             : 
     292             :     /* huffman decode tables */
     293          65 :     offset = 0;
     294        1040 :     for (i = 1; i < 16; i++) {
     295         975 :         const HuffTable *h = &mpa_huff_tables[i];
     296             :         int xsize, x, y;
     297         975 :         uint8_t  tmp_bits [512] = { 0 };
     298         975 :         uint16_t tmp_codes[512] = { 0 };
     299             : 
     300         975 :         xsize = h->xsize;
     301             : 
     302         975 :         j = 0;
     303        8905 :         for (x = 0; x < xsize; x++) {
     304       97500 :             for (y = 0; y < xsize; y++) {
     305       89570 :                 tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j  ];
     306       89570 :                 tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
     307             :             }
     308             :         }
     309             : 
     310             :         /* XXX: fail test */
     311         975 :         huff_vlc[i].table = huff_vlc_tables+offset;
     312         975 :         huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
     313         975 :         init_vlc(&huff_vlc[i], 7, 512,
     314             :                  tmp_bits, 1, 1, tmp_codes, 2, 2,
     315             :                  INIT_VLC_USE_NEW_STATIC);
     316         975 :         offset += huff_vlc_tables_sizes[i];
     317             :     }
     318          65 :     av_assert0(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
     319             : 
     320          65 :     offset = 0;
     321         195 :     for (i = 0; i < 2; i++) {
     322         130 :         huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
     323         130 :         huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
     324         130 :         init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
     325             :                  mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
     326             :                  INIT_VLC_USE_NEW_STATIC);
     327         130 :         offset += huff_quad_vlc_tables_sizes[i];
     328             :     }
     329          65 :     av_assert0(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
     330             : 
     331         650 :     for (i = 0; i < 9; i++) {
     332         585 :         k = 0;
     333       13455 :         for (j = 0; j < 22; j++) {
     334       12870 :             band_index_long[i][j] = k;
     335       12870 :             k += band_size_long[i][j];
     336             :         }
     337         585 :         band_index_long[i][22] = k;
     338             :     }
     339             : 
     340             :     /* compute n ^ (4/3) and store it in mantissa/exp format */
     341             : 
     342          65 :     mpegaudio_tableinit();
     343             : 
     344         325 :     for (i = 0; i < 4; i++) {
     345         260 :         if (ff_mpa_quant_bits[i] < 0) {
     346      154115 :             for (j = 0; j < (1 << (-ff_mpa_quant_bits[i]+1)); j++) {
     347             :                 int val1, val2, val3, steps;
     348      153920 :                 int val = j;
     349      153920 :                 steps   = ff_mpa_quant_steps[i];
     350      153920 :                 val1    = val % steps;
     351      153920 :                 val    /= steps;
     352      153920 :                 val2    = val % steps;
     353      153920 :                 val3    = val / steps;
     354      153920 :                 division_tabs[i][j] = val1 + (val2 << 4) + (val3 << 8);
     355             :             }
     356             :         }
     357             :     }
     358             : 
     359             : 
     360         520 :     for (i = 0; i < 7; i++) {
     361             :         float f;
     362             :         INTFLOAT v;
     363         455 :         if (i != 6) {
     364         390 :             f = tan((double)i * M_PI / 12.0);
     365         390 :             v = FIXR(f / (1.0 + f));
     366             :         } else {
     367          65 :             v = FIXR(1.0);
     368             :         }
     369         455 :         is_table[0][    i] = v;
     370         455 :         is_table[1][6 - i] = v;
     371             :     }
     372             :     /* invalid values */
     373         650 :     for (i = 7; i < 16; i++)
     374         585 :         is_table[0][i] = is_table[1][i] = 0.0;
     375             : 
     376        1105 :     for (i = 0; i < 16; i++) {
     377             :         double f;
     378             :         int e, k;
     379             : 
     380        3120 :         for (j = 0; j < 2; j++) {
     381        2080 :             e = -(j + 1) * ((i + 1) >> 1);
     382        2080 :             f = exp2(e / 4.0);
     383        2080 :             k = i & 1;
     384        2080 :             is_table_lsf[j][k ^ 1][i] = FIXR(f);
     385        2080 :             is_table_lsf[j][k    ][i] = FIXR(1.0);
     386             :             ff_dlog(NULL, "is_table_lsf %d %d: %f %f\n",
     387             :                     i, j, (float) is_table_lsf[j][0][i],
     388             :                     (float) is_table_lsf[j][1][i]);
     389             :         }
     390             :     }
     391             : 
     392         585 :     for (i = 0; i < 8; i++) {
     393             :         double ci, cs, ca;
     394         520 :         ci = ci_table[i];
     395         520 :         cs = 1.0 / sqrt(1.0 + ci * ci);
     396         520 :         ca = cs * ci;
     397             : #if !USE_FLOATS
     398         456 :         csa_table[i][0] = FIXHR(cs/4);
     399         456 :         csa_table[i][1] = FIXHR(ca/4);
     400         456 :         csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
     401         456 :         csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
     402             : #else
     403          64 :         csa_table[i][0] = cs;
     404          64 :         csa_table[i][1] = ca;
     405          64 :         csa_table[i][2] = ca + cs;
     406          64 :         csa_table[i][3] = ca - cs;
     407             : #endif
     408             :     }
     409          65 : }
     410             : 
     411             : #if USE_FLOATS
     412          16 : static av_cold int decode_close(AVCodecContext * avctx)
     413             : {
     414          16 :     MPADecodeContext *s = avctx->priv_data;
     415          16 :     av_freep(&s->fdsp);
     416             : 
     417          16 :     return 0;
     418             : }
     419             : #endif
     420             : 
     421         108 : static av_cold int decode_init(AVCodecContext * avctx)
     422             : {
     423             :     static int initialized_tables = 0;
     424         108 :     MPADecodeContext *s = avctx->priv_data;
     425             : 
     426         108 :     if (!initialized_tables) {
     427          65 :         decode_init_static();
     428          65 :         initialized_tables = 1;
     429             :     }
     430             : 
     431         108 :     s->avctx = avctx;
     432             : 
     433             : #if USE_FLOATS
     434          16 :     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
     435          16 :     if (!s->fdsp)
     436           0 :         return AVERROR(ENOMEM);
     437             : #endif
     438             : 
     439         108 :     ff_mpadsp_init(&s->mpadsp);
     440             : 
     441         108 :     if (avctx->request_sample_fmt == OUT_FMT &&
     442           0 :         avctx->codec_id != AV_CODEC_ID_MP3ON4)
     443           0 :         avctx->sample_fmt = OUT_FMT;
     444             :     else
     445         108 :         avctx->sample_fmt = OUT_FMT_P;
     446         108 :     s->err_recognition = avctx->err_recognition;
     447             : 
     448         108 :     if (avctx->codec_id == AV_CODEC_ID_MP3ADU)
     449           0 :         s->adu_mode = 1;
     450             : 
     451         108 :     return 0;
     452             : }
     453             : 
     454             : #define C3 FIXHR(0.86602540378443864676/2)
     455             : #define C4 FIXHR(0.70710678118654752439/2) //0.5 / cos(pi*(9)/36)
     456             : #define C5 FIXHR(0.51763809020504152469/2) //0.5 / cos(pi*(5)/36)
     457             : #define C6 FIXHR(1.93185165257813657349/4) //0.5 / cos(pi*(15)/36)
     458             : 
     459             : /* 12 points IMDCT. We compute it "by hand" by factorizing obvious
     460             :    cases. */
     461       19308 : static void imdct12(INTFLOAT *out, SUINTFLOAT *in)
     462             : {
     463             :     SUINTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
     464             : 
     465       19308 :     in0  = in[0*3];
     466       19308 :     in1  = in[1*3] + in[0*3];
     467       19308 :     in2  = in[2*3] + in[1*3];
     468       19308 :     in3  = in[3*3] + in[2*3];
     469       19308 :     in4  = in[4*3] + in[3*3];
     470       19308 :     in5  = in[5*3] + in[4*3];
     471       19308 :     in5 += in3;
     472       19308 :     in3 += in1;
     473             : 
     474       19308 :     in2  = MULH3(in2, C3, 2);
     475       19308 :     in3  = MULH3(in3, C3, 4);
     476             : 
     477       19308 :     t1   = in0 - in4;
     478       19308 :     t2   = MULH3(in1 - in5, C4, 2);
     479             : 
     480       38616 :     out[ 7] =
     481       38616 :     out[10] = t1 + t2;
     482       38616 :     out[ 1] =
     483       38616 :     out[ 4] = t1 - t2;
     484             : 
     485       19308 :     in0    += SHR(in4, 1);
     486       19308 :     in4     = in0 + in2;
     487       19308 :     in5    += 2*in1;
     488       19308 :     in1     = MULH3(in5 + in3, C5, 1);
     489       38616 :     out[ 8] =
     490       38616 :     out[ 9] = in4 + in1;
     491       38616 :     out[ 2] =
     492       38616 :     out[ 3] = in4 - in1;
     493             : 
     494       19308 :     in0    -= in2;
     495       19308 :     in5     = MULH3(in5 - in3, C6, 2);
     496       19308 :     out[ 0] =
     497       19308 :     out[ 5] = in0 - in5;
     498       38616 :     out[ 6] =
     499       38616 :     out[11] = in0 + in5;
     500       19308 : }
     501             : 
     502             : /* return the number of decoded frames */
     503           0 : static int mp_decode_layer1(MPADecodeContext *s)
     504             : {
     505             :     int bound, i, v, n, ch, j, mant;
     506             :     uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
     507             :     uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
     508             : 
     509           0 :     if (s->mode == MPA_JSTEREO)
     510           0 :         bound = (s->mode_ext + 1) * 4;
     511             :     else
     512           0 :         bound = SBLIMIT;
     513             : 
     514             :     /* allocation bits */
     515           0 :     for (i = 0; i < bound; i++) {
     516           0 :         for (ch = 0; ch < s->nb_channels; ch++) {
     517           0 :             allocation[ch][i] = get_bits(&s->gb, 4);
     518             :         }
     519             :     }
     520           0 :     for (i = bound; i < SBLIMIT; i++)
     521           0 :         allocation[0][i] = get_bits(&s->gb, 4);
     522             : 
     523             :     /* scale factors */
     524           0 :     for (i = 0; i < bound; i++) {
     525           0 :         for (ch = 0; ch < s->nb_channels; ch++) {
     526           0 :             if (allocation[ch][i])
     527           0 :                 scale_factors[ch][i] = get_bits(&s->gb, 6);
     528             :         }
     529             :     }
     530           0 :     for (i = bound; i < SBLIMIT; i++) {
     531           0 :         if (allocation[0][i]) {
     532           0 :             scale_factors[0][i] = get_bits(&s->gb, 6);
     533           0 :             scale_factors[1][i] = get_bits(&s->gb, 6);
     534             :         }
     535             :     }
     536             : 
     537             :     /* compute samples */
     538           0 :     for (j = 0; j < 12; j++) {
     539           0 :         for (i = 0; i < bound; i++) {
     540           0 :             for (ch = 0; ch < s->nb_channels; ch++) {
     541           0 :                 n = allocation[ch][i];
     542           0 :                 if (n) {
     543           0 :                     mant = get_bits(&s->gb, n + 1);
     544           0 :                     v = l1_unscale(n, mant, scale_factors[ch][i]);
     545             :                 } else {
     546           0 :                     v = 0;
     547             :                 }
     548           0 :                 s->sb_samples[ch][j][i] = v;
     549             :             }
     550             :         }
     551           0 :         for (i = bound; i < SBLIMIT; i++) {
     552           0 :             n = allocation[0][i];
     553           0 :             if (n) {
     554           0 :                 mant = get_bits(&s->gb, n + 1);
     555           0 :                 v = l1_unscale(n, mant, scale_factors[0][i]);
     556           0 :                 s->sb_samples[0][j][i] = v;
     557           0 :                 v = l1_unscale(n, mant, scale_factors[1][i]);
     558           0 :                 s->sb_samples[1][j][i] = v;
     559             :             } else {
     560           0 :                 s->sb_samples[0][j][i] = 0;
     561           0 :                 s->sb_samples[1][j][i] = 0;
     562             :             }
     563             :         }
     564             :     }
     565           0 :     return 12;
     566             : }
     567             : 
     568        3397 : static int mp_decode_layer2(MPADecodeContext *s)
     569             : {
     570             :     int sblimit; /* number of used subbands */
     571             :     const unsigned char *alloc_table;
     572             :     int table, bit_alloc_bits, i, j, ch, bound, v;
     573             :     unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
     574             :     unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
     575             :     unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
     576             :     int scale, qindex, bits, steps, k, l, m, b;
     577             : 
     578             :     /* select decoding table */
     579        3397 :     table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
     580             :                                    s->sample_rate, s->lsf);
     581        3397 :     sblimit     = ff_mpa_sblimit_table[table];
     582        3397 :     alloc_table = ff_mpa_alloc_tables[table];
     583             : 
     584        3397 :     if (s->mode == MPA_JSTEREO)
     585           0 :         bound = (s->mode_ext + 1) * 4;
     586             :     else
     587        3397 :         bound = sblimit;
     588             : 
     589             :     ff_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
     590             : 
     591             :     /* sanity check */
     592        3397 :     if (bound > sblimit)
     593           0 :         bound = sblimit;
     594             : 
     595             :     /* parse bit allocation */
     596        3397 :     j = 0;
     597      102712 :     for (i = 0; i < bound; i++) {
     598       99315 :         bit_alloc_bits = alloc_table[j];
     599      216768 :         for (ch = 0; ch < s->nb_channels; ch++)
     600      117453 :             bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
     601       99315 :         j += 1 << bit_alloc_bits;
     602             :     }
     603        3397 :     for (i = bound; i < sblimit; i++) {
     604           0 :         bit_alloc_bits = alloc_table[j];
     605           0 :         v = get_bits(&s->gb, bit_alloc_bits);
     606           0 :         bit_alloc[0][i] = v;
     607           0 :         bit_alloc[1][i] = v;
     608           0 :         j += 1 << bit_alloc_bits;
     609             :     }
     610             : 
     611             :     /* scale codes */
     612      102712 :     for (i = 0; i < sblimit; i++) {
     613      216768 :         for (ch = 0; ch < s->nb_channels; ch++) {
     614      117453 :             if (bit_alloc[ch][i])
     615       78973 :                 scale_code[ch][i] = get_bits(&s->gb, 2);
     616             :         }
     617             :     }
     618             : 
     619             :     /* scale factors */
     620      102712 :     for (i = 0; i < sblimit; i++) {
     621      216768 :         for (ch = 0; ch < s->nb_channels; ch++) {
     622      117453 :             if (bit_alloc[ch][i]) {
     623       78973 :                 sf = scale_factors[ch][i];
     624       78973 :                 switch (scale_code[ch][i]) {
     625        2124 :                 default:
     626             :                 case 0:
     627        2124 :                     sf[0] = get_bits(&s->gb, 6);
     628        2124 :                     sf[1] = get_bits(&s->gb, 6);
     629        2124 :                     sf[2] = get_bits(&s->gb, 6);
     630        2124 :                     break;
     631       72455 :                 case 2:
     632       72455 :                     sf[0] = get_bits(&s->gb, 6);
     633       72455 :                     sf[1] = sf[0];
     634       72455 :                     sf[2] = sf[0];
     635       72455 :                     break;
     636        1484 :                 case 1:
     637        1484 :                     sf[0] = get_bits(&s->gb, 6);
     638        1484 :                     sf[2] = get_bits(&s->gb, 6);
     639        1484 :                     sf[1] = sf[0];
     640        1484 :                     break;
     641        2910 :                 case 3:
     642        2910 :                     sf[0] = get_bits(&s->gb, 6);
     643        2910 :                     sf[2] = get_bits(&s->gb, 6);
     644        2910 :                     sf[1] = sf[2];
     645        2910 :                     break;
     646             :                 }
     647       38480 :             }
     648             :         }
     649             :     }
     650             : 
     651             :     /* samples */
     652       13588 :     for (k = 0; k < 3; k++) {
     653       50955 :         for (l = 0; l < 12; l += 3) {
     654       40764 :             j = 0;
     655     1232544 :             for (i = 0; i < bound; i++) {
     656     1191780 :                 bit_alloc_bits = alloc_table[j];
     657     2601216 :                 for (ch = 0; ch < s->nb_channels; ch++) {
     658     1409436 :                     b = bit_alloc[ch][i];
     659     1409436 :                     if (b) {
     660      947676 :                         scale = scale_factors[ch][i][k];
     661      947676 :                         qindex = alloc_table[j+b];
     662      947676 :                         bits = ff_mpa_quant_bits[qindex];
     663      947676 :                         if (bits < 0) {
     664             :                             int v2;
     665             :                             /* 3 values at the same time */
     666      206472 :                             v = get_bits(&s->gb, -bits);
     667      206472 :                             v2 = division_tabs[qindex][v];
     668      206472 :                             steps  = ff_mpa_quant_steps[qindex];
     669             : 
     670      412944 :                             s->sb_samples[ch][k * 12 + l + 0][i] =
     671      412944 :                                 l2_unscale_group(steps,  v2       & 15, scale);
     672      412944 :                             s->sb_samples[ch][k * 12 + l + 1][i] =
     673      412944 :                                 l2_unscale_group(steps, (v2 >> 4) & 15, scale);
     674      412944 :                             s->sb_samples[ch][k * 12 + l + 2][i] =
     675      412944 :                                 l2_unscale_group(steps,  v2 >> 8      , scale);
     676             :                         } else {
     677     2964816 :                             for (m = 0; m < 3; m++) {
     678     2223612 :                                 v = get_bits(&s->gb, bits);
     679     2223612 :                                 v = l1_unscale(bits - 1, v, scale);
     680     2223612 :                                 s->sb_samples[ch][k * 12 + l + m][i] = v;
     681             :                             }
     682             :                         }
     683             :                     } else {
     684      461760 :                         s->sb_samples[ch][k * 12 + l + 0][i] = 0;
     685      461760 :                         s->sb_samples[ch][k * 12 + l + 1][i] = 0;
     686      461760 :                         s->sb_samples[ch][k * 12 + l + 2][i] = 0;
     687             :                     }
     688             :                 }
     689             :                 /* next subband in alloc table */
     690     1191780 :                 j += 1 << bit_alloc_bits;
     691             :             }
     692             :             /* XXX: find a way to avoid this duplication of code */
     693       40764 :             for (i = bound; i < sblimit; i++) {
     694           0 :                 bit_alloc_bits = alloc_table[j];
     695           0 :                 b = bit_alloc[0][i];
     696           0 :                 if (b) {
     697             :                     int mant, scale0, scale1;
     698           0 :                     scale0 = scale_factors[0][i][k];
     699           0 :                     scale1 = scale_factors[1][i][k];
     700           0 :                     qindex = alloc_table[j+b];
     701           0 :                     bits = ff_mpa_quant_bits[qindex];
     702           0 :                     if (bits < 0) {
     703             :                         /* 3 values at the same time */
     704           0 :                         v = get_bits(&s->gb, -bits);
     705           0 :                         steps = ff_mpa_quant_steps[qindex];
     706           0 :                         mant = v % steps;
     707           0 :                         v = v / steps;
     708           0 :                         s->sb_samples[0][k * 12 + l + 0][i] =
     709           0 :                             l2_unscale_group(steps, mant, scale0);
     710           0 :                         s->sb_samples[1][k * 12 + l + 0][i] =
     711           0 :                             l2_unscale_group(steps, mant, scale1);
     712           0 :                         mant = v % steps;
     713           0 :                         v = v / steps;
     714           0 :                         s->sb_samples[0][k * 12 + l + 1][i] =
     715           0 :                             l2_unscale_group(steps, mant, scale0);
     716           0 :                         s->sb_samples[1][k * 12 + l + 1][i] =
     717           0 :                             l2_unscale_group(steps, mant, scale1);
     718           0 :                         s->sb_samples[0][k * 12 + l + 2][i] =
     719           0 :                             l2_unscale_group(steps, v, scale0);
     720           0 :                         s->sb_samples[1][k * 12 + l + 2][i] =
     721           0 :                             l2_unscale_group(steps, v, scale1);
     722             :                     } else {
     723           0 :                         for (m = 0; m < 3; m++) {
     724           0 :                             mant = get_bits(&s->gb, bits);
     725           0 :                             s->sb_samples[0][k * 12 + l + m][i] =
     726           0 :                                 l1_unscale(bits - 1, mant, scale0);
     727           0 :                             s->sb_samples[1][k * 12 + l + m][i] =
     728           0 :                                 l1_unscale(bits - 1, mant, scale1);
     729             :                         }
     730             :                     }
     731             :                 } else {
     732           0 :                     s->sb_samples[0][k * 12 + l + 0][i] = 0;
     733           0 :                     s->sb_samples[0][k * 12 + l + 1][i] = 0;
     734           0 :                     s->sb_samples[0][k * 12 + l + 2][i] = 0;
     735           0 :                     s->sb_samples[1][k * 12 + l + 0][i] = 0;
     736           0 :                     s->sb_samples[1][k * 12 + l + 1][i] = 0;
     737           0 :                     s->sb_samples[1][k * 12 + l + 2][i] = 0;
     738             :                 }
     739             :                 /* next subband in alloc table */
     740           0 :                 j += 1 << bit_alloc_bits;
     741             :             }
     742             :             /* fill remaining samples to zero */
     743      153432 :             for (i = sblimit; i < SBLIMIT; i++) {
     744      255744 :                 for (ch = 0; ch < s->nb_channels; ch++) {
     745      143076 :                     s->sb_samples[ch][k * 12 + l + 0][i] = 0;
     746      143076 :                     s->sb_samples[ch][k * 12 + l + 1][i] = 0;
     747      143076 :                     s->sb_samples[ch][k * 12 + l + 2][i] = 0;
     748             :                 }
     749             :             }
     750             :         }
     751             :     }
     752        3397 :     return 3 * 12;
     753             : }
     754             : 
     755             : #define SPLIT(dst,sf,n)             \
     756             :     if (n == 3) {                   \
     757             :         int m = (sf * 171) >> 9;    \
     758             :         dst   = sf - 3 * m;         \
     759             :         sf    = m;                  \
     760             :     } else if (n == 4) {            \
     761             :         dst  = sf & 3;              \
     762             :         sf >>= 2;                   \
     763             :     } else if (n == 5) {            \
     764             :         int m = (sf * 205) >> 10;   \
     765             :         dst   = sf - 5 * m;         \
     766             :         sf    = m;                  \
     767             :     } else if (n == 6) {            \
     768             :         int m = (sf * 171) >> 10;   \
     769             :         dst   = sf - 6 * m;         \
     770             :         sf    = m;                  \
     771             :     } else {                        \
     772             :         dst = 0;                    \
     773             :     }
     774             : 
     775           4 : static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2,
     776             :                                            int n3)
     777             : {
     778           4 :     SPLIT(slen[3], sf, n3)
     779           4 :     SPLIT(slen[2], sf, n2)
     780           4 :     SPLIT(slen[1], sf, n1)
     781           4 :     slen[0] = sf;
     782           4 : }
     783             : 
     784        8110 : static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,
     785             :                                          int16_t *exponents)
     786             : {
     787             :     const uint8_t *bstab, *pretab;
     788             :     int len, i, j, k, l, v0, shift, gain, gains[3];
     789             :     int16_t *exp_ptr;
     790             : 
     791        8110 :     exp_ptr = exponents;
     792        8110 :     gain    = g->global_gain - 210;
     793        8110 :     shift   = g->scalefac_scale + 1;
     794             : 
     795        8110 :     bstab  = band_size_long[s->sample_rate_index];
     796        8110 :     pretab = mpa_pretab[g->preflag];
     797      179968 :     for (i = 0; i < g->long_end; i++) {
     798      171858 :         v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
     799      171858 :         len = bstab[i];
     800     4669158 :         for (j = len; j > 0; j--)
     801     4497300 :             *exp_ptr++ = v0;
     802             :     }
     803             : 
     804        8110 :     if (g->short_start < 13) {
     805         303 :         bstab    = band_size_short[s->sample_rate_index];
     806         303 :         gains[0] = gain - (g->subblock_gain[0] << 3);
     807         303 :         gains[1] = gain - (g->subblock_gain[1] << 3);
     808         303 :         gains[2] = gain - (g->subblock_gain[2] << 3);
     809         303 :         k        = g->long_end;
     810        4203 :         for (i = g->short_start; i < 13; i++) {
     811        3900 :             len = bstab[i];
     812       15600 :             for (l = 0; l < 3; l++) {
     813       11700 :                 v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
     814      185760 :                 for (j = len; j > 0; j--)
     815      174060 :                     *exp_ptr++ = v0;
     816             :             }
     817             :         }
     818             :     }
     819        8110 : }
     820             : 
     821       16795 : static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,
     822             :                           int *end_pos2)
     823             : {
     824       16795 :     if (s->in_gb.buffer && *pos >= s->gb.size_in_bits - s->extrasize * 8) {
     825         939 :         s->gb           = s->in_gb;
     826         939 :         s->in_gb.buffer = NULL;
     827         939 :         s->extrasize    = 0;
     828             :         av_assert2((get_bits_count(&s->gb) & 7) == 0);
     829         939 :         skip_bits_long(&s->gb, *pos - *end_pos);
     830         939 :         *end_pos2 =
     831         939 :         *end_pos  = *end_pos2 + get_bits_count(&s->gb) - *pos;
     832         939 :         *pos      = get_bits_count(&s->gb);
     833             :     }
     834       16795 : }
     835             : 
     836             : /* Following is an optimized code for
     837             :             INTFLOAT v = *src
     838             :             if(get_bits1(&s->gb))
     839             :                 v = -v;
     840             :             *dst = v;
     841             : */
     842             : #if USE_FLOATS
     843             : #define READ_FLIP_SIGN(dst,src)                     \
     844             :     v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31);  \
     845             :     AV_WN32A(dst, v);
     846             : #else
     847             : #define READ_FLIP_SIGN(dst,src)     \
     848             :     v      = -get_bits1(&s->gb);    \
     849             :     *(dst) = (*(src) ^ v) - v;
     850             : #endif
     851             : 
     852        8110 : static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
     853             :                           int16_t *exponents, int end_pos2)
     854             : {
     855             :     int s_index;
     856             :     int i;
     857             :     int last_pos, bits_left;
     858             :     VLC *vlc;
     859        8110 :     int end_pos = FFMIN(end_pos2, s->gb.size_in_bits - s->extrasize * 8);
     860             : 
     861             :     /* low frequencies (called big values) */
     862        8110 :     s_index = 0;
     863       32440 :     for (i = 0; i < 3; i++) {
     864             :         int j, k, l, linbits;
     865       24330 :         j = g->region_size[i];
     866       24330 :         if (j == 0)
     867        1289 :             continue;
     868             :         /* select vlc table */
     869       23041 :         k       = g->table_select[i];
     870       23041 :         l       = mpa_huff_data[k][0];
     871       23041 :         linbits = mpa_huff_data[k][1];
     872       23041 :         vlc     = &huff_vlc[l];
     873             : 
     874       23041 :         if (!l) {
     875          92 :             memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
     876          92 :             s_index += 2 * j;
     877          92 :             continue;
     878             :         }
     879             : 
     880             :         /* read huffcode and compute each couple */
     881      909391 :         for (; j > 0; j--) {
     882             :             int exponent, x, y;
     883             :             int v;
     884      886442 :             int pos = get_bits_count(&s->gb);
     885             : 
     886      886442 :             if (pos >= end_pos){
     887         789 :                 switch_buffer(s, &pos, &end_pos, &end_pos2);
     888         789 :                 if (pos >= end_pos)
     889           0 :                     break;
     890             :             }
     891      886442 :             y = get_vlc2(&s->gb, vlc->table, 7, 3);
     892             : 
     893      886442 :             if (!y) {
     894      215654 :                 g->sb_hybrid[s_index  ] =
     895      215654 :                 g->sb_hybrid[s_index+1] = 0;
     896      215654 :                 s_index += 2;
     897      215654 :                 continue;
     898             :             }
     899             : 
     900      670788 :             exponent= exponents[s_index];
     901             : 
     902             :             ff_dlog(s->avctx, "region=%d n=%d y=%d exp=%d\n",
     903             :                     i, g->region_size[i] - j, y, exponent);
     904      670788 :             if (y & 16) {
     905      426180 :                 x = y >> 5;
     906      426180 :                 y = y & 0x0f;
     907      426180 :                 if (x < 15) {
     908      400232 :                     READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)
     909             :                 } else {
     910       25948 :                     x += get_bitsz(&s->gb, linbits);
     911       25948 :                     v  = l3_unscale(x, exponent);
     912       25948 :                     if (get_bits1(&s->gb))
     913       12440 :                         v = -v;
     914       25948 :                     g->sb_hybrid[s_index] = v;
     915             :                 }
     916      426180 :                 if (y < 15) {
     917      401198 :                     READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)
     918             :                 } else {
     919       24982 :                     y += get_bitsz(&s->gb, linbits);
     920       24982 :                     v  = l3_unscale(y, exponent);
     921       24982 :                     if (get_bits1(&s->gb))
     922       11889 :                         v = -v;
     923       24982 :                     g->sb_hybrid[s_index+1] = v;
     924             :                 }
     925             :             } else {
     926      244608 :                 x = y >> 5;
     927      244608 :                 y = y & 0x0f;
     928      244608 :                 x += y;
     929      244608 :                 if (x < 15) {
     930      238803 :                     READ_FLIP_SIGN(g->sb_hybrid + s_index + !!y, RENAME(expval_table)[exponent] + x)
     931             :                 } else {
     932        5805 :                     x += get_bitsz(&s->gb, linbits);
     933        5805 :                     v  = l3_unscale(x, exponent);
     934        5805 :                     if (get_bits1(&s->gb))
     935        2114 :                         v = -v;
     936        5805 :                     g->sb_hybrid[s_index+!!y] = v;
     937             :                 }
     938      244608 :                 g->sb_hybrid[s_index + !y] = 0;
     939             :             }
     940      670788 :             s_index += 2;
     941             :         }
     942             :     }
     943             : 
     944             :     /* high frequencies */
     945        8110 :     vlc = &huff_quad_vlc[g->count1table_select];
     946        8110 :     last_pos = 0;
     947      234704 :     while (s_index <= 572) {
     948             :         int pos, code;
     949      226293 :         pos = get_bits_count(&s->gb);
     950      226293 :         if (pos >= end_pos) {
     951        7896 :             if (pos > end_pos2 && last_pos) {
     952             :                 /* some encoders generate an incorrect size for this
     953             :                    part. We must go back into the data */
     954           0 :                 s_index -= 4;
     955           0 :                 skip_bits_long(&s->gb, last_pos - pos);
     956           0 :                 av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
     957           0 :                 if(s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
     958           0 :                     s_index=0;
     959        7809 :                 break;
     960             :             }
     961        7896 :             switch_buffer(s, &pos, &end_pos, &end_pos2);
     962        7896 :             if (pos >= end_pos)
     963        7809 :                 break;
     964             :         }
     965      218484 :         last_pos = pos;
     966             : 
     967      218484 :         code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
     968             :         ff_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
     969      218484 :         g->sb_hybrid[s_index+0] =
     970      436968 :         g->sb_hybrid[s_index+1] =
     971      655452 :         g->sb_hybrid[s_index+2] =
     972      436968 :         g->sb_hybrid[s_index+3] = 0;
     973      585103 :         while (code) {
     974             :             static const int idxtab[16] = { 3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0 };
     975             :             int v;
     976      148135 :             int pos = s_index + idxtab[code];
     977      148135 :             code   ^= 8 >> idxtab[code];
     978      148135 :             READ_FLIP_SIGN(g->sb_hybrid + pos, RENAME(exp_table)+exponents[pos])
     979             :         }
     980      218484 :         s_index += 4;
     981             :     }
     982             :     /* skip extension bits */
     983        8110 :     bits_left = end_pos2 - get_bits_count(&s->gb);
     984        8110 :     if (bits_left < 0 && (s->err_recognition & (AV_EF_BUFFER|AV_EF_COMPLIANT))) {
     985           0 :         av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
     986           0 :         s_index=0;
     987        8110 :     } else if (bits_left > 0 && (s->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE))) {
     988           0 :         av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
     989           0 :         s_index = 0;
     990             :     }
     991        8110 :     memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));
     992        8110 :     skip_bits_long(&s->gb, bits_left);
     993             : 
     994        8110 :     i = get_bits_count(&s->gb);
     995        8110 :     switch_buffer(s, &i, &end_pos, &end_pos2);
     996             : 
     997        8110 :     return 0;
     998             : }
     999             : 
    1000             : /* Reorder short blocks from bitstream order to interleaved order. It
    1001             :    would be faster to do it in parsing, but the code would be far more
    1002             :    complicated */
    1003        8110 : static void reorder_block(MPADecodeContext *s, GranuleDef *g)
    1004             : {
    1005             :     int i, j, len;
    1006             :     INTFLOAT *ptr, *dst, *ptr1;
    1007             :     INTFLOAT tmp[576];
    1008             : 
    1009        8110 :     if (g->block_type != 2)
    1010        7807 :         return;
    1011             : 
    1012         303 :     if (g->switch_point) {
    1013          13 :         if (s->sample_rate_index != 8)
    1014          13 :             ptr = g->sb_hybrid + 36;
    1015             :         else
    1016           0 :             ptr = g->sb_hybrid + 72;
    1017             :     } else {
    1018         290 :         ptr = g->sb_hybrid;
    1019             :     }
    1020             : 
    1021        4203 :     for (i = g->short_start; i < 13; i++) {
    1022        3900 :         len  = band_size_short[s->sample_rate_index][i];
    1023        3900 :         ptr1 = ptr;
    1024        3900 :         dst  = tmp;
    1025       61920 :         for (j = len; j > 0; j--) {
    1026       58020 :             *dst++ = ptr[0*len];
    1027       58020 :             *dst++ = ptr[1*len];
    1028       58020 :             *dst++ = ptr[2*len];
    1029       58020 :             ptr++;
    1030             :         }
    1031        3900 :         ptr += 2 * len;
    1032        3900 :         memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
    1033             :     }
    1034             : }
    1035             : 
    1036             : #define ISQRT2 FIXR(0.70710678118654752440)
    1037             : 
    1038        2447 : static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
    1039             : {
    1040             :     int i, j, k, l;
    1041             :     int sf_max, sf, len, non_zero_found;
    1042             :     INTFLOAT (*is_tab)[16], *tab0, *tab1, v1, v2;
    1043             :     SUINTFLOAT tmp0, tmp1;
    1044             :     int non_zero_found_short[3];
    1045             : 
    1046             :     /* intensity stereo */
    1047        2447 :     if (s->mode_ext & MODE_EXT_I_STEREO) {
    1048           1 :         if (!s->lsf) {
    1049           0 :             is_tab = is_table;
    1050           0 :             sf_max = 7;
    1051             :         } else {
    1052           1 :             is_tab = is_table_lsf[g1->scalefac_compress & 1];
    1053           1 :             sf_max = 16;
    1054             :         }
    1055             : 
    1056           1 :         tab0 = g0->sb_hybrid + 576;
    1057           1 :         tab1 = g1->sb_hybrid + 576;
    1058             : 
    1059           1 :         non_zero_found_short[0] = 0;
    1060           1 :         non_zero_found_short[1] = 0;
    1061           1 :         non_zero_found_short[2] = 0;
    1062           1 :         k = (13 - g1->short_start) * 3 + g1->long_end - 3;
    1063           1 :         for (i = 12; i >= g1->short_start; i--) {
    1064             :             /* for last band, use previous scale factor */
    1065           0 :             if (i != 11)
    1066           0 :                 k -= 3;
    1067           0 :             len = band_size_short[s->sample_rate_index][i];
    1068           0 :             for (l = 2; l >= 0; l--) {
    1069           0 :                 tab0 -= len;
    1070           0 :                 tab1 -= len;
    1071           0 :                 if (!non_zero_found_short[l]) {
    1072             :                     /* test if non zero band. if so, stop doing i-stereo */
    1073           0 :                     for (j = 0; j < len; j++) {
    1074           0 :                         if (tab1[j] != 0) {
    1075           0 :                             non_zero_found_short[l] = 1;
    1076           0 :                             goto found1;
    1077             :                         }
    1078             :                     }
    1079           0 :                     sf = g1->scale_factors[k + l];
    1080           0 :                     if (sf >= sf_max)
    1081           0 :                         goto found1;
    1082             : 
    1083           0 :                     v1 = is_tab[0][sf];
    1084           0 :                     v2 = is_tab[1][sf];
    1085           0 :                     for (j = 0; j < len; j++) {
    1086           0 :                         tmp0    = tab0[j];
    1087           0 :                         tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
    1088           0 :                         tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
    1089             :                     }
    1090             :                 } else {
    1091           0 : found1:
    1092           0 :                     if (s->mode_ext & MODE_EXT_MS_STEREO) {
    1093             :                         /* lower part of the spectrum : do ms stereo
    1094             :                            if enabled */
    1095           0 :                         for (j = 0; j < len; j++) {
    1096           0 :                             tmp0    = tab0[j];
    1097           0 :                             tmp1    = tab1[j];
    1098           0 :                             tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
    1099           0 :                             tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
    1100             :                         }
    1101             :                     }
    1102             :                 }
    1103             :             }
    1104             :         }
    1105             : 
    1106           3 :         non_zero_found = non_zero_found_short[0] |
    1107           1 :                          non_zero_found_short[1] |
    1108           1 :                          non_zero_found_short[2];
    1109             : 
    1110          23 :         for (i = g1->long_end - 1;i >= 0;i--) {
    1111          22 :             len   = band_size_long[s->sample_rate_index][i];
    1112          22 :             tab0 -= len;
    1113          22 :             tab1 -= len;
    1114             :             /* test if non zero band. if so, stop doing i-stereo */
    1115          22 :             if (!non_zero_found) {
    1116         598 :                 for (j = 0; j < len; j++) {
    1117         576 :                     if (tab1[j] != 0) {
    1118           0 :                         non_zero_found = 1;
    1119           0 :                         goto found2;
    1120             :                     }
    1121             :                 }
    1122             :                 /* for last band, use previous scale factor */
    1123          22 :                 k  = (i == 21) ? 20 : i;
    1124          22 :                 sf = g1->scale_factors[k];
    1125          22 :                 if (sf >= sf_max)
    1126           0 :                     goto found2;
    1127          22 :                 v1 = is_tab[0][sf];
    1128          22 :                 v2 = is_tab[1][sf];
    1129         598 :                 for (j = 0; j < len; j++) {
    1130         576 :                     tmp0    = tab0[j];
    1131         576 :                     tab0[j] = MULLx(tmp0, v1, FRAC_BITS);
    1132         576 :                     tab1[j] = MULLx(tmp0, v2, FRAC_BITS);
    1133             :                 }
    1134             :             } else {
    1135           0 : found2:
    1136           0 :                 if (s->mode_ext & MODE_EXT_MS_STEREO) {
    1137             :                     /* lower part of the spectrum : do ms stereo
    1138             :                        if enabled */
    1139           0 :                     for (j = 0; j < len; j++) {
    1140           0 :                         tmp0    = tab0[j];
    1141           0 :                         tmp1    = tab1[j];
    1142           0 :                         tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);
    1143           0 :                         tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);
    1144             :                     }
    1145             :                 }
    1146             :             }
    1147             :         }
    1148        2446 :     } else if (s->mode_ext & MODE_EXT_MS_STEREO) {
    1149             :         /* ms stereo ONLY */
    1150             :         /* NOTE: the 1/sqrt(2) normalization factor is included in the
    1151             :            global gain */
    1152             : #if USE_FLOATS
    1153           0 :        s->fdsp->butterflies_float(g0->sb_hybrid, g1->sb_hybrid, 576);
    1154             : #else
    1155        2228 :         tab0 = g0->sb_hybrid;
    1156        2228 :         tab1 = g1->sb_hybrid;
    1157     1285556 :         for (i = 0; i < 576; i++) {
    1158     1283328 :             tmp0    = tab0[i];
    1159     1283328 :             tmp1    = tab1[i];
    1160     1283328 :             tab0[i] = tmp0 + tmp1;
    1161     1283328 :             tab1[i] = tmp0 - tmp1;
    1162             :         }
    1163             : #endif
    1164             :     }
    1165        2447 : }
    1166             : 
    1167             : #if USE_FLOATS
    1168             : #if HAVE_MIPSFPU
    1169             : #   include "mips/compute_antialias_float.h"
    1170             : #endif /* HAVE_MIPSFPU */
    1171             : #else
    1172             : #if HAVE_MIPSDSP
    1173             : #   include "mips/compute_antialias_fixed.h"
    1174             : #endif /* HAVE_MIPSDSP */
    1175             : #endif /* USE_FLOATS */
    1176             : 
    1177             : #ifndef compute_antialias
    1178             : #if USE_FLOATS
    1179             : #define AA(j) do {                                                      \
    1180             :         float tmp0 = ptr[-1-j];                                         \
    1181             :         float tmp1 = ptr[   j];                                         \
    1182             :         ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1];    \
    1183             :         ptr[   j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0];    \
    1184             :     } while (0)
    1185             : #else
    1186             : #define AA(j) do {                                              \
    1187             :         SUINT tmp0 = ptr[-1-j];                                   \
    1188             :         SUINT tmp1 = ptr[   j];                                   \
    1189             :         SUINT tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]);          \
    1190             :         ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2]));   \
    1191             :         ptr[   j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3]));   \
    1192             :     } while (0)
    1193             : #endif
    1194             : 
    1195        8110 : static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
    1196             : {
    1197             :     INTFLOAT *ptr;
    1198             :     int n, i;
    1199             : 
    1200             :     /* we antialias only "long" bands */
    1201        8110 :     if (g->block_type == 2) {
    1202         303 :         if (!g->switch_point)
    1203         290 :             return;
    1204             :         /* XXX: check this for 8000Hz case */
    1205          13 :         n = 1;
    1206             :     } else {
    1207        7807 :         n = SBLIMIT - 1;
    1208             :     }
    1209             : 
    1210        7820 :     ptr = g->sb_hybrid + 18;
    1211      249850 :     for (i = n; i > 0; i--) {
    1212      242030 :         AA(0);
    1213      242030 :         AA(1);
    1214      242030 :         AA(2);
    1215      242030 :         AA(3);
    1216      242030 :         AA(4);
    1217      242030 :         AA(5);
    1218      242030 :         AA(6);
    1219      242030 :         AA(7);
    1220             : 
    1221      242030 :         ptr += 18;
    1222             :     }
    1223             : }
    1224             : #endif /* compute_antialias */
    1225             : 
    1226        8114 : static void compute_imdct(MPADecodeContext *s, GranuleDef *g,
    1227             :                           INTFLOAT *sb_samples, INTFLOAT *mdct_buf)
    1228             : {
    1229             :     INTFLOAT *win, *out_ptr, *ptr, *buf, *ptr1;
    1230             :     INTFLOAT out2[12];
    1231             :     int i, j, mdct_long_end, sblimit;
    1232             : 
    1233             :     /* find last non zero block */
    1234        8114 :     ptr  = g->sb_hybrid + 576;
    1235        8114 :     ptr1 = g->sb_hybrid + 2 * 18;
    1236      320053 :     while (ptr >= ptr1) {
    1237             :         int32_t *p;
    1238      311757 :         ptr -= 6;
    1239      311757 :         p    = (int32_t*)ptr;
    1240      311757 :         if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])
    1241        7932 :             break;
    1242             :     }
    1243        8114 :     sblimit = ((ptr - g->sb_hybrid) / 18) + 1;
    1244             : 
    1245        8114 :     if (g->block_type == 2) {
    1246             :         /* XXX: check for 8000 Hz */
    1247         304 :         if (g->switch_point)
    1248          13 :             mdct_long_end = 2;
    1249             :         else
    1250         291 :             mdct_long_end = 0;
    1251             :     } else {
    1252        7810 :         mdct_long_end = sblimit;
    1253             :     }
    1254             : 
    1255       24342 :     s->mpadsp.RENAME(imdct36_blocks)(sb_samples, mdct_buf, g->sb_hybrid,
    1256        8114 :                                      mdct_long_end, g->switch_point,
    1257        8114 :                                      g->block_type);
    1258             : 
    1259        8114 :     buf = mdct_buf + 4*18*(mdct_long_end >> 2) + (mdct_long_end & 3);
    1260        8114 :     ptr = g->sb_hybrid + 18 * mdct_long_end;
    1261             : 
    1262       14550 :     for (j = mdct_long_end; j < sblimit; j++) {
    1263             :         /* select frequency inversion */
    1264        6436 :         win     = RENAME(ff_mdct_win)[2 + (4  & -(j & 1))];
    1265        6436 :         out_ptr = sb_samples + j;
    1266             : 
    1267       45052 :         for (i = 0; i < 6; i++) {
    1268       38616 :             *out_ptr = buf[4*i];
    1269       38616 :             out_ptr += SBLIMIT;
    1270             :         }
    1271        6436 :         imdct12(out2, ptr + 0);
    1272       45052 :         for (i = 0; i < 6; i++) {
    1273       38616 :             *out_ptr     = MULH3(out2[i    ], win[i    ], 1) + buf[4*(i + 6*1)];
    1274       38616 :             buf[4*(i + 6*2)] = MULH3(out2[i + 6], win[i + 6], 1);
    1275       38616 :             out_ptr += SBLIMIT;
    1276             :         }
    1277        6436 :         imdct12(out2, ptr + 1);
    1278       45052 :         for (i = 0; i < 6; i++) {
    1279       38616 :             *out_ptr     = MULH3(out2[i    ], win[i    ], 1) + buf[4*(i + 6*2)];
    1280       38616 :             buf[4*(i + 6*0)] = MULH3(out2[i + 6], win[i + 6], 1);
    1281       38616 :             out_ptr += SBLIMIT;
    1282             :         }
    1283        6436 :         imdct12(out2, ptr + 2);
    1284       45052 :         for (i = 0; i < 6; i++) {
    1285       38616 :             buf[4*(i + 6*0)] = MULH3(out2[i    ], win[i    ], 1) + buf[4*(i + 6*0)];
    1286       38616 :             buf[4*(i + 6*1)] = MULH3(out2[i + 6], win[i + 6], 1);
    1287       38616 :             buf[4*(i + 6*2)] = 0;
    1288             :         }
    1289        6436 :         ptr += 18;
    1290        6436 :         buf += (j&3) != 3 ? 1 : (4*18-3);
    1291             :     }
    1292             :     /* zero bands */
    1293      105653 :     for (j = sblimit; j < SBLIMIT; j++) {
    1294             :         /* overlap */
    1295       97539 :         out_ptr = sb_samples + j;
    1296     1853241 :         for (i = 0; i < 18; i++) {
    1297     1755702 :             *out_ptr = buf[4*i];
    1298     1755702 :             buf[4*i]   = 0;
    1299     1755702 :             out_ptr += SBLIMIT;
    1300             :         }
    1301       97539 :         buf += (j&3) != 3 ? 1 : (4*18-3);
    1302             :     }
    1303        8114 : }
    1304             : 
    1305             : /* main layer3 decoding function */
    1306        2802 : static int mp_decode_layer3(MPADecodeContext *s)
    1307             : {
    1308             :     int nb_granules, main_data_begin;
    1309             :     int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
    1310             :     GranuleDef *g;
    1311             :     int16_t exponents[576]; //FIXME try INTFLOAT
    1312             : 
    1313             :     /* read side info */
    1314        2802 :     if (s->lsf) {
    1315           3 :         main_data_begin = get_bits(&s->gb, 8);
    1316           3 :         skip_bits(&s->gb, s->nb_channels);
    1317           3 :         nb_granules = 1;
    1318             :     } else {
    1319        2799 :         main_data_begin = get_bits(&s->gb, 9);
    1320        2799 :         if (s->nb_channels == 2)
    1321        1256 :             skip_bits(&s->gb, 3);
    1322             :         else
    1323        1543 :             skip_bits(&s->gb, 5);
    1324        2799 :         nb_granules = 2;
    1325        6854 :         for (ch = 0; ch < s->nb_channels; ch++) {
    1326        4055 :             s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
    1327        4055 :             s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
    1328             :         }
    1329             :     }
    1330             : 
    1331        8403 :     for (gr = 0; gr < nb_granules; gr++) {
    1332       13715 :         for (ch = 0; ch < s->nb_channels; ch++) {
    1333             :             ff_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
    1334        8114 :             g = &s->granules[ch][gr];
    1335        8114 :             g->part2_3_length = get_bits(&s->gb, 12);
    1336        8114 :             g->big_values     = get_bits(&s->gb,  9);
    1337        8114 :             if (g->big_values > 288) {
    1338           0 :                 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
    1339           0 :                 return AVERROR_INVALIDDATA;
    1340             :             }
    1341             : 
    1342        8114 :             g->global_gain = get_bits(&s->gb, 8);
    1343             :             /* if MS stereo only is selected, we precompute the
    1344             :                1/sqrt(2) renormalization factor */
    1345        8114 :             if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
    1346             :                 MODE_EXT_MS_STEREO)
    1347        4456 :                 g->global_gain -= 2;
    1348        8114 :             if (s->lsf)
    1349           4 :                 g->scalefac_compress = get_bits(&s->gb, 9);
    1350             :             else
    1351        8110 :                 g->scalefac_compress = get_bits(&s->gb, 4);
    1352        8114 :             blocksplit_flag = get_bits1(&s->gb);
    1353        8114 :             if (blocksplit_flag) {
    1354         843 :                 g->block_type = get_bits(&s->gb, 2);
    1355         843 :                 if (g->block_type == 0) {
    1356           0 :                     av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
    1357           0 :                     return AVERROR_INVALIDDATA;
    1358             :                 }
    1359         843 :                 g->switch_point = get_bits1(&s->gb);
    1360        2529 :                 for (i = 0; i < 2; i++)
    1361        1686 :                     g->table_select[i] = get_bits(&s->gb, 5);
    1362        3372 :                 for (i = 0; i < 3; i++)
    1363        2529 :                     g->subblock_gain[i] = get_bits(&s->gb, 3);
    1364         843 :                 init_short_region(s, g);
    1365             :             } else {
    1366             :                 int region_address1, region_address2;
    1367        7271 :                 g->block_type = 0;
    1368        7271 :                 g->switch_point = 0;
    1369       29084 :                 for (i = 0; i < 3; i++)
    1370       21813 :                     g->table_select[i] = get_bits(&s->gb, 5);
    1371             :                 /* compute huffman coded region sizes */
    1372        7271 :                 region_address1 = get_bits(&s->gb, 4);
    1373        7271 :                 region_address2 = get_bits(&s->gb, 3);
    1374             :                 ff_dlog(s->avctx, "region1=%d region2=%d\n",
    1375             :                         region_address1, region_address2);
    1376        7271 :                 init_long_region(s, g, region_address1, region_address2);
    1377             :             }
    1378        8114 :             region_offset2size(g);
    1379        8114 :             compute_band_indexes(s, g);
    1380             : 
    1381        8114 :             g->preflag = 0;
    1382        8114 :             if (!s->lsf)
    1383        8110 :                 g->preflag = get_bits1(&s->gb);
    1384        8114 :             g->scalefac_scale     = get_bits1(&s->gb);
    1385        8114 :             g->count1table_select = get_bits1(&s->gb);
    1386             :             ff_dlog(s->avctx, "block_type=%d switch_point=%d\n",
    1387             :                     g->block_type, g->switch_point);
    1388             :         }
    1389             :     }
    1390             : 
    1391        2802 :     if (!s->adu_mode) {
    1392             :         int skip;
    1393        2802 :         const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
    1394        2802 :         s->extrasize = av_clip((get_bits_left(&s->gb) >> 3) - s->extrasize, 0,
    1395        2802 :                                FFMAX(0, LAST_BUF_SIZE - s->last_buf_size));
    1396             :         av_assert1((get_bits_count(&s->gb) & 7) == 0);
    1397             :         /* now we get bits from the main_data_begin offset */
    1398             :         ff_dlog(s->avctx, "seekback:%d, lastbuf:%d\n",
    1399             :                 main_data_begin, s->last_buf_size);
    1400             : 
    1401        2802 :         memcpy(s->last_buf + s->last_buf_size, ptr, s->extrasize);
    1402        2802 :         s->in_gb = s->gb;
    1403        2802 :         init_get_bits(&s->gb, s->last_buf, (s->last_buf_size + s->extrasize) * 8);
    1404        2802 :         s->last_buf_size <<= 3;
    1405        2806 :         for (gr = 0; gr < nb_granules && (s->last_buf_size >> 3) < main_data_begin; gr++) {
    1406           8 :             for (ch = 0; ch < s->nb_channels; ch++) {
    1407           4 :                 g = &s->granules[ch][gr];
    1408           4 :                 s->last_buf_size += g->part2_3_length;
    1409           4 :                 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
    1410           4 :                 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
    1411             :             }
    1412             :         }
    1413        2802 :         skip = s->last_buf_size - 8 * main_data_begin;
    1414        2802 :         if (skip >= s->gb.size_in_bits - s->extrasize * 8 && s->in_gb.buffer) {
    1415         144 :             skip_bits_long(&s->in_gb, skip - s->gb.size_in_bits + s->extrasize * 8);
    1416         144 :             s->gb           = s->in_gb;
    1417         144 :             s->in_gb.buffer = NULL;
    1418         144 :             s->extrasize    = 0;
    1419             :         } else {
    1420        2658 :             skip_bits_long(&s->gb, skip);
    1421             :         }
    1422             :     } else {
    1423           0 :         gr = 0;
    1424           0 :         s->extrasize = 0;
    1425             :     }
    1426             : 
    1427        8399 :     for (; gr < nb_granules; gr++) {
    1428       13707 :         for (ch = 0; ch < s->nb_channels; ch++) {
    1429        8110 :             g = &s->granules[ch][gr];
    1430        8110 :             bits_pos = get_bits_count(&s->gb);
    1431             : 
    1432        8110 :             if (!s->lsf) {
    1433             :                 uint8_t *sc;
    1434             :                 int slen, slen1, slen2;
    1435             : 
    1436             :                 /* MPEG-1 scale factors */
    1437        8106 :                 slen1 = slen_table[0][g->scalefac_compress];
    1438        8106 :                 slen2 = slen_table[1][g->scalefac_compress];
    1439             :                 ff_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
    1440        8106 :                 if (g->block_type == 2) {
    1441         303 :                     n = g->switch_point ? 17 : 18;
    1442         303 :                     j = 0;
    1443         303 :                     if (slen1) {
    1444         737 :                         for (i = 0; i < n; i++)
    1445         698 :                             g->scale_factors[j++] = get_bits(&s->gb, slen1);
    1446             :                     } else {
    1447        5007 :                         for (i = 0; i < n; i++)
    1448        4743 :                             g->scale_factors[j++] = 0;
    1449             :                     }
    1450         303 :                     if (slen2) {
    1451        4807 :                         for (i = 0; i < 18; i++)
    1452        4554 :                             g->scale_factors[j++] = get_bits(&s->gb, slen2);
    1453        1012 :                         for (i = 0; i < 3; i++)
    1454         759 :                             g->scale_factors[j++] = 0;
    1455             :                     } else {
    1456        1100 :                         for (i = 0; i < 21; i++)
    1457        1050 :                             g->scale_factors[j++] = 0;
    1458             :                     }
    1459             :                 } else {
    1460        7803 :                     sc = s->granules[ch][0].scale_factors;
    1461        7803 :                     j = 0;
    1462       39015 :                     for (k = 0; k < 4; k++) {
    1463       31212 :                         n = k == 0 ? 6 : 5;
    1464       31212 :                         if ((g->scfsi & (0x8 >> k)) == 0) {
    1465       26866 :                             slen = (k < 2) ? slen1 : slen2;
    1466       26866 :                             if (slen) {
    1467       88804 :                                 for (i = 0; i < n; i++)
    1468       74446 :                                     g->scale_factors[j++] = get_bits(&s->gb, slen);
    1469             :                             } else {
    1470       78786 :                                 for (i = 0; i < n; i++)
    1471       66278 :                                     g->scale_factors[j++] = 0;
    1472             :                             }
    1473             :                         } else {
    1474             :                             /* simply copy from last granule */
    1475       27485 :                             for (i = 0; i < n; i++) {
    1476       23139 :                                 g->scale_factors[j] = sc[j];
    1477       23139 :                                 j++;
    1478             :                             }
    1479             :                         }
    1480             :                     }
    1481        7803 :                     g->scale_factors[j++] = 0;
    1482             :                 }
    1483             :             } else {
    1484             :                 int tindex, tindex2, slen[4], sl, sf;
    1485             : 
    1486             :                 /* LSF scale factors */
    1487           4 :                 if (g->block_type == 2)
    1488           0 :                     tindex = g->switch_point ? 2 : 1;
    1489             :                 else
    1490           4 :                     tindex = 0;
    1491             : 
    1492           4 :                 sf = g->scalefac_compress;
    1493           4 :                 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
    1494             :                     /* intensity stereo case */
    1495           1 :                     sf >>= 1;
    1496           2 :                     if (sf < 180) {
    1497           1 :                         lsf_sf_expand(slen, sf, 6, 6, 0);
    1498           1 :                         tindex2 = 3;
    1499           0 :                     } else if (sf < 244) {
    1500           0 :                         lsf_sf_expand(slen, sf - 180, 4, 4, 0);
    1501           0 :                         tindex2 = 4;
    1502             :                     } else {
    1503           0 :                         lsf_sf_expand(slen, sf - 244, 3, 0, 0);
    1504           0 :                         tindex2 = 5;
    1505             :                     }
    1506             :                 } else {
    1507             :                     /* normal case */
    1508           3 :                     if (sf < 400) {
    1509           1 :                         lsf_sf_expand(slen, sf, 5, 4, 4);
    1510           1 :                         tindex2 = 0;
    1511           2 :                     } else if (sf < 500) {
    1512           2 :                         lsf_sf_expand(slen, sf - 400, 5, 4, 0);
    1513           2 :                         tindex2 = 1;
    1514             :                     } else {
    1515           0 :                         lsf_sf_expand(slen, sf - 500, 3, 0, 0);
    1516           0 :                         tindex2 = 2;
    1517           0 :                         g->preflag = 1;
    1518             :                     }
    1519             :                 }
    1520             : 
    1521           4 :                 j = 0;
    1522          20 :                 for (k = 0; k < 4; k++) {
    1523          16 :                     n  = lsf_nsf_table[tindex2][tindex][k];
    1524          16 :                     sl = slen[k];
    1525          16 :                     if (sl) {
    1526          45 :                         for (i = 0; i < n; i++)
    1527          39 :                             g->scale_factors[j++] = get_bits(&s->gb, sl);
    1528             :                     } else {
    1529          55 :                         for (i = 0; i < n; i++)
    1530          45 :                             g->scale_factors[j++] = 0;
    1531             :                     }
    1532             :                 }
    1533             :                 /* XXX: should compute exact size */
    1534          80 :                 for (; j < 40; j++)
    1535          76 :                     g->scale_factors[j] = 0;
    1536             :             }
    1537             : 
    1538        8110 :             exponents_from_scale_factors(s, g, exponents);
    1539             : 
    1540             :             /* read Huffman coded residue */
    1541        8110 :             huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
    1542             :         } /* ch */
    1543             : 
    1544        5597 :         if (s->mode == MPA_JSTEREO)
    1545        2447 :             compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);
    1546             : 
    1547       13707 :         for (ch = 0; ch < s->nb_channels; ch++) {
    1548        8110 :             g = &s->granules[ch][gr];
    1549             : 
    1550        8110 :             reorder_block(s, g);
    1551        8110 :             compute_antialias(s, g);
    1552        8110 :             compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
    1553             :         }
    1554             :     } /* gr */
    1555        2802 :     if (get_bits_count(&s->gb) < 0)
    1556           0 :         skip_bits_long(&s->gb, -get_bits_count(&s->gb));
    1557        2802 :     return nb_granules * 18;
    1558             : }
    1559             : 
    1560        6199 : static int mp_decode_frame(MPADecodeContext *s, OUT_INT **samples,
    1561             :                            const uint8_t *buf, int buf_size)
    1562             : {
    1563             :     int i, nb_frames, ch, ret;
    1564             :     OUT_INT *samples_ptr;
    1565             : 
    1566        6199 :     init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
    1567             : 
    1568             :     /* skip error protection field */
    1569        6199 :     if (s->error_protection)
    1570         117 :         skip_bits(&s->gb, 16);
    1571             : 
    1572        6199 :     switch(s->layer) {
    1573           0 :     case 1:
    1574           0 :         s->avctx->frame_size = 384;
    1575           0 :         nb_frames = mp_decode_layer1(s);
    1576           0 :         break;
    1577        3397 :     case 2:
    1578        3397 :         s->avctx->frame_size = 1152;
    1579        3397 :         nb_frames = mp_decode_layer2(s);
    1580        3397 :         break;
    1581        2802 :     case 3:
    1582        2802 :         s->avctx->frame_size = s->lsf ? 576 : 1152;
    1583        2802 :     default:
    1584        2802 :         nb_frames = mp_decode_layer3(s);
    1585             : 
    1586        2802 :         s->last_buf_size=0;
    1587        2802 :         if (s->in_gb.buffer) {
    1588        1719 :             align_get_bits(&s->gb);
    1589        1719 :             i = (get_bits_left(&s->gb) >> 3) - s->extrasize;
    1590        1719 :             if (i >= 0 && i <= BACKSTEP_SIZE) {
    1591        1719 :                 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
    1592        1719 :                 s->last_buf_size=i;
    1593             :             } else
    1594           0 :                 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
    1595        1719 :             s->gb           = s->in_gb;
    1596        1719 :             s->in_gb.buffer = NULL;
    1597        1719 :             s->extrasize    = 0;
    1598             :         }
    1599             : 
    1600        2802 :         align_get_bits(&s->gb);
    1601             :         av_assert1((get_bits_count(&s->gb) & 7) == 0);
    1602        2802 :         i = (get_bits_left(&s->gb) >> 3) - s->extrasize;
    1603        2802 :         if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {
    1604         230 :             if (i < 0)
    1605           0 :                 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
    1606         230 :             i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
    1607             :         }
    1608             :         av_assert1(i <= buf_size - HEADER_SIZE && i >= 0);
    1609        2802 :         memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
    1610        2802 :         s->last_buf_size += i;
    1611             :     }
    1612             : 
    1613        6199 :     if(nb_frames < 0)
    1614           0 :         return nb_frames;
    1615             : 
    1616             :     /* get output buffer */
    1617        6199 :     if (!samples) {
    1618        6199 :         av_assert0(s->frame);
    1619        6199 :         s->frame->nb_samples = s->avctx->frame_size;
    1620        6199 :         if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0)
    1621           0 :             return ret;
    1622        6199 :         samples = (OUT_INT **)s->frame->extended_data;
    1623             :     }
    1624             : 
    1625             :     /* apply the synthesis filter */
    1626       14301 :     for (ch = 0; ch < s->nb_channels; ch++) {
    1627             :         int sample_stride;
    1628        8102 :         if (s->avctx->sample_fmt == OUT_FMT_P) {
    1629        8102 :             samples_ptr   = samples[ch];
    1630        8102 :             sample_stride = 1;
    1631             :         } else {
    1632           0 :             samples_ptr   = samples[0] + ch;
    1633           0 :             sample_stride = s->nb_channels;
    1634             :         }
    1635      299702 :         for (i = 0; i < nb_frames; i++) {
    1636      291600 :             RENAME(ff_mpa_synth_filter)(&s->mpadsp, s->synth_buf[ch],
    1637             :                                         &(s->synth_buf_offset[ch]),
    1638             :                                         RENAME(ff_mpa_synth_window),
    1639             :                                         &s->dither_state, samples_ptr,
    1640      291600 :                                         sample_stride, s->sb_samples[ch][i]);
    1641      291600 :             samples_ptr += 32 * sample_stride;
    1642             :         }
    1643             :     }
    1644             : 
    1645        6199 :     return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
    1646             : }
    1647             : 
    1648        6201 : static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
    1649             :                         AVPacket *avpkt)
    1650             : {
    1651        6201 :     const uint8_t *buf  = avpkt->data;
    1652        6201 :     int buf_size        = avpkt->size;
    1653        6201 :     MPADecodeContext *s = avctx->priv_data;
    1654             :     uint32_t header;
    1655             :     int ret;
    1656             : 
    1657        6201 :     int skipped = 0;
    1658       12402 :     while(buf_size && !*buf){
    1659           0 :         buf++;
    1660           0 :         buf_size--;
    1661           0 :         skipped++;
    1662             :     }
    1663             : 
    1664        6201 :     if (buf_size < HEADER_SIZE)
    1665           0 :         return AVERROR_INVALIDDATA;
    1666             : 
    1667        6201 :     header = AV_RB32(buf);
    1668        6201 :     if (header>>8 == AV_RB32("TAG")>>8) {
    1669           0 :         av_log(avctx, AV_LOG_DEBUG, "discarding ID3 tag\n");
    1670           0 :         return buf_size + skipped;
    1671             :     }
    1672        6201 :     ret = avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
    1673        6201 :     if (ret < 0) {
    1674           2 :         av_log(avctx, AV_LOG_ERROR, "Header missing\n");
    1675           2 :         return AVERROR_INVALIDDATA;
    1676        6199 :     } else if (ret == 1) {
    1677             :         /* free format: prepare to compute frame size */
    1678           0 :         s->frame_size = -1;
    1679           0 :         return AVERROR_INVALIDDATA;
    1680             :     }
    1681             :     /* update codec info */
    1682        6199 :     avctx->channels       = s->nb_channels;
    1683        6199 :     avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
    1684        6199 :     if (!avctx->bit_rate)
    1685           4 :         avctx->bit_rate = s->bit_rate;
    1686             : 
    1687        6199 :     if (s->frame_size <= 0) {
    1688           0 :         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
    1689           0 :         return AVERROR_INVALIDDATA;
    1690        6199 :     } else if (s->frame_size < buf_size) {
    1691           0 :         av_log(avctx, AV_LOG_DEBUG, "incorrect frame size - multiple frames in buffer?\n");
    1692           0 :         buf_size= s->frame_size;
    1693             :     }
    1694             : 
    1695        6199 :     s->frame = data;
    1696             : 
    1697        6199 :     ret = mp_decode_frame(s, NULL, buf, buf_size);
    1698        6199 :     if (ret >= 0) {
    1699        6199 :         s->frame->nb_samples = avctx->frame_size;
    1700        6199 :         *got_frame_ptr       = 1;
    1701        6199 :         avctx->sample_rate   = s->sample_rate;
    1702             :         //FIXME maybe move the other codec info stuff from above here too
    1703             :     } else {
    1704           0 :         av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
    1705             :         /* Only return an error if the bad frame makes up the whole packet or
    1706             :          * the error is related to buffer management.
    1707             :          * If there is more data in the packet, just consume the bad frame
    1708             :          * instead of returning an error, which would discard the whole
    1709             :          * packet. */
    1710           0 :         *got_frame_ptr = 0;
    1711           0 :         if (buf_size == avpkt->size || ret != AVERROR_INVALIDDATA)
    1712           0 :             return ret;
    1713             :     }
    1714        6199 :     s->frame_size = 0;
    1715        6199 :     return buf_size + skipped;
    1716             : }
    1717             : 
    1718           0 : static void mp_flush(MPADecodeContext *ctx)
    1719             : {
    1720           0 :     memset(ctx->synth_buf, 0, sizeof(ctx->synth_buf));
    1721           0 :     memset(ctx->mdct_buf, 0, sizeof(ctx->mdct_buf));
    1722           0 :     ctx->last_buf_size = 0;
    1723           0 :     ctx->dither_state = 0;
    1724           0 : }
    1725             : 
    1726           0 : static void flush(AVCodecContext *avctx)
    1727             : {
    1728           0 :     mp_flush(avctx->priv_data);
    1729           0 : }
    1730             : 
    1731             : #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
    1732           0 : static int decode_frame_adu(AVCodecContext *avctx, void *data,
    1733             :                             int *got_frame_ptr, AVPacket *avpkt)
    1734             : {
    1735           0 :     const uint8_t *buf  = avpkt->data;
    1736           0 :     int buf_size        = avpkt->size;
    1737           0 :     MPADecodeContext *s = avctx->priv_data;
    1738             :     uint32_t header;
    1739             :     int len, ret;
    1740             :     int av_unused out_size;
    1741             : 
    1742           0 :     len = buf_size;
    1743             : 
    1744             :     // Discard too short frames
    1745           0 :     if (buf_size < HEADER_SIZE) {
    1746           0 :         av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
    1747           0 :         return AVERROR_INVALIDDATA;
    1748             :     }
    1749             : 
    1750             : 
    1751           0 :     if (len > MPA_MAX_CODED_FRAME_SIZE)
    1752           0 :         len = MPA_MAX_CODED_FRAME_SIZE;
    1753             : 
    1754             :     // Get header and restore sync word
    1755           0 :     header = AV_RB32(buf) | 0xffe00000;
    1756             : 
    1757           0 :     ret = avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
    1758           0 :     if (ret < 0) {
    1759           0 :         av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
    1760           0 :         return ret;
    1761             :     }
    1762             :     /* update codec info */
    1763           0 :     avctx->sample_rate = s->sample_rate;
    1764           0 :     avctx->channels    = s->nb_channels;
    1765           0 :     avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
    1766           0 :     if (!avctx->bit_rate)
    1767           0 :         avctx->bit_rate = s->bit_rate;
    1768             : 
    1769           0 :     s->frame_size = len;
    1770             : 
    1771           0 :     s->frame = data;
    1772             : 
    1773           0 :     ret = mp_decode_frame(s, NULL, buf, buf_size);
    1774           0 :     if (ret < 0) {
    1775           0 :         av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
    1776           0 :         return ret;
    1777             :     }
    1778             : 
    1779           0 :     *got_frame_ptr = 1;
    1780             : 
    1781           0 :     return buf_size;
    1782             : }
    1783             : #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
    1784             : 
    1785             : #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
    1786             : 
    1787             : /**
    1788             :  * Context for MP3On4 decoder
    1789             :  */
    1790             : typedef struct MP3On4DecodeContext {
    1791             :     int frames;                     ///< number of mp3 frames per block (number of mp3 decoder instances)
    1792             :     int syncword;                   ///< syncword patch
    1793             :     const uint8_t *coff;            ///< channel offsets in output buffer
    1794             :     MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
    1795             : } MP3On4DecodeContext;
    1796             : 
    1797             : #include "mpeg4audio.h"
    1798             : 
    1799             : /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
    1800             : 
    1801             : /* number of mp3 decoder instances */
    1802             : static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };
    1803             : 
    1804             : /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
    1805             : static const uint8_t chan_offset[8][5] = {
    1806             :     { 0             },
    1807             :     { 0             },  // C
    1808             :     { 0             },  // FLR
    1809             :     { 2, 0          },  // C FLR
    1810             :     { 2, 0, 3       },  // C FLR BS
    1811             :     { 2, 0, 3       },  // C FLR BLRS
    1812             :     { 2, 0, 4, 3    },  // C FLR BLRS LFE
    1813             :     { 2, 0, 6, 4, 3 },  // C FLR BLRS BLR LFE
    1814             : };
    1815             : 
    1816             : /* mp3on4 channel layouts */
    1817             : static const int16_t chan_layout[8] = {
    1818             :     0,
    1819             :     AV_CH_LAYOUT_MONO,
    1820             :     AV_CH_LAYOUT_STEREO,
    1821             :     AV_CH_LAYOUT_SURROUND,
    1822             :     AV_CH_LAYOUT_4POINT0,
    1823             :     AV_CH_LAYOUT_5POINT0,
    1824             :     AV_CH_LAYOUT_5POINT1,
    1825             :     AV_CH_LAYOUT_7POINT1
    1826             : };
    1827             : 
    1828           0 : static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
    1829             : {
    1830           0 :     MP3On4DecodeContext *s = avctx->priv_data;
    1831             :     int i;
    1832             : 
    1833           0 :     if (s->mp3decctx[0])
    1834           0 :         av_freep(&s->mp3decctx[0]->fdsp);
    1835             : 
    1836           0 :     for (i = 0; i < s->frames; i++)
    1837           0 :         av_freep(&s->mp3decctx[i]);
    1838             : 
    1839           0 :     return 0;
    1840             : }
    1841             : 
    1842             : 
    1843           0 : static av_cold int decode_init_mp3on4(AVCodecContext * avctx)
    1844             : {
    1845           0 :     MP3On4DecodeContext *s = avctx->priv_data;
    1846             :     MPEG4AudioConfig cfg;
    1847             :     int i;
    1848             : 
    1849           0 :     if ((avctx->extradata_size < 2) || !avctx->extradata) {
    1850           0 :         av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
    1851           0 :         return AVERROR_INVALIDDATA;
    1852             :     }
    1853             : 
    1854           0 :     avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
    1855           0 :                                  avctx->extradata_size * 8, 1);
    1856           0 :     if (!cfg.chan_config || cfg.chan_config > 7) {
    1857           0 :         av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
    1858           0 :         return AVERROR_INVALIDDATA;
    1859             :     }
    1860           0 :     s->frames             = mp3Frames[cfg.chan_config];
    1861           0 :     s->coff               = chan_offset[cfg.chan_config];
    1862           0 :     avctx->channels       = ff_mpeg4audio_channels[cfg.chan_config];
    1863           0 :     avctx->channel_layout = chan_layout[cfg.chan_config];
    1864             : 
    1865           0 :     if (cfg.sample_rate < 16000)
    1866           0 :         s->syncword = 0xffe00000;
    1867             :     else
    1868           0 :         s->syncword = 0xfff00000;
    1869             : 
    1870             :     /* Init the first mp3 decoder in standard way, so that all tables get builded
    1871             :      * We replace avctx->priv_data with the context of the first decoder so that
    1872             :      * decode_init() does not have to be changed.
    1873             :      * Other decoders will be initialized here copying data from the first context
    1874             :      */
    1875             :     // Allocate zeroed memory for the first decoder context
    1876           0 :     s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
    1877           0 :     if (!s->mp3decctx[0])
    1878           0 :         goto alloc_fail;
    1879             :     // Put decoder context in place to make init_decode() happy
    1880           0 :     avctx->priv_data = s->mp3decctx[0];
    1881           0 :     decode_init(avctx);
    1882             :     // Restore mp3on4 context pointer
    1883           0 :     avctx->priv_data = s;
    1884           0 :     s->mp3decctx[0]->adu_mode = 1; // Set adu mode
    1885             : 
    1886             :     /* Create a separate codec/context for each frame (first is already ok).
    1887             :      * Each frame is 1 or 2 channels - up to 5 frames allowed
    1888             :      */
    1889           0 :     for (i = 1; i < s->frames; i++) {
    1890           0 :         s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
    1891           0 :         if (!s->mp3decctx[i])
    1892           0 :             goto alloc_fail;
    1893           0 :         s->mp3decctx[i]->adu_mode = 1;
    1894           0 :         s->mp3decctx[i]->avctx = avctx;
    1895           0 :         s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
    1896           0 :         s->mp3decctx[i]->fdsp = s->mp3decctx[0]->fdsp;
    1897             :     }
    1898             : 
    1899           0 :     return 0;
    1900           0 : alloc_fail:
    1901           0 :     decode_close_mp3on4(avctx);
    1902           0 :     return AVERROR(ENOMEM);
    1903             : }
    1904             : 
    1905             : 
    1906           0 : static void flush_mp3on4(AVCodecContext *avctx)
    1907             : {
    1908             :     int i;
    1909           0 :     MP3On4DecodeContext *s = avctx->priv_data;
    1910             : 
    1911           0 :     for (i = 0; i < s->frames; i++)
    1912           0 :         mp_flush(s->mp3decctx[i]);
    1913           0 : }
    1914             : 
    1915             : 
    1916           0 : static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
    1917             :                                int *got_frame_ptr, AVPacket *avpkt)
    1918             : {
    1919           0 :     AVFrame *frame         = data;
    1920           0 :     const uint8_t *buf     = avpkt->data;
    1921           0 :     int buf_size           = avpkt->size;
    1922           0 :     MP3On4DecodeContext *s = avctx->priv_data;
    1923             :     MPADecodeContext *m;
    1924           0 :     int fsize, len = buf_size, out_size = 0;
    1925             :     uint32_t header;
    1926             :     OUT_INT **out_samples;
    1927             :     OUT_INT *outptr[2];
    1928             :     int fr, ch, ret;
    1929             : 
    1930             :     /* get output buffer */
    1931           0 :     frame->nb_samples = MPA_FRAME_SIZE;
    1932           0 :     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
    1933           0 :         return ret;
    1934           0 :     out_samples = (OUT_INT **)frame->extended_data;
    1935             : 
    1936             :     // Discard too short frames
    1937           0 :     if (buf_size < HEADER_SIZE)
    1938           0 :         return AVERROR_INVALIDDATA;
    1939             : 
    1940           0 :     avctx->bit_rate = 0;
    1941             : 
    1942           0 :     ch = 0;
    1943           0 :     for (fr = 0; fr < s->frames; fr++) {
    1944           0 :         fsize = AV_RB16(buf) >> 4;
    1945           0 :         fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
    1946           0 :         m     = s->mp3decctx[fr];
    1947             :         av_assert1(m);
    1948             : 
    1949           0 :         if (fsize < HEADER_SIZE) {
    1950           0 :             av_log(avctx, AV_LOG_ERROR, "Frame size smaller than header size\n");
    1951           0 :             return AVERROR_INVALIDDATA;
    1952             :         }
    1953           0 :         header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
    1954             : 
    1955           0 :         ret = avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
    1956           0 :         if (ret < 0) {
    1957           0 :             av_log(avctx, AV_LOG_ERROR, "Bad header, discard block\n");
    1958           0 :             return AVERROR_INVALIDDATA;
    1959             :         }
    1960             : 
    1961           0 :         if (ch + m->nb_channels > avctx->channels ||
    1962           0 :             s->coff[fr] + m->nb_channels > avctx->channels) {
    1963           0 :             av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
    1964             :                                         "channel count\n");
    1965           0 :             return AVERROR_INVALIDDATA;
    1966             :         }
    1967           0 :         ch += m->nb_channels;
    1968             : 
    1969           0 :         outptr[0] = out_samples[s->coff[fr]];
    1970           0 :         if (m->nb_channels > 1)
    1971           0 :             outptr[1] = out_samples[s->coff[fr] + 1];
    1972             : 
    1973           0 :         if ((ret = mp_decode_frame(m, outptr, buf, fsize)) < 0) {
    1974           0 :             av_log(avctx, AV_LOG_ERROR, "failed to decode channel %d\n", ch);
    1975           0 :             memset(outptr[0], 0, MPA_FRAME_SIZE*sizeof(OUT_INT));
    1976           0 :             if (m->nb_channels > 1)
    1977           0 :                 memset(outptr[1], 0, MPA_FRAME_SIZE*sizeof(OUT_INT));
    1978           0 :             ret = m->nb_channels * MPA_FRAME_SIZE*sizeof(OUT_INT);
    1979             :         }
    1980             : 
    1981           0 :         out_size += ret;
    1982           0 :         buf      += fsize;
    1983           0 :         len      -= fsize;
    1984             : 
    1985           0 :         avctx->bit_rate += m->bit_rate;
    1986             :     }
    1987           0 :     if (ch != avctx->channels) {
    1988           0 :         av_log(avctx, AV_LOG_ERROR, "failed to decode all channels\n");
    1989           0 :         return AVERROR_INVALIDDATA;
    1990             :     }
    1991             : 
    1992             :     /* update codec info */
    1993           0 :     avctx->sample_rate = s->mp3decctx[0]->sample_rate;
    1994             : 
    1995           0 :     frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
    1996           0 :     *got_frame_ptr    = 1;
    1997             : 
    1998           0 :     return buf_size;
    1999             : }
    2000             : #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */

Generated by: LCOV version 1.13