3 * Copyright (c) 2001, 2002 Fabrice Bellard.
5 * This file is part of FFmpeg.
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.
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.
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
23 * @file mpegaudiodec.c
29 #include "bitstream.h"
34 * - in low precision mode, use more 16 bit multiplies in synth filter
35 * - test lsf / mpeg25 extensively.
38 /* define USE_HIGHPRECISION to have a bit exact (but slower) mpeg
40 #ifdef CONFIG_MPEGAUDIO_HP
41 # define USE_HIGHPRECISION
44 #include "mpegaudio.h"
45 #include "mpegaudiodecheader.h"
49 /* WARNING: only correct for posititive numbers */
50 #define FIXR(a) ((int)((a) * FRAC_ONE + 0.5))
51 #define FRAC_RND(a) (((a) + (FRAC_ONE/2)) >> FRAC_BITS)
53 #define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
59 /* layer 3 "granule" */
60 typedef struct GranuleDef
{
65 int scalefac_compress
;
70 uint8_t scalefac_scale
;
71 uint8_t count1table_select
;
72 int region_size
[3]; /* number of huffman codes in each region */
74 int short_start
, long_end
; /* long/short band indexes */
75 uint8_t scale_factors
[40];
76 int32_t sb_hybrid
[SBLIMIT
* 18]; /* 576 samples */
79 #include "mpegaudiodata.h"
80 #include "mpegaudiodectab.h"
82 static void compute_antialias_integer(MPADecodeContext
*s
, GranuleDef
*g
);
83 static void compute_antialias_float(MPADecodeContext
*s
, GranuleDef
*g
);
85 /* vlc structure for decoding layer 3 huffman tables */
86 static VLC huff_vlc
[16];
87 static VLC huff_quad_vlc
[2];
88 /* computed from band_size_long */
89 static uint16_t band_index_long
[9][23];
90 /* XXX: free when all decoders are closed */
91 #define TABLE_4_3_SIZE (8191 + 16)*4
92 static int8_t table_4_3_exp
[TABLE_4_3_SIZE
];
93 static uint32_t table_4_3_value
[TABLE_4_3_SIZE
];
94 static uint32_t exp_table
[512];
95 static uint32_t expval_table
[512][16];
96 /* intensity stereo coef table */
97 static int32_t is_table
[2][16];
98 static int32_t is_table_lsf
[2][2][16];
99 static int32_t csa_table
[8][4];
100 static float csa_table_float
[8][4];
101 static int32_t mdct_win
[8][36];
103 /* lower 2 bits: modulo 3, higher bits: shift */
104 static uint16_t scale_factor_modshift
[64];
105 /* [i][j]: 2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
106 static int32_t scale_factor_mult
[15][3];
107 /* mult table for layer 2 group quantization */
109 #define SCALE_GEN(v) \
110 { FIXR(1.0 * (v)), FIXR(0.7937005259 * (v)), FIXR(0.6299605249 * (v)) }
112 static const int32_t scale_factor_mult2
[3][3] = {
113 SCALE_GEN(4.0 / 3.0), /* 3 steps */
114 SCALE_GEN(4.0 / 5.0), /* 5 steps */
115 SCALE_GEN(4.0 / 9.0), /* 9 steps */
118 static DECLARE_ALIGNED_16(MPA_INT
, window
[512]);
121 * Convert region offsets to region sizes and truncate
122 * size to big_values.
124 void ff_region_offset2size(GranuleDef
*g
){
126 g
->region_size
[2] = (576 / 2);
128 k
= FFMIN(g
->region_size
[i
], g
->big_values
);
129 g
->region_size
[i
] = k
- j
;
134 void ff_init_short_region(MPADecodeContext
*s
, GranuleDef
*g
){
135 if (g
->block_type
== 2)
136 g
->region_size
[0] = (36 / 2);
138 if (s
->sample_rate_index
<= 2)
139 g
->region_size
[0] = (36 / 2);
140 else if (s
->sample_rate_index
!= 8)
141 g
->region_size
[0] = (54 / 2);
143 g
->region_size
[0] = (108 / 2);
145 g
->region_size
[1] = (576 / 2);
148 void ff_init_long_region(MPADecodeContext
*s
, GranuleDef
*g
, int ra1
, int ra2
){
151 band_index_long
[s
->sample_rate_index
][ra1
+ 1] >> 1;
152 /* should not overflow */
153 l
= FFMIN(ra1
+ ra2
+ 2, 22);
155 band_index_long
[s
->sample_rate_index
][l
] >> 1;
158 void ff_compute_band_indexes(MPADecodeContext
*s
, GranuleDef
*g
){
159 if (g
->block_type
== 2) {
160 if (g
->switch_point
) {
161 /* if switched mode, we handle the 36 first samples as
162 long blocks. For 8000Hz, we handle the 48 first
163 exponents as long blocks (XXX: check this!) */
164 if (s
->sample_rate_index
<= 2)
166 else if (s
->sample_rate_index
!= 8)
169 g
->long_end
= 4; /* 8000 Hz */
171 g
->short_start
= 2 + (s
->sample_rate_index
!= 8);
182 /* layer 1 unscaling */
183 /* n = number of bits of the mantissa minus 1 */
184 static inline int l1_unscale(int n
, int mant
, int scale_factor
)
189 shift
= scale_factor_modshift
[scale_factor
];
192 val
= MUL64(mant
+ (-1 << n
) + 1, scale_factor_mult
[n
-1][mod
]);
194 /* NOTE: at this point, 1 <= shift >= 21 + 15 */
195 return (int)((val
+ (1LL << (shift
- 1))) >> shift
);
198 static inline int l2_unscale_group(int steps
, int mant
, int scale_factor
)
202 shift
= scale_factor_modshift
[scale_factor
];
206 val
= (mant
- (steps
>> 1)) * scale_factor_mult2
[steps
>> 2][mod
];
207 /* NOTE: at this point, 0 <= shift <= 21 */
209 val
= (val
+ (1 << (shift
- 1))) >> shift
;
213 /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
214 static inline int l3_unscale(int value
, int exponent
)
219 e
= table_4_3_exp
[4*value
+ (exponent
&3)];
220 m
= table_4_3_value
[4*value
+ (exponent
&3)];
221 e
-= (exponent
>> 2);
225 m
= (m
+ (1 << (e
-1))) >> e
;
230 /* all integer n^(4/3) computation code */
233 #define POW_FRAC_BITS 24
234 #define POW_FRAC_ONE (1 << POW_FRAC_BITS)
235 #define POW_FIX(a) ((int)((a) * POW_FRAC_ONE))
236 #define POW_MULL(a,b) (((int64_t)(a) * (int64_t)(b)) >> POW_FRAC_BITS)
238 static int dev_4_3_coefs
[DEV_ORDER
];
241 static int pow_mult3
[3] = {
243 POW_FIX(1.25992104989487316476),
244 POW_FIX(1.58740105196819947474),
248 static void int_pow_init(void)
253 for(i
=0;i
<DEV_ORDER
;i
++) {
254 a
= POW_MULL(a
, POW_FIX(4.0 / 3.0) - i
* POW_FIX(1.0)) / (i
+ 1);
255 dev_4_3_coefs
[i
] = a
;
259 #if 0 /* unused, remove? */
260 /* return the mantissa and the binary exponent */
261 static int int_pow(int i
, int *exp_ptr
)
269 while (a
< (1 << (POW_FRAC_BITS
- 1))) {
273 a
-= (1 << POW_FRAC_BITS
);
275 for(j
= DEV_ORDER
- 1; j
>= 0; j
--)
276 a1
= POW_MULL(a
, dev_4_3_coefs
[j
] + a1
);
277 a
= (1 << POW_FRAC_BITS
) + a1
;
278 /* exponent compute (exact) */
282 a
= POW_MULL(a
, pow_mult3
[er
]);
283 while (a
>= 2 * POW_FRAC_ONE
) {
287 /* convert to float */
288 while (a
< POW_FRAC_ONE
) {
292 /* now POW_FRAC_ONE <= a < 2 * POW_FRAC_ONE */
293 #if POW_FRAC_BITS > FRAC_BITS
294 a
= (a
+ (1 << (POW_FRAC_BITS
- FRAC_BITS
- 1))) >> (POW_FRAC_BITS
- FRAC_BITS
);
295 /* correct overflow */
296 if (a
>= 2 * (1 << FRAC_BITS
)) {
306 static int decode_init(AVCodecContext
* avctx
)
308 MPADecodeContext
*s
= avctx
->priv_data
;
314 #if defined(USE_HIGHPRECISION) && defined(CONFIG_AUDIO_NONSHORT)
315 avctx
->sample_fmt
= SAMPLE_FMT_S32
;
317 avctx
->sample_fmt
= SAMPLE_FMT_S16
;
319 s
->error_resilience
= avctx
->error_resilience
;
321 if(avctx
->antialias_algo
!= FF_AA_FLOAT
)
322 s
->compute_antialias
= compute_antialias_integer
;
324 s
->compute_antialias
= compute_antialias_float
;
326 if (!init
&& !avctx
->parse_only
) {
327 /* scale factors table for layer 1/2 */
330 /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
333 scale_factor_modshift
[i
] = mod
| (shift
<< 2);
336 /* scale factor multiply for layer 1 */
340 norm
= ((INT64_C(1) << n
) * FRAC_ONE
) / ((1 << n
) - 1);
341 scale_factor_mult
[i
][0] = MULL(FIXR(1.0 * 2.0), norm
);
342 scale_factor_mult
[i
][1] = MULL(FIXR(0.7937005259 * 2.0), norm
);
343 scale_factor_mult
[i
][2] = MULL(FIXR(0.6299605249 * 2.0), norm
);
344 dprintf(avctx
, "%d: norm=%x s=%x %x %x\n",
346 scale_factor_mult
[i
][0],
347 scale_factor_mult
[i
][1],
348 scale_factor_mult
[i
][2]);
351 ff_mpa_synth_init(window
);
353 /* huffman decode tables */
355 const HuffTable
*h
= &mpa_huff_tables
[i
];
358 uint8_t tmp_bits
[512];
359 uint16_t tmp_codes
[512];
361 memset(tmp_bits
, 0, sizeof(tmp_bits
));
362 memset(tmp_codes
, 0, sizeof(tmp_codes
));
368 for(x
=0;x
<xsize
;x
++) {
369 for(y
=0;y
<xsize
;y
++){
370 tmp_bits
[(x
<< 5) | y
| ((x
&&y
)<<4)]= h
->bits
[j
];
371 tmp_codes
[(x
<< 5) | y
| ((x
&&y
)<<4)]= h
->codes
[j
++];
376 init_vlc(&huff_vlc
[i
], 7, 512,
377 tmp_bits
, 1, 1, tmp_codes
, 2, 2, 1);
380 init_vlc(&huff_quad_vlc
[i
], i
== 0 ? 7 : 4, 16,
381 mpa_quad_bits
[i
], 1, 1, mpa_quad_codes
[i
], 1, 1, 1);
387 band_index_long
[i
][j
] = k
;
388 k
+= band_size_long
[i
][j
];
390 band_index_long
[i
][22] = k
;
393 /* compute n ^ (4/3) and store it in mantissa/exp format */
396 for(i
=1;i
<TABLE_4_3_SIZE
;i
++) {
399 f
= pow((double)(i
/4), 4.0 / 3.0) * pow(2, (i
&3)*0.25);
401 m
= (uint32_t)(fm
*(1LL<<31) + 0.5);
402 e
+= FRAC_BITS
- 31 + 5 - 100;
404 /* normalized to FRAC_BITS */
405 table_4_3_value
[i
] = m
;
406 // av_log(NULL, AV_LOG_DEBUG, "%d %d %f\n", i, m, pow((double)i, 4.0 / 3.0));
407 table_4_3_exp
[i
] = -e
;
409 for(i
=0; i
<512*16; i
++){
410 int exponent
= (i
>>4);
411 double f
= pow(i
&15, 4.0 / 3.0) * pow(2, (exponent
-400)*0.25 + FRAC_BITS
+ 5);
412 expval_table
[exponent
][i
&15]= llrint(f
);
414 exp_table
[exponent
]= llrint(f
);
421 f
= tan((double)i
* M_PI
/ 12.0);
422 v
= FIXR(f
/ (1.0 + f
));
427 is_table
[1][6 - i
] = v
;
431 is_table
[0][i
] = is_table
[1][i
] = 0.0;
438 e
= -(j
+ 1) * ((i
+ 1) >> 1);
439 f
= pow(2.0, e
/ 4.0);
441 is_table_lsf
[j
][k
^ 1][i
] = FIXR(f
);
442 is_table_lsf
[j
][k
][i
] = FIXR(1.0);
443 dprintf(avctx
, "is_table_lsf %d %d: %x %x\n",
444 i
, j
, is_table_lsf
[j
][0][i
], is_table_lsf
[j
][1][i
]);
451 cs
= 1.0 / sqrt(1.0 + ci
* ci
);
453 csa_table
[i
][0] = FIXHR(cs
/4);
454 csa_table
[i
][1] = FIXHR(ca
/4);
455 csa_table
[i
][2] = FIXHR(ca
/4) + FIXHR(cs
/4);
456 csa_table
[i
][3] = FIXHR(ca
/4) - FIXHR(cs
/4);
457 csa_table_float
[i
][0] = cs
;
458 csa_table_float
[i
][1] = ca
;
459 csa_table_float
[i
][2] = ca
+ cs
;
460 csa_table_float
[i
][3] = ca
- cs
;
461 // printf("%d %d %d %d\n", FIX(cs), FIX(cs-1), FIX(ca), FIX(cs)-FIX(ca));
462 // av_log(NULL, AV_LOG_DEBUG,"%f %f %f %f\n", cs, ca, ca+cs, ca-cs);
465 /* compute mdct windows */
473 d
= sin(M_PI
* (i
+ 0.5) / 36.0);
476 else if(i
>=24) d
= sin(M_PI
* (i
- 18 + 0.5) / 12.0);
480 else if(i
< 12) d
= sin(M_PI
* (i
- 6 + 0.5) / 12.0);
483 //merge last stage of imdct into the window coefficients
484 d
*= 0.5 / cos(M_PI
*(2*i
+ 19)/72);
487 mdct_win
[j
][i
/3] = FIXHR((d
/ (1<<5)));
489 mdct_win
[j
][i
] = FIXHR((d
/ (1<<5)));
490 // av_log(NULL, AV_LOG_DEBUG, "%2d %d %f\n", i,j,d / (1<<5));
494 /* NOTE: we do frequency inversion adter the MDCT by changing
495 the sign of the right window coefs */
498 mdct_win
[j
+ 4][i
] = mdct_win
[j
][i
];
499 mdct_win
[j
+ 4][i
+ 1] = -mdct_win
[j
][i
+ 1];
505 av_log(avctx
, AV_LOG_DEBUG
, "win%d=\n", j
);
507 av_log(avctx
, AV_LOG_DEBUG
, "%f, ", (double)mdct_win
[j
][i
] / FRAC_ONE
);
508 av_log(avctx
, AV_LOG_DEBUG
, "\n");
517 if (avctx
->codec_id
== CODEC_ID_MP3ADU
)
522 /* tab[i][j] = 1.0 / (2.0 * cos(pi*(2*k+1) / 2^(6 - j))) */
526 #define COS0_0 FIXHR(0.50060299823519630134/2)
527 #define COS0_1 FIXHR(0.50547095989754365998/2)
528 #define COS0_2 FIXHR(0.51544730992262454697/2)
529 #define COS0_3 FIXHR(0.53104259108978417447/2)
530 #define COS0_4 FIXHR(0.55310389603444452782/2)
531 #define COS0_5 FIXHR(0.58293496820613387367/2)
532 #define COS0_6 FIXHR(0.62250412303566481615/2)
533 #define COS0_7 FIXHR(0.67480834145500574602/2)
534 #define COS0_8 FIXHR(0.74453627100229844977/2)
535 #define COS0_9 FIXHR(0.83934964541552703873/2)
536 #define COS0_10 FIXHR(0.97256823786196069369/2)
537 #define COS0_11 FIXHR(1.16943993343288495515/4)
538 #define COS0_12 FIXHR(1.48416461631416627724/4)
539 #define COS0_13 FIXHR(2.05778100995341155085/8)
540 #define COS0_14 FIXHR(3.40760841846871878570/8)
541 #define COS0_15 FIXHR(10.19000812354805681150/32)
543 #define COS1_0 FIXHR(0.50241928618815570551/2)
544 #define COS1_1 FIXHR(0.52249861493968888062/2)
545 #define COS1_2 FIXHR(0.56694403481635770368/2)
546 #define COS1_3 FIXHR(0.64682178335999012954/2)
547 #define COS1_4 FIXHR(0.78815462345125022473/2)
548 #define COS1_5 FIXHR(1.06067768599034747134/4)
549 #define COS1_6 FIXHR(1.72244709823833392782/4)
550 #define COS1_7 FIXHR(5.10114861868916385802/16)
552 #define COS2_0 FIXHR(0.50979557910415916894/2)
553 #define COS2_1 FIXHR(0.60134488693504528054/2)
554 #define COS2_2 FIXHR(0.89997622313641570463/2)
555 #define COS2_3 FIXHR(2.56291544774150617881/8)
557 #define COS3_0 FIXHR(0.54119610014619698439/2)
558 #define COS3_1 FIXHR(1.30656296487637652785/4)
560 #define COS4_0 FIXHR(0.70710678118654752439/2)
562 /* butterfly operator */
563 #define BF(a, b, c, s)\
565 tmp0 = tab[a] + tab[b];\
566 tmp1 = tab[a] - tab[b];\
568 tab[b] = MULH(tmp1<<(s), c);\
571 #define BF1(a, b, c, d)\
573 BF(a, b, COS4_0, 1);\
574 BF(c, d,-COS4_0, 1);\
578 #define BF2(a, b, c, d)\
580 BF(a, b, COS4_0, 1);\
581 BF(c, d,-COS4_0, 1);\
588 #define ADD(a, b) tab[a] += tab[b]
590 /* DCT32 without 1/sqrt(2) coef zero scaling. */
591 static void dct32(int32_t *out
, int32_t *tab
)
596 BF( 0, 31, COS0_0
, 1);
597 BF(15, 16, COS0_15
, 5);
599 BF( 0, 15, COS1_0
, 1);
600 BF(16, 31,-COS1_0
, 1);
602 BF( 7, 24, COS0_7
, 1);
603 BF( 8, 23, COS0_8
, 1);
605 BF( 7, 8, COS1_7
, 4);
606 BF(23, 24,-COS1_7
, 4);
608 BF( 0, 7, COS2_0
, 1);
609 BF( 8, 15,-COS2_0
, 1);
610 BF(16, 23, COS2_0
, 1);
611 BF(24, 31,-COS2_0
, 1);
613 BF( 3, 28, COS0_3
, 1);
614 BF(12, 19, COS0_12
, 2);
616 BF( 3, 12, COS1_3
, 1);
617 BF(19, 28,-COS1_3
, 1);
619 BF( 4, 27, COS0_4
, 1);
620 BF(11, 20, COS0_11
, 2);
622 BF( 4, 11, COS1_4
, 1);
623 BF(20, 27,-COS1_4
, 1);
625 BF( 3, 4, COS2_3
, 3);
626 BF(11, 12,-COS2_3
, 3);
627 BF(19, 20, COS2_3
, 3);
628 BF(27, 28,-COS2_3
, 3);
630 BF( 0, 3, COS3_0
, 1);
631 BF( 4, 7,-COS3_0
, 1);
632 BF( 8, 11, COS3_0
, 1);
633 BF(12, 15,-COS3_0
, 1);
634 BF(16, 19, COS3_0
, 1);
635 BF(20, 23,-COS3_0
, 1);
636 BF(24, 27, COS3_0
, 1);
637 BF(28, 31,-COS3_0
, 1);
642 BF( 1, 30, COS0_1
, 1);
643 BF(14, 17, COS0_14
, 3);
645 BF( 1, 14, COS1_1
, 1);
646 BF(17, 30,-COS1_1
, 1);
648 BF( 6, 25, COS0_6
, 1);
649 BF( 9, 22, COS0_9
, 1);
651 BF( 6, 9, COS1_6
, 2);
652 BF(22, 25,-COS1_6
, 2);
654 BF( 1, 6, COS2_1
, 1);
655 BF( 9, 14,-COS2_1
, 1);
656 BF(17, 22, COS2_1
, 1);
657 BF(25, 30,-COS2_1
, 1);
660 BF( 2, 29, COS0_2
, 1);
661 BF(13, 18, COS0_13
, 3);
663 BF( 2, 13, COS1_2
, 1);
664 BF(18, 29,-COS1_2
, 1);
666 BF( 5, 26, COS0_5
, 1);
667 BF(10, 21, COS0_10
, 1);
669 BF( 5, 10, COS1_5
, 2);
670 BF(21, 26,-COS1_5
, 2);
672 BF( 2, 5, COS2_2
, 1);
673 BF(10, 13,-COS2_2
, 1);
674 BF(18, 21, COS2_2
, 1);
675 BF(26, 29,-COS2_2
, 1);
677 BF( 1, 2, COS3_1
, 2);
678 BF( 5, 6,-COS3_1
, 2);
679 BF( 9, 10, COS3_1
, 2);
680 BF(13, 14,-COS3_1
, 2);
681 BF(17, 18, COS3_1
, 2);
682 BF(21, 22,-COS3_1
, 2);
683 BF(25, 26, COS3_1
, 2);
684 BF(29, 30,-COS3_1
, 2);
731 out
[ 1] = tab
[16] + tab
[24];
732 out
[17] = tab
[17] + tab
[25];
733 out
[ 9] = tab
[18] + tab
[26];
734 out
[25] = tab
[19] + tab
[27];
735 out
[ 5] = tab
[20] + tab
[28];
736 out
[21] = tab
[21] + tab
[29];
737 out
[13] = tab
[22] + tab
[30];
738 out
[29] = tab
[23] + tab
[31];
739 out
[ 3] = tab
[24] + tab
[20];
740 out
[19] = tab
[25] + tab
[21];
741 out
[11] = tab
[26] + tab
[22];
742 out
[27] = tab
[27] + tab
[23];
743 out
[ 7] = tab
[28] + tab
[18];
744 out
[23] = tab
[29] + tab
[19];
745 out
[15] = tab
[30] + tab
[17];
751 static inline int round_sample(int *sum
)
754 sum1
= (*sum
) >> OUT_SHIFT
;
755 *sum
&= (1<<OUT_SHIFT
)-1;
758 else if (sum1
> OUT_MAX
)
763 /* signed 16x16 -> 32 multiply add accumulate */
764 #define MACS(rt, ra, rb) MAC16(rt, ra, rb)
766 /* signed 16x16 -> 32 multiply */
767 #define MULS(ra, rb) MUL16(ra, rb)
771 static inline int round_sample(int64_t *sum
)
774 sum1
= (int)((*sum
) >> OUT_SHIFT
);
775 *sum
&= (1<<OUT_SHIFT
)-1;
778 else if (sum1
> OUT_MAX
)
783 # define MULS(ra, rb) MUL64(ra, rb)
786 #define SUM8(sum, op, w, p) \
788 sum op MULS((w)[0 * 64], p[0 * 64]);\
789 sum op MULS((w)[1 * 64], p[1 * 64]);\
790 sum op MULS((w)[2 * 64], p[2 * 64]);\
791 sum op MULS((w)[3 * 64], p[3 * 64]);\
792 sum op MULS((w)[4 * 64], p[4 * 64]);\
793 sum op MULS((w)[5 * 64], p[5 * 64]);\
794 sum op MULS((w)[6 * 64], p[6 * 64]);\
795 sum op MULS((w)[7 * 64], p[7 * 64]);\
798 #define SUM8P2(sum1, op1, sum2, op2, w1, w2, p) \
802 sum1 op1 MULS((w1)[0 * 64], tmp);\
803 sum2 op2 MULS((w2)[0 * 64], tmp);\
805 sum1 op1 MULS((w1)[1 * 64], tmp);\
806 sum2 op2 MULS((w2)[1 * 64], tmp);\
808 sum1 op1 MULS((w1)[2 * 64], tmp);\
809 sum2 op2 MULS((w2)[2 * 64], tmp);\
811 sum1 op1 MULS((w1)[3 * 64], tmp);\
812 sum2 op2 MULS((w2)[3 * 64], tmp);\
814 sum1 op1 MULS((w1)[4 * 64], tmp);\
815 sum2 op2 MULS((w2)[4 * 64], tmp);\
817 sum1 op1 MULS((w1)[5 * 64], tmp);\
818 sum2 op2 MULS((w2)[5 * 64], tmp);\
820 sum1 op1 MULS((w1)[6 * 64], tmp);\
821 sum2 op2 MULS((w2)[6 * 64], tmp);\
823 sum1 op1 MULS((w1)[7 * 64], tmp);\
824 sum2 op2 MULS((w2)[7 * 64], tmp);\
827 void ff_mpa_synth_init(MPA_INT
*window
)
831 /* max = 18760, max sum over all 16 coefs : 44736 */
834 v
= ff_mpa_enwindow
[i
];
836 v
= (v
+ (1 << (16 - WFRAC_BITS
- 1))) >> (16 - WFRAC_BITS
);
846 /* 32 sub band synthesis filter. Input: 32 sub band samples, Output:
848 /* XXX: optimize by avoiding ring buffer usage */
849 void ff_mpa_synth_filter(MPA_INT
*synth_buf_ptr
, int *synth_buf_offset
,
850 MPA_INT
*window
, int *dither_state
,
851 OUT_INT
*samples
, int incr
,
852 int32_t sb_samples
[SBLIMIT
])
855 register MPA_INT
*synth_buf
;
856 register const MPA_INT
*w
, *w2
, *p
;
865 dct32(tmp
, sb_samples
);
867 offset
= *synth_buf_offset
;
868 synth_buf
= synth_buf_ptr
+ offset
;
873 /* NOTE: can cause a loss in precision if very high amplitude
875 v
= av_clip_int16(v
);
879 /* copy to avoid wrap */
880 memcpy(synth_buf
+ 512, synth_buf
, 32 * sizeof(MPA_INT
));
882 samples2
= samples
+ 31 * incr
;
890 SUM8(sum
, -=, w
+ 32, p
);
891 *samples
= round_sample(&sum
);
895 /* we calculate two samples at the same time to avoid one memory
896 access per two sample */
899 p
= synth_buf
+ 16 + j
;
900 SUM8P2(sum
, +=, sum2
, -=, w
, w2
, p
);
901 p
= synth_buf
+ 48 - j
;
902 SUM8P2(sum
, -=, sum2
, -=, w
+ 32, w2
+ 32, p
);
904 *samples
= round_sample(&sum
);
907 *samples2
= round_sample(&sum
);
914 SUM8(sum
, -=, w
+ 32, p
);
915 *samples
= round_sample(&sum
);
918 offset
= (offset
- 32) & 511;
919 *synth_buf_offset
= offset
;
922 #define C3 FIXHR(0.86602540378443864676/2)
924 /* 0.5 / cos(pi*(2*i+1)/36) */
925 static const int icos36
[9] = {
926 FIXR(0.50190991877167369479),
927 FIXR(0.51763809020504152469), //0
928 FIXR(0.55168895948124587824),
929 FIXR(0.61038729438072803416),
930 FIXR(0.70710678118654752439), //1
931 FIXR(0.87172339781054900991),
932 FIXR(1.18310079157624925896),
933 FIXR(1.93185165257813657349), //2
934 FIXR(5.73685662283492756461),
937 /* 0.5 / cos(pi*(2*i+1)/36) */
938 static const int icos36h
[9] = {
939 FIXHR(0.50190991877167369479/2),
940 FIXHR(0.51763809020504152469/2), //0
941 FIXHR(0.55168895948124587824/2),
942 FIXHR(0.61038729438072803416/2),
943 FIXHR(0.70710678118654752439/2), //1
944 FIXHR(0.87172339781054900991/2),
945 FIXHR(1.18310079157624925896/4),
946 FIXHR(1.93185165257813657349/4), //2
947 // FIXHR(5.73685662283492756461),
950 /* 12 points IMDCT. We compute it "by hand" by factorizing obvious
952 static void imdct12(int *out
, int *in
)
954 int in0
, in1
, in2
, in3
, in4
, in5
, t1
, t2
;
957 in1
= in
[1*3] + in
[0*3];
958 in2
= in
[2*3] + in
[1*3];
959 in3
= in
[3*3] + in
[2*3];
960 in4
= in
[4*3] + in
[3*3];
961 in5
= in
[5*3] + in
[4*3];
965 in2
= MULH(2*in2
, C3
);
966 in3
= MULH(4*in3
, C3
);
969 t2
= MULH(2*(in1
- in5
), icos36h
[4]);
979 in1
= MULH(in5
+ in3
, icos36h
[1]);
986 in5
= MULH(2*(in5
- in3
), icos36h
[7]);
994 #define C1 FIXHR(0.98480775301220805936/2)
995 #define C2 FIXHR(0.93969262078590838405/2)
996 #define C3 FIXHR(0.86602540378443864676/2)
997 #define C4 FIXHR(0.76604444311897803520/2)
998 #define C5 FIXHR(0.64278760968653932632/2)
999 #define C6 FIXHR(0.5/2)
1000 #define C7 FIXHR(0.34202014332566873304/2)
1001 #define C8 FIXHR(0.17364817766693034885/2)
1004 /* using Lee like decomposition followed by hand coded 9 points DCT */
1005 static void imdct36(int *out
, int *buf
, int *in
, int *win
)
1007 int i
, j
, t0
, t1
, t2
, t3
, s0
, s1
, s2
, s3
;
1008 int tmp
[18], *tmp1
, *in1
;
1019 //more accurate but slower
1020 int64_t t0
, t1
, t2
, t3
;
1021 t2
= in1
[2*4] + in1
[2*8] - in1
[2*2];
1023 t3
= (in1
[2*0] + (int64_t)(in1
[2*6]>>1))<<32;
1024 t1
= in1
[2*0] - in1
[2*6];
1025 tmp1
[ 6] = t1
- (t2
>>1);
1028 t0
= MUL64(2*(in1
[2*2] + in1
[2*4]), C2
);
1029 t1
= MUL64( in1
[2*4] - in1
[2*8] , -2*C8
);
1030 t2
= MUL64(2*(in1
[2*2] + in1
[2*8]), -C4
);
1032 tmp1
[10] = (t3
- t0
- t2
) >> 32;
1033 tmp1
[ 2] = (t3
+ t0
+ t1
) >> 32;
1034 tmp1
[14] = (t3
+ t2
- t1
) >> 32;
1036 tmp1
[ 4] = MULH(2*(in1
[2*5] + in1
[2*7] - in1
[2*1]), -C3
);
1037 t2
= MUL64(2*(in1
[2*1] + in1
[2*5]), C1
);
1038 t3
= MUL64( in1
[2*5] - in1
[2*7] , -2*C7
);
1039 t0
= MUL64(2*in1
[2*3], C3
);
1041 t1
= MUL64(2*(in1
[2*1] + in1
[2*7]), -C5
);
1043 tmp1
[ 0] = (t2
+ t3
+ t0
) >> 32;
1044 tmp1
[12] = (t2
+ t1
- t0
) >> 32;
1045 tmp1
[ 8] = (t3
- t1
- t0
) >> 32;
1047 t2
= in1
[2*4] + in1
[2*8] - in1
[2*2];
1049 t3
= in1
[2*0] + (in1
[2*6]>>1);
1050 t1
= in1
[2*0] - in1
[2*6];
1051 tmp1
[ 6] = t1
- (t2
>>1);
1054 t0
= MULH(2*(in1
[2*2] + in1
[2*4]), C2
);
1055 t1
= MULH( in1
[2*4] - in1
[2*8] , -2*C8
);
1056 t2
= MULH(2*(in1
[2*2] + in1
[2*8]), -C4
);
1058 tmp1
[10] = t3
- t0
- t2
;
1059 tmp1
[ 2] = t3
+ t0
+ t1
;
1060 tmp1
[14] = t3
+ t2
- t1
;
1062 tmp1
[ 4] = MULH(2*(in1
[2*5] + in1
[2*7] - in1
[2*1]), -C3
);
1063 t2
= MULH(2*(in1
[2*1] + in1
[2*5]), C1
);
1064 t3
= MULH( in1
[2*5] - in1
[2*7] , -2*C7
);
1065 t0
= MULH(2*in1
[2*3], C3
);
1067 t1
= MULH(2*(in1
[2*1] + in1
[2*7]), -C5
);
1069 tmp1
[ 0] = t2
+ t3
+ t0
;
1070 tmp1
[12] = t2
+ t1
- t0
;
1071 tmp1
[ 8] = t3
- t1
- t0
;
1084 s1
= MULH(2*(t3
+ t2
), icos36h
[j
]);
1085 s3
= MULL(t3
- t2
, icos36
[8 - j
]);
1089 out
[(9 + j
)*SBLIMIT
] = MULH(t1
, win
[9 + j
]) + buf
[9 + j
];
1090 out
[(8 - j
)*SBLIMIT
] = MULH(t1
, win
[8 - j
]) + buf
[8 - j
];
1091 buf
[9 + j
] = MULH(t0
, win
[18 + 9 + j
]);
1092 buf
[8 - j
] = MULH(t0
, win
[18 + 8 - j
]);
1096 out
[(9 + 8 - j
)*SBLIMIT
] = MULH(t1
, win
[9 + 8 - j
]) + buf
[9 + 8 - j
];
1097 out
[( j
)*SBLIMIT
] = MULH(t1
, win
[ j
]) + buf
[ j
];
1098 buf
[9 + 8 - j
] = MULH(t0
, win
[18 + 9 + 8 - j
]);
1099 buf
[ + j
] = MULH(t0
, win
[18 + j
]);
1104 s1
= MULH(2*tmp
[17], icos36h
[4]);
1107 out
[(9 + 4)*SBLIMIT
] = MULH(t1
, win
[9 + 4]) + buf
[9 + 4];
1108 out
[(8 - 4)*SBLIMIT
] = MULH(t1
, win
[8 - 4]) + buf
[8 - 4];
1109 buf
[9 + 4] = MULH(t0
, win
[18 + 9 + 4]);
1110 buf
[8 - 4] = MULH(t0
, win
[18 + 8 - 4]);
1113 /* return the number of decoded frames */
1114 static int mp_decode_layer1(MPADecodeContext
*s
)
1116 int bound
, i
, v
, n
, ch
, j
, mant
;
1117 uint8_t allocation
[MPA_MAX_CHANNELS
][SBLIMIT
];
1118 uint8_t scale_factors
[MPA_MAX_CHANNELS
][SBLIMIT
];
1120 if (s
->mode
== MPA_JSTEREO
)
1121 bound
= (s
->mode_ext
+ 1) * 4;
1125 /* allocation bits */
1126 for(i
=0;i
<bound
;i
++) {
1127 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
1128 allocation
[ch
][i
] = get_bits(&s
->gb
, 4);
1131 for(i
=bound
;i
<SBLIMIT
;i
++) {
1132 allocation
[0][i
] = get_bits(&s
->gb
, 4);
1136 for(i
=0;i
<bound
;i
++) {
1137 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
1138 if (allocation
[ch
][i
])
1139 scale_factors
[ch
][i
] = get_bits(&s
->gb
, 6);
1142 for(i
=bound
;i
<SBLIMIT
;i
++) {
1143 if (allocation
[0][i
]) {
1144 scale_factors
[0][i
] = get_bits(&s
->gb
, 6);
1145 scale_factors
[1][i
] = get_bits(&s
->gb
, 6);
1149 /* compute samples */
1151 for(i
=0;i
<bound
;i
++) {
1152 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
1153 n
= allocation
[ch
][i
];
1155 mant
= get_bits(&s
->gb
, n
+ 1);
1156 v
= l1_unscale(n
, mant
, scale_factors
[ch
][i
]);
1160 s
->sb_samples
[ch
][j
][i
] = v
;
1163 for(i
=bound
;i
<SBLIMIT
;i
++) {
1164 n
= allocation
[0][i
];
1166 mant
= get_bits(&s
->gb
, n
+ 1);
1167 v
= l1_unscale(n
, mant
, scale_factors
[0][i
]);
1168 s
->sb_samples
[0][j
][i
] = v
;
1169 v
= l1_unscale(n
, mant
, scale_factors
[1][i
]);
1170 s
->sb_samples
[1][j
][i
] = v
;
1172 s
->sb_samples
[0][j
][i
] = 0;
1173 s
->sb_samples
[1][j
][i
] = 0;
1180 static int mp_decode_layer2(MPADecodeContext
*s
)
1182 int sblimit
; /* number of used subbands */
1183 const unsigned char *alloc_table
;
1184 int table
, bit_alloc_bits
, i
, j
, ch
, bound
, v
;
1185 unsigned char bit_alloc
[MPA_MAX_CHANNELS
][SBLIMIT
];
1186 unsigned char scale_code
[MPA_MAX_CHANNELS
][SBLIMIT
];
1187 unsigned char scale_factors
[MPA_MAX_CHANNELS
][SBLIMIT
][3], *sf
;
1188 int scale
, qindex
, bits
, steps
, k
, l
, m
, b
;
1190 /* select decoding table */
1191 table
= ff_mpa_l2_select_table(s
->bit_rate
/ 1000, s
->nb_channels
,
1192 s
->sample_rate
, s
->lsf
);
1193 sblimit
= ff_mpa_sblimit_table
[table
];
1194 alloc_table
= ff_mpa_alloc_tables
[table
];
1196 if (s
->mode
== MPA_JSTEREO
)
1197 bound
= (s
->mode_ext
+ 1) * 4;
1201 dprintf(s
->avctx
, "bound=%d sblimit=%d\n", bound
, sblimit
);
1204 if( bound
> sblimit
) bound
= sblimit
;
1206 /* parse bit allocation */
1208 for(i
=0;i
<bound
;i
++) {
1209 bit_alloc_bits
= alloc_table
[j
];
1210 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
1211 bit_alloc
[ch
][i
] = get_bits(&s
->gb
, bit_alloc_bits
);
1213 j
+= 1 << bit_alloc_bits
;
1215 for(i
=bound
;i
<sblimit
;i
++) {
1216 bit_alloc_bits
= alloc_table
[j
];
1217 v
= get_bits(&s
->gb
, bit_alloc_bits
);
1218 bit_alloc
[0][i
] = v
;
1219 bit_alloc
[1][i
] = v
;
1220 j
+= 1 << bit_alloc_bits
;
1225 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
1226 for(i
=0;i
<sblimit
;i
++)
1227 dprintf(s
->avctx
, " %d", bit_alloc
[ch
][i
]);
1228 dprintf(s
->avctx
, "\n");
1234 for(i
=0;i
<sblimit
;i
++) {
1235 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
1236 if (bit_alloc
[ch
][i
])
1237 scale_code
[ch
][i
] = get_bits(&s
->gb
, 2);
1242 for(i
=0;i
<sblimit
;i
++) {
1243 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
1244 if (bit_alloc
[ch
][i
]) {
1245 sf
= scale_factors
[ch
][i
];
1246 switch(scale_code
[ch
][i
]) {
1249 sf
[0] = get_bits(&s
->gb
, 6);
1250 sf
[1] = get_bits(&s
->gb
, 6);
1251 sf
[2] = get_bits(&s
->gb
, 6);
1254 sf
[0] = get_bits(&s
->gb
, 6);
1259 sf
[0] = get_bits(&s
->gb
, 6);
1260 sf
[2] = get_bits(&s
->gb
, 6);
1264 sf
[0] = get_bits(&s
->gb
, 6);
1265 sf
[2] = get_bits(&s
->gb
, 6);
1274 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
1275 for(i
=0;i
<sblimit
;i
++) {
1276 if (bit_alloc
[ch
][i
]) {
1277 sf
= scale_factors
[ch
][i
];
1278 dprintf(s
->avctx
, " %d %d %d", sf
[0], sf
[1], sf
[2]);
1280 dprintf(s
->avctx
, " -");
1283 dprintf(s
->avctx
, "\n");
1289 for(l
=0;l
<12;l
+=3) {
1291 for(i
=0;i
<bound
;i
++) {
1292 bit_alloc_bits
= alloc_table
[j
];
1293 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
1294 b
= bit_alloc
[ch
][i
];
1296 scale
= scale_factors
[ch
][i
][k
];
1297 qindex
= alloc_table
[j
+b
];
1298 bits
= ff_mpa_quant_bits
[qindex
];
1300 /* 3 values at the same time */
1301 v
= get_bits(&s
->gb
, -bits
);
1302 steps
= ff_mpa_quant_steps
[qindex
];
1303 s
->sb_samples
[ch
][k
* 12 + l
+ 0][i
] =
1304 l2_unscale_group(steps
, v
% steps
, scale
);
1306 s
->sb_samples
[ch
][k
* 12 + l
+ 1][i
] =
1307 l2_unscale_group(steps
, v
% steps
, scale
);
1309 s
->sb_samples
[ch
][k
* 12 + l
+ 2][i
] =
1310 l2_unscale_group(steps
, v
, scale
);
1313 v
= get_bits(&s
->gb
, bits
);
1314 v
= l1_unscale(bits
- 1, v
, scale
);
1315 s
->sb_samples
[ch
][k
* 12 + l
+ m
][i
] = v
;
1319 s
->sb_samples
[ch
][k
* 12 + l
+ 0][i
] = 0;
1320 s
->sb_samples
[ch
][k
* 12 + l
+ 1][i
] = 0;
1321 s
->sb_samples
[ch
][k
* 12 + l
+ 2][i
] = 0;
1324 /* next subband in alloc table */
1325 j
+= 1 << bit_alloc_bits
;
1327 /* XXX: find a way to avoid this duplication of code */
1328 for(i
=bound
;i
<sblimit
;i
++) {
1329 bit_alloc_bits
= alloc_table
[j
];
1330 b
= bit_alloc
[0][i
];
1332 int mant
, scale0
, scale1
;
1333 scale0
= scale_factors
[0][i
][k
];
1334 scale1
= scale_factors
[1][i
][k
];
1335 qindex
= alloc_table
[j
+b
];
1336 bits
= ff_mpa_quant_bits
[qindex
];
1338 /* 3 values at the same time */
1339 v
= get_bits(&s
->gb
, -bits
);
1340 steps
= ff_mpa_quant_steps
[qindex
];
1343 s
->sb_samples
[0][k
* 12 + l
+ 0][i
] =
1344 l2_unscale_group(steps
, mant
, scale0
);
1345 s
->sb_samples
[1][k
* 12 + l
+ 0][i
] =
1346 l2_unscale_group(steps
, mant
, scale1
);
1349 s
->sb_samples
[0][k
* 12 + l
+ 1][i
] =
1350 l2_unscale_group(steps
, mant
, scale0
);
1351 s
->sb_samples
[1][k
* 12 + l
+ 1][i
] =
1352 l2_unscale_group(steps
, mant
, scale1
);
1353 s
->sb_samples
[0][k
* 12 + l
+ 2][i
] =
1354 l2_unscale_group(steps
, v
, scale0
);
1355 s
->sb_samples
[1][k
* 12 + l
+ 2][i
] =
1356 l2_unscale_group(steps
, v
, scale1
);
1359 mant
= get_bits(&s
->gb
, bits
);
1360 s
->sb_samples
[0][k
* 12 + l
+ m
][i
] =
1361 l1_unscale(bits
- 1, mant
, scale0
);
1362 s
->sb_samples
[1][k
* 12 + l
+ m
][i
] =
1363 l1_unscale(bits
- 1, mant
, scale1
);
1367 s
->sb_samples
[0][k
* 12 + l
+ 0][i
] = 0;
1368 s
->sb_samples
[0][k
* 12 + l
+ 1][i
] = 0;
1369 s
->sb_samples
[0][k
* 12 + l
+ 2][i
] = 0;
1370 s
->sb_samples
[1][k
* 12 + l
+ 0][i
] = 0;
1371 s
->sb_samples
[1][k
* 12 + l
+ 1][i
] = 0;
1372 s
->sb_samples
[1][k
* 12 + l
+ 2][i
] = 0;
1374 /* next subband in alloc table */
1375 j
+= 1 << bit_alloc_bits
;
1377 /* fill remaining samples to zero */
1378 for(i
=sblimit
;i
<SBLIMIT
;i
++) {
1379 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
1380 s
->sb_samples
[ch
][k
* 12 + l
+ 0][i
] = 0;
1381 s
->sb_samples
[ch
][k
* 12 + l
+ 1][i
] = 0;
1382 s
->sb_samples
[ch
][k
* 12 + l
+ 2][i
] = 0;
1390 static inline void lsf_sf_expand(int *slen
,
1391 int sf
, int n1
, int n2
, int n3
)
1410 static void exponents_from_scale_factors(MPADecodeContext
*s
,
1414 const uint8_t *bstab
, *pretab
;
1415 int len
, i
, j
, k
, l
, v0
, shift
, gain
, gains
[3];
1418 exp_ptr
= exponents
;
1419 gain
= g
->global_gain
- 210;
1420 shift
= g
->scalefac_scale
+ 1;
1422 bstab
= band_size_long
[s
->sample_rate_index
];
1423 pretab
= mpa_pretab
[g
->preflag
];
1424 for(i
=0;i
<g
->long_end
;i
++) {
1425 v0
= gain
- ((g
->scale_factors
[i
] + pretab
[i
]) << shift
) + 400;
1431 if (g
->short_start
< 13) {
1432 bstab
= band_size_short
[s
->sample_rate_index
];
1433 gains
[0] = gain
- (g
->subblock_gain
[0] << 3);
1434 gains
[1] = gain
- (g
->subblock_gain
[1] << 3);
1435 gains
[2] = gain
- (g
->subblock_gain
[2] << 3);
1437 for(i
=g
->short_start
;i
<13;i
++) {
1440 v0
= gains
[l
] - (g
->scale_factors
[k
++] << shift
) + 400;
1448 /* handle n = 0 too */
1449 static inline int get_bitsz(GetBitContext
*s
, int n
)
1454 return get_bits(s
, n
);
1458 static void switch_buffer(MPADecodeContext
*s
, int *pos
, int *end_pos
, int *end_pos2
){
1459 if(s
->in_gb
.buffer
&& *pos
>= s
->gb
.size_in_bits
){
1461 s
->in_gb
.buffer
=NULL
;
1462 assert((get_bits_count(&s
->gb
) & 7) == 0);
1463 skip_bits_long(&s
->gb
, *pos
- *end_pos
);
1465 *end_pos
= *end_pos2
+ get_bits_count(&s
->gb
) - *pos
;
1466 *pos
= get_bits_count(&s
->gb
);
1470 static int huffman_decode(MPADecodeContext
*s
, GranuleDef
*g
,
1471 int16_t *exponents
, int end_pos2
)
1475 int last_pos
, bits_left
;
1477 int end_pos
= FFMIN(end_pos2
, s
->gb
.size_in_bits
);
1479 /* low frequencies (called big values) */
1482 int j
, k
, l
, linbits
;
1483 j
= g
->region_size
[i
];
1486 /* select vlc table */
1487 k
= g
->table_select
[i
];
1488 l
= mpa_huff_data
[k
][0];
1489 linbits
= mpa_huff_data
[k
][1];
1493 memset(&g
->sb_hybrid
[s_index
], 0, sizeof(*g
->sb_hybrid
)*2*j
);
1498 /* read huffcode and compute each couple */
1500 int exponent
, x
, y
, v
;
1501 int pos
= get_bits_count(&s
->gb
);
1503 if (pos
>= end_pos
){
1504 // av_log(NULL, AV_LOG_ERROR, "pos: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
1505 switch_buffer(s
, &pos
, &end_pos
, &end_pos2
);
1506 // av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos);
1510 y
= get_vlc2(&s
->gb
, vlc
->table
, 7, 3);
1513 g
->sb_hybrid
[s_index
] =
1514 g
->sb_hybrid
[s_index
+1] = 0;
1519 exponent
= exponents
[s_index
];
1521 dprintf(s
->avctx
, "region=%d n=%d x=%d y=%d exp=%d\n",
1522 i
, g
->region_size
[i
] - j
, x
, y
, exponent
);
1527 v
= expval_table
[ exponent
][ x
];
1528 // v = expval_table[ (exponent&3) ][ x ] >> FFMIN(0 - (exponent>>2), 31);
1530 x
+= get_bitsz(&s
->gb
, linbits
);
1531 v
= l3_unscale(x
, exponent
);
1533 if (get_bits1(&s
->gb
))
1535 g
->sb_hybrid
[s_index
] = v
;
1537 v
= expval_table
[ exponent
][ y
];
1539 y
+= get_bitsz(&s
->gb
, linbits
);
1540 v
= l3_unscale(y
, exponent
);
1542 if (get_bits1(&s
->gb
))
1544 g
->sb_hybrid
[s_index
+1] = v
;
1550 v
= expval_table
[ exponent
][ x
];
1552 x
+= get_bitsz(&s
->gb
, linbits
);
1553 v
= l3_unscale(x
, exponent
);
1555 if (get_bits1(&s
->gb
))
1557 g
->sb_hybrid
[s_index
+!!y
] = v
;
1558 g
->sb_hybrid
[s_index
+ !y
] = 0;
1564 /* high frequencies */
1565 vlc
= &huff_quad_vlc
[g
->count1table_select
];
1567 while (s_index
<= 572) {
1569 pos
= get_bits_count(&s
->gb
);
1570 if (pos
>= end_pos
) {
1571 if (pos
> end_pos2
&& last_pos
){
1572 /* some encoders generate an incorrect size for this
1573 part. We must go back into the data */
1575 skip_bits_long(&s
->gb
, last_pos
- pos
);
1576 av_log(NULL
, AV_LOG_INFO
, "overread, skip %d enddists: %d %d\n", last_pos
- pos
, end_pos
-pos
, end_pos2
-pos
);
1577 if(s
->error_resilience
>= FF_ER_COMPLIANT
)
1581 // av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
1582 switch_buffer(s
, &pos
, &end_pos
, &end_pos2
);
1583 // av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index);
1589 code
= get_vlc2(&s
->gb
, vlc
->table
, vlc
->bits
, 1);
1590 dprintf(s
->avctx
, "t=%d code=%d\n", g
->count1table_select
, code
);
1591 g
->sb_hybrid
[s_index
+0]=
1592 g
->sb_hybrid
[s_index
+1]=
1593 g
->sb_hybrid
[s_index
+2]=
1594 g
->sb_hybrid
[s_index
+3]= 0;
1596 static const int idxtab
[16]={3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0};
1598 int pos
= s_index
+idxtab
[code
];
1599 code
^= 8>>idxtab
[code
];
1600 v
= exp_table
[ exponents
[pos
] ];
1601 // v = exp_table[ (exponents[pos]&3) ] >> FFMIN(0 - (exponents[pos]>>2), 31);
1602 if(get_bits1(&s
->gb
))
1604 g
->sb_hybrid
[pos
] = v
;
1608 /* skip extension bits */
1609 bits_left
= end_pos2
- get_bits_count(&s
->gb
);
1610 //av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer);
1611 if (bits_left
< 0/* || bits_left > 500*/) {
1612 av_log(NULL
, AV_LOG_ERROR
, "bits_left=%d\n", bits_left
);
1614 }else if(bits_left
> 0 && s
->error_resilience
>= FF_ER_AGGRESSIVE
){
1615 av_log(NULL
, AV_LOG_ERROR
, "bits_left=%d\n", bits_left
);
1618 memset(&g
->sb_hybrid
[s_index
], 0, sizeof(*g
->sb_hybrid
)*(576 - s_index
));
1619 skip_bits_long(&s
->gb
, bits_left
);
1621 i
= get_bits_count(&s
->gb
);
1622 switch_buffer(s
, &i
, &end_pos
, &end_pos2
);
1627 /* Reorder short blocks from bitstream order to interleaved order. It
1628 would be faster to do it in parsing, but the code would be far more
1630 static void reorder_block(MPADecodeContext
*s
, GranuleDef
*g
)
1633 int32_t *ptr
, *dst
, *ptr1
;
1636 if (g
->block_type
!= 2)
1639 if (g
->switch_point
) {
1640 if (s
->sample_rate_index
!= 8) {
1641 ptr
= g
->sb_hybrid
+ 36;
1643 ptr
= g
->sb_hybrid
+ 48;
1649 for(i
=g
->short_start
;i
<13;i
++) {
1650 len
= band_size_short
[s
->sample_rate_index
][i
];
1653 for(j
=len
;j
>0;j
--) {
1654 *dst
++ = ptr
[0*len
];
1655 *dst
++ = ptr
[1*len
];
1656 *dst
++ = ptr
[2*len
];
1660 memcpy(ptr1
, tmp
, len
* 3 * sizeof(*ptr1
));
1664 #define ISQRT2 FIXR(0.70710678118654752440)
1666 static void compute_stereo(MPADecodeContext
*s
,
1667 GranuleDef
*g0
, GranuleDef
*g1
)
1671 int sf_max
, tmp0
, tmp1
, sf
, len
, non_zero_found
;
1672 int32_t (*is_tab
)[16];
1673 int32_t *tab0
, *tab1
;
1674 int non_zero_found_short
[3];
1676 /* intensity stereo */
1677 if (s
->mode_ext
& MODE_EXT_I_STEREO
) {
1682 is_tab
= is_table_lsf
[g1
->scalefac_compress
& 1];
1686 tab0
= g0
->sb_hybrid
+ 576;
1687 tab1
= g1
->sb_hybrid
+ 576;
1689 non_zero_found_short
[0] = 0;
1690 non_zero_found_short
[1] = 0;
1691 non_zero_found_short
[2] = 0;
1692 k
= (13 - g1
->short_start
) * 3 + g1
->long_end
- 3;
1693 for(i
= 12;i
>= g1
->short_start
;i
--) {
1694 /* for last band, use previous scale factor */
1697 len
= band_size_short
[s
->sample_rate_index
][i
];
1701 if (!non_zero_found_short
[l
]) {
1702 /* test if non zero band. if so, stop doing i-stereo */
1703 for(j
=0;j
<len
;j
++) {
1705 non_zero_found_short
[l
] = 1;
1709 sf
= g1
->scale_factors
[k
+ l
];
1715 for(j
=0;j
<len
;j
++) {
1717 tab0
[j
] = MULL(tmp0
, v1
);
1718 tab1
[j
] = MULL(tmp0
, v2
);
1722 if (s
->mode_ext
& MODE_EXT_MS_STEREO
) {
1723 /* lower part of the spectrum : do ms stereo
1725 for(j
=0;j
<len
;j
++) {
1728 tab0
[j
] = MULL(tmp0
+ tmp1
, ISQRT2
);
1729 tab1
[j
] = MULL(tmp0
- tmp1
, ISQRT2
);
1736 non_zero_found
= non_zero_found_short
[0] |
1737 non_zero_found_short
[1] |
1738 non_zero_found_short
[2];
1740 for(i
= g1
->long_end
- 1;i
>= 0;i
--) {
1741 len
= band_size_long
[s
->sample_rate_index
][i
];
1744 /* test if non zero band. if so, stop doing i-stereo */
1745 if (!non_zero_found
) {
1746 for(j
=0;j
<len
;j
++) {
1752 /* for last band, use previous scale factor */
1753 k
= (i
== 21) ? 20 : i
;
1754 sf
= g1
->scale_factors
[k
];
1759 for(j
=0;j
<len
;j
++) {
1761 tab0
[j
] = MULL(tmp0
, v1
);
1762 tab1
[j
] = MULL(tmp0
, v2
);
1766 if (s
->mode_ext
& MODE_EXT_MS_STEREO
) {
1767 /* lower part of the spectrum : do ms stereo
1769 for(j
=0;j
<len
;j
++) {
1772 tab0
[j
] = MULL(tmp0
+ tmp1
, ISQRT2
);
1773 tab1
[j
] = MULL(tmp0
- tmp1
, ISQRT2
);
1778 } else if (s
->mode_ext
& MODE_EXT_MS_STEREO
) {
1779 /* ms stereo ONLY */
1780 /* NOTE: the 1/sqrt(2) normalization factor is included in the
1782 tab0
= g0
->sb_hybrid
;
1783 tab1
= g1
->sb_hybrid
;
1784 for(i
=0;i
<576;i
++) {
1787 tab0
[i
] = tmp0
+ tmp1
;
1788 tab1
[i
] = tmp0
- tmp1
;
1793 static void compute_antialias_integer(MPADecodeContext
*s
,
1799 /* we antialias only "long" bands */
1800 if (g
->block_type
== 2) {
1801 if (!g
->switch_point
)
1803 /* XXX: check this for 8000Hz case */
1809 ptr
= g
->sb_hybrid
+ 18;
1810 for(i
= n
;i
> 0;i
--) {
1811 int tmp0
, tmp1
, tmp2
;
1812 csa
= &csa_table
[0][0];
1816 tmp2= MULH(tmp0 + tmp1, csa[0+4*j]);\
1817 ptr[-1-j] = 4*(tmp2 - MULH(tmp1, csa[2+4*j]));\
1818 ptr[ j] = 4*(tmp2 + MULH(tmp0, csa[3+4*j]));
1833 static void compute_antialias_float(MPADecodeContext
*s
,
1839 /* we antialias only "long" bands */
1840 if (g
->block_type
== 2) {
1841 if (!g
->switch_point
)
1843 /* XXX: check this for 8000Hz case */
1849 ptr
= g
->sb_hybrid
+ 18;
1850 for(i
= n
;i
> 0;i
--) {
1852 float *csa
= &csa_table_float
[0][0];
1853 #define FLOAT_AA(j)\
1856 ptr[-1-j] = lrintf(tmp0 * csa[0+4*j] - tmp1 * csa[1+4*j]);\
1857 ptr[ j] = lrintf(tmp0 * csa[1+4*j] + tmp1 * csa[0+4*j]);
1872 static void compute_imdct(MPADecodeContext
*s
,
1874 int32_t *sb_samples
,
1877 int32_t *ptr
, *win
, *win1
, *buf
, *out_ptr
, *ptr1
;
1879 int i
, j
, mdct_long_end
, v
, sblimit
;
1881 /* find last non zero block */
1882 ptr
= g
->sb_hybrid
+ 576;
1883 ptr1
= g
->sb_hybrid
+ 2 * 18;
1884 while (ptr
>= ptr1
) {
1886 v
= ptr
[0] | ptr
[1] | ptr
[2] | ptr
[3] | ptr
[4] | ptr
[5];
1890 sblimit
= ((ptr
- g
->sb_hybrid
) / 18) + 1;
1892 if (g
->block_type
== 2) {
1893 /* XXX: check for 8000 Hz */
1894 if (g
->switch_point
)
1899 mdct_long_end
= sblimit
;
1904 for(j
=0;j
<mdct_long_end
;j
++) {
1905 /* apply window & overlap with previous buffer */
1906 out_ptr
= sb_samples
+ j
;
1908 if (g
->switch_point
&& j
< 2)
1911 win1
= mdct_win
[g
->block_type
];
1912 /* select frequency inversion */
1913 win
= win1
+ ((4 * 36) & -(j
& 1));
1914 imdct36(out_ptr
, buf
, ptr
, win
);
1915 out_ptr
+= 18*SBLIMIT
;
1919 for(j
=mdct_long_end
;j
<sblimit
;j
++) {
1920 /* select frequency inversion */
1921 win
= mdct_win
[2] + ((4 * 36) & -(j
& 1));
1922 out_ptr
= sb_samples
+ j
;
1928 imdct12(out2
, ptr
+ 0);
1930 *out_ptr
= MULH(out2
[i
], win
[i
]) + buf
[i
+ 6*1];
1931 buf
[i
+ 6*2] = MULH(out2
[i
+ 6], win
[i
+ 6]);
1934 imdct12(out2
, ptr
+ 1);
1936 *out_ptr
= MULH(out2
[i
], win
[i
]) + buf
[i
+ 6*2];
1937 buf
[i
+ 6*0] = MULH(out2
[i
+ 6], win
[i
+ 6]);
1940 imdct12(out2
, ptr
+ 2);
1942 buf
[i
+ 6*0] = MULH(out2
[i
], win
[i
]) + buf
[i
+ 6*0];
1943 buf
[i
+ 6*1] = MULH(out2
[i
+ 6], win
[i
+ 6]);
1950 for(j
=sblimit
;j
<SBLIMIT
;j
++) {
1952 out_ptr
= sb_samples
+ j
;
1963 void sample_dump(int fnum
, int32_t *tab
, int n
)
1965 static FILE *files
[16], *f
;
1972 snprintf(buf
, sizeof(buf
), "/tmp/out%d.%s.pcm",
1974 #ifdef USE_HIGHPRECISION
1980 f
= fopen(buf
, "w");
1988 av_log(NULL
, AV_LOG_DEBUG
, "pos=%d\n", pos
);
1990 av_log(NULL
, AV_LOG_DEBUG
, " %0.4f", (double)tab
[i
] / FRAC_ONE
);
1992 av_log(NULL
, AV_LOG_DEBUG
, "\n");
1997 /* normalize to 23 frac bits */
1998 v
= tab
[i
] << (23 - FRAC_BITS
);
1999 fwrite(&v
, 1, sizeof(int32_t), f
);
2005 /* main layer3 decoding function */
2006 static int mp_decode_layer3(MPADecodeContext
*s
)
2008 int nb_granules
, main_data_begin
, private_bits
;
2009 int gr
, ch
, blocksplit_flag
, i
, j
, k
, n
, bits_pos
;
2010 GranuleDef granules
[2][2], *g
;
2011 int16_t exponents
[576];
2013 /* read side info */
2015 main_data_begin
= get_bits(&s
->gb
, 8);
2016 private_bits
= get_bits(&s
->gb
, s
->nb_channels
);
2019 main_data_begin
= get_bits(&s
->gb
, 9);
2020 if (s
->nb_channels
== 2)
2021 private_bits
= get_bits(&s
->gb
, 3);
2023 private_bits
= get_bits(&s
->gb
, 5);
2025 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
2026 granules
[ch
][0].scfsi
= 0; /* all scale factors are transmitted */
2027 granules
[ch
][1].scfsi
= get_bits(&s
->gb
, 4);
2031 for(gr
=0;gr
<nb_granules
;gr
++) {
2032 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
2033 dprintf(s
->avctx
, "gr=%d ch=%d: side_info\n", gr
, ch
);
2034 g
= &granules
[ch
][gr
];
2035 g
->part2_3_length
= get_bits(&s
->gb
, 12);
2036 g
->big_values
= get_bits(&s
->gb
, 9);
2037 if(g
->big_values
> 288){
2038 av_log(s
->avctx
, AV_LOG_ERROR
, "big_values too big\n");
2042 g
->global_gain
= get_bits(&s
->gb
, 8);
2043 /* if MS stereo only is selected, we precompute the
2044 1/sqrt(2) renormalization factor */
2045 if ((s
->mode_ext
& (MODE_EXT_MS_STEREO
| MODE_EXT_I_STEREO
)) ==
2047 g
->global_gain
-= 2;
2049 g
->scalefac_compress
= get_bits(&s
->gb
, 9);
2051 g
->scalefac_compress
= get_bits(&s
->gb
, 4);
2052 blocksplit_flag
= get_bits1(&s
->gb
);
2053 if (blocksplit_flag
) {
2054 g
->block_type
= get_bits(&s
->gb
, 2);
2055 if (g
->block_type
== 0){
2056 av_log(NULL
, AV_LOG_ERROR
, "invalid block type\n");
2059 g
->switch_point
= get_bits1(&s
->gb
);
2061 g
->table_select
[i
] = get_bits(&s
->gb
, 5);
2063 g
->subblock_gain
[i
] = get_bits(&s
->gb
, 3);
2064 ff_init_short_region(s
, g
);
2066 int region_address1
, region_address2
;
2068 g
->switch_point
= 0;
2070 g
->table_select
[i
] = get_bits(&s
->gb
, 5);
2071 /* compute huffman coded region sizes */
2072 region_address1
= get_bits(&s
->gb
, 4);
2073 region_address2
= get_bits(&s
->gb
, 3);
2074 dprintf(s
->avctx
, "region1=%d region2=%d\n",
2075 region_address1
, region_address2
);
2076 ff_init_long_region(s
, g
, region_address1
, region_address2
);
2078 ff_region_offset2size(g
);
2079 ff_compute_band_indexes(s
, g
);
2083 g
->preflag
= get_bits1(&s
->gb
);
2084 g
->scalefac_scale
= get_bits1(&s
->gb
);
2085 g
->count1table_select
= get_bits1(&s
->gb
);
2086 dprintf(s
->avctx
, "block_type=%d switch_point=%d\n",
2087 g
->block_type
, g
->switch_point
);
2092 const uint8_t *ptr
= s
->gb
.buffer
+ (get_bits_count(&s
->gb
)>>3);
2093 assert((get_bits_count(&s
->gb
) & 7) == 0);
2094 /* now we get bits from the main_data_begin offset */
2095 dprintf(s
->avctx
, "seekback: %d\n", main_data_begin
);
2096 //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
2098 memcpy(s
->last_buf
+ s
->last_buf_size
, ptr
, EXTRABYTES
);
2100 init_get_bits(&s
->gb
, s
->last_buf
, s
->last_buf_size
*8);
2101 skip_bits_long(&s
->gb
, 8*(s
->last_buf_size
- main_data_begin
));
2104 for(gr
=0;gr
<nb_granules
;gr
++) {
2105 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
2106 g
= &granules
[ch
][gr
];
2107 if(get_bits_count(&s
->gb
)<0){
2108 av_log(NULL
, AV_LOG_ERROR
, "mdb:%d, lastbuf:%d skipping granule %d\n",
2109 main_data_begin
, s
->last_buf_size
, gr
);
2110 skip_bits_long(&s
->gb
, g
->part2_3_length
);
2111 memset(g
->sb_hybrid
, 0, sizeof(g
->sb_hybrid
));
2112 if(get_bits_count(&s
->gb
) >= s
->gb
.size_in_bits
&& s
->in_gb
.buffer
){
2113 skip_bits_long(&s
->in_gb
, get_bits_count(&s
->gb
) - s
->gb
.size_in_bits
);
2115 s
->in_gb
.buffer
=NULL
;
2120 bits_pos
= get_bits_count(&s
->gb
);
2124 int slen
, slen1
, slen2
;
2126 /* MPEG1 scale factors */
2127 slen1
= slen_table
[0][g
->scalefac_compress
];
2128 slen2
= slen_table
[1][g
->scalefac_compress
];
2129 dprintf(s
->avctx
, "slen1=%d slen2=%d\n", slen1
, slen2
);
2130 if (g
->block_type
== 2) {
2131 n
= g
->switch_point
? 17 : 18;
2135 g
->scale_factors
[j
++] = get_bits(&s
->gb
, slen1
);
2138 g
->scale_factors
[j
++] = 0;
2142 g
->scale_factors
[j
++] = get_bits(&s
->gb
, slen2
);
2144 g
->scale_factors
[j
++] = 0;
2147 g
->scale_factors
[j
++] = 0;
2150 sc
= granules
[ch
][0].scale_factors
;
2153 n
= (k
== 0 ? 6 : 5);
2154 if ((g
->scfsi
& (0x8 >> k
)) == 0) {
2155 slen
= (k
< 2) ? slen1
: slen2
;
2158 g
->scale_factors
[j
++] = get_bits(&s
->gb
, slen
);
2161 g
->scale_factors
[j
++] = 0;
2164 /* simply copy from last granule */
2166 g
->scale_factors
[j
] = sc
[j
];
2171 g
->scale_factors
[j
++] = 0;
2175 dprintf(s
->avctx
, "scfsi=%x gr=%d ch=%d scale_factors:\n",
2178 dprintf(s
->avctx
, " %d", g
->scale_factors
[i
]);
2179 dprintf(s
->avctx
, "\n");
2183 int tindex
, tindex2
, slen
[4], sl
, sf
;
2185 /* LSF scale factors */
2186 if (g
->block_type
== 2) {
2187 tindex
= g
->switch_point
? 2 : 1;
2191 sf
= g
->scalefac_compress
;
2192 if ((s
->mode_ext
& MODE_EXT_I_STEREO
) && ch
== 1) {
2193 /* intensity stereo case */
2196 lsf_sf_expand(slen
, sf
, 6, 6, 0);
2198 } else if (sf
< 244) {
2199 lsf_sf_expand(slen
, sf
- 180, 4, 4, 0);
2202 lsf_sf_expand(slen
, sf
- 244, 3, 0, 0);
2208 lsf_sf_expand(slen
, sf
, 5, 4, 4);
2210 } else if (sf
< 500) {
2211 lsf_sf_expand(slen
, sf
- 400, 5, 4, 0);
2214 lsf_sf_expand(slen
, sf
- 500, 3, 0, 0);
2222 n
= lsf_nsf_table
[tindex2
][tindex
][k
];
2226 g
->scale_factors
[j
++] = get_bits(&s
->gb
, sl
);
2229 g
->scale_factors
[j
++] = 0;
2232 /* XXX: should compute exact size */
2234 g
->scale_factors
[j
] = 0;
2237 dprintf(s
->avctx
, "gr=%d ch=%d scale_factors:\n",
2240 dprintf(s
->avctx
, " %d", g
->scale_factors
[i
]);
2241 dprintf(s
->avctx
, "\n");
2246 exponents_from_scale_factors(s
, g
, exponents
);
2248 /* read Huffman coded residue */
2249 huffman_decode(s
, g
, exponents
, bits_pos
+ g
->part2_3_length
);
2251 sample_dump(0, g
->sb_hybrid
, 576);
2255 if (s
->nb_channels
== 2)
2256 compute_stereo(s
, &granules
[0][gr
], &granules
[1][gr
]);
2258 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
2259 g
= &granules
[ch
][gr
];
2261 reorder_block(s
, g
);
2263 sample_dump(0, g
->sb_hybrid
, 576);
2265 s
->compute_antialias(s
, g
);
2267 sample_dump(1, g
->sb_hybrid
, 576);
2269 compute_imdct(s
, g
, &s
->sb_samples
[ch
][18 * gr
][0], s
->mdct_buf
[ch
]);
2271 sample_dump(2, &s
->sb_samples
[ch
][18 * gr
][0], 576);
2275 if(get_bits_count(&s
->gb
)<0)
2276 skip_bits_long(&s
->gb
, -get_bits_count(&s
->gb
));
2277 return nb_granules
* 18;
2280 static int mp_decode_frame(MPADecodeContext
*s
,
2281 OUT_INT
*samples
, const uint8_t *buf
, int buf_size
)
2283 int i
, nb_frames
, ch
;
2284 OUT_INT
*samples_ptr
;
2286 init_get_bits(&s
->gb
, buf
+ HEADER_SIZE
, (buf_size
- HEADER_SIZE
)*8);
2288 /* skip error protection field */
2289 if (s
->error_protection
)
2290 skip_bits(&s
->gb
, 16);
2292 dprintf(s
->avctx
, "frame %d:\n", s
->frame_count
);
2295 s
->avctx
->frame_size
= 384;
2296 nb_frames
= mp_decode_layer1(s
);
2299 s
->avctx
->frame_size
= 1152;
2300 nb_frames
= mp_decode_layer2(s
);
2303 s
->avctx
->frame_size
= s
->lsf
? 576 : 1152;
2305 nb_frames
= mp_decode_layer3(s
);
2308 if(s
->in_gb
.buffer
){
2309 align_get_bits(&s
->gb
);
2310 i
= (s
->gb
.size_in_bits
- get_bits_count(&s
->gb
))>>3;
2311 if(i
>= 0 && i
<= BACKSTEP_SIZE
){
2312 memmove(s
->last_buf
, s
->gb
.buffer
+ (get_bits_count(&s
->gb
)>>3), i
);
2315 av_log(NULL
, AV_LOG_ERROR
, "invalid old backstep %d\n", i
);
2317 s
->in_gb
.buffer
= NULL
;
2320 align_get_bits(&s
->gb
);
2321 assert((get_bits_count(&s
->gb
) & 7) == 0);
2322 i
= (s
->gb
.size_in_bits
- get_bits_count(&s
->gb
))>>3;
2324 if(i
<0 || i
> BACKSTEP_SIZE
|| nb_frames
<0){
2325 av_log(NULL
, AV_LOG_ERROR
, "invalid new backstep %d\n", i
);
2326 i
= FFMIN(BACKSTEP_SIZE
, buf_size
- HEADER_SIZE
);
2328 assert(i
<= buf_size
- HEADER_SIZE
&& i
>= 0);
2329 memcpy(s
->last_buf
+ s
->last_buf_size
, s
->gb
.buffer
+ buf_size
- HEADER_SIZE
- i
, i
);
2330 s
->last_buf_size
+= i
;
2335 for(i
=0;i
<nb_frames
;i
++) {
2336 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
2338 dprintf(s
->avctx
, "%d-%d:", i
, ch
);
2339 for(j
=0;j
<SBLIMIT
;j
++)
2340 dprintf(s
->avctx
, " %0.6f", (double)s
->sb_samples
[ch
][i
][j
] / FRAC_ONE
);
2341 dprintf(s
->avctx
, "\n");
2345 /* apply the synthesis filter */
2346 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
2347 samples_ptr
= samples
+ ch
;
2348 for(i
=0;i
<nb_frames
;i
++) {
2349 ff_mpa_synth_filter(s
->synth_buf
[ch
], &(s
->synth_buf_offset
[ch
]),
2350 window
, &s
->dither_state
,
2351 samples_ptr
, s
->nb_channels
,
2352 s
->sb_samples
[ch
][i
]);
2353 samples_ptr
+= 32 * s
->nb_channels
;
2359 return nb_frames
* 32 * sizeof(OUT_INT
) * s
->nb_channels
;
2362 static int decode_frame(AVCodecContext
* avctx
,
2363 void *data
, int *data_size
,
2364 const uint8_t * buf
, int buf_size
)
2366 MPADecodeContext
*s
= avctx
->priv_data
;
2369 OUT_INT
*out_samples
= data
;
2372 if(buf_size
< HEADER_SIZE
)
2375 header
= AV_RB32(buf
);
2376 if(ff_mpa_check_header(header
) < 0){
2379 av_log(avctx
, AV_LOG_ERROR
, "Header missing skipping one byte.\n");
2383 if (ff_mpegaudio_decode_header(s
, header
) == 1) {
2384 /* free format: prepare to compute frame size */
2388 /* update codec info */
2389 avctx
->channels
= s
->nb_channels
;
2390 avctx
->bit_rate
= s
->bit_rate
;
2391 avctx
->sub_id
= s
->layer
;
2393 if(s
->frame_size
<=0 || s
->frame_size
> buf_size
){
2394 av_log(avctx
, AV_LOG_ERROR
, "incomplete frame\n");
2396 }else if(s
->frame_size
< buf_size
){
2397 av_log(avctx
, AV_LOG_ERROR
, "incorrect frame size\n");
2398 buf_size
= s
->frame_size
;
2401 out_size
= mp_decode_frame(s
, out_samples
, buf
, buf_size
);
2403 *data_size
= out_size
;
2404 avctx
->sample_rate
= s
->sample_rate
;
2405 //FIXME maybe move the other codec info stuff from above here too
2407 av_log(avctx
, AV_LOG_DEBUG
, "Error while decoding MPEG audio frame.\n"); //FIXME return -1 / but also return the number of bytes consumed
2412 static void flush(AVCodecContext
*avctx
){
2413 MPADecodeContext
*s
= avctx
->priv_data
;
2414 memset(s
->synth_buf
, 0, sizeof(s
->synth_buf
));
2415 s
->last_buf_size
= 0;
2418 #ifdef CONFIG_MP3ADU_DECODER
2419 static int decode_frame_adu(AVCodecContext
* avctx
,
2420 void *data
, int *data_size
,
2421 const uint8_t * buf
, int buf_size
)
2423 MPADecodeContext
*s
= avctx
->priv_data
;
2426 OUT_INT
*out_samples
= data
;
2430 // Discard too short frames
2431 if (buf_size
< HEADER_SIZE
) {
2437 if (len
> MPA_MAX_CODED_FRAME_SIZE
)
2438 len
= MPA_MAX_CODED_FRAME_SIZE
;
2440 // Get header and restore sync word
2441 header
= AV_RB32(buf
) | 0xffe00000;
2443 if (ff_mpa_check_header(header
) < 0) { // Bad header, discard frame
2448 ff_mpegaudio_decode_header(s
, header
);
2449 /* update codec info */
2450 avctx
->sample_rate
= s
->sample_rate
;
2451 avctx
->channels
= s
->nb_channels
;
2452 avctx
->bit_rate
= s
->bit_rate
;
2453 avctx
->sub_id
= s
->layer
;
2455 s
->frame_size
= len
;
2457 if (avctx
->parse_only
) {
2458 out_size
= buf_size
;
2460 out_size
= mp_decode_frame(s
, out_samples
, buf
, buf_size
);
2463 *data_size
= out_size
;
2466 #endif /* CONFIG_MP3ADU_DECODER */
2468 #ifdef CONFIG_MP3ON4_DECODER
2471 * Context for MP3On4 decoder
2473 typedef struct MP3On4DecodeContext
{
2474 int frames
; ///< number of mp3 frames per block (number of mp3 decoder instances)
2475 int syncword
; ///< syncword patch
2476 const uint8_t *coff
; ///< channels offsets in output buffer
2477 MPADecodeContext
*mp3decctx
[5]; ///< MPADecodeContext for every decoder instance
2478 } MP3On4DecodeContext
;
2480 #include "mpeg4audio.h"
2482 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
2483 static const uint8_t mp3Frames
[8] = {0,1,1,2,3,3,4,5}; /* number of mp3 decoder instances */
2484 /* offsets into output buffer, assume output order is FL FR BL BR C LFE */
2485 static const uint8_t chan_offset
[8][5] = {
2490 {2,0,3}, // C FLR BS
2491 {4,0,2}, // C FLR BLRS
2492 {4,0,2,5}, // C FLR BLRS LFE
2493 {4,0,2,6,5}, // C FLR BLRS BLR LFE
2497 static int decode_init_mp3on4(AVCodecContext
* avctx
)
2499 MP3On4DecodeContext
*s
= avctx
->priv_data
;
2500 MPEG4AudioConfig cfg
;
2503 if ((avctx
->extradata_size
< 2) || (avctx
->extradata
== NULL
)) {
2504 av_log(avctx
, AV_LOG_ERROR
, "Codec extradata missing or too short.\n");
2508 ff_mpeg4audio_get_config(&cfg
, avctx
->extradata
, avctx
->extradata_size
);
2509 if (!cfg
.chan_config
|| cfg
.chan_config
> 7) {
2510 av_log(avctx
, AV_LOG_ERROR
, "Invalid channel config number.\n");
2513 s
->frames
= mp3Frames
[cfg
.chan_config
];
2514 s
->coff
= chan_offset
[cfg
.chan_config
];
2515 avctx
->channels
= ff_mpeg4audio_channels
[cfg
.chan_config
];
2517 if (cfg
.sample_rate
< 16000)
2518 s
->syncword
= 0xffe00000;
2520 s
->syncword
= 0xfff00000;
2522 /* Init the first mp3 decoder in standard way, so that all tables get builded
2523 * We replace avctx->priv_data with the context of the first decoder so that
2524 * decode_init() does not have to be changed.
2525 * Other decoders will be initialized here copying data from the first context
2527 // Allocate zeroed memory for the first decoder context
2528 s
->mp3decctx
[0] = av_mallocz(sizeof(MPADecodeContext
));
2529 // Put decoder context in place to make init_decode() happy
2530 avctx
->priv_data
= s
->mp3decctx
[0];
2532 // Restore mp3on4 context pointer
2533 avctx
->priv_data
= s
;
2534 s
->mp3decctx
[0]->adu_mode
= 1; // Set adu mode
2536 /* Create a separate codec/context for each frame (first is already ok).
2537 * Each frame is 1 or 2 channels - up to 5 frames allowed
2539 for (i
= 1; i
< s
->frames
; i
++) {
2540 s
->mp3decctx
[i
] = av_mallocz(sizeof(MPADecodeContext
));
2541 s
->mp3decctx
[i
]->compute_antialias
= s
->mp3decctx
[0]->compute_antialias
;
2542 s
->mp3decctx
[i
]->adu_mode
= 1;
2543 s
->mp3decctx
[i
]->avctx
= avctx
;
2550 static int decode_close_mp3on4(AVCodecContext
* avctx
)
2552 MP3On4DecodeContext
*s
= avctx
->priv_data
;
2555 for (i
= 0; i
< s
->frames
; i
++)
2556 if (s
->mp3decctx
[i
])
2557 av_free(s
->mp3decctx
[i
]);
2563 static int decode_frame_mp3on4(AVCodecContext
* avctx
,
2564 void *data
, int *data_size
,
2565 const uint8_t * buf
, int buf_size
)
2567 MP3On4DecodeContext
*s
= avctx
->priv_data
;
2568 MPADecodeContext
*m
;
2569 int fsize
, len
= buf_size
, out_size
= 0;
2571 OUT_INT
*out_samples
= data
;
2572 OUT_INT decoded_buf
[MPA_FRAME_SIZE
* MPA_MAX_CHANNELS
];
2573 OUT_INT
*outptr
, *bp
;
2577 // Discard too short frames
2578 if (buf_size
< HEADER_SIZE
)
2581 // If only one decoder interleave is not needed
2582 outptr
= s
->frames
== 1 ? out_samples
: decoded_buf
;
2584 avctx
->bit_rate
= 0;
2586 for (fr
= 0; fr
< s
->frames
; fr
++) {
2587 fsize
= AV_RB16(buf
) >> 4;
2588 fsize
= FFMIN3(fsize
, len
, MPA_MAX_CODED_FRAME_SIZE
);
2589 m
= s
->mp3decctx
[fr
];
2592 header
= (AV_RB32(buf
) & 0x000fffff) | s
->syncword
; // patch header
2594 if (ff_mpa_check_header(header
) < 0) // Bad header, discard block
2597 ff_mpegaudio_decode_header(m
, header
);
2598 out_size
+= mp_decode_frame(m
, outptr
, buf
, fsize
);
2603 n
= m
->avctx
->frame_size
*m
->nb_channels
;
2604 /* interleave output data */
2605 bp
= out_samples
+ s
->coff
[fr
];
2606 if(m
->nb_channels
== 1) {
2607 for(j
= 0; j
< n
; j
++) {
2608 *bp
= decoded_buf
[j
];
2609 bp
+= avctx
->channels
;
2612 for(j
= 0; j
< n
; j
++) {
2613 bp
[0] = decoded_buf
[j
++];
2614 bp
[1] = decoded_buf
[j
];
2615 bp
+= avctx
->channels
;
2619 avctx
->bit_rate
+= m
->bit_rate
;
2622 /* update codec info */
2623 avctx
->sample_rate
= s
->mp3decctx
[0]->sample_rate
;
2625 *data_size
= out_size
;
2628 #endif /* CONFIG_MP3ON4_DECODER */
2630 #ifdef CONFIG_MP2_DECODER
2631 AVCodec mp2_decoder
=
2636 sizeof(MPADecodeContext
),
2641 CODEC_CAP_PARSE_ONLY
,
2643 .long_name
= "MP2 (MPEG audio layer 2)",
2646 #ifdef CONFIG_MP3_DECODER
2647 AVCodec mp3_decoder
=
2652 sizeof(MPADecodeContext
),
2657 CODEC_CAP_PARSE_ONLY
,
2659 .long_name
= "MP3 (MPEG audio layer 3)",
2662 #ifdef CONFIG_MP3ADU_DECODER
2663 AVCodec mp3adu_decoder
=
2668 sizeof(MPADecodeContext
),
2673 CODEC_CAP_PARSE_ONLY
,
2675 .long_name
= "ADU (Application Data Unit) MP3 (MPEG audio layer 3)",
2678 #ifdef CONFIG_MP3ON4_DECODER
2679 AVCodec mp3on4_decoder
=
2684 sizeof(MP3On4DecodeContext
),
2687 decode_close_mp3on4
,
2688 decode_frame_mp3on4
,
2690 .long_name
= "MP3onMP4",