falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
30949 Commits
32 Branches
283MB
Tree: a2b51fe87c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a2b51fe87c'
${ noResults }
FFmpeg/libavcodec/mpegaudiodec.c

2186 lines
71KB
Raw Blame History 

  1. /*

  2.  * MPEG Audio decoder

  3.  * Copyright (c) 2001, 2002 Fabrice Bellard

  4.  *

  5.  * This file is part of Libav.

  6.  *

  7.  * Libav 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.  * Libav 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 Libav; 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/audioconvert.h"

  28. #include "avcodec.h"

  29. #include "get_bits.h"

  30. #include "mathops.h"

  31. #include "mpegaudiodsp.h"

  32. 

  33. /*

  34.  * TODO:

  35.  *  - test lsf / mpeg25 extensively.

  36.  */

  37. 

  38. #include "mpegaudio.h"

  39. #include "mpegaudiodecheader.h"

  40. 

  41. #define BACKSTEP_SIZE 512

  42. #define EXTRABYTES 24

  43. 

  44. /* layer 3 "granule" */

  45. typedef struct GranuleDef {

  46.     uint8_t scfsi;

  47.     int part2_3_length;

  48.     int big_values;

  49.     int global_gain;

  50.     int scalefac_compress;

  51.     uint8_t block_type;

  52.     uint8_t switch_point;

  53.     int table_select[3];

  54.     int subblock_gain[3];

  55.     uint8_t scalefac_scale;

  56.     uint8_t count1table_select;

  57.     int region_size[3]; /* number of huffman codes in each region */

  58.     int preflag;

  59.     int short_start, long_end; /* long/short band indexes */

  60.     uint8_t scale_factors[40];

  61.     INTFLOAT sb_hybrid[SBLIMIT * 18]; /* 576 samples */

  62. } GranuleDef;

  63. 

  64. typedef struct MPADecodeContext {

  65.     MPA_DECODE_HEADER

  66.     uint8_t last_buf[2 * BACKSTEP_SIZE + EXTRABYTES];

  67.     int last_buf_size;

  68.     /* next header (used in free format parsing) */

  69.     uint32_t free_format_next_header;

  70.     GetBitContext gb;

  71.     GetBitContext in_gb;

  72.     DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];

  73.     int synth_buf_offset[MPA_MAX_CHANNELS];

  74.     DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];

  75.     INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */

  76.     GranuleDef granules[2][2]; /* Used in Layer 3 */

  77.     int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3

  78.     int dither_state;

  79.     int err_recognition;

  80.     AVCodecContext* avctx;

  81.     MPADSPContext mpadsp;

  82. } MPADecodeContext;

  83. 

  84. #if CONFIG_FLOAT

  85. #   define SHR(a,b)       ((a)*(1.0f/(1<<(b))))

  86. #   define FIXR_OLD(a)    ((int)((a) * FRAC_ONE + 0.5))

  87. #   define FIXR(x)        ((float)(x))

  88. #   define FIXHR(x)       ((float)(x))

  89. #   define MULH3(x, y, s) ((s)*(y)*(x))

  90. #   define MULLx(x, y, s) ((y)*(x))

  91. #   define RENAME(a) a ## _float

  92. #   define OUT_FMT AV_SAMPLE_FMT_FLT

  93. #else

  94. #   define SHR(a,b)       ((a)>>(b))

  95. /* WARNING: only correct for positive numbers */

  96. #   define FIXR_OLD(a)    ((int)((a) * FRAC_ONE + 0.5))

  97. #   define FIXR(a)        ((int)((a) * FRAC_ONE + 0.5))

  98. #   define FIXHR(a)       ((int)((a) * (1LL<<32) + 0.5))

  99. #   define MULH3(x, y, s) MULH((s)*(x), y)

  100. #   define MULLx(x, y, s) MULL(x,y,s)

  101. #   define RENAME(a)      a ## _fixed

  102. #   define OUT_FMT AV_SAMPLE_FMT_S16

  103. #endif

  104. 

  105. /****************/

  106. 

  107. #define HEADER_SIZE 4

  108. 

  109. #include "mpegaudiodata.h"

  110. #include "mpegaudiodectab.h"

  111. 

  112. /* vlc structure for decoding layer 3 huffman tables */

  113. static VLC huff_vlc[16];

  114. static VLC_TYPE huff_vlc_tables[

  115.     0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +

  116.   142 + 204 + 190 + 170 + 542 + 460 + 662 + 414

  117.   ][2];

  118. static const int huff_vlc_tables_sizes[16] = {

  119.     0,  128,  128,  128,  130,  128,  154,  166,

  120.   142,  204,  190,  170,  542,  460,  662,  414

  121. };

  122. static VLC huff_quad_vlc[2];

  123. static VLC_TYPE  huff_quad_vlc_tables[128+16][2];

  124. static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };

  125. /* computed from band_size_long */

  126. static uint16_t band_index_long[9][23];

  127. #include "mpegaudio_tablegen.h"

  128. /* intensity stereo coef table */

  129. static INTFLOAT is_table[2][16];

  130. static INTFLOAT is_table_lsf[2][2][16];

  131. static INTFLOAT csa_table[8][4];

  132. static INTFLOAT mdct_win[8][36];

  133. 

  134. static int16_t division_tab3[1<<6 ];

  135. static int16_t division_tab5[1<<8 ];

  136. static int16_t division_tab9[1<<11];

  137. 

  138. static int16_t * const division_tabs[4] = {

  139.     division_tab3, division_tab5, NULL, division_tab9

  140. };

  141. 

  142. /* lower 2 bits: modulo 3, higher bits: shift */

  143. static uint16_t scale_factor_modshift[64];

  144. /* [i][j]:  2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */

  145. static int32_t scale_factor_mult[15][3];

  146. /* mult table for layer 2 group quantization */

  147. 

  148. #define SCALE_GEN(v) \

  149. { FIXR_OLD(1.0 * (v)), FIXR_OLD(0.7937005259 * (v)), FIXR_OLD(0.6299605249 * (v)) }

  150. 

  151. static const int32_t scale_factor_mult2[3][3] = {

  152.     SCALE_GEN(4.0 / 3.0), /* 3 steps */

  153.     SCALE_GEN(4.0 / 5.0), /* 5 steps */

  154.     SCALE_GEN(4.0 / 9.0), /* 9 steps */

  155. };

  156. 

  157. /**

  158.  * Convert region offsets to region sizes and truncate

  159.  * size to big_values.

  160.  */

  161. static void ff_region_offset2size(GranuleDef *g)

  162. {

  163.     int i, k, j = 0;

  164.     g->region_size[2] = 576 / 2;

  165.     for (i = 0; i < 3; i++) {

  166.         k = FFMIN(g->region_size[i], g->big_values);

  167.         g->region_size[i] = k - j;

  168.         j = k;

  169.     }

  170. }

  171. 

  172. static void ff_init_short_region(MPADecodeContext *s, GranuleDef *g)

  173. {

  174.     if (g->block_type == 2)

  175.         g->region_size[0] = (36 / 2);

  176.     else {

  177.         if (s->sample_rate_index <= 2)

  178.             g->region_size[0] = (36 / 2);

  179.         else if (s->sample_rate_index != 8)

  180.             g->region_size[0] = (54 / 2);

  181.         else

  182.             g->region_size[0] = (108 / 2);

  183.     }

  184.     g->region_size[1] = (576 / 2);

  185. }

  186. 

  187. static void ff_init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2)

  188. {

  189.     int l;

  190.     g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;

  191.     /* should not overflow */

  192.     l = FFMIN(ra1 + ra2 + 2, 22);

  193.     g->region_size[1] = band_index_long[s->sample_rate_index][      l] >> 1;

  194. }

  195. 

  196. static void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g)

  197. {

  198.     if (g->block_type == 2) {

  199.         if (g->switch_point) {

  200.             /* if switched mode, we handle the 36 first samples as

  201.                 long blocks.  For 8000Hz, we handle the 48 first

  202.                 exponents as long blocks (XXX: check this!) */

  203.             if (s->sample_rate_index <= 2)

  204.                 g->long_end = 8;

  205.             else if (s->sample_rate_index != 8)

  206.                 g->long_end = 6;

  207.             else

  208.                 g->long_end = 4; /* 8000 Hz */

  209. 

  210.             g->short_start = 2 + (s->sample_rate_index != 8);

  211.         } else {

  212.             g->long_end    = 0;

  213.             g->short_start = 0;

  214.         }

  215.     } else {

  216.         g->short_start = 13;

  217.         g->long_end    = 22;

  218.     }

  219. }

  220. 

  221. /* layer 1 unscaling */

  222. /* n = number of bits of the mantissa minus 1 */

  223. static inline int l1_unscale(int n, int mant, int scale_factor)

  224. {

  225.     int shift, mod;

  226.     int64_t val;

  227. 

  228.     shift   = scale_factor_modshift[scale_factor];

  229.     mod     = shift & 3;

  230.     shift >>= 2;

  231.     val     = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);

  232.     shift  += n;

  233.     /* NOTE: at this point, 1 <= shift >= 21 + 15 */

  234.     return (int)((val + (1LL << (shift - 1))) >> shift);

  235. }

  236. 

  237. static inline int l2_unscale_group(int steps, int mant, int scale_factor)

  238. {

  239.     int shift, mod, val;

  240. 

  241.     shift   = scale_factor_modshift[scale_factor];

  242.     mod     = shift & 3;

  243.     shift >>= 2;

  244. 

  245.     val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];

  246.     /* NOTE: at this point, 0 <= shift <= 21 */

  247.     if (shift > 0)

  248.         val = (val + (1 << (shift - 1))) >> shift;

  249.     return val;

  250. }

  251. 

  252. /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */

  253. static inline int l3_unscale(int value, int exponent)

  254. {

  255.     unsigned int m;

  256.     int e;

  257. 

  258.     e  = table_4_3_exp  [4 * value + (exponent & 3)];

  259.     m  = table_4_3_value[4 * value + (exponent & 3)];

  260.     e -= exponent >> 2;

  261.     assert(e >= 1);

  262.     if (e > 31)

  263.         return 0;

  264.     m = (m + (1 << (e - 1))) >> e;

  265. 

  266.     return m;

  267. }

  268. 

  269. static void decode_init_static(AVCodec *codec)

  270. {

  271.     int i, j, k;

  272.     int offset;

  273. 

  274.     /* scale factors table for layer 1/2 */

  275.     for (i = 0; i < 64; i++) {

  276.         int shift, mod;

  277.         /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */

  278.         shift = i / 3;

  279.         mod   = i % 3;

  280.         scale_factor_modshift[i] = mod | (shift << 2);

  281.     }

  282. 

  283.     /* scale factor multiply for layer 1 */

  284.     for (i = 0; i < 15; i++) {

  285.         int n, norm;

  286.         n = i + 2;

  287.         norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);

  288.         scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0          * 2.0), FRAC_BITS);

  289.         scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);

  290.         scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);

  291.         av_dlog(NULL, "%d: norm=%x s=%x %x %x\n", i, norm,

  292.                 scale_factor_mult[i][0],

  293.                 scale_factor_mult[i][1],

  294.                 scale_factor_mult[i][2]);

  295.     }

  296. 

  297.     RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));

  298. 

  299.     /* huffman decode tables */

  300.     offset = 0;

  301.     for (i = 1; i < 16; i++) {

  302.         const HuffTable *h = &mpa_huff_tables[i];

  303.         int xsize, x, y;

  304.         uint8_t  tmp_bits [512];

  305.         uint16_t tmp_codes[512];

  306. 

  307.         memset(tmp_bits , 0, sizeof(tmp_bits ));

  308.         memset(tmp_codes, 0, sizeof(tmp_codes));

  309. 

  310.         xsize = h->xsize;

  311. 

  312.         j = 0;

  313.         for (x = 0; x < xsize; x++) {

  314.             for (y = 0; y < xsize; y++) {

  315.                 tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j  ];

  316.                 tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];

  317.             }

  318.         }

  319. 

  320.         /* XXX: fail test */

  321.         huff_vlc[i].table = huff_vlc_tables+offset;

  322.         huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];

  323.         init_vlc(&huff_vlc[i], 7, 512,

  324.                  tmp_bits, 1, 1, tmp_codes, 2, 2,

  325.                  INIT_VLC_USE_NEW_STATIC);

  326.         offset += huff_vlc_tables_sizes[i];

  327.     }

  328.     assert(offset == FF_ARRAY_ELEMS(huff_vlc_tables));

  329. 

  330.     offset = 0;

  331.     for (i = 0; i < 2; i++) {

  332.         huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;

  333.         huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];

  334.         init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,

  335.                  mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,

  336.                  INIT_VLC_USE_NEW_STATIC);

  337.         offset += huff_quad_vlc_tables_sizes[i];

  338.     }

  339.     assert(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));

  340. 

  341.     for (i = 0; i < 9; i++) {

  342.         k = 0;

  343.         for (j = 0; j < 22; j++) {

  344.             band_index_long[i][j] = k;

  345.             k += band_size_long[i][j];

  346.         }

  347.         band_index_long[i][22] = k;

  348.     }

  349. 

  350.     /* compute n ^ (4/3) and store it in mantissa/exp format */

  351. 

  352.     mpegaudio_tableinit();

  353. 

  354.     for (i = 0; i < 4; i++) {

  355.         if (ff_mpa_quant_bits[i] < 0) {

  356.             for (j = 0; j < (1 << (-ff_mpa_quant_bits[i]+1)); j++) {

  357.                 int val1, val2, val3, steps;

  358.                 int val = j;

  359.                 steps   = ff_mpa_quant_steps[i];

  360.                 val1    = val % steps;

  361.                 val    /= steps;

  362.                 val2    = val % steps;

  363.                 val3    = val / steps;

  364.                 division_tabs[i][j] = val1 + (val2 << 4) + (val3 << 8);

  365.             }

  366.         }

  367.     }

  368. 

  369. 

  370.     for (i = 0; i < 7; i++) {

  371.         float f;

  372.         INTFLOAT v;

  373.         if (i != 6) {

  374.             f = tan((double)i * M_PI / 12.0);

  375.             v = FIXR(f / (1.0 + f));

  376.         } else {

  377.             v = FIXR(1.0);

  378.         }

  379.         is_table[0][    i] = v;

  380.         is_table[1][6 - i] = v;

  381.     }

  382.     /* invalid values */

  383.     for (i = 7; i < 16; i++)

  384.         is_table[0][i] = is_table[1][i] = 0.0;

  385. 

  386.     for (i = 0; i < 16; i++) {

  387.         double f;

  388.         int e, k;

  389. 

  390.         for (j = 0; j < 2; j++) {

  391.             e = -(j + 1) * ((i + 1) >> 1);

  392.             f = pow(2.0, e / 4.0);

  393.             k = i & 1;

  394.             is_table_lsf[j][k ^ 1][i] = FIXR(f);

  395.             is_table_lsf[j][k    ][i] = FIXR(1.0);

  396.             av_dlog(NULL, "is_table_lsf %d %d: %f %f\n",

  397.                     i, j, (float) is_table_lsf[j][0][i],

  398.                     (float) is_table_lsf[j][1][i]);

  399.         }

  400.     }

  401. 

  402.     for (i = 0; i < 8; i++) {

  403.         float ci, cs, ca;

  404.         ci = ci_table[i];

  405.         cs = 1.0 / sqrt(1.0 + ci * ci);

  406.         ca = cs * ci;

  407. #if !CONFIG_FLOAT

  408.         csa_table[i][0] = FIXHR(cs/4);

  409.         csa_table[i][1] = FIXHR(ca/4);

  410.         csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);

  411.         csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);

  412. #else

  413.         csa_table[i][0] = cs;

  414.         csa_table[i][1] = ca;

  415.         csa_table[i][2] = ca + cs;

  416.         csa_table[i][3] = ca - cs;

  417. #endif

  418.     }

  419. 

  420.     /* compute mdct windows */

  421.     for (i = 0; i < 36; i++) {

  422.         for (j = 0; j < 4; j++) {

  423.             double d;

  424. 

  425.             if (j == 2 && i % 3 != 1)

  426.                 continue;

  427. 

  428.             d = sin(M_PI * (i + 0.5) / 36.0);

  429.             if (j == 1) {

  430.                 if      (i >= 30) d = 0;

  431.                 else if (i >= 24) d = sin(M_PI * (i - 18 + 0.5) / 12.0);

  432.                 else if (i >= 18) d = 1;

  433.             } else if (j == 3) {

  434.                 if      (i <   6) d = 0;

  435.                 else if (i <  12) d = sin(M_PI * (i -  6 + 0.5) / 12.0);

  436.                 else if (i <  18) d = 1;

  437.             }

  438.             //merge last stage of imdct into the window coefficients

  439.             d *= 0.5 / cos(M_PI * (2 * i + 19) / 72);

  440. 

  441.             if (j == 2)

  442.                 mdct_win[j][i/3] = FIXHR((d / (1<<5)));

  443.             else

  444.                 mdct_win[j][i  ] = FIXHR((d / (1<<5)));

  445.         }

  446.     }

  447. 

  448.     /* NOTE: we do frequency inversion adter the MDCT by changing

  449.         the sign of the right window coefs */

  450.     for (j = 0; j < 4; j++) {

  451.         for (i = 0; i < 36; i += 2) {

  452.             mdct_win[j + 4][i    ] =  mdct_win[j][i    ];

  453.             mdct_win[j + 4][i + 1] = -mdct_win[j][i + 1];

  454.         }

  455.     }

  456. }

  457. 

  458. static av_cold int decode_init(AVCodecContext * avctx)

  459. {

  460.     MPADecodeContext *s = avctx->priv_data;

  461. 

  462.     s->avctx = avctx;

  463. 

  464.     ff_mpadsp_init(&s->mpadsp);

  465. 

  466.     avctx->sample_fmt= OUT_FMT;

  467.     s->err_recognition = avctx->err_recognition;

  468. 

  469.     if (avctx->codec_id == CODEC_ID_MP3ADU)

  470.         s->adu_mode = 1;

  471.     return 0;

  472. }

  473. 

  474. #define C3 FIXHR(0.86602540378443864676/2)

  475. 

  476. /* 0.5 / cos(pi*(2*i+1)/36) */

  477. static const INTFLOAT icos36[9] = {

  478.     FIXR(0.50190991877167369479),

  479.     FIXR(0.51763809020504152469), //0

  480.     FIXR(0.55168895948124587824),

  481.     FIXR(0.61038729438072803416),

  482.     FIXR(0.70710678118654752439), //1

  483.     FIXR(0.87172339781054900991),

  484.     FIXR(1.18310079157624925896),

  485.     FIXR(1.93185165257813657349), //2

  486.     FIXR(5.73685662283492756461),

  487. };

  488. 

  489. /* 0.5 / cos(pi*(2*i+1)/36) */

  490. static const INTFLOAT icos36h[9] = {

  491.     FIXHR(0.50190991877167369479/2),

  492.     FIXHR(0.51763809020504152469/2), //0

  493.     FIXHR(0.55168895948124587824/2),

  494.     FIXHR(0.61038729438072803416/2),

  495.     FIXHR(0.70710678118654752439/2), //1

  496.     FIXHR(0.87172339781054900991/2),

  497.     FIXHR(1.18310079157624925896/4),

  498.     FIXHR(1.93185165257813657349/4), //2

  499. //    FIXHR(5.73685662283492756461),

  500. };

  501. 

  502. /* 12 points IMDCT. We compute it "by hand" by factorizing obvious

  503.    cases. */

  504. static void imdct12(INTFLOAT *out, INTFLOAT *in)

  505. {

  506.     INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;

  507. 

  508.     in0  = in[0*3];

  509.     in1  = in[1*3] + in[0*3];

  510.     in2  = in[2*3] + in[1*3];

  511.     in3  = in[3*3] + in[2*3];

  512.     in4  = in[4*3] + in[3*3];

  513.     in5  = in[5*3] + in[4*3];

  514.     in5 += in3;

  515.     in3 += in1;

  516. 

  517.     in2  = MULH3(in2, C3, 2);

  518.     in3  = MULH3(in3, C3, 4);

  519. 

  520.     t1   = in0 - in4;

  521.     t2   = MULH3(in1 - in5, icos36h[4], 2);

  522. 

  523.     out[ 7] =

  524.     out[10] = t1 + t2;

  525.     out[ 1] =

  526.     out[ 4] = t1 - t2;

  527. 

  528.     in0    += SHR(in4, 1);

  529.     in4     = in0 + in2;

  530.     in5    += 2*in1;

  531.     in1     = MULH3(in5 + in3, icos36h[1], 1);

  532.     out[ 8] =

  533.     out[ 9] = in4 + in1;

  534.     out[ 2] =

  535.     out[ 3] = in4 - in1;

  536. 

  537.     in0    -= in2;

  538.     in5     = MULH3(in5 - in3, icos36h[7], 2);

  539.     out[ 0] =

  540.     out[ 5] = in0 - in5;

  541.     out[ 6] =

  542.     out[11] = in0 + in5;

  543. }

  544. 

  545. /* cos(pi*i/18) */

  546. #define C1 FIXHR(0.98480775301220805936/2)

  547. #define C2 FIXHR(0.93969262078590838405/2)

  548. #define C3 FIXHR(0.86602540378443864676/2)

  549. #define C4 FIXHR(0.76604444311897803520/2)

  550. #define C5 FIXHR(0.64278760968653932632/2)

  551. #define C6 FIXHR(0.5/2)

  552. #define C7 FIXHR(0.34202014332566873304/2)

  553. #define C8 FIXHR(0.17364817766693034885/2)

  554. 

  555. 

  556. /* using Lee like decomposition followed by hand coded 9 points DCT */

  557. static void imdct36(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, INTFLOAT *win)

  558. {

  559.     int i, j;

  560.     INTFLOAT t0, t1, t2, t3, s0, s1, s2, s3;

  561.     INTFLOAT tmp[18], *tmp1, *in1;

  562. 

  563.     for (i = 17; i >= 1; i--)

  564.         in[i] += in[i-1];

  565.     for (i = 17; i >= 3; i -= 2)

  566.         in[i] += in[i-2];

  567. 

  568.     for (j = 0; j < 2; j++) {

  569.         tmp1 = tmp + j;

  570.         in1 = in + j;

  571. 

  572.         t2 = in1[2*4] + in1[2*8] - in1[2*2];

  573. 

  574.         t3 = in1[2*0] + SHR(in1[2*6],1);

  575.         t1 = in1[2*0] - in1[2*6];

  576.         tmp1[ 6] = t1 - SHR(t2,1);

  577.         tmp1[16] = t1 + t2;

  578. 

  579.         t0 = MULH3(in1[2*2] + in1[2*4] ,    C2, 2);

  580.         t1 = MULH3(in1[2*4] - in1[2*8] , -2*C8, 1);

  581.         t2 = MULH3(in1[2*2] + in1[2*8] ,   -C4, 2);

  582. 

  583.         tmp1[10] = t3 - t0 - t2;

  584.         tmp1[ 2] = t3 + t0 + t1;

  585.         tmp1[14] = t3 + t2 - t1;

  586. 

  587.         tmp1[ 4] = MULH3(in1[2*5] + in1[2*7] - in1[2*1], -C3, 2);

  588.         t2 = MULH3(in1[2*1] + in1[2*5],    C1, 2);

  589.         t3 = MULH3(in1[2*5] - in1[2*7], -2*C7, 1);

  590.         t0 = MULH3(in1[2*3], C3, 2);

  591. 

  592.         t1 = MULH3(in1[2*1] + in1[2*7],   -C5, 2);

  593. 

  594.         tmp1[ 0] = t2 + t3 + t0;

  595.         tmp1[12] = t2 + t1 - t0;

  596.         tmp1[ 8] = t3 - t1 - t0;

  597.     }

  598. 

  599.     i = 0;

  600.     for (j = 0; j < 4; j++) {

  601.         t0 = tmp[i];

  602.         t1 = tmp[i + 2];

  603.         s0 = t1 + t0;

  604.         s2 = t1 - t0;

  605. 

  606.         t2 = tmp[i + 1];

  607.         t3 = tmp[i + 3];

  608.         s1 = MULH3(t3 + t2, icos36h[    j], 2);

  609.         s3 = MULLx(t3 - t2, icos36 [8 - j], FRAC_BITS);

  610. 

  611.         t0 = s0 + s1;

  612.         t1 = s0 - s1;

  613.         out[(9 + j) * SBLIMIT] = MULH3(t1, win[     9 + j], 1) + buf[9 + j];

  614.         out[(8 - j) * SBLIMIT] = MULH3(t1, win[     8 - j], 1) + buf[8 - j];

  615.         buf[ 9 + j           ] = MULH3(t0, win[18 + 9 + j], 1);

  616.         buf[ 8 - j           ] = MULH3(t0, win[18 + 8 - j], 1);

  617. 

  618.         t0 = s2 + s3;

  619.         t1 = s2 - s3;

  620.         out[(9 + 8 - j) * SBLIMIT] = MULH3(t1, win[     9 + 8 - j], 1) + buf[9 + 8 - j];

  621.         out[         j  * SBLIMIT] = MULH3(t1, win[             j], 1) + buf[        j];

  622.         buf[ 9 + 8 - j           ] = MULH3(t0, win[18 + 9 + 8 - j], 1);

  623.         buf[         j           ] = MULH3(t0, win[18         + j], 1);

  624.         i += 4;

  625.     }

  626. 

  627.     s0 = tmp[16];

  628.     s1 = MULH3(tmp[17], icos36h[4], 2);

  629.     t0 = s0 + s1;

  630.     t1 = s0 - s1;

  631.     out[(9 + 4) * SBLIMIT] = MULH3(t1, win[     9 + 4], 1) + buf[9 + 4];

  632.     out[(8 - 4) * SBLIMIT] = MULH3(t1, win[     8 - 4], 1) + buf[8 - 4];

  633.     buf[ 9 + 4           ] = MULH3(t0, win[18 + 9 + 4], 1);

  634.     buf[ 8 - 4           ] = MULH3(t0, win[18 + 8 - 4], 1);

  635. }

  636. 

  637. /* return the number of decoded frames */

  638. static int mp_decode_layer1(MPADecodeContext *s)

  639. {

  640.     int bound, i, v, n, ch, j, mant;

  641.     uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];

  642.     uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];

  643. 

  644.     if (s->mode == MPA_JSTEREO)

  645.         bound = (s->mode_ext + 1) * 4;

  646.     else

  647.         bound = SBLIMIT;

  648. 

  649.     /* allocation bits */

  650.     for (i = 0; i < bound; i++) {

  651.         for (ch = 0; ch < s->nb_channels; ch++) {

  652.             allocation[ch][i] = get_bits(&s->gb, 4);

  653.         }

  654.     }

  655.     for (i = bound; i < SBLIMIT; i++)

  656.         allocation[0][i] = get_bits(&s->gb, 4);

  657. 

  658.     /* scale factors */

  659.     for (i = 0; i < bound; i++) {

  660.         for (ch = 0; ch < s->nb_channels; ch++) {

  661.             if (allocation[ch][i])

  662.                 scale_factors[ch][i] = get_bits(&s->gb, 6);

  663.         }

  664.     }

  665.     for (i = bound; i < SBLIMIT; i++) {

  666.         if (allocation[0][i]) {

  667.             scale_factors[0][i] = get_bits(&s->gb, 6);

  668.             scale_factors[1][i] = get_bits(&s->gb, 6);

  669.         }

  670.     }

  671. 

  672.     /* compute samples */

  673.     for (j = 0; j < 12; j++) {

  674.         for (i = 0; i < bound; i++) {

  675.             for (ch = 0; ch < s->nb_channels; ch++) {

  676.                 n = allocation[ch][i];

  677.                 if (n) {

  678.                     mant = get_bits(&s->gb, n + 1);

  679.                     v = l1_unscale(n, mant, scale_factors[ch][i]);

  680.                 } else {

  681.                     v = 0;

  682.                 }

  683.                 s->sb_samples[ch][j][i] = v;

  684.             }

  685.         }

  686.         for (i = bound; i < SBLIMIT; i++) {

  687.             n = allocation[0][i];

  688.             if (n) {

  689.                 mant = get_bits(&s->gb, n + 1);

  690.                 v = l1_unscale(n, mant, scale_factors[0][i]);

  691.                 s->sb_samples[0][j][i] = v;

  692.                 v = l1_unscale(n, mant, scale_factors[1][i]);

  693.                 s->sb_samples[1][j][i] = v;

  694.             } else {

  695.                 s->sb_samples[0][j][i] = 0;

  696.                 s->sb_samples[1][j][i] = 0;

  697.             }

  698.         }

  699.     }

  700.     return 12;

  701. }

  702. 

  703. static int mp_decode_layer2(MPADecodeContext *s)

  704. {

  705.     int sblimit; /* number of used subbands */

  706.     const unsigned char *alloc_table;

  707.     int table, bit_alloc_bits, i, j, ch, bound, v;

  708.     unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];

  709.     unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];

  710.     unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;

  711.     int scale, qindex, bits, steps, k, l, m, b;

  712. 

  713.     /* select decoding table */

  714.     table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,

  715.                                    s->sample_rate, s->lsf);

  716.     sblimit     = ff_mpa_sblimit_table[table];

  717.     alloc_table = ff_mpa_alloc_tables[table];

  718. 

  719.     if (s->mode == MPA_JSTEREO)

  720.         bound = (s->mode_ext + 1) * 4;

  721.     else

  722.         bound = sblimit;

  723. 

  724.     av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);

  725. 

  726.     /* sanity check */

  727.     if (bound > sblimit)

  728.         bound = sblimit;

  729. 

  730.     /* parse bit allocation */

  731.     j = 0;

  732.     for (i = 0; i < bound; i++) {

  733.         bit_alloc_bits = alloc_table[j];

  734.         for (ch = 0; ch < s->nb_channels; ch++)

  735.             bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);

  736.         j += 1 << bit_alloc_bits;

  737.     }

  738.     for (i = bound; i < sblimit; i++) {

  739.         bit_alloc_bits = alloc_table[j];

  740.         v = get_bits(&s->gb, bit_alloc_bits);

  741.         bit_alloc[0][i] = v;

  742.         bit_alloc[1][i] = v;

  743.         j += 1 << bit_alloc_bits;

  744.     }

  745. 

  746.     /* scale codes */

  747.     for (i = 0; i < sblimit; i++) {

  748.         for (ch = 0; ch < s->nb_channels; ch++) {

  749.             if (bit_alloc[ch][i])

  750.                 scale_code[ch][i] = get_bits(&s->gb, 2);

  751.         }

  752.     }

  753. 

  754.     /* scale factors */

  755.     for (i = 0; i < sblimit; i++) {

  756.         for (ch = 0; ch < s->nb_channels; ch++) {

  757.             if (bit_alloc[ch][i]) {

  758.                 sf = scale_factors[ch][i];

  759.                 switch (scale_code[ch][i]) {

  760.                 default:

  761.                 case 0:

  762.                     sf[0] = get_bits(&s->gb, 6);

  763.                     sf[1] = get_bits(&s->gb, 6);

  764.                     sf[2] = get_bits(&s->gb, 6);

  765.                     break;

  766.                 case 2:

  767.                     sf[0] = get_bits(&s->gb, 6);

  768.                     sf[1] = sf[0];

  769.                     sf[2] = sf[0];

  770.                     break;

  771.                 case 1:

  772.                     sf[0] = get_bits(&s->gb, 6);

  773.                     sf[2] = get_bits(&s->gb, 6);

  774.                     sf[1] = sf[0];

  775.                     break;

  776.                 case 3:

  777.                     sf[0] = get_bits(&s->gb, 6);

  778.                     sf[2] = get_bits(&s->gb, 6);

  779.                     sf[1] = sf[2];

  780.                     break;

  781.                 }

  782.             }

  783.         }

  784.     }

  785. 

  786.     /* samples */

  787.     for (k = 0; k < 3; k++) {

  788.         for (l = 0; l < 12; l += 3) {

  789.             j = 0;

  790.             for (i = 0; i < bound; i++) {

  791.                 bit_alloc_bits = alloc_table[j];

  792.                 for (ch = 0; ch < s->nb_channels; ch++) {

  793.                     b = bit_alloc[ch][i];

  794.                     if (b) {

  795.                         scale = scale_factors[ch][i][k];

  796.                         qindex = alloc_table[j+b];

  797.                         bits = ff_mpa_quant_bits[qindex];

  798.                         if (bits < 0) {

  799.                             int v2;

  800.                             /* 3 values at the same time */

  801.                             v = get_bits(&s->gb, -bits);

  802.                             v2 = division_tabs[qindex][v];

  803.                             steps  = ff_mpa_quant_steps[qindex];

  804. 

  805.                             s->sb_samples[ch][k * 12 + l + 0][i] =

  806.                                 l2_unscale_group(steps,  v2       & 15, scale);

  807.                             s->sb_samples[ch][k * 12 + l + 1][i] =

  808.                                 l2_unscale_group(steps, (v2 >> 4) & 15, scale);

  809.                             s->sb_samples[ch][k * 12 + l + 2][i] =

  810.                                 l2_unscale_group(steps,  v2 >> 8      , scale);

  811.                         } else {

  812.                             for (m = 0; m < 3; m++) {

  813.                                 v = get_bits(&s->gb, bits);

  814.                                 v = l1_unscale(bits - 1, v, scale);

  815.                                 s->sb_samples[ch][k * 12 + l + m][i] = v;

  816.                             }

  817.                         }

  818.                     } else {

  819.                         s->sb_samples[ch][k * 12 + l + 0][i] = 0;

  820.                         s->sb_samples[ch][k * 12 + l + 1][i] = 0;

  821.                         s->sb_samples[ch][k * 12 + l + 2][i] = 0;

  822.                     }

  823.                 }

  824.                 /* next subband in alloc table */

  825.                 j += 1 << bit_alloc_bits;

  826.             }

  827.             /* XXX: find a way to avoid this duplication of code */

  828.             for (i = bound; i < sblimit; i++) {

  829.                 bit_alloc_bits = alloc_table[j];

  830.                 b = bit_alloc[0][i];

  831.                 if (b) {

  832.                     int mant, scale0, scale1;

  833.                     scale0 = scale_factors[0][i][k];

  834.                     scale1 = scale_factors[1][i][k];

  835.                     qindex = alloc_table[j+b];

  836.                     bits = ff_mpa_quant_bits[qindex];

  837.                     if (bits < 0) {

  838.                         /* 3 values at the same time */

  839.                         v = get_bits(&s->gb, -bits);

  840.                         steps = ff_mpa_quant_steps[qindex];

  841.                         mant = v % steps;

  842.                         v = v / steps;

  843.                         s->sb_samples[0][k * 12 + l + 0][i] =

  844.                             l2_unscale_group(steps, mant, scale0);

  845.                         s->sb_samples[1][k * 12 + l + 0][i] =

  846.                             l2_unscale_group(steps, mant, scale1);

  847.                         mant = v % steps;

  848.                         v = v / steps;

  849.                         s->sb_samples[0][k * 12 + l + 1][i] =

  850.                             l2_unscale_group(steps, mant, scale0);

  851.                         s->sb_samples[1][k * 12 + l + 1][i] =

  852.                             l2_unscale_group(steps, mant, scale1);

  853.                         s->sb_samples[0][k * 12 + l + 2][i] =

  854.                             l2_unscale_group(steps, v, scale0);

  855.                         s->sb_samples[1][k * 12 + l + 2][i] =

  856.                             l2_unscale_group(steps, v, scale1);

  857.                     } else {

  858.                         for (m = 0; m < 3; m++) {

  859.                             mant = get_bits(&s->gb, bits);

  860.                             s->sb_samples[0][k * 12 + l + m][i] =

  861.                                 l1_unscale(bits - 1, mant, scale0);

  862.                             s->sb_samples[1][k * 12 + l + m][i] =

  863.                                 l1_unscale(bits - 1, mant, scale1);

  864.                         }

  865.                     }

  866.                 } else {

  867.                     s->sb_samples[0][k * 12 + l + 0][i] = 0;

  868.                     s->sb_samples[0][k * 12 + l + 1][i] = 0;

  869.                     s->sb_samples[0][k * 12 + l + 2][i] = 0;

  870.                     s->sb_samples[1][k * 12 + l + 0][i] = 0;

  871.                     s->sb_samples[1][k * 12 + l + 1][i] = 0;

  872.                     s->sb_samples[1][k * 12 + l + 2][i] = 0;

  873.                 }

  874.                 /* next subband in alloc table */

  875.                 j += 1 << bit_alloc_bits;

  876.             }

  877.             /* fill remaining samples to zero */

  878.             for (i = sblimit; i < SBLIMIT; i++) {

  879.                 for (ch = 0; ch < s->nb_channels; ch++) {

  880.                     s->sb_samples[ch][k * 12 + l + 0][i] = 0;

  881.                     s->sb_samples[ch][k * 12 + l + 1][i] = 0;

  882.                     s->sb_samples[ch][k * 12 + l + 2][i] = 0;

  883.                 }

  884.             }

  885.         }

  886.     }

  887.     return 3 * 12;

  888. }

  889. 

  890. #define SPLIT(dst,sf,n)             \

  891.     if (n == 3) {                   \

  892.         int m = (sf * 171) >> 9;    \

  893.         dst   = sf - 3 * m;         \

  894.         sf    = m;                  \

  895.     } else if (n == 4) {            \

  896.         dst  = sf & 3;              \

  897.         sf >>= 2;                   \

  898.     } else if (n == 5) {            \

  899.         int m = (sf * 205) >> 10;   \

  900.         dst   = sf - 5 * m;         \

  901.         sf    = m;                  \

  902.     } else if (n == 6) {            \

  903.         int m = (sf * 171) >> 10;   \

  904.         dst   = sf - 6 * m;         \

  905.         sf    = m;                  \

  906.     } else {                        \

  907.         dst = 0;                    \

  908.     }

  909. 

  910. static av_always_inline void lsf_sf_expand(int *slen, int sf, int n1, int n2,

  911.                                            int n3)

  912. {

  913.     SPLIT(slen[3], sf, n3)

  914.     SPLIT(slen[2], sf, n2)

  915.     SPLIT(slen[1], sf, n1)

  916.     slen[0] = sf;

  917. }

  918. 

  919. static void exponents_from_scale_factors(MPADecodeContext *s, GranuleDef *g,

  920.                                          int16_t *exponents)

  921. {

  922.     const uint8_t *bstab, *pretab;

  923.     int len, i, j, k, l, v0, shift, gain, gains[3];

  924.     int16_t *exp_ptr;

  925. 

  926.     exp_ptr = exponents;

  927.     gain    = g->global_gain - 210;

  928.     shift   = g->scalefac_scale + 1;

  929. 

  930.     bstab  = band_size_long[s->sample_rate_index];

  931.     pretab = mpa_pretab[g->preflag];

  932.     for (i = 0; i < g->long_end; i++) {

  933.         v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;

  934.         len = bstab[i];

  935.         for (j = len; j > 0; j--)

  936.             *exp_ptr++ = v0;

  937.     }

  938. 

  939.     if (g->short_start < 13) {

  940.         bstab    = band_size_short[s->sample_rate_index];

  941.         gains[0] = gain - (g->subblock_gain[0] << 3);

  942.         gains[1] = gain - (g->subblock_gain[1] << 3);

  943.         gains[2] = gain - (g->subblock_gain[2] << 3);

  944.         k        = g->long_end;

  945.         for (i = g->short_start; i < 13; i++) {

  946.             len = bstab[i];

  947.             for (l = 0; l < 3; l++) {

  948.                 v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;

  949.                 for (j = len; j > 0; j--)

  950.                     *exp_ptr++ = v0;

  951.             }

  952.         }

  953.     }

  954. }

  955. 

  956. /* handle n = 0 too */

  957. static inline int get_bitsz(GetBitContext *s, int n)

  958. {

  959.     return n ? get_bits(s, n) : 0;

  960. }

  961. 

  962. 

  963. static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos,

  964.                           int *end_pos2)

  965. {

  966.     if (s->in_gb.buffer && *pos >= s->gb.size_in_bits) {

  967.         s->gb           = s->in_gb;

  968.         s->in_gb.buffer = NULL;

  969.         assert((get_bits_count(&s->gb) & 7) == 0);

  970.         skip_bits_long(&s->gb, *pos - *end_pos);

  971.         *end_pos2 =

  972.         *end_pos  = *end_pos2 + get_bits_count(&s->gb) - *pos;

  973.         *pos      = get_bits_count(&s->gb);

  974.     }

  975. }

  976. 

  977. /* Following is a optimized code for

  978.             INTFLOAT v = *src

  979.             if(get_bits1(&s->gb))

  980.                 v = -v;

  981.             *dst = v;

  982. */

  983. #if CONFIG_FLOAT

  984. #define READ_FLIP_SIGN(dst,src)                     \

  985.     v = AV_RN32A(src) ^ (get_bits1(&s->gb) << 31);  \

  986.     AV_WN32A(dst, v);

  987. #else

  988. #define READ_FLIP_SIGN(dst,src)     \

  989.     v      = -get_bits1(&s->gb);    \

  990.     *(dst) = (*(src) ^ v) - v;

  991. #endif

  992. 

  993. static int huffman_decode(MPADecodeContext *s, GranuleDef *g,

  994.                           int16_t *exponents, int end_pos2)

  995. {

  996.     int s_index;

  997.     int i;

  998.     int last_pos, bits_left;

  999.     VLC *vlc;

  1000.     int end_pos = FFMIN(end_pos2, s->gb.size_in_bits);

  1001. 

  1002.     /* low frequencies (called big values) */

  1003.     s_index = 0;

  1004.     for (i = 0; i < 3; i++) {

  1005.         int j, k, l, linbits;

  1006.         j = g->region_size[i];

  1007.         if (j == 0)

  1008.             continue;

  1009.         /* select vlc table */

  1010.         k       = g->table_select[i];

  1011.         l       = mpa_huff_data[k][0];

  1012.         linbits = mpa_huff_data[k][1];

  1013.         vlc     = &huff_vlc[l];

  1014. 

  1015.         if (!l) {

  1016.             memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);

  1017.             s_index += 2 * j;

  1018.             continue;

  1019.         }

  1020. 

  1021.         /* read huffcode and compute each couple */

  1022.         for (; j > 0; j--) {

  1023.             int exponent, x, y;

  1024.             int v;

  1025.             int pos = get_bits_count(&s->gb);

  1026. 

  1027.             if (pos >= end_pos){

  1028. //                av_log(NULL, AV_LOG_ERROR, "pos: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);

  1029.                 switch_buffer(s, &pos, &end_pos, &end_pos2);

  1030. //                av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos);

  1031.                 if (pos >= end_pos)

  1032.                     break;

  1033.             }

  1034.             y = get_vlc2(&s->gb, vlc->table, 7, 3);

  1035. 

  1036.             if (!y) {

  1037.                 g->sb_hybrid[s_index  ] =

  1038.                 g->sb_hybrid[s_index+1] = 0;

  1039.                 s_index += 2;

  1040.                 continue;

  1041.             }

  1042. 

  1043.             exponent= exponents[s_index];

  1044. 

  1045.             av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",

  1046.                     i, g->region_size[i] - j, x, y, exponent);

  1047.             if (y & 16) {

  1048.                 x = y >> 5;

  1049.                 y = y & 0x0f;

  1050.                 if (x < 15) {

  1051.                     READ_FLIP_SIGN(g->sb_hybrid + s_index, RENAME(expval_table)[exponent] + x)

  1052.                 } else {

  1053.                     x += get_bitsz(&s->gb, linbits);

  1054.                     v  = l3_unscale(x, exponent);

  1055.                     if (get_bits1(&s->gb))

  1056.                         v = -v;

  1057.                     g->sb_hybrid[s_index] = v;

  1058.                 }

  1059.                 if (y < 15) {

  1060.                     READ_FLIP_SIGN(g->sb_hybrid + s_index + 1, RENAME(expval_table)[exponent] + y)

  1061.                 } else {

  1062.                     y += get_bitsz(&s->gb, linbits);

  1063.                     v  = l3_unscale(y, exponent);

  1064.                     if (get_bits1(&s->gb))

  1065.                         v = -v;

  1066.                     g->sb_hybrid[s_index+1] = v;

  1067.                 }

  1068.             } else {

  1069.                 x = y >> 5;

  1070.                 y = y & 0x0f;

  1071.                 x += y;

  1072.                 if (x < 15) {

  1073.                     READ_FLIP_SIGN(g->sb_hybrid + s_index + !!y, RENAME(expval_table)[exponent] + x)

  1074.                 } else {

  1075.                     x += get_bitsz(&s->gb, linbits);

  1076.                     v  = l3_unscale(x, exponent);

  1077.                     if (get_bits1(&s->gb))

  1078.                         v = -v;

  1079.                     g->sb_hybrid[s_index+!!y] = v;

  1080.                 }

  1081.                 g->sb_hybrid[s_index + !y] = 0;

  1082.             }

  1083.             s_index += 2;

  1084.         }

  1085.     }

  1086. 

  1087.     /* high frequencies */

  1088.     vlc = &huff_quad_vlc[g->count1table_select];

  1089.     last_pos = 0;

  1090.     while (s_index <= 572) {

  1091.         int pos, code;

  1092.         pos = get_bits_count(&s->gb);

  1093.         if (pos >= end_pos) {

  1094.             if (pos > end_pos2 && last_pos) {

  1095.                 /* some encoders generate an incorrect size for this

  1096.                    part. We must go back into the data */

  1097.                 s_index -= 4;

  1098.                 skip_bits_long(&s->gb, last_pos - pos);

  1099.                 av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);

  1100.                 if(s->err_recognition & AV_EF_BITSTREAM)

  1101.                     s_index=0;

  1102.                 break;

  1103.             }

  1104. //                av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);

  1105.             switch_buffer(s, &pos, &end_pos, &end_pos2);

  1106. //                av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index);

  1107.             if (pos >= end_pos)

  1108.                 break;

  1109.         }

  1110.         last_pos = pos;

  1111. 

  1112.         code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);

  1113.         av_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);

  1114.         g->sb_hybrid[s_index+0] =

  1115.         g->sb_hybrid[s_index+1] =

  1116.         g->sb_hybrid[s_index+2] =

  1117.         g->sb_hybrid[s_index+3] = 0;

  1118.         while (code) {

  1119.             static const int idxtab[16] = { 3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0 };

  1120.             int v;

  1121.             int pos = s_index + idxtab[code];

  1122.             code   ^= 8 >> idxtab[code];

  1123.             READ_FLIP_SIGN(g->sb_hybrid + pos, RENAME(exp_table)+exponents[pos])

  1124.         }

  1125.         s_index += 4;

  1126.     }

  1127.     /* skip extension bits */

  1128.     bits_left = end_pos2 - get_bits_count(&s->gb);

  1129. //av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer);

  1130.     if (bits_left < 0 && (s->err_recognition & AV_EF_BITSTREAM)) {

  1131.         av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);

  1132.         s_index=0;

  1133.     } else if (bits_left > 0 && (s->err_recognition & AV_EF_BUFFER)) {

  1134.         av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);

  1135.         s_index = 0;

  1136.     }

  1137.     memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * (576 - s_index));

  1138.     skip_bits_long(&s->gb, bits_left);

  1139. 

  1140.     i = get_bits_count(&s->gb);

  1141.     switch_buffer(s, &i, &end_pos, &end_pos2);

  1142. 

  1143.     return 0;

  1144. }

  1145. 

  1146. /* Reorder short blocks from bitstream order to interleaved order. It

  1147.    would be faster to do it in parsing, but the code would be far more

  1148.    complicated */

  1149. static void reorder_block(MPADecodeContext *s, GranuleDef *g)

  1150. {

  1151.     int i, j, len;

  1152.     INTFLOAT *ptr, *dst, *ptr1;

  1153.     INTFLOAT tmp[576];

  1154. 

  1155.     if (g->block_type != 2)

  1156.         return;

  1157. 

  1158.     if (g->switch_point) {

  1159.         if (s->sample_rate_index != 8)

  1160.             ptr = g->sb_hybrid + 36;

  1161.         else

  1162.             ptr = g->sb_hybrid + 48;

  1163.     } else {

  1164.         ptr = g->sb_hybrid;

  1165.     }

  1166. 

  1167.     for (i = g->short_start; i < 13; i++) {

  1168.         len  = band_size_short[s->sample_rate_index][i];

  1169.         ptr1 = ptr;

  1170.         dst  = tmp;

  1171.         for (j = len; j > 0; j--) {

  1172.             *dst++ = ptr[0*len];

  1173.             *dst++ = ptr[1*len];

  1174.             *dst++ = ptr[2*len];

  1175.             ptr++;

  1176.         }

  1177.         ptr += 2 * len;

  1178.         memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));

  1179.     }

  1180. }

  1181. 

  1182. #define ISQRT2 FIXR(0.70710678118654752440)

  1183. 

  1184. static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)

  1185. {

  1186.     int i, j, k, l;

  1187.     int sf_max, sf, len, non_zero_found;

  1188.     INTFLOAT (*is_tab)[16], *tab0, *tab1, tmp0, tmp1, v1, v2;

  1189.     int non_zero_found_short[3];

  1190. 

  1191.     /* intensity stereo */

  1192.     if (s->mode_ext & MODE_EXT_I_STEREO) {

  1193.         if (!s->lsf) {

  1194.             is_tab = is_table;

  1195.             sf_max = 7;

  1196.         } else {

  1197.             is_tab = is_table_lsf[g1->scalefac_compress & 1];

  1198.             sf_max = 16;

  1199.         }

  1200. 

  1201.         tab0 = g0->sb_hybrid + 576;

  1202.         tab1 = g1->sb_hybrid + 576;

  1203. 

  1204.         non_zero_found_short[0] = 0;

  1205.         non_zero_found_short[1] = 0;

  1206.         non_zero_found_short[2] = 0;

  1207.         k = (13 - g1->short_start) * 3 + g1->long_end - 3;

  1208.         for (i = 12; i >= g1->short_start; i--) {

  1209.             /* for last band, use previous scale factor */

  1210.             if (i != 11)

  1211.                 k -= 3;

  1212.             len = band_size_short[s->sample_rate_index][i];

  1213.             for (l = 2; l >= 0; l--) {

  1214.                 tab0 -= len;

  1215.                 tab1 -= len;

  1216.                 if (!non_zero_found_short[l]) {

  1217.                     /* test if non zero band. if so, stop doing i-stereo */

  1218.                     for (j = 0; j < len; j++) {

  1219.                         if (tab1[j] != 0) {

  1220.                             non_zero_found_short[l] = 1;

  1221.                             goto found1;

  1222.                         }

  1223.                     }

  1224.                     sf = g1->scale_factors[k + l];

  1225.                     if (sf >= sf_max)

  1226.                         goto found1;

  1227. 

  1228.                     v1 = is_tab[0][sf];

  1229.                     v2 = is_tab[1][sf];

  1230.                     for (j = 0; j < len; j++) {

  1231.                         tmp0    = tab0[j];

  1232.                         tab0[j] = MULLx(tmp0, v1, FRAC_BITS);

  1233.                         tab1[j] = MULLx(tmp0, v2, FRAC_BITS);

  1234.                     }

  1235.                 } else {

  1236. found1:

  1237.                     if (s->mode_ext & MODE_EXT_MS_STEREO) {

  1238.                         /* lower part of the spectrum : do ms stereo

  1239.                            if enabled */

  1240.                         for (j = 0; j < len; j++) {

  1241.                             tmp0    = tab0[j];

  1242.                             tmp1    = tab1[j];

  1243.                             tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);

  1244.                             tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);

  1245.                         }

  1246.                     }

  1247.                 }

  1248.             }

  1249.         }

  1250. 

  1251.         non_zero_found = non_zero_found_short[0] |

  1252.                          non_zero_found_short[1] |

  1253.                          non_zero_found_short[2];

  1254. 

  1255.         for (i = g1->long_end - 1;i >= 0;i--) {

  1256.             len   = band_size_long[s->sample_rate_index][i];

  1257.             tab0 -= len;

  1258.             tab1 -= len;

  1259.             /* test if non zero band. if so, stop doing i-stereo */

  1260.             if (!non_zero_found) {

  1261.                 for (j = 0; j < len; j++) {

  1262.                     if (tab1[j] != 0) {

  1263.                         non_zero_found = 1;

  1264.                         goto found2;

  1265.                     }

  1266.                 }

  1267.                 /* for last band, use previous scale factor */

  1268.                 k  = (i == 21) ? 20 : i;

  1269.                 sf = g1->scale_factors[k];

  1270.                 if (sf >= sf_max)

  1271.                     goto found2;

  1272.                 v1 = is_tab[0][sf];

  1273.                 v2 = is_tab[1][sf];

  1274.                 for (j = 0; j < len; j++) {

  1275.                     tmp0    = tab0[j];

  1276.                     tab0[j] = MULLx(tmp0, v1, FRAC_BITS);

  1277.                     tab1[j] = MULLx(tmp0, v2, FRAC_BITS);

  1278.                 }

  1279.             } else {

  1280. found2:

  1281.                 if (s->mode_ext & MODE_EXT_MS_STEREO) {

  1282.                     /* lower part of the spectrum : do ms stereo

  1283.                        if enabled */

  1284.                     for (j = 0; j < len; j++) {

  1285.                         tmp0    = tab0[j];

  1286.                         tmp1    = tab1[j];

  1287.                         tab0[j] = MULLx(tmp0 + tmp1, ISQRT2, FRAC_BITS);

  1288.                         tab1[j] = MULLx(tmp0 - tmp1, ISQRT2, FRAC_BITS);

  1289.                     }

  1290.                 }

  1291.             }

  1292.         }

  1293.     } else if (s->mode_ext & MODE_EXT_MS_STEREO) {

  1294.         /* ms stereo ONLY */

  1295.         /* NOTE: the 1/sqrt(2) normalization factor is included in the

  1296.            global gain */

  1297.         tab0 = g0->sb_hybrid;

  1298.         tab1 = g1->sb_hybrid;

  1299.         for (i = 0; i < 576; i++) {

  1300.             tmp0    = tab0[i];

  1301.             tmp1    = tab1[i];

  1302.             tab0[i] = tmp0 + tmp1;

  1303.             tab1[i] = tmp0 - tmp1;

  1304.         }

  1305.     }

  1306. }

  1307. 

  1308. #if CONFIG_FLOAT

  1309. #define AA(j) do {                                                      \

  1310.         float tmp0 = ptr[-1-j];                                         \

  1311.         float tmp1 = ptr[   j];                                         \

  1312.         ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1];    \

  1313.         ptr[   j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0];    \

  1314.     } while (0)

  1315. #else

  1316. #define AA(j) do {                                              \

  1317.         int tmp0 = ptr[-1-j];                                   \

  1318.         int tmp1 = ptr[   j];                                   \

  1319.         int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]);          \

  1320.         ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2]));   \

  1321.         ptr[   j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3]));   \

  1322.     } while (0)

  1323. #endif

  1324. 

  1325. static void compute_antialias(MPADecodeContext *s, GranuleDef *g)

  1326. {

  1327.     INTFLOAT *ptr;

  1328.     int n, i;

  1329. 

  1330.     /* we antialias only "long" bands */

  1331.     if (g->block_type == 2) {

  1332.         if (!g->switch_point)

  1333.             return;

  1334.         /* XXX: check this for 8000Hz case */

  1335.         n = 1;

  1336.     } else {

  1337.         n = SBLIMIT - 1;

  1338.     }

  1339. 

  1340.     ptr = g->sb_hybrid + 18;

  1341.     for (i = n; i > 0; i--) {

  1342.         AA(0);

  1343.         AA(1);

  1344.         AA(2);

  1345.         AA(3);

  1346.         AA(4);

  1347.         AA(5);

  1348.         AA(6);

  1349.         AA(7);

  1350. 

  1351.         ptr += 18;

  1352.     }

  1353. }

  1354. 

  1355. static void compute_imdct(MPADecodeContext *s, GranuleDef *g,

  1356.                           INTFLOAT *sb_samples, INTFLOAT *mdct_buf)

  1357. {

  1358.     INTFLOAT *win, *win1, *out_ptr, *ptr, *buf, *ptr1;

  1359.     INTFLOAT out2[12];

  1360.     int i, j, mdct_long_end, sblimit;

  1361. 

  1362.     /* find last non zero block */

  1363.     ptr  = g->sb_hybrid + 576;

  1364.     ptr1 = g->sb_hybrid + 2 * 18;

  1365.     while (ptr >= ptr1) {

  1366.         int32_t *p;

  1367.         ptr -= 6;

  1368.         p    = (int32_t*)ptr;

  1369.         if (p[0] | p[1] | p[2] | p[3] | p[4] | p[5])

  1370.             break;

  1371.     }

  1372.     sblimit = ((ptr - g->sb_hybrid) / 18) + 1;

  1373. 

  1374.     if (g->block_type == 2) {

  1375.         /* XXX: check for 8000 Hz */

  1376.         if (g->switch_point)

  1377.             mdct_long_end = 2;

  1378.         else

  1379.             mdct_long_end = 0;

  1380.     } else {

  1381.         mdct_long_end = sblimit;

  1382.     }

  1383. 

  1384.     buf = mdct_buf;

  1385.     ptr = g->sb_hybrid;

  1386.     for (j = 0; j < mdct_long_end; j++) {

  1387.         /* apply window & overlap with previous buffer */

  1388.         out_ptr = sb_samples + j;

  1389.         /* select window */

  1390.         if (g->switch_point && j < 2)

  1391.             win1 = mdct_win[0];

  1392.         else

  1393.             win1 = mdct_win[g->block_type];

  1394.         /* select frequency inversion */

  1395.         win = win1 + ((4 * 36) & -(j & 1));

  1396.         imdct36(out_ptr, buf, ptr, win);

  1397.         out_ptr += 18 * SBLIMIT;

  1398.         ptr     += 18;

  1399.         buf     += 18;

  1400.     }

  1401.     for (j = mdct_long_end; j < sblimit; j++) {

  1402.         /* select frequency inversion */

  1403.         win     = mdct_win[2] + ((4 * 36) & -(j & 1));

  1404.         out_ptr = sb_samples + j;

  1405. 

  1406.         for (i = 0; i < 6; i++) {

  1407.             *out_ptr = buf[i];

  1408.             out_ptr += SBLIMIT;

  1409.         }

  1410.         imdct12(out2, ptr + 0);

  1411.         for (i = 0; i < 6; i++) {

  1412.             *out_ptr     = MULH3(out2[i    ], win[i    ], 1) + buf[i + 6*1];

  1413.             buf[i + 6*2] = MULH3(out2[i + 6], win[i + 6], 1);

  1414.             out_ptr += SBLIMIT;

  1415.         }

  1416.         imdct12(out2, ptr + 1);

  1417.         for (i = 0; i < 6; i++) {

  1418.             *out_ptr     = MULH3(out2[i    ], win[i    ], 1) + buf[i + 6*2];

  1419.             buf[i + 6*0] = MULH3(out2[i + 6], win[i + 6], 1);

  1420.             out_ptr += SBLIMIT;

  1421.         }

  1422.         imdct12(out2, ptr + 2);

  1423.         for (i = 0; i < 6; i++) {

  1424.             buf[i + 6*0] = MULH3(out2[i    ], win[i    ], 1) + buf[i + 6*0];

  1425.             buf[i + 6*1] = MULH3(out2[i + 6], win[i + 6], 1);

  1426.             buf[i + 6*2] = 0;

  1427.         }

  1428.         ptr += 18;

  1429.         buf += 18;

  1430.     }

  1431.     /* zero bands */

  1432.     for (j = sblimit; j < SBLIMIT; j++) {

  1433.         /* overlap */

  1434.         out_ptr = sb_samples + j;

  1435.         for (i = 0; i < 18; i++) {

  1436.             *out_ptr = buf[i];

  1437.             buf[i]   = 0;

  1438.             out_ptr += SBLIMIT;

  1439.         }

  1440.         buf += 18;

  1441.     }

  1442. }

  1443. 

  1444. /* main layer3 decoding function */

  1445. static int mp_decode_layer3(MPADecodeContext *s)

  1446. {

  1447.     int nb_granules, main_data_begin;

  1448.     int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;

  1449.     GranuleDef *g;

  1450.     int16_t exponents[576]; //FIXME try INTFLOAT

  1451. 

  1452.     /* read side info */

  1453.     if (s->lsf) {

  1454.         main_data_begin = get_bits(&s->gb, 8);

  1455.         skip_bits(&s->gb, s->nb_channels);

  1456.         nb_granules = 1;

  1457.     } else {

  1458.         main_data_begin = get_bits(&s->gb, 9);

  1459.         if (s->nb_channels == 2)

  1460.             skip_bits(&s->gb, 3);

  1461.         else

  1462.             skip_bits(&s->gb, 5);

  1463.         nb_granules = 2;

  1464.         for (ch = 0; ch < s->nb_channels; ch++) {

  1465.             s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */

  1466.             s->granules[ch][1].scfsi = get_bits(&s->gb, 4);

  1467.         }

  1468.     }

  1469. 

  1470.     for (gr = 0; gr < nb_granules; gr++) {

  1471.         for (ch = 0; ch < s->nb_channels; ch++) {

  1472.             av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);

  1473.             g = &s->granules[ch][gr];

  1474.             g->part2_3_length = get_bits(&s->gb, 12);

  1475.             g->big_values     = get_bits(&s->gb,  9);

  1476.             if (g->big_values > 288) {

  1477.                 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");

  1478.                 return AVERROR_INVALIDDATA;

  1479.             }

  1480. 

  1481.             g->global_gain = get_bits(&s->gb, 8);

  1482.             /* if MS stereo only is selected, we precompute the

  1483.                1/sqrt(2) renormalization factor */

  1484.             if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==

  1485.                 MODE_EXT_MS_STEREO)

  1486.                 g->global_gain -= 2;

  1487.             if (s->lsf)

  1488.                 g->scalefac_compress = get_bits(&s->gb, 9);

  1489.             else

  1490.                 g->scalefac_compress = get_bits(&s->gb, 4);

  1491.             blocksplit_flag = get_bits1(&s->gb);

  1492.             if (blocksplit_flag) {

  1493.                 g->block_type = get_bits(&s->gb, 2);

  1494.                 if (g->block_type == 0) {

  1495.                     av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");

  1496.                     return AVERROR_INVALIDDATA;

  1497.                 }

  1498.                 g->switch_point = get_bits1(&s->gb);

  1499.                 for (i = 0; i < 2; i++)

  1500.                     g->table_select[i] = get_bits(&s->gb, 5);

  1501.                 for (i = 0; i < 3; i++)

  1502.                     g->subblock_gain[i] = get_bits(&s->gb, 3);

  1503.                 ff_init_short_region(s, g);

  1504.             } else {

  1505.                 int region_address1, region_address2;

  1506.                 g->block_type = 0;

  1507.                 g->switch_point = 0;

  1508.                 for (i = 0; i < 3; i++)

  1509.                     g->table_select[i] = get_bits(&s->gb, 5);

  1510.                 /* compute huffman coded region sizes */

  1511.                 region_address1 = get_bits(&s->gb, 4);

  1512.                 region_address2 = get_bits(&s->gb, 3);

  1513.                 av_dlog(s->avctx, "region1=%d region2=%d\n",

  1514.                         region_address1, region_address2);

  1515.                 ff_init_long_region(s, g, region_address1, region_address2);

  1516.             }

  1517.             ff_region_offset2size(g);

  1518.             ff_compute_band_indexes(s, g);

  1519. 

  1520.             g->preflag = 0;

  1521.             if (!s->lsf)

  1522.                 g->preflag = get_bits1(&s->gb);

  1523.             g->scalefac_scale     = get_bits1(&s->gb);

  1524.             g->count1table_select = get_bits1(&s->gb);

  1525.             av_dlog(s->avctx, "block_type=%d switch_point=%d\n",

  1526.                     g->block_type, g->switch_point);

  1527.         }

  1528.     }

  1529. 

  1530.     if (!s->adu_mode) {

  1531.         const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);

  1532.         assert((get_bits_count(&s->gb) & 7) == 0);

  1533.         /* now we get bits from the main_data_begin offset */

  1534.         av_dlog(s->avctx, "seekback: %d\n", main_data_begin);

  1535.     //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);

  1536. 

  1537.         memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);

  1538.         s->in_gb = s->gb;

  1539.         init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);

  1540.         skip_bits_long(&s->gb, 8*(s->last_buf_size - main_data_begin));

  1541.     }

  1542. 

  1543.     for (gr = 0; gr < nb_granules; gr++) {

  1544.         for (ch = 0; ch < s->nb_channels; ch++) {

  1545.             g = &s->granules[ch][gr];

  1546.             if (get_bits_count(&s->gb) < 0) {

  1547.                 av_log(s->avctx, AV_LOG_DEBUG, "mdb:%d, lastbuf:%d skipping granule %d\n",

  1548.                        main_data_begin, s->last_buf_size, gr);

  1549.                 skip_bits_long(&s->gb, g->part2_3_length);

  1550.                 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));

  1551.                 if (get_bits_count(&s->gb) >= s->gb.size_in_bits && s->in_gb.buffer) {

  1552.                     skip_bits_long(&s->in_gb, get_bits_count(&s->gb) - s->gb.size_in_bits);

  1553.                     s->gb           = s->in_gb;

  1554.                     s->in_gb.buffer = NULL;

  1555.                 }

  1556.                 continue;

  1557.             }

  1558. 

  1559.             bits_pos = get_bits_count(&s->gb);

  1560. 

  1561.             if (!s->lsf) {

  1562.                 uint8_t *sc;

  1563.                 int slen, slen1, slen2;

  1564. 

  1565.                 /* MPEG1 scale factors */

  1566.                 slen1 = slen_table[0][g->scalefac_compress];

  1567.                 slen2 = slen_table[1][g->scalefac_compress];

  1568.                 av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);

  1569.                 if (g->block_type == 2) {

  1570.                     n = g->switch_point ? 17 : 18;

  1571.                     j = 0;

  1572.                     if (slen1) {

  1573.                         for (i = 0; i < n; i++)

  1574.                             g->scale_factors[j++] = get_bits(&s->gb, slen1);

  1575.                     } else {

  1576.                         for (i = 0; i < n; i++)

  1577.                             g->scale_factors[j++] = 0;

  1578.                     }

  1579.                     if (slen2) {

  1580.                         for (i = 0; i < 18; i++)

  1581.                             g->scale_factors[j++] = get_bits(&s->gb, slen2);

  1582.                         for (i = 0; i < 3; i++)

  1583.                             g->scale_factors[j++] = 0;

  1584.                     } else {

  1585.                         for (i = 0; i < 21; i++)

  1586.                             g->scale_factors[j++] = 0;

  1587.                     }

  1588.                 } else {

  1589.                     sc = s->granules[ch][0].scale_factors;

  1590.                     j = 0;

  1591.                     for (k = 0; k < 4; k++) {

  1592.                         n = k == 0 ? 6 : 5;

  1593.                         if ((g->scfsi & (0x8 >> k)) == 0) {

  1594.                             slen = (k < 2) ? slen1 : slen2;

  1595.                             if (slen) {

  1596.                                 for (i = 0; i < n; i++)

  1597.                                     g->scale_factors[j++] = get_bits(&s->gb, slen);

  1598.                             } else {

  1599.                                 for (i = 0; i < n; i++)

  1600.                                     g->scale_factors[j++] = 0;

  1601.                             }

  1602.                         } else {

  1603.                             /* simply copy from last granule */

  1604.                             for (i = 0; i < n; i++) {

  1605.                                 g->scale_factors[j] = sc[j];

  1606.                                 j++;

  1607.                             }

  1608.                         }

  1609.                     }

  1610.                     g->scale_factors[j++] = 0;

  1611.                 }

  1612.             } else {

  1613.                 int tindex, tindex2, slen[4], sl, sf;

  1614. 

  1615.                 /* LSF scale factors */

  1616.                 if (g->block_type == 2)

  1617.                     tindex = g->switch_point ? 2 : 1;

  1618.                 else

  1619.                     tindex = 0;

  1620. 

  1621.                 sf = g->scalefac_compress;

  1622.                 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {

  1623.                     /* intensity stereo case */

  1624.                     sf >>= 1;

  1625.                     if (sf < 180) {

  1626.                         lsf_sf_expand(slen, sf, 6, 6, 0);

  1627.                         tindex2 = 3;

  1628.                     } else if (sf < 244) {

  1629.                         lsf_sf_expand(slen, sf - 180, 4, 4, 0);

  1630.                         tindex2 = 4;

  1631.                     } else {

  1632.                         lsf_sf_expand(slen, sf - 244, 3, 0, 0);

  1633.                         tindex2 = 5;

  1634.                     }

  1635.                 } else {

  1636.                     /* normal case */

  1637.                     if (sf < 400) {

  1638.                         lsf_sf_expand(slen, sf, 5, 4, 4);

  1639.                         tindex2 = 0;

  1640.                     } else if (sf < 500) {

  1641.                         lsf_sf_expand(slen, sf - 400, 5, 4, 0);

  1642.                         tindex2 = 1;

  1643.                     } else {

  1644.                         lsf_sf_expand(slen, sf - 500, 3, 0, 0);

  1645.                         tindex2 = 2;

  1646.                         g->preflag = 1;

  1647.                     }

  1648.                 }

  1649. 

  1650.                 j = 0;

  1651.                 for (k = 0; k < 4; k++) {

  1652.                     n  = lsf_nsf_table[tindex2][tindex][k];

  1653.                     sl = slen[k];

  1654.                     if (sl) {

  1655.                         for (i = 0; i < n; i++)

  1656.                             g->scale_factors[j++] = get_bits(&s->gb, sl);

  1657.                     } else {

  1658.                         for (i = 0; i < n; i++)

  1659.                             g->scale_factors[j++] = 0;

  1660.                     }

  1661.                 }

  1662.                 /* XXX: should compute exact size */

  1663.                 for (; j < 40; j++)

  1664.                     g->scale_factors[j] = 0;

  1665.             }

  1666. 

  1667.             exponents_from_scale_factors(s, g, exponents);

  1668. 

  1669.             /* read Huffman coded residue */

  1670.             huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);

  1671.         } /* ch */

  1672. 

  1673.         if (s->nb_channels == 2)

  1674.             compute_stereo(s, &s->granules[0][gr], &s->granules[1][gr]);

  1675. 

  1676.         for (ch = 0; ch < s->nb_channels; ch++) {

  1677.             g = &s->granules[ch][gr];

  1678. 

  1679.             reorder_block(s, g);

  1680.             compute_antialias(s, g);

  1681.             compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);

  1682.         }

  1683.     } /* gr */

  1684.     if (get_bits_count(&s->gb) < 0)

  1685.         skip_bits_long(&s->gb, -get_bits_count(&s->gb));

  1686.     return nb_granules * 18;

  1687. }

  1688. 

  1689. static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,

  1690.                            const uint8_t *buf, int buf_size)

  1691. {

  1692.     int i, nb_frames, ch;

  1693.     OUT_INT *samples_ptr;

  1694. 

  1695.     init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);

  1696. 

  1697.     /* skip error protection field */

  1698.     if (s->error_protection)

  1699.         skip_bits(&s->gb, 16);

  1700. 

  1701.     switch(s->layer) {

  1702.     case 1:

  1703.         s->avctx->frame_size = 384;

  1704.         nb_frames = mp_decode_layer1(s);

  1705.         break;

  1706.     case 2:

  1707.         s->avctx->frame_size = 1152;

  1708.         nb_frames = mp_decode_layer2(s);

  1709.         break;

  1710.     case 3:

  1711.         s->avctx->frame_size = s->lsf ? 576 : 1152;

  1712.     default:

  1713.         nb_frames = mp_decode_layer3(s);

  1714. 

  1715.         s->last_buf_size=0;

  1716.         if (s->in_gb.buffer) {

  1717.             align_get_bits(&s->gb);

  1718.             i = get_bits_left(&s->gb)>>3;

  1719.             if (i >= 0 && i <= BACKSTEP_SIZE) {

  1720.                 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);

  1721.                 s->last_buf_size=i;

  1722.             } else

  1723.                 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);

  1724.             s->gb           = s->in_gb;

  1725.             s->in_gb.buffer = NULL;

  1726.         }

  1727. 

  1728.         align_get_bits(&s->gb);

  1729.         assert((get_bits_count(&s->gb) & 7) == 0);

  1730.         i = get_bits_left(&s->gb) >> 3;

  1731. 

  1732.         if (i < 0 || i > BACKSTEP_SIZE || nb_frames < 0) {

  1733.             if (i < 0)

  1734.                 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);

  1735.             i = FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);

  1736.         }

  1737.         assert(i <= buf_size - HEADER_SIZE && i >= 0);

  1738.         memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);

  1739.         s->last_buf_size += i;

  1740. 

  1741.         break;

  1742.     }

  1743. 

  1744.     /* apply the synthesis filter */

  1745.     for (ch = 0; ch < s->nb_channels; ch++) {

  1746.         samples_ptr = samples + ch;

  1747.         for (i = 0; i < nb_frames; i++) {

  1748.             RENAME(ff_mpa_synth_filter)(

  1749.                          &s->mpadsp,

  1750.                          s->synth_buf[ch], &(s->synth_buf_offset[ch]),

  1751.                          RENAME(ff_mpa_synth_window), &s->dither_state,

  1752.                          samples_ptr, s->nb_channels,

  1753.                          s->sb_samples[ch][i]);

  1754.             samples_ptr += 32 * s->nb_channels;

  1755.         }

  1756.     }

  1757. 

  1758.     return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;

  1759. }

  1760. 

  1761. static int decode_frame(AVCodecContext * avctx, void *data, int *data_size,

  1762.                         AVPacket *avpkt)

  1763. {

  1764.     const uint8_t *buf  = avpkt->data;

  1765.     int buf_size        = avpkt->size;

  1766.     MPADecodeContext *s = avctx->priv_data;

  1767.     uint32_t header;

  1768.     int out_size;

  1769.     OUT_INT *out_samples = data;

  1770. 

  1771.     if (buf_size < HEADER_SIZE)

  1772.         return AVERROR_INVALIDDATA;

  1773. 

  1774.     header = AV_RB32(buf);

  1775.     if (ff_mpa_check_header(header) < 0) {

  1776.         av_log(avctx, AV_LOG_ERROR, "Header missing\n");

  1777.         return AVERROR_INVALIDDATA;

  1778.     }

  1779. 

  1780.     if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {

  1781.         /* free format: prepare to compute frame size */

  1782.         s->frame_size = -1;

  1783.         return AVERROR_INVALIDDATA;

  1784.     }

  1785.     /* update codec info */

  1786.     avctx->channels       = s->nb_channels;

  1787.     avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;

  1788.     if (!avctx->bit_rate)

  1789.         avctx->bit_rate = s->bit_rate;

  1790.     avctx->sub_id = s->layer;

  1791. 

  1792.     if (*data_size < avctx->frame_size * avctx->channels * sizeof(OUT_INT))

  1793.         return AVERROR(EINVAL);

  1794.     *data_size = 0;

  1795. 

  1796.     if (s->frame_size <= 0 || s->frame_size > buf_size) {

  1797.         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");

  1798.         return AVERROR_INVALIDDATA;

  1799.     } else if (s->frame_size < buf_size) {

  1800.         av_log(avctx, AV_LOG_ERROR, "incorrect frame size\n");

  1801.         buf_size= s->frame_size;

  1802.     }

  1803. 

  1804.     out_size = mp_decode_frame(s, out_samples, buf, buf_size);

  1805.     if (out_size >= 0) {

  1806.         *data_size         = out_size;

  1807.         avctx->sample_rate = s->sample_rate;

  1808.         //FIXME maybe move the other codec info stuff from above here too

  1809.     } else {

  1810.         av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");

  1811.         /* Only return an error if the bad frame makes up the whole packet.

  1812.            If there is more data in the packet, just consume the bad frame

  1813.            instead of returning an error, which would discard the whole

  1814.            packet. */

  1815.         if (buf_size == avpkt->size)

  1816.             return out_size;

  1817.     }

  1818.     s->frame_size = 0;

  1819.     return buf_size;

  1820. }

  1821. 

  1822. static void flush(AVCodecContext *avctx)

  1823. {

  1824.     MPADecodeContext *s = avctx->priv_data;

  1825.     memset(s->synth_buf, 0, sizeof(s->synth_buf));

  1826.     s->last_buf_size = 0;

  1827. }

  1828. 

  1829. #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER

  1830. static int decode_frame_adu(AVCodecContext *avctx, void *data, int *data_size,

  1831.                             AVPacket *avpkt)

  1832. {

  1833.     const uint8_t *buf  = avpkt->data;

  1834.     int buf_size        = avpkt->size;

  1835.     MPADecodeContext *s = avctx->priv_data;

  1836.     uint32_t header;

  1837.     int len, out_size;

  1838.     OUT_INT *out_samples = data;

  1839. 

  1840.     len = buf_size;

  1841. 

  1842.     // Discard too short frames

  1843.     if (buf_size < HEADER_SIZE) {

  1844.         av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");

  1845.         return AVERROR_INVALIDDATA;

  1846.     }

  1847. 

  1848. 

  1849.     if (len > MPA_MAX_CODED_FRAME_SIZE)

  1850.         len = MPA_MAX_CODED_FRAME_SIZE;

  1851. 

  1852.     // Get header and restore sync word

  1853.     header = AV_RB32(buf) | 0xffe00000;

  1854. 

  1855.     if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame

  1856.         av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");

  1857.         return AVERROR_INVALIDDATA;

  1858.     }

  1859. 

  1860.     avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);

  1861.     /* update codec info */

  1862.     avctx->sample_rate = s->sample_rate;

  1863.     avctx->channels    = s->nb_channels;

  1864.     if (!avctx->bit_rate)

  1865.         avctx->bit_rate = s->bit_rate;

  1866.     avctx->sub_id = s->layer;

  1867. 

  1868.     if (*data_size < avctx->frame_size * avctx->channels * sizeof(OUT_INT))

  1869.         return AVERROR(EINVAL);

  1870. 

  1871.     s->frame_size = len;

  1872. 

  1873. #if FF_API_PARSE_FRAME

  1874.     if (avctx->parse_only)

  1875.         out_size = buf_size;

  1876.     else

  1877. #endif

  1878.     out_size = mp_decode_frame(s, out_samples, buf, buf_size);

  1879. 

  1880.     *data_size = out_size;

  1881.     return buf_size;

  1882. }

  1883. #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */

  1884. 

  1885. #if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER

  1886. 

  1887. /**

  1888.  * Context for MP3On4 decoder

  1889.  */

  1890. typedef struct MP3On4DecodeContext {

  1891.     int frames;                     ///< number of mp3 frames per block (number of mp3 decoder instances)

  1892.     int syncword;                   ///< syncword patch

  1893.     const uint8_t *coff;            ///< channel offsets in output buffer

  1894.     MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance

  1895.     OUT_INT *decoded_buf;           ///< output buffer for decoded samples

  1896. } MP3On4DecodeContext;

  1897. 

  1898. #include "mpeg4audio.h"

  1899. 

  1900. /* Next 3 arrays are indexed by channel config number (passed via codecdata) */

  1901. 

  1902. /* number of mp3 decoder instances */

  1903. static const uint8_t mp3Frames[8] = { 0, 1, 1, 2, 3, 3, 4, 5 };

  1904. 

  1905. /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */

  1906. static const uint8_t chan_offset[8][5] = {

  1907.     { 0             },

  1908.     { 0             },  // C

  1909.     { 0             },  // FLR

  1910.     { 2, 0          },  // C FLR

  1911.     { 2, 0, 3       },  // C FLR BS

  1912.     { 2, 0, 3       },  // C FLR BLRS

  1913.     { 2, 0, 4, 3    },  // C FLR BLRS LFE

  1914.     { 2, 0, 6, 4, 3 },  // C FLR BLRS BLR LFE

  1915. };

  1916. 

  1917. /* mp3on4 channel layouts */

  1918. static const int16_t chan_layout[8] = {

  1919.     0,

  1920.     AV_CH_LAYOUT_MONO,

  1921.     AV_CH_LAYOUT_STEREO,

  1922.     AV_CH_LAYOUT_SURROUND,

  1923.     AV_CH_LAYOUT_4POINT0,

  1924.     AV_CH_LAYOUT_5POINT0,

  1925.     AV_CH_LAYOUT_5POINT1,

  1926.     AV_CH_LAYOUT_7POINT1

  1927. };

  1928. 

  1929. static av_cold int decode_close_mp3on4(AVCodecContext * avctx)

  1930. {

  1931.     MP3On4DecodeContext *s = avctx->priv_data;

  1932.     int i;

  1933. 

  1934.     for (i = 0; i < s->frames; i++)

  1935.         av_free(s->mp3decctx[i]);

  1936. 

  1937.     av_freep(&s->decoded_buf);

  1938. 

  1939.     return 0;

  1940. }

  1941. 

  1942. 

  1943. static int decode_init_mp3on4(AVCodecContext * avctx)

  1944. {

  1945.     MP3On4DecodeContext *s = avctx->priv_data;

  1946.     MPEG4AudioConfig cfg;

  1947.     int i;

  1948. 

  1949.     if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {

  1950.         av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");

  1951.         return AVERROR_INVALIDDATA;

  1952.     }

  1953. 

  1954.     avpriv_mpeg4audio_get_config(&cfg, avctx->extradata, avctx->extradata_size);

  1955.     if (!cfg.chan_config || cfg.chan_config > 7) {

  1956.         av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");

  1957.         return AVERROR_INVALIDDATA;

  1958.     }

  1959.     s->frames             = mp3Frames[cfg.chan_config];

  1960.     s->coff               = chan_offset[cfg.chan_config];

  1961.     avctx->channels       = ff_mpeg4audio_channels[cfg.chan_config];

  1962.     avctx->channel_layout = chan_layout[cfg.chan_config];

  1963. 

  1964.     if (cfg.sample_rate < 16000)

  1965.         s->syncword = 0xffe00000;

  1966.     else

  1967.         s->syncword = 0xfff00000;

  1968. 

  1969.     /* Init the first mp3 decoder in standard way, so that all tables get builded

  1970.      * We replace avctx->priv_data with the context of the first decoder so that

  1971.      * decode_init() does not have to be changed.

  1972.      * Other decoders will be initialized here copying data from the first context

  1973.      */

  1974.     // Allocate zeroed memory for the first decoder context

  1975.     s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));

  1976.     if (!s->mp3decctx[0])

  1977.         goto alloc_fail;

  1978.     // Put decoder context in place to make init_decode() happy

  1979.     avctx->priv_data = s->mp3decctx[0];

  1980.     decode_init(avctx);

  1981.     // Restore mp3on4 context pointer

  1982.     avctx->priv_data = s;

  1983.     s->mp3decctx[0]->adu_mode = 1; // Set adu mode

  1984. 

  1985.     /* Create a separate codec/context for each frame (first is already ok).

  1986.      * Each frame is 1 or 2 channels - up to 5 frames allowed

  1987.      */

  1988.     for (i = 1; i < s->frames; i++) {

  1989.         s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));

  1990.         if (!s->mp3decctx[i])

  1991.             goto alloc_fail;

  1992.         s->mp3decctx[i]->adu_mode = 1;

  1993.         s->mp3decctx[i]->avctx = avctx;

  1994.         s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;

  1995.     }

  1996. 

  1997.     /* Allocate buffer for multi-channel output if needed */

  1998.     if (s->frames > 1) {

  1999.         s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *

  2000.                                    sizeof(*s->decoded_buf));

  2001.         if (!s->decoded_buf)

  2002.             goto alloc_fail;

  2003.     }

  2004. 

  2005.     return 0;

  2006. alloc_fail:

  2007.     decode_close_mp3on4(avctx);

  2008.     return AVERROR(ENOMEM);

  2009. }

  2010. 

  2011. 

  2012. static void flush_mp3on4(AVCodecContext *avctx)

  2013. {

  2014.     int i;

  2015.     MP3On4DecodeContext *s = avctx->priv_data;

  2016. 

  2017.     for (i = 0; i < s->frames; i++) {

  2018.         MPADecodeContext *m = s->mp3decctx[i];

  2019.         memset(m->synth_buf, 0, sizeof(m->synth_buf));

  2020.         m->last_buf_size = 0;

  2021.     }

  2022. }

  2023. 

  2024. 

  2025. static int decode_frame_mp3on4(AVCodecContext * avctx,

  2026.                         void *data, int *data_size,

  2027.                         AVPacket *avpkt)

  2028. {

  2029.     const uint8_t *buf     = avpkt->data;

  2030.     int buf_size           = avpkt->size;

  2031.     MP3On4DecodeContext *s = avctx->priv_data;

  2032.     MPADecodeContext *m;

  2033.     int fsize, len = buf_size, out_size = 0;

  2034.     uint32_t header;

  2035.     OUT_INT *out_samples = data;

  2036.     OUT_INT *outptr, *bp;

  2037.     int fr, j, n, ch;

  2038. 

  2039.     if (*data_size < MPA_FRAME_SIZE * avctx->channels * sizeof(OUT_INT)) {

  2040.         av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");

  2041.         return AVERROR(EINVAL);

  2042.     }

  2043. 

  2044.     // Discard too short frames

  2045.     if (buf_size < HEADER_SIZE)

  2046.         return AVERROR_INVALIDDATA;

  2047. 

  2048.     // If only one decoder interleave is not needed

  2049.     outptr = s->frames == 1 ? out_samples : s->decoded_buf;

  2050. 

  2051.     avctx->bit_rate = 0;

  2052. 

  2053.     ch = 0;

  2054.     for (fr = 0; fr < s->frames; fr++) {

  2055.         fsize = AV_RB16(buf) >> 4;

  2056.         fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);

  2057.         m     = s->mp3decctx[fr];

  2058.         assert(m != NULL);

  2059. 

  2060.         header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header

  2061. 

  2062.         if (ff_mpa_check_header(header) < 0) // Bad header, discard block

  2063.             break;

  2064. 

  2065.         avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);

  2066. 

  2067.         if (ch + m->nb_channels > avctx->channels) {

  2068.             av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "

  2069.                                         "channel count\n");

  2070.             return AVERROR_INVALIDDATA;

  2071.         }

  2072.         ch += m->nb_channels;

  2073. 

  2074.         out_size += mp_decode_frame(m, outptr, buf, fsize);

  2075.         buf      += fsize;

  2076.         len      -= fsize;

  2077. 

  2078.         if (s->frames > 1) {

  2079.             n = m->avctx->frame_size*m->nb_channels;

  2080.             /* interleave output data */

  2081.             bp = out_samples + s->coff[fr];

  2082.             if (m->nb_channels == 1) {

  2083.                 for (j = 0; j < n; j++) {

  2084.                     *bp = s->decoded_buf[j];

  2085.                     bp += avctx->channels;

  2086.                 }

  2087.             } else {

  2088.                 for (j = 0; j < n; j++) {

  2089.                     bp[0] = s->decoded_buf[j++];

  2090.                     bp[1] = s->decoded_buf[j];

  2091.                     bp   += avctx->channels;

  2092.                 }

  2093.             }

  2094.         }

  2095.         avctx->bit_rate += m->bit_rate;

  2096.     }

  2097. 

  2098.     /* update codec info */

  2099.     avctx->sample_rate = s->mp3decctx[0]->sample_rate;

  2100. 

  2101.     *data_size = out_size;

  2102.     return buf_size;

  2103. }

  2104. #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */

  2105. 

  2106. #if !CONFIG_FLOAT

  2107. #if CONFIG_MP1_DECODER

  2108. AVCodec ff_mp1_decoder = {

  2109.     .name           = "mp1",

  2110.     .type           = AVMEDIA_TYPE_AUDIO,

  2111.     .id             = CODEC_ID_MP1,

  2112.     .priv_data_size = sizeof(MPADecodeContext),

  2113.     .init_static_data = decode_init_static,

  2114.     .init           = decode_init,

  2115.     .decode         = decode_frame,

  2116. #if FF_API_PARSE_FRAME

  2117.     .capabilities   = CODEC_CAP_PARSE_ONLY,

  2118. #endif

  2119.     .flush          = flush,

  2120.     .long_name      = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),

  2121. };

  2122. #endif

  2123. #if CONFIG_MP2_DECODER

  2124. AVCodec ff_mp2_decoder = {

  2125.     .name           = "mp2",

  2126.     .type           = AVMEDIA_TYPE_AUDIO,

  2127.     .id             = CODEC_ID_MP2,

  2128.     .priv_data_size = sizeof(MPADecodeContext),

  2129.     .init_static_data = decode_init_static,

  2130.     .init           = decode_init,

  2131.     .decode         = decode_frame,

  2132. #if FF_API_PARSE_FRAME

  2133.     .capabilities   = CODEC_CAP_PARSE_ONLY,

  2134. #endif

  2135.     .flush          = flush,

  2136.     .long_name      = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),

  2137. };

  2138. #endif

  2139. #if CONFIG_MP3_DECODER

  2140. AVCodec ff_mp3_decoder = {

  2141.     .name           = "mp3",

  2142.     .type           = AVMEDIA_TYPE_AUDIO,

  2143.     .id             = CODEC_ID_MP3,

  2144.     .priv_data_size = sizeof(MPADecodeContext),

  2145.     .init_static_data = decode_init_static,

  2146.     .init           = decode_init,

  2147.     .decode         = decode_frame,

  2148. #if FF_API_PARSE_FRAME

  2149.     .capabilities   = CODEC_CAP_PARSE_ONLY,

  2150. #endif

  2151.     .flush          = flush,

  2152.     .long_name      = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),

  2153. };

  2154. #endif

  2155. #if CONFIG_MP3ADU_DECODER

  2156. AVCodec ff_mp3adu_decoder = {

  2157.     .name           = "mp3adu",

  2158.     .type           = AVMEDIA_TYPE_AUDIO,

  2159.     .id             = CODEC_ID_MP3ADU,

  2160.     .priv_data_size = sizeof(MPADecodeContext),

  2161.     .init_static_data = decode_init_static,

  2162.     .init           = decode_init,

  2163.     .decode         = decode_frame_adu,

  2164. #if FF_API_PARSE_FRAME

  2165.     .capabilities   = CODEC_CAP_PARSE_ONLY,

  2166. #endif

  2167.     .flush          = flush,

  2168.     .long_name      = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),

  2169. };

  2170. #endif

  2171. #if CONFIG_MP3ON4_DECODER

  2172. AVCodec ff_mp3on4_decoder = {

  2173.     .name           = "mp3on4",

  2174.     .type           = AVMEDIA_TYPE_AUDIO,

  2175.     .id             = CODEC_ID_MP3ON4,

  2176.     .priv_data_size = sizeof(MP3On4DecodeContext),

  2177.     .init_static_data = decode_init_static,

  2178.     .init           = decode_init_mp3on4,

  2179.     .close          = decode_close_mp3on4,

  2180.     .decode         = decode_frame_mp3on4,

  2181.     .flush          = flush_mp3on4,

  2182.     .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),

  2183. };

  2184. #endif

  2185. #endif