annotate mpegaudiodec.c @ 8616:225104b68cbb libavcodec

Alpha: fix dct_unquantize_h263_inter/intra_axp()
author mru
date Sat, 17 Jan 2009 21:44:56 +0000
parents 6550218be3b7
children 04423b2f6e0b
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1 /*
986e461dc072 Initial revision
glantau
parents:
diff changeset
2 * MPEG Audio decoder
429
718a22dc121f license/copyright change
glantau
parents: 407
diff changeset
3 * Copyright (c) 2001, 2002 Fabrice Bellard.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4 *
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3938
diff changeset
5 * This file is part of FFmpeg.
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3938
diff changeset
6 *
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3938
diff changeset
7 * FFmpeg is free software; you can redistribute it and/or
429
718a22dc121f license/copyright change
glantau
parents: 407
diff changeset
8 * modify it under the terms of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 407
diff changeset
9 * License as published by the Free Software Foundation; either
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3938
diff changeset
10 * version 2.1 of the License, or (at your option) any later version.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
11 *
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3938
diff changeset
12 * FFmpeg is distributed in the hope that it will be useful,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
429
718a22dc121f license/copyright change
glantau
parents: 407
diff changeset
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
718a22dc121f license/copyright change
glantau
parents: 407
diff changeset
15 * Lesser General Public License for more details.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
16 *
429
718a22dc121f license/copyright change
glantau
parents: 407
diff changeset
17 * You should have received a copy of the GNU Lesser General Public
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3938
diff changeset
18 * License along with FFmpeg; if not, write to the Free Software
3036
0b546eab515d Update licensing information: The FSF changed postal address.
diego
parents: 3023
diff changeset
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
20 */
1106
1e39f273ecd6 per file doxy
michaelni
parents: 1064
diff changeset
21
1e39f273ecd6 per file doxy
michaelni
parents: 1064
diff changeset
22 /**
1e39f273ecd6 per file doxy
michaelni
parents: 1064
diff changeset
23 * @file mpegaudiodec.c
1e39f273ecd6 per file doxy
michaelni
parents: 1064
diff changeset
24 * MPEG Audio decoder.
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
25 */
1106
1e39f273ecd6 per file doxy
michaelni
parents: 1064
diff changeset
26
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
27 #include "avcodec.h"
2398
582e635cfa08 common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents: 2370
diff changeset
28 #include "bitstream.h"
1734
8aace334bcf0 lrintf patch by ("Steven M. Schultz" <sms at 2BSD dot COM>)
michael
parents: 1733
diff changeset
29 #include "dsputil.h"
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
30
986e461dc072 Initial revision
glantau
parents:
diff changeset
31 /*
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
32 * TODO:
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
33 * - in low precision mode, use more 16 bit multiplies in synth filter
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
34 * - test lsf / mpeg25 extensively.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
35 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
36
2913
cc55bc1f8d92 QDM2 compatible decoder
rtognimp
parents: 2911
diff changeset
37 #include "mpegaudio.h"
5050
a5f6fbc9fa66 loosen dependencies over mpegaudiodec
aurel
parents: 5032
diff changeset
38 #include "mpegaudiodecheader.h"
2479
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
39
3752
32b2da1060ea Use mathops
lu_zero
parents: 3732
diff changeset
40 #include "mathops.h"
32b2da1060ea Use mathops
lu_zero
parents: 3732
diff changeset
41
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
42 /* WARNING: only correct for posititive numbers */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
43 #define FIXR(a) ((int)((a) * FRAC_ONE + 0.5))
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
44 #define FRAC_RND(a) (((a) + (FRAC_ONE/2)) >> FRAC_BITS)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
45
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
46 #define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
47
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
48 /****************/
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
49
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
50 #define HEADER_SIZE 4
986e461dc072 Initial revision
glantau
parents:
diff changeset
51
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
52 /* layer 3 "granule" */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
53 typedef struct GranuleDef {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
54 uint8_t scfsi;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
55 int part2_3_length;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
56 int big_values;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
57 int global_gain;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
58 int scalefac_compress;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
59 uint8_t block_type;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
60 uint8_t switch_point;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
61 int table_select[3];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
62 int subblock_gain[3];
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
63 uint8_t scalefac_scale;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
64 uint8_t count1table_select;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
65 int region_size[3]; /* number of huffman codes in each region */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
66 int preflag;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
67 int short_start, long_end; /* long/short band indexes */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
68 uint8_t scale_factors[40];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
69 int32_t sb_hybrid[SBLIMIT * 18]; /* 576 samples */
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
70 } GranuleDef;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
71
5031
70f194a2ee53 move some common mpeg audio tables from mpegaudiodectab.h to mpegaudiodata.c
aurel
parents: 5009
diff changeset
72 #include "mpegaudiodata.h"
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
73 #include "mpegaudiodectab.h"
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
74
1733
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
75 static void compute_antialias_integer(MPADecodeContext *s, GranuleDef *g);
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
76 static void compute_antialias_float(MPADecodeContext *s, GranuleDef *g);
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
77
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
78 /* vlc structure for decoding layer 3 huffman tables */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
79 static VLC huff_vlc[16];
7452
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
80 static VLC_TYPE huff_vlc_tables[
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
81 0+128+128+128+130+128+154+166+
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
82 142+204+190+170+542+460+662+414
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
83 ][2];
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
84 static const int huff_vlc_tables_sizes[16] = {
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
85 0, 128, 128, 128, 130, 128, 154, 166,
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
86 142, 204, 190, 170, 542, 460, 662, 414
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
87 };
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
88 static VLC huff_quad_vlc[2];
7452
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
89 static VLC_TYPE huff_quad_vlc_tables[128+16][2];
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
90 static const int huff_quad_vlc_tables_sizes[2] = {
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
91 128, 16
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
92 };
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
93 /* computed from band_size_long */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
94 static uint16_t band_index_long[9][23];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
95 /* XXX: free when all decoders are closed */
2490
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
96 #define TABLE_4_3_SIZE (8191 + 16)*4
4662
36c100bb7758 kill another 2 av_mallocz_static()
michael
parents: 4652
diff changeset
97 static int8_t table_4_3_exp[TABLE_4_3_SIZE];
36c100bb7758 kill another 2 av_mallocz_static()
michael
parents: 4652
diff changeset
98 static uint32_t table_4_3_value[TABLE_4_3_SIZE];
3621
d4896ea0305b replace l3_unscale(1, exponents[pos]) by LUT
michael
parents: 3620
diff changeset
99 static uint32_t exp_table[512];
3622
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
100 static uint32_t expval_table[512][16];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
101 /* intensity stereo coef table */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
102 static int32_t is_table[2][16];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
103 static int32_t is_table_lsf[2][2][16];
1733
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
104 static int32_t csa_table[8][4];
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
105 static float csa_table_float[8][4];
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
106 static int32_t mdct_win[8][36];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
107
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
108 /* lower 2 bits: modulo 3, higher bits: shift */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
109 static uint16_t scale_factor_modshift[64];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
110 /* [i][j]: 2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
111 static int32_t scale_factor_mult[15][3];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
112 /* mult table for layer 2 group quantization */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
113
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
114 #define SCALE_GEN(v) \
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
115 { FIXR(1.0 * (v)), FIXR(0.7937005259 * (v)), FIXR(0.6299605249 * (v)) }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
116
2753
ba8ecddf5598 adding a few const
michael
parents: 2647
diff changeset
117 static const int32_t scale_factor_mult2[3][3] = {
449
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
118 SCALE_GEN(4.0 / 3.0), /* 3 steps */
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
119 SCALE_GEN(4.0 / 5.0), /* 5 steps */
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
120 SCALE_GEN(4.0 / 9.0), /* 9 steps */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
121 };
986e461dc072 Initial revision
glantau
parents:
diff changeset
122
5009
4d10df33e823 Use DECLARE_ALIGNED to ease porting
reimar
parents: 4908
diff changeset
123 static DECLARE_ALIGNED_16(MPA_INT, window[512]);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
124
6138
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
125 /**
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
126 * Convert region offsets to region sizes and truncate
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
127 * size to big_values.
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
128 */
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
129 void ff_region_offset2size(GranuleDef *g){
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
130 int i, k, j=0;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
131 g->region_size[2] = (576 / 2);
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
132 for(i=0;i<3;i++) {
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
133 k = FFMIN(g->region_size[i], g->big_values);
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
134 g->region_size[i] = k - j;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
135 j = k;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
136 }
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
137 }
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
138
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
139 void ff_init_short_region(MPADecodeContext *s, GranuleDef *g){
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
140 if (g->block_type == 2)
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
141 g->region_size[0] = (36 / 2);
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
142 else {
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
143 if (s->sample_rate_index <= 2)
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
144 g->region_size[0] = (36 / 2);
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
145 else if (s->sample_rate_index != 8)
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
146 g->region_size[0] = (54 / 2);
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
147 else
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
148 g->region_size[0] = (108 / 2);
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
149 }
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
150 g->region_size[1] = (576 / 2);
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
151 }
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
152
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
153 void ff_init_long_region(MPADecodeContext *s, GranuleDef *g, int ra1, int ra2){
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
154 int l;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
155 g->region_size[0] =
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
156 band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
157 /* should not overflow */
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
158 l = FFMIN(ra1 + ra2 + 2, 22);
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
159 g->region_size[1] =
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
160 band_index_long[s->sample_rate_index][l] >> 1;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
161 }
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
162
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
163 void ff_compute_band_indexes(MPADecodeContext *s, GranuleDef *g){
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
164 if (g->block_type == 2) {
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
165 if (g->switch_point) {
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
166 /* if switched mode, we handle the 36 first samples as
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
167 long blocks. For 8000Hz, we handle the 48 first
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
168 exponents as long blocks (XXX: check this!) */
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
169 if (s->sample_rate_index <= 2)
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
170 g->long_end = 8;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
171 else if (s->sample_rate_index != 8)
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
172 g->long_end = 6;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
173 else
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
174 g->long_end = 4; /* 8000 Hz */
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
175
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
176 g->short_start = 2 + (s->sample_rate_index != 8);
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
177 } else {
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
178 g->long_end = 0;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
179 g->short_start = 0;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
180 }
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
181 } else {
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
182 g->short_start = 13;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
183 g->long_end = 22;
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
184 }
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
185 }
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
186
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
187 /* layer 1 unscaling */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
188 /* n = number of bits of the mantissa minus 1 */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
189 static inline int l1_unscale(int n, int mant, int scale_factor)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
190 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
191 int shift, mod;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
192 int64_t val;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
193
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
194 shift = scale_factor_modshift[scale_factor];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
195 mod = shift & 3;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
196 shift >>= 2;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
197 val = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
198 shift += n;
449
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
199 /* NOTE: at this point, 1 <= shift >= 21 + 15 */
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
200 return (int)((val + (1LL << (shift - 1))) >> shift);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
201 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
202
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
203 static inline int l2_unscale_group(int steps, int mant, int scale_factor)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
204 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
205 int shift, mod, val;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
206
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
207 shift = scale_factor_modshift[scale_factor];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
208 mod = shift & 3;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
209 shift >>= 2;
449
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
210
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
211 val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
212 /* NOTE: at this point, 0 <= shift <= 21 */
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
213 if (shift > 0)
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
214 val = (val + (1 << (shift - 1))) >> shift;
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
215 return val;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
216 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
217
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
218 /* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
219 static inline int l3_unscale(int value, int exponent)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
220 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
221 unsigned int m;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
222 int e;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
223
2490
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
224 e = table_4_3_exp [4*value + (exponent&3)];
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
225 m = table_4_3_value[4*value + (exponent&3)];
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
226 e -= (exponent >> 2);
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
227 assert(e>=1);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
228 if (e > 31)
2478
6744ea5ff950 more accurate dequant of near zero coefficients
michael
parents: 2477
diff changeset
229 return 0;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
230 m = (m + (1 << (e-1))) >> e;
2490
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
231
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
232 return m;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
233 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
234
392
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
235 /* all integer n^(4/3) computation code */
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
236 #define DEV_ORDER 13
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
237
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
238 #define POW_FRAC_BITS 24
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
239 #define POW_FRAC_ONE (1 << POW_FRAC_BITS)
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
240 #define POW_FIX(a) ((int)((a) * POW_FRAC_ONE))
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
241 #define POW_MULL(a,b) (((int64_t)(a) * (int64_t)(b)) >> POW_FRAC_BITS)
392
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
242
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
243 static int dev_4_3_coefs[DEV_ORDER];
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
244
2522
e25782262d7d kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents: 2507
diff changeset
245 #if 0 /* unused */
392
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
246 static int pow_mult3[3] = {
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
247 POW_FIX(1.0),
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
248 POW_FIX(1.25992104989487316476),
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
249 POW_FIX(1.58740105196819947474),
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
250 };
2522
e25782262d7d kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents: 2507
diff changeset
251 #endif
392
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
252
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
253 static void int_pow_init(void)
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
254 {
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
255 int i, a;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
256
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
257 a = POW_FIX(1.0);
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
258 for(i=0;i<DEV_ORDER;i++) {
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
259 a = POW_MULL(a, POW_FIX(4.0 / 3.0) - i * POW_FIX(1.0)) / (i + 1);
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
260 dev_4_3_coefs[i] = a;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
261 }
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
262 }
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
263
2522
e25782262d7d kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents: 2507
diff changeset
264 #if 0 /* unused, remove? */
392
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
265 /* return the mantissa and the binary exponent */
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
266 static int int_pow(int i, int *exp_ptr)
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
267 {
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
268 int e, er, eq, j;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
269 int a, a1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
270
392
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
271 /* renormalize */
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
272 a = i;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
273 e = POW_FRAC_BITS;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
274 while (a < (1 << (POW_FRAC_BITS - 1))) {
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
275 a = a << 1;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
276 e--;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
277 }
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
278 a -= (1 << POW_FRAC_BITS);
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
279 a1 = 0;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
280 for(j = DEV_ORDER - 1; j >= 0; j--)
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
281 a1 = POW_MULL(a, dev_4_3_coefs[j] + a1);
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
282 a = (1 << POW_FRAC_BITS) + a1;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
283 /* exponent compute (exact) */
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
284 e = e * 4;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
285 er = e % 3;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
286 eq = e / 3;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
287 a = POW_MULL(a, pow_mult3[er]);
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
288 while (a >= 2 * POW_FRAC_ONE) {
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
289 a = a >> 1;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
290 eq++;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
291 }
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
292 /* convert to float */
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
293 while (a < POW_FRAC_ONE) {
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
294 a = a << 1;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
295 eq--;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
296 }
407
c3aebacf546e fixed incorrect global gain - slightly increased precision of n^(4/3) table
glantau
parents: 404
diff changeset
297 /* now POW_FRAC_ONE <= a < 2 * POW_FRAC_ONE */
449
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
298 #if POW_FRAC_BITS > FRAC_BITS
407
c3aebacf546e fixed incorrect global gain - slightly increased precision of n^(4/3) table
glantau
parents: 404
diff changeset
299 a = (a + (1 << (POW_FRAC_BITS - FRAC_BITS - 1))) >> (POW_FRAC_BITS - FRAC_BITS);
c3aebacf546e fixed incorrect global gain - slightly increased precision of n^(4/3) table
glantau
parents: 404
diff changeset
300 /* correct overflow */
c3aebacf546e fixed incorrect global gain - slightly increased precision of n^(4/3) table
glantau
parents: 404
diff changeset
301 if (a >= 2 * (1 << FRAC_BITS)) {
c3aebacf546e fixed incorrect global gain - slightly increased precision of n^(4/3) table
glantau
parents: 404
diff changeset
302 a = a >> 1;
c3aebacf546e fixed incorrect global gain - slightly increased precision of n^(4/3) table
glantau
parents: 404
diff changeset
303 eq++;
c3aebacf546e fixed incorrect global gain - slightly increased precision of n^(4/3) table
glantau
parents: 404
diff changeset
304 }
c3aebacf546e fixed incorrect global gain - slightly increased precision of n^(4/3) table
glantau
parents: 404
diff changeset
305 #endif
392
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
306 *exp_ptr = eq;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
307 return a;
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
308 }
2522
e25782262d7d kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents: 2507
diff changeset
309 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
310
986e461dc072 Initial revision
glantau
parents:
diff changeset
311 static int decode_init(AVCodecContext * avctx)
986e461dc072 Initial revision
glantau
parents:
diff changeset
312 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
313 MPADecodeContext *s = avctx->priv_data;
836
932eb34d17c1 vc++ sucks, found by ("csharprules" <csharprules at hotmail dot com>)
michaelni
parents: 602
diff changeset
314 static int init=0;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
315 int i, j, k;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
316
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
317 s->avctx = avctx;
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
318
8598
6550218be3b7 simplify: group all the AUDIO_NONSHORT parameters in the same place
aurel
parents: 8594
diff changeset
319 avctx->sample_fmt= OUT_FMT;
7831
8195c970d077 Rename error_resilience to error_recognition.
michael
parents: 7763
diff changeset
320 s->error_recognition= avctx->error_recognition;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
321
2491
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
322 if(avctx->antialias_algo != FF_AA_FLOAT)
1762
michael
parents: 1734
diff changeset
323 s->compute_antialias= compute_antialias_integer;
michael
parents: 1734
diff changeset
324 else
michael
parents: 1734
diff changeset
325 s->compute_antialias= compute_antialias_float;
michael
parents: 1734
diff changeset
326
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
327 if (!init && !avctx->parse_only) {
7452
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
328 int offset;
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
329
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
330 /* scale factors table for layer 1/2 */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
331 for(i=0;i<64;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
332 int shift, mod;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
333 /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
449
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
334 shift = (i / 3);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
335 mod = i % 3;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
336 scale_factor_modshift[i] = mod | (shift << 2);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
337 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
338
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
339 /* scale factor multiply for layer 1 */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
340 for(i=0;i<15;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
341 int n, norm;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
342 n = i + 2;
4274
07625477adfa use the standard INT64_C() macro for 64-bit constants
mru
parents: 4205
diff changeset
343 norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
8201
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
344 scale_factor_mult[i][0] = MULL(FIXR(1.0 * 2.0), norm, FRAC_BITS);
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
345 scale_factor_mult[i][1] = MULL(FIXR(0.7937005259 * 2.0), norm, FRAC_BITS);
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
346 scale_factor_mult[i][2] = MULL(FIXR(0.6299605249 * 2.0), norm, FRAC_BITS);
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
347 dprintf(avctx, "%d: norm=%x s=%x %x %x\n",
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
348 i, norm,
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
349 scale_factor_mult[i][0],
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
350 scale_factor_mult[i][1],
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
351 scale_factor_mult[i][2]);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
352 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
353
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
354 ff_mpa_synth_init(window);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
355
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
356 /* huffman decode tables */
7452
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
357 offset = 0;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
358 for(i=1;i<16;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
359 const HuffTable *h = &mpa_huff_tables[i];
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
360 int xsize, x, y;
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1025
diff changeset
361 unsigned int n;
3627
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
362 uint8_t tmp_bits [512];
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
363 uint16_t tmp_codes[512];
3608
f713d34d5d01 simplify
michael
parents: 3607
diff changeset
364
f713d34d5d01 simplify
michael
parents: 3607
diff changeset
365 memset(tmp_bits , 0, sizeof(tmp_bits ));
f713d34d5d01 simplify
michael
parents: 3607
diff changeset
366 memset(tmp_codes, 0, sizeof(tmp_codes));
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
367
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
368 xsize = h->xsize;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
369 n = xsize * xsize;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
370
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
371 j = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
372 for(x=0;x<xsize;x++) {
3608
f713d34d5d01 simplify
michael
parents: 3607
diff changeset
373 for(y=0;y<xsize;y++){
3627
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
374 tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j ];
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
375 tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
3608
f713d34d5d01 simplify
michael
parents: 3607
diff changeset
376 }
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
377 }
3608
f713d34d5d01 simplify
michael
parents: 3607
diff changeset
378
f713d34d5d01 simplify
michael
parents: 3607
diff changeset
379 /* XXX: fail test */
7452
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
380 huff_vlc[i].table = huff_vlc_tables+offset;
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
381 huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
3627
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
382 init_vlc(&huff_vlc[i], 7, 512,
7452
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
383 tmp_bits, 1, 1, tmp_codes, 2, 2,
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
384 INIT_VLC_USE_NEW_STATIC);
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
385 offset += huff_vlc_tables_sizes[i];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
386 }
8042
e70975d5ff80 uses FF_ARRAY_ELEMS() where appropriate
aurel
parents: 7870
diff changeset
387 assert(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
7452
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
388
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
389 offset = 0;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
390 for(i=0;i<2;i++) {
7452
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
391 huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
392 huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
393 init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
7452
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
394 mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
395 INIT_VLC_USE_NEW_STATIC);
2240c6340eac Use static vlc structure to decode layer 3 huffman tables.
benoit
parents: 7330
diff changeset
396 offset += huff_quad_vlc_tables_sizes[i];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
397 }
8042
e70975d5ff80 uses FF_ARRAY_ELEMS() where appropriate
aurel
parents: 7870
diff changeset
398 assert(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
399
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
400 for(i=0;i<9;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
401 k = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
402 for(j=0;j<22;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
403 band_index_long[i][j] = k;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
404 k += band_size_long[i][j];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
405 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
406 band_index_long[i][22] = k;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
407 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
408
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
409 /* compute n ^ (4/3) and store it in mantissa/exp format */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
410
392
4ef26ed29399 put all integer init code to compute n^(4/3) - memory alloc and header fixes
glantau
parents: 322
diff changeset
411 int_pow_init();
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
412 for(i=1;i<TABLE_4_3_SIZE;i++) {
2490
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
413 double f, fm;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
414 int e, m;
2490
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
415 f = pow((double)(i/4), 4.0 / 3.0) * pow(2, (i&3)*0.25);
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
416 fm = frexp(f, &e);
2532
b7511e7dabb7 cast to uint32 as the table is uint32_t, this also worksaround a gcc or libc bug related to frexp()
michael
parents: 2522
diff changeset
417 m = (uint32_t)(fm*(1LL<<31) + 0.5);
3625
8042fcb3a62a move the +400 out of the innermost loop
michael
parents: 3624
diff changeset
418 e+= FRAC_BITS - 31 + 5 - 100;
2490
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
419
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
420 /* normalized to FRAC_BITS */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
421 table_4_3_value[i] = m;
2490
c2c642ad6ef4 faster, simpler and more accurate l3_unscale()
michael
parents: 2489
diff changeset
422 table_4_3_exp[i] = -e;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
423 }
3622
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
424 for(i=0; i<512*16; i++){
3625
8042fcb3a62a move the +400 out of the innermost loop
michael
parents: 3624
diff changeset
425 int exponent= (i>>4);
8042fcb3a62a move the +400 out of the innermost loop
michael
parents: 3624
diff changeset
426 double f= pow(i&15, 4.0 / 3.0) * pow(2, (exponent-400)*0.25 + FRAC_BITS + 5);
3732
2c0b93338765 use correct rounding functions
michael
parents: 3722
diff changeset
427 expval_table[exponent][i&15]= llrint(f);
3622
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
428 if((i&15)==1)
3732
2c0b93338765 use correct rounding functions
michael
parents: 3722
diff changeset
429 exp_table[exponent]= llrint(f);
3621
d4896ea0305b replace l3_unscale(1, exponents[pos]) by LUT
michael
parents: 3620
diff changeset
430 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
431
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
432 for(i=0;i<7;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
433 float f;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
434 int v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
435 if (i != 6) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
436 f = tan((double)i * M_PI / 12.0);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
437 v = FIXR(f / (1.0 + f));
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
438 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
439 v = FIXR(1.0);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
440 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
441 is_table[0][i] = v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
442 is_table[1][6 - i] = v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
443 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
444 /* invalid values */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
445 for(i=7;i<16;i++)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
446 is_table[0][i] = is_table[1][i] = 0.0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
447
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
448 for(i=0;i<16;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
449 double f;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
450 int e, k;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
451
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
452 for(j=0;j<2;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
453 e = -(j + 1) * ((i + 1) >> 1);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
454 f = pow(2.0, e / 4.0);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
455 k = i & 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
456 is_table_lsf[j][k ^ 1][i] = FIXR(f);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
457 is_table_lsf[j][k][i] = FIXR(1.0);
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
458 dprintf(avctx, "is_table_lsf %d %d: %x %x\n",
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
459 i, j, is_table_lsf[j][0][i], is_table_lsf[j][1][i]);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
460 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
461 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
462
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
463 for(i=0;i<8;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
464 float ci, cs, ca;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
465 ci = ci_table[i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
466 cs = 1.0 / sqrt(1.0 + ci * ci);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
467 ca = cs * ci;
2491
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
468 csa_table[i][0] = FIXHR(cs/4);
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
469 csa_table[i][1] = FIXHR(ca/4);
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
470 csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
471 csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
1733
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
472 csa_table_float[i][0] = cs;
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
473 csa_table_float[i][1] = ca;
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
474 csa_table_float[i][2] = ca + cs;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
475 csa_table_float[i][3] = ca - cs;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
476 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
477
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
478 /* compute mdct windows */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
479 for(i=0;i<36;i++) {
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
480 for(j=0; j<4; j++){
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
481 double d;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
482
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
483 if(j==2 && i%3 != 1)
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
484 continue;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
485
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
486 d= sin(M_PI * (i + 0.5) / 36.0);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
487 if(j==1){
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
488 if (i>=30) d= 0;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
489 else if(i>=24) d= sin(M_PI * (i - 18 + 0.5) / 12.0);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
490 else if(i>=18) d= 1;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
491 }else if(j==3){
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
492 if (i< 6) d= 0;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
493 else if(i< 12) d= sin(M_PI * (i - 6 + 0.5) / 12.0);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
494 else if(i< 18) d= 1;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
495 }
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
496 //merge last stage of imdct into the window coefficients
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
497 d*= 0.5 / cos(M_PI*(2*i + 19)/72);
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
498
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
499 if(j==2)
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
500 mdct_win[j][i/3] = FIXHR((d / (1<<5)));
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
501 else
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
502 mdct_win[j][i ] = FIXHR((d / (1<<5)));
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
503 }
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
504 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
505
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
506 /* NOTE: we do frequency inversion adter the MDCT by changing
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
507 the sign of the right window coefs */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
508 for(j=0;j<4;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
509 for(i=0;i<36;i+=2) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
510 mdct_win[j + 4][i] = mdct_win[j][i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
511 mdct_win[j + 4][i + 1] = -mdct_win[j][i + 1];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
512 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
513 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
514
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
515 init = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
516 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
517
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
518 if (avctx->codec_id == CODEC_ID_MP3ADU)
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
519 s->adu_mode = 1;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
520 return 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
521 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
522
1014
48349e11c9b2 C99 initializers and kill warnings patch by (mru at users dot sourceforge dot net (M«©ns Rullg«©rd))
michaelni
parents: 902
diff changeset
523 /* tab[i][j] = 1.0 / (2.0 * cos(pi*(2*k+1) / 2^(6 - j))) */
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
524
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
525 /* cos(i*pi/64) */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
526
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
527 #define COS0_0 FIXHR(0.50060299823519630134/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
528 #define COS0_1 FIXHR(0.50547095989754365998/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
529 #define COS0_2 FIXHR(0.51544730992262454697/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
530 #define COS0_3 FIXHR(0.53104259108978417447/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
531 #define COS0_4 FIXHR(0.55310389603444452782/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
532 #define COS0_5 FIXHR(0.58293496820613387367/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
533 #define COS0_6 FIXHR(0.62250412303566481615/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
534 #define COS0_7 FIXHR(0.67480834145500574602/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
535 #define COS0_8 FIXHR(0.74453627100229844977/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
536 #define COS0_9 FIXHR(0.83934964541552703873/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
537 #define COS0_10 FIXHR(0.97256823786196069369/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
538 #define COS0_11 FIXHR(1.16943993343288495515/4)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
539 #define COS0_12 FIXHR(1.48416461631416627724/4)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
540 #define COS0_13 FIXHR(2.05778100995341155085/8)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
541 #define COS0_14 FIXHR(3.40760841846871878570/8)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
542 #define COS0_15 FIXHR(10.19000812354805681150/32)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
543
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
544 #define COS1_0 FIXHR(0.50241928618815570551/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
545 #define COS1_1 FIXHR(0.52249861493968888062/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
546 #define COS1_2 FIXHR(0.56694403481635770368/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
547 #define COS1_3 FIXHR(0.64682178335999012954/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
548 #define COS1_4 FIXHR(0.78815462345125022473/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
549 #define COS1_5 FIXHR(1.06067768599034747134/4)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
550 #define COS1_6 FIXHR(1.72244709823833392782/4)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
551 #define COS1_7 FIXHR(5.10114861868916385802/16)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
552
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
553 #define COS2_0 FIXHR(0.50979557910415916894/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
554 #define COS2_1 FIXHR(0.60134488693504528054/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
555 #define COS2_2 FIXHR(0.89997622313641570463/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
556 #define COS2_3 FIXHR(2.56291544774150617881/8)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
557
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
558 #define COS3_0 FIXHR(0.54119610014619698439/2)
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
559 #define COS3_1 FIXHR(1.30656296487637652785/4)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
560
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
561 #define COS4_0 FIXHR(0.70710678118654752439/2)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
562
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
563 /* butterfly operator */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
564 #define BF(a, b, c, s)\
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
565 {\
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
566 tmp0 = tab[a] + tab[b];\
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
567 tmp1 = tab[a] - tab[b];\
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
568 tab[a] = tmp0;\
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
569 tab[b] = MULH(tmp1<<(s), c);\
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
570 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
571
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
572 #define BF1(a, b, c, d)\
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
573 {\
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
574 BF(a, b, COS4_0, 1);\
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
575 BF(c, d,-COS4_0, 1);\
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
576 tab[c] += tab[d];\
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
577 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
578
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
579 #define BF2(a, b, c, d)\
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
580 {\
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
581 BF(a, b, COS4_0, 1);\
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
582 BF(c, d,-COS4_0, 1);\
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
583 tab[c] += tab[d];\
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
584 tab[a] += tab[c];\
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
585 tab[c] += tab[b];\
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
586 tab[b] += tab[d];\
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
587 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
588
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
589 #define ADD(a, b) tab[a] += tab[b]
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
590
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
591 /* DCT32 without 1/sqrt(2) coef zero scaling. */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
592 static void dct32(int32_t *out, int32_t *tab)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
593 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
594 int tmp0, tmp1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
595
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
596 /* pass 1 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
597 BF( 0, 31, COS0_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
598 BF(15, 16, COS0_15, 5);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
599 /* pass 2 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
600 BF( 0, 15, COS1_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
601 BF(16, 31,-COS1_0 , 1);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
602 /* pass 1 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
603 BF( 7, 24, COS0_7 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
604 BF( 8, 23, COS0_8 , 1);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
605 /* pass 2 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
606 BF( 7, 8, COS1_7 , 4);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
607 BF(23, 24,-COS1_7 , 4);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
608 /* pass 3 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
609 BF( 0, 7, COS2_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
610 BF( 8, 15,-COS2_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
611 BF(16, 23, COS2_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
612 BF(24, 31,-COS2_0 , 1);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
613 /* pass 1 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
614 BF( 3, 28, COS0_3 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
615 BF(12, 19, COS0_12, 2);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
616 /* pass 2 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
617 BF( 3, 12, COS1_3 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
618 BF(19, 28,-COS1_3 , 1);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
619 /* pass 1 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
620 BF( 4, 27, COS0_4 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
621 BF(11, 20, COS0_11, 2);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
622 /* pass 2 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
623 BF( 4, 11, COS1_4 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
624 BF(20, 27,-COS1_4 , 1);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
625 /* pass 3 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
626 BF( 3, 4, COS2_3 , 3);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
627 BF(11, 12,-COS2_3 , 3);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
628 BF(19, 20, COS2_3 , 3);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
629 BF(27, 28,-COS2_3 , 3);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
630 /* pass 4 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
631 BF( 0, 3, COS3_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
632 BF( 4, 7,-COS3_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
633 BF( 8, 11, COS3_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
634 BF(12, 15,-COS3_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
635 BF(16, 19, COS3_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
636 BF(20, 23,-COS3_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
637 BF(24, 27, COS3_0 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
638 BF(28, 31,-COS3_0 , 1);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
639
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
640
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
641
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
642 /* pass 1 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
643 BF( 1, 30, COS0_1 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
644 BF(14, 17, COS0_14, 3);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
645 /* pass 2 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
646 BF( 1, 14, COS1_1 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
647 BF(17, 30,-COS1_1 , 1);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
648 /* pass 1 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
649 BF( 6, 25, COS0_6 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
650 BF( 9, 22, COS0_9 , 1);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
651 /* pass 2 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
652 BF( 6, 9, COS1_6 , 2);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
653 BF(22, 25,-COS1_6 , 2);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
654 /* pass 3 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
655 BF( 1, 6, COS2_1 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
656 BF( 9, 14,-COS2_1 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
657 BF(17, 22, COS2_1 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
658 BF(25, 30,-COS2_1 , 1);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
659
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
660 /* pass 1 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
661 BF( 2, 29, COS0_2 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
662 BF(13, 18, COS0_13, 3);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
663 /* pass 2 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
664 BF( 2, 13, COS1_2 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
665 BF(18, 29,-COS1_2 , 1);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
666 /* pass 1 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
667 BF( 5, 26, COS0_5 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
668 BF(10, 21, COS0_10, 1);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
669 /* pass 2 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
670 BF( 5, 10, COS1_5 , 2);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
671 BF(21, 26,-COS1_5 , 2);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
672 /* pass 3 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
673 BF( 2, 5, COS2_2 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
674 BF(10, 13,-COS2_2 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
675 BF(18, 21, COS2_2 , 1);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
676 BF(26, 29,-COS2_2 , 1);
3598
181b0e8f6d81 reorder butterflies to reduce memory load/store
michael
parents: 3431
diff changeset
677 /* pass 4 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
678 BF( 1, 2, COS3_1 , 2);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
679 BF( 5, 6,-COS3_1 , 2);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
680 BF( 9, 10, COS3_1 , 2);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
681 BF(13, 14,-COS3_1 , 2);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
682 BF(17, 18, COS3_1 , 2);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
683 BF(21, 22,-COS3_1 , 2);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
684 BF(25, 26, COS3_1 , 2);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
685 BF(29, 30,-COS3_1 , 2);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
686
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
687 /* pass 5 */
3600
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
688 BF1( 0, 1, 2, 3);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
689 BF2( 4, 5, 6, 7);
949219039897 replace MULL by MULH + shift in dct32() (code is very slightly faster, and the compiler should be able to optimize the shift away on 64bit archs)
michael
parents: 3599
diff changeset
690 BF1( 8, 9, 10, 11);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
691 BF2(12, 13, 14, 15);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
692 BF1(16, 17, 18, 19);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
693 BF2(20, 21, 22, 23);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
694 BF1(24, 25, 26, 27);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
695 BF2(28, 29, 30, 31);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
696
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
697 /* pass 6 */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
698
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
699 ADD( 8, 12);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
700 ADD(12, 10);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
701 ADD(10, 14);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
702 ADD(14, 9);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
703 ADD( 9, 13);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
704 ADD(13, 11);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
705 ADD(11, 15);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
706
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
707 out[ 0] = tab[0];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
708 out[16] = tab[1];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
709 out[ 8] = tab[2];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
710 out[24] = tab[3];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
711 out[ 4] = tab[4];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
712 out[20] = tab[5];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
713 out[12] = tab[6];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
714 out[28] = tab[7];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
715 out[ 2] = tab[8];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
716 out[18] = tab[9];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
717 out[10] = tab[10];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
718 out[26] = tab[11];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
719 out[ 6] = tab[12];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
720 out[22] = tab[13];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
721 out[14] = tab[14];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
722 out[30] = tab[15];
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
723
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
724 ADD(24, 28);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
725 ADD(28, 26);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
726 ADD(26, 30);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
727 ADD(30, 25);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
728 ADD(25, 29);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
729 ADD(29, 27);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
730 ADD(27, 31);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
731
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
732 out[ 1] = tab[16] + tab[24];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
733 out[17] = tab[17] + tab[25];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
734 out[ 9] = tab[18] + tab[26];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
735 out[25] = tab[19] + tab[27];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
736 out[ 5] = tab[20] + tab[28];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
737 out[21] = tab[21] + tab[29];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
738 out[13] = tab[22] + tab[30];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
739 out[29] = tab[23] + tab[31];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
740 out[ 3] = tab[24] + tab[20];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
741 out[19] = tab[25] + tab[21];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
742 out[11] = tab[26] + tab[22];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
743 out[27] = tab[27] + tab[23];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
744 out[ 7] = tab[28] + tab[18];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
745 out[23] = tab[29] + tab[19];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
746 out[15] = tab[30] + tab[17];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
747 out[31] = tab[31];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
748 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
749
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
750 #if FRAC_BITS <= 15
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
751
2472
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
752 static inline int round_sample(int *sum)
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
753 {
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
754 int sum1;
2472
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
755 sum1 = (*sum) >> OUT_SHIFT;
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
756 *sum &= (1<<OUT_SHIFT)-1;
2479
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
757 if (sum1 < OUT_MIN)
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
758 sum1 = OUT_MIN;
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
759 else if (sum1 > OUT_MAX)
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
760 sum1 = OUT_MAX;
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
761 return sum1;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
762 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
763
3752
32b2da1060ea Use mathops
lu_zero
parents: 3732
diff changeset
764 /* signed 16x16 -> 32 multiply add accumulate */
32b2da1060ea Use mathops
lu_zero
parents: 3732
diff changeset
765 #define MACS(rt, ra, rb) MAC16(rt, ra, rb)
3705
b3149af07681 armv5 optimizations
diego
parents: 3687
diff changeset
766
3752
32b2da1060ea Use mathops
lu_zero
parents: 3732
diff changeset
767 /* signed 16x16 -> 32 multiply */
32b2da1060ea Use mathops
lu_zero
parents: 3732
diff changeset
768 #define MULS(ra, rb) MUL16(ra, rb)
3705
b3149af07681 armv5 optimizations
diego
parents: 3687
diff changeset
769
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
770 #define MLSS(rt, ra, rb) MLS16(rt, ra, rb)
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
771
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
772 #else
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
773
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
774 static inline int round_sample(int64_t *sum)
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
775 {
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
776 int sum1;
2472
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
777 sum1 = (int)((*sum) >> OUT_SHIFT);
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
778 *sum &= (1<<OUT_SHIFT)-1;
2479
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
779 if (sum1 < OUT_MIN)
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
780 sum1 = OUT_MIN;
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
781 else if (sum1 > OUT_MAX)
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
782 sum1 = OUT_MAX;
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
783 return sum1;
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
784 }
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
785
3603
42b6cefc6c1a replacing MULH by asm for x86
michael
parents: 3602
diff changeset
786 # define MULS(ra, rb) MUL64(ra, rb)
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
787 # define MACS(rt, ra, rb) MAC64(rt, ra, rb)
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
788 # define MLSS(rt, ra, rb) MLS64(rt, ra, rb)
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
789 #endif
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
790
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
791 #define SUM8(op, sum, w, p) \
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
792 { \
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
793 op(sum, (w)[0 * 64], p[0 * 64]); \
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
794 op(sum, (w)[1 * 64], p[1 * 64]); \
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
795 op(sum, (w)[2 * 64], p[2 * 64]); \
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
796 op(sum, (w)[3 * 64], p[3 * 64]); \
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
797 op(sum, (w)[4 * 64], p[4 * 64]); \
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
798 op(sum, (w)[5 * 64], p[5 * 64]); \
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
799 op(sum, (w)[6 * 64], p[6 * 64]); \
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
800 op(sum, (w)[7 * 64], p[7 * 64]); \
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
801 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
802
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
803 #define SUM8P2(sum1, op1, sum2, op2, w1, w2, p) \
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
804 { \
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
805 int tmp;\
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
806 tmp = p[0 * 64];\
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
807 op1(sum1, (w1)[0 * 64], tmp);\
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
808 op2(sum2, (w2)[0 * 64], tmp);\
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
809 tmp = p[1 * 64];\
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
810 op1(sum1, (w1)[1 * 64], tmp);\
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
811 op2(sum2, (w2)[1 * 64], tmp);\
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
812 tmp = p[2 * 64];\
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
813 op1(sum1, (w1)[2 * 64], tmp);\
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
814 op2(sum2, (w2)[2 * 64], tmp);\
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
815 tmp = p[3 * 64];\
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
816 op1(sum1, (w1)[3 * 64], tmp);\
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
817 op2(sum2, (w2)[3 * 64], tmp);\
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
818 tmp = p[4 * 64];\
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
819 op1(sum1, (w1)[4 * 64], tmp);\
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
820 op2(sum2, (w2)[4 * 64], tmp);\
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
821 tmp = p[5 * 64];\
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
822 op1(sum1, (w1)[5 * 64], tmp);\
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
823 op2(sum2, (w2)[5 * 64], tmp);\
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
824 tmp = p[6 * 64];\
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
825 op1(sum1, (w1)[6 * 64], tmp);\
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
826 op2(sum2, (w2)[6 * 64], tmp);\
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
827 tmp = p[7 * 64];\
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
828 op1(sum1, (w1)[7 * 64], tmp);\
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
829 op2(sum2, (w2)[7 * 64], tmp);\
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
830 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
831
2468
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
832 void ff_mpa_synth_init(MPA_INT *window)
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
833 {
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
834 int i;
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
835
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
836 /* max = 18760, max sum over all 16 coefs : 44736 */
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
837 for(i=0;i<257;i++) {
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
838 int v;
5032
d47ee2d1d7da add proper prefix to extern mpeg audio data tables
aurel
parents: 5031
diff changeset
839 v = ff_mpa_enwindow[i];
2468
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
840 #if WFRAC_BITS < 16
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
841 v = (v + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS);
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
842 #endif
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
843 window[i] = v;
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
844 if ((i & 63) != 0)
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
845 v = -v;
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
846 if (i != 0)
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
847 window[512 - i] = v;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
848 }
2468
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
849 }
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
850
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
851 /* 32 sub band synthesis filter. Input: 32 sub band samples, Output:
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
852 32 samples. */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
853 /* XXX: optimize by avoiding ring buffer usage */
2468
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
854 void ff_mpa_synth_filter(MPA_INT *synth_buf_ptr, int *synth_buf_offset,
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
855 MPA_INT *window, int *dither_state,
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
856 OUT_INT *samples, int incr,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
857 int32_t sb_samples[SBLIMIT])
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
858 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
859 int32_t tmp[32];
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
860 register MPA_INT *synth_buf;
2100
8bf89660fffe warning fix
alex
parents: 2028
diff changeset
861 register const MPA_INT *w, *w2, *p;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
862 int j, offset, v;
2479
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
863 OUT_INT *samples2;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
864 #if FRAC_BITS <= 15
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
865 int sum, sum2;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
866 #else
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
867 int64_t sum, sum2;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
868 #endif
2468
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
869
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
870 dct32(tmp, sb_samples);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
871
2468
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
872 offset = *synth_buf_offset;
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
873 synth_buf = synth_buf_ptr + offset;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
874
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
875 for(j=0;j<32;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
876 v = tmp[j];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
877 #if FRAC_BITS <= 15
449
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
878 /* NOTE: can cause a loss in precision if very high amplitude
7b2f23b5dcdd fixed layer1/2 overflow if very loud sound - fixed broken free format decoding to pass all mpeg audio standard decoding tests (please avoid patching the parser without having all test streams available - contact me if necessary)
bellard
parents: 440
diff changeset
879 sound */
5523
c2ab2ac31edb use av_clip_int16() where it makes sense
aurel
parents: 5518
diff changeset
880 v = av_clip_int16(v);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
881 #endif
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
882 synth_buf[j] = v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
883 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
884 /* copy to avoid wrap */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
885 memcpy(synth_buf + 512, synth_buf, 32 * sizeof(MPA_INT));
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
886
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
887 samples2 = samples + 31 * incr;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
888 w = window;
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
889 w2 = window + 31;
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
890
2473
73afecc117a3 10l (didnt test code after cvs up ...)
michael
parents: 2472
diff changeset
891 sum = *dither_state;
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
892 p = synth_buf + 16;
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
893 SUM8(MACS, sum, w, p);
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
894 p = synth_buf + 48;
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
895 SUM8(MLSS, sum, w + 32, p);
2472
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
896 *samples = round_sample(&sum);
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
897 samples += incr;
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
898 w++;
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
899
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
900 /* we calculate two samples at the same time to avoid one memory
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
901 access per two sample */
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
902 for(j=1;j<16;j++) {
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
903 sum2 = 0;
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
904 p = synth_buf + 16 + j;
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
905 SUM8P2(sum, MACS, sum2, MLSS, w, w2, p);
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
906 p = synth_buf + 48 - j;
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
907 SUM8P2(sum, MLSS, sum2, MLSS, w + 32, w2 + 32, p);
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
908
2472
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
909 *samples = round_sample(&sum);
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
910 samples += incr;
2472
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
911 sum += sum2;
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
912 *samples2 = round_sample(&sum);
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
913 samples2 -= incr;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
914 w++;
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
915 w2--;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
916 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
917
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
918 p = synth_buf + 32;
7256
7c13d54f389d mpegaudio: use MAC/MLS macros in ff_mpa_synth_filter
mru
parents: 7040
diff changeset
919 SUM8(MLSS, sum, w + 32, p);
2472
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
920 *samples = round_sample(&sum);
2473
73afecc117a3 10l (didnt test code after cvs up ...)
michael
parents: 2472
diff changeset
921 *dither_state= sum;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
922
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
923 offset = (offset - 32) & 511;
2468
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
924 *synth_buf_offset = offset;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
925 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
926
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
927 #define C3 FIXHR(0.86602540378443864676/2)
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
928
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
929 /* 0.5 / cos(pi*(2*i+1)/36) */
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
930 static const int icos36[9] = {
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
931 FIXR(0.50190991877167369479),
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
932 FIXR(0.51763809020504152469), //0
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
933 FIXR(0.55168895948124587824),
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
934 FIXR(0.61038729438072803416),
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
935 FIXR(0.70710678118654752439), //1
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
936 FIXR(0.87172339781054900991),
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
937 FIXR(1.18310079157624925896),
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
938 FIXR(1.93185165257813657349), //2
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
939 FIXR(5.73685662283492756461),
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
940 };
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
941
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
942 /* 0.5 / cos(pi*(2*i+1)/36) */
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
943 static const int icos36h[9] = {
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
944 FIXHR(0.50190991877167369479/2),
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
945 FIXHR(0.51763809020504152469/2), //0
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
946 FIXHR(0.55168895948124587824/2),
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
947 FIXHR(0.61038729438072803416/2),
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
948 FIXHR(0.70710678118654752439/2), //1
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
949 FIXHR(0.87172339781054900991/2),
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
950 FIXHR(1.18310079157624925896/4),
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
951 FIXHR(1.93185165257813657349/4), //2
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
952 // FIXHR(5.73685662283492756461),
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
953 };
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
954
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
955 /* 12 points IMDCT. We compute it "by hand" by factorizing obvious
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
956 cases. */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
957 static void imdct12(int *out, int *in)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
958 {
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
959 int in0, in1, in2, in3, in4, in5, t1, t2;
2496
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
960
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
961 in0= in[0*3];
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
962 in1= in[1*3] + in[0*3];
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
963 in2= in[2*3] + in[1*3];
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
964 in3= in[3*3] + in[2*3];
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
965 in4= in[4*3] + in[3*3];
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
966 in5= in[5*3] + in[4*3];
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
967 in5 += in3;
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
968 in3 += in1;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
969
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
970 in2= MULH(2*in2, C3);
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
971 in3= MULH(4*in3, C3);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
972
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
973 t1 = in0 - in4;
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
974 t2 = MULH(2*(in1 - in5), icos36h[4]);
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
975
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
976 out[ 7]=
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
977 out[10]= t1 + t2;
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
978 out[ 1]=
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
979 out[ 4]= t1 - t2;
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
980
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
981 in0 += in4>>1;
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
982 in4 = in0 + in2;
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
983 in5 += 2*in1;
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
984 in1 = MULH(in5 + in3, icos36h[1]);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
985 out[ 8]=
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
986 out[ 9]= in4 + in1;
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
987 out[ 2]=
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
988 out[ 3]= in4 - in1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
989
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
990 in0 -= in2;
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
991 in5 = MULH(2*(in5 - in3), icos36h[7]);
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
992 out[ 0]=
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
993 out[ 5]= in0 - in5;
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
994 out[ 6]=
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
995 out[11]= in0 + in5;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
996 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
997
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
998 /* cos(pi*i/18) */
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
999 #define C1 FIXHR(0.98480775301220805936/2)
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1000 #define C2 FIXHR(0.93969262078590838405/2)
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1001 #define C3 FIXHR(0.86602540378443864676/2)
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1002 #define C4 FIXHR(0.76604444311897803520/2)
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1003 #define C5 FIXHR(0.64278760968653932632/2)
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1004 #define C6 FIXHR(0.5/2)
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1005 #define C7 FIXHR(0.34202014332566873304/2)
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1006 #define C8 FIXHR(0.17364817766693034885/2)
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1007
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1008
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1009 /* using Lee like decomposition followed by hand coded 9 points DCT */
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1010 static void imdct36(int *out, int *buf, int *in, int *win)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1011 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1012 int i, j, t0, t1, t2, t3, s0, s1, s2, s3;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1013 int tmp[18], *tmp1, *in1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1014
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1015 for(i=17;i>=1;i--)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1016 in[i] += in[i-1];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1017 for(i=17;i>=3;i-=2)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1018 in[i] += in[i-2];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1019
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1020 for(j=0;j<2;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1021 tmp1 = tmp + j;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1022 in1 = in + j;
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1023 #if 0
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1024 //more accurate but slower
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1025 int64_t t0, t1, t2, t3;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1026 t2 = in1[2*4] + in1[2*8] - in1[2*2];
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1027
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1028 t3 = (in1[2*0] + (int64_t)(in1[2*6]>>1))<<32;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1029 t1 = in1[2*0] - in1[2*6];
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1030 tmp1[ 6] = t1 - (t2>>1);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1031 tmp1[16] = t1 + t2;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1032
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1033 t0 = MUL64(2*(in1[2*2] + in1[2*4]), C2);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1034 t1 = MUL64( in1[2*4] - in1[2*8] , -2*C8);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1035 t2 = MUL64(2*(in1[2*2] + in1[2*8]), -C4);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1036
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1037 tmp1[10] = (t3 - t0 - t2) >> 32;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1038 tmp1[ 2] = (t3 + t0 + t1) >> 32;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1039 tmp1[14] = (t3 + t2 - t1) >> 32;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1040
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1041 tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1042 t2 = MUL64(2*(in1[2*1] + in1[2*5]), C1);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1043 t3 = MUL64( in1[2*5] - in1[2*7] , -2*C7);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1044 t0 = MUL64(2*in1[2*3], C3);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1045
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1046 t1 = MUL64(2*(in1[2*1] + in1[2*7]), -C5);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1047
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1048 tmp1[ 0] = (t2 + t3 + t0) >> 32;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1049 tmp1[12] = (t2 + t1 - t0) >> 32;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1050 tmp1[ 8] = (t3 - t1 - t0) >> 32;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1051 #else
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1052 t2 = in1[2*4] + in1[2*8] - in1[2*2];
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1053
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1054 t3 = in1[2*0] + (in1[2*6]>>1);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1055 t1 = in1[2*0] - in1[2*6];
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1056 tmp1[ 6] = t1 - (t2>>1);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1057 tmp1[16] = t1 + t2;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1058
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1059 t0 = MULH(2*(in1[2*2] + in1[2*4]), C2);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1060 t1 = MULH( in1[2*4] - in1[2*8] , -2*C8);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1061 t2 = MULH(2*(in1[2*2] + in1[2*8]), -C4);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1062
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1063 tmp1[10] = t3 - t0 - t2;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1064 tmp1[ 2] = t3 + t0 + t1;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1065 tmp1[14] = t3 + t2 - t1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1066
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1067 tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1068 t2 = MULH(2*(in1[2*1] + in1[2*5]), C1);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1069 t3 = MULH( in1[2*5] - in1[2*7] , -2*C7);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1070 t0 = MULH(2*in1[2*3], C3);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1071
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1072 t1 = MULH(2*(in1[2*1] + in1[2*7]), -C5);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1073
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1074 tmp1[ 0] = t2 + t3 + t0;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1075 tmp1[12] = t2 + t1 - t0;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1076 tmp1[ 8] = t3 - t1 - t0;
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1077 #endif
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1078 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1079
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1080 i = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1081 for(j=0;j<4;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1082 t0 = tmp[i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1083 t1 = tmp[i + 2];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1084 s0 = t1 + t0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1085 s2 = t1 - t0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1086
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1087 t2 = tmp[i + 1];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1088 t3 = tmp[i + 3];
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
1089 s1 = MULH(2*(t3 + t2), icos36h[j]);
8201
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
1090 s3 = MULL(t3 - t2, icos36[8 - j], FRAC_BITS);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1091
2496
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
1092 t0 = s0 + s1;
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
1093 t1 = s0 - s1;
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1094 out[(9 + j)*SBLIMIT] = MULH(t1, win[9 + j]) + buf[9 + j];
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1095 out[(8 - j)*SBLIMIT] = MULH(t1, win[8 - j]) + buf[8 - j];
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1096 buf[9 + j] = MULH(t0, win[18 + 9 + j]);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1097 buf[8 - j] = MULH(t0, win[18 + 8 - j]);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1098
2496
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
1099 t0 = s2 + s3;
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
1100 t1 = s2 - s3;
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1101 out[(9 + 8 - j)*SBLIMIT] = MULH(t1, win[9 + 8 - j]) + buf[9 + 8 - j];
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1102 out[( j)*SBLIMIT] = MULH(t1, win[ j]) + buf[ j];
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1103 buf[9 + 8 - j] = MULH(t0, win[18 + 9 + 8 - j]);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1104 buf[ + j] = MULH(t0, win[18 + j]);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1105 i += 4;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1106 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1107
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1108 s0 = tmp[16];
3599
9a069376b7e3 replace a few MULL by MULH
michael
parents: 3598
diff changeset
1109 s1 = MULH(2*tmp[17], icos36h[4]);
2496
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
1110 t0 = s0 + s1;
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
1111 t1 = s0 - s1;
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1112 out[(9 + 4)*SBLIMIT] = MULH(t1, win[9 + 4]) + buf[9 + 4];
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1113 out[(8 - 4)*SBLIMIT] = MULH(t1, win[8 - 4]) + buf[8 - 4];
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1114 buf[9 + 4] = MULH(t0, win[18 + 9 + 4]);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1115 buf[8 - 4] = MULH(t0, win[18 + 8 - 4]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1116 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1117
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1118 /* return the number of decoded frames */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1119 static int mp_decode_layer1(MPADecodeContext *s)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1120 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1121 int bound, i, v, n, ch, j, mant;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1122 uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1123 uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1124
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1125 if (s->mode == MPA_JSTEREO)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1126 bound = (s->mode_ext + 1) * 4;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1127 else
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1128 bound = SBLIMIT;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1129
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1130 /* allocation bits */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1131 for(i=0;i<bound;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1132 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1133 allocation[ch][i] = get_bits(&s->gb, 4);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1134 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1135 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1136 for(i=bound;i<SBLIMIT;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1137 allocation[0][i] = get_bits(&s->gb, 4);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1138 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1139
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1140 /* scale factors */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1141 for(i=0;i<bound;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1142 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1143 if (allocation[ch][i])
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1144 scale_factors[ch][i] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1145 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1146 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1147 for(i=bound;i<SBLIMIT;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1148 if (allocation[0][i]) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1149 scale_factors[0][i] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1150 scale_factors[1][i] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1151 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1152 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1153
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1154 /* compute samples */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1155 for(j=0;j<12;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1156 for(i=0;i<bound;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1157 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1158 n = allocation[ch][i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1159 if (n) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1160 mant = get_bits(&s->gb, n + 1);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1161 v = l1_unscale(n, mant, scale_factors[ch][i]);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1162 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1163 v = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1164 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1165 s->sb_samples[ch][j][i] = v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1166 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1167 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1168 for(i=bound;i<SBLIMIT;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1169 n = allocation[0][i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1170 if (n) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1171 mant = get_bits(&s->gb, n + 1);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1172 v = l1_unscale(n, mant, scale_factors[0][i]);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1173 s->sb_samples[0][j][i] = v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1174 v = l1_unscale(n, mant, scale_factors[1][i]);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1175 s->sb_samples[1][j][i] = v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1176 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1177 s->sb_samples[0][j][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1178 s->sb_samples[1][j][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1179 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1180 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1181 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1182 return 12;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1183 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1184
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1185 static int mp_decode_layer2(MPADecodeContext *s)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1186 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1187 int sblimit; /* number of used subbands */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1188 const unsigned char *alloc_table;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1189 int table, bit_alloc_bits, i, j, ch, bound, v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1190 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1191 unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1192 unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1193 int scale, qindex, bits, steps, k, l, m, b;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1194
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1195 /* select decoding table */
5052
d981eb275c8f remove dependency of mpeg audio encoder over mpeg audio decoder
aurel
parents: 5051
diff changeset
1196 table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1197 s->sample_rate, s->lsf);
5032
d47ee2d1d7da add proper prefix to extern mpeg audio data tables
aurel
parents: 5031
diff changeset
1198 sblimit = ff_mpa_sblimit_table[table];
d47ee2d1d7da add proper prefix to extern mpeg audio data tables
aurel
parents: 5031
diff changeset
1199 alloc_table = ff_mpa_alloc_tables[table];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1200
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1201 if (s->mode == MPA_JSTEREO)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1202 bound = (s->mode_ext + 1) * 4;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1203 else
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1204 bound = sblimit;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1205
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
1206 dprintf(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
1780
cc4c1eb18eec fixes by Gildas Bazin <gbazin at altern dot org>
michael
parents: 1762
diff changeset
1207
cc4c1eb18eec fixes by Gildas Bazin <gbazin at altern dot org>
michael
parents: 1762
diff changeset
1208 /* sanity check */
cc4c1eb18eec fixes by Gildas Bazin <gbazin at altern dot org>
michael
parents: 1762
diff changeset
1209 if( bound > sblimit ) bound = sblimit;
cc4c1eb18eec fixes by Gildas Bazin <gbazin at altern dot org>
michael
parents: 1762
diff changeset
1210
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1211 /* parse bit allocation */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1212 j = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1213 for(i=0;i<bound;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1214 bit_alloc_bits = alloc_table[j];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1215 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1216 bit_alloc[ch][i] = get_bits(&s->gb, bit_alloc_bits);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1217 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1218 j += 1 << bit_alloc_bits;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1219 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1220 for(i=bound;i<sblimit;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1221 bit_alloc_bits = alloc_table[j];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1222 v = get_bits(&s->gb, bit_alloc_bits);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1223 bit_alloc[0][i] = v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1224 bit_alloc[1][i] = v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1225 j += 1 << bit_alloc_bits;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1226 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1227
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1228 /* scale codes */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1229 for(i=0;i<sblimit;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1230 for(ch=0;ch<s->nb_channels;ch++) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1231 if (bit_alloc[ch][i])
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1232 scale_code[ch][i] = get_bits(&s->gb, 2);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1233 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1234 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1235
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1236 /* scale factors */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1237 for(i=0;i<sblimit;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1238 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1239 if (bit_alloc[ch][i]) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1240 sf = scale_factors[ch][i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1241 switch(scale_code[ch][i]) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1242 default:
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1243 case 0:
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1244 sf[0] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1245 sf[1] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1246 sf[2] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1247 break;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1248 case 2:
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1249 sf[0] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1250 sf[1] = sf[0];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1251 sf[2] = sf[0];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1252 break;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1253 case 1:
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1254 sf[0] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1255 sf[2] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1256 sf[1] = sf[0];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1257 break;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1258 case 3:
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1259 sf[0] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1260 sf[2] = get_bits(&s->gb, 6);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1261 sf[1] = sf[2];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1262 break;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1263 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1264 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1265 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1266 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1267
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1268 /* samples */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1269 for(k=0;k<3;k++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1270 for(l=0;l<12;l+=3) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1271 j = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1272 for(i=0;i<bound;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1273 bit_alloc_bits = alloc_table[j];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1274 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1275 b = bit_alloc[ch][i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1276 if (b) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1277 scale = scale_factors[ch][i][k];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1278 qindex = alloc_table[j+b];
5032
d47ee2d1d7da add proper prefix to extern mpeg audio data tables
aurel
parents: 5031
diff changeset
1279 bits = ff_mpa_quant_bits[qindex];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1280 if (bits < 0) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1281 /* 3 values at the same time */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1282 v = get_bits(&s->gb, -bits);
5032
d47ee2d1d7da add proper prefix to extern mpeg audio data tables
aurel
parents: 5031
diff changeset
1283 steps = ff_mpa_quant_steps[qindex];
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1284 s->sb_samples[ch][k * 12 + l + 0][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1285 l2_unscale_group(steps, v % steps, scale);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1286 v = v / steps;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1287 s->sb_samples[ch][k * 12 + l + 1][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1288 l2_unscale_group(steps, v % steps, scale);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1289 v = v / steps;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1290 s->sb_samples[ch][k * 12 + l + 2][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1291 l2_unscale_group(steps, v, scale);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1292 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1293 for(m=0;m<3;m++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1294 v = get_bits(&s->gb, bits);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1295 v = l1_unscale(bits - 1, v, scale);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1296 s->sb_samples[ch][k * 12 + l + m][i] = v;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1297 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1298 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1299 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1300 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1301 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1302 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1303 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1304 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1305 /* next subband in alloc table */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1306 j += 1 << bit_alloc_bits;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1307 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1308 /* XXX: find a way to avoid this duplication of code */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1309 for(i=bound;i<sblimit;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1310 bit_alloc_bits = alloc_table[j];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1311 b = bit_alloc[0][i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1312 if (b) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1313 int mant, scale0, scale1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1314 scale0 = scale_factors[0][i][k];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1315 scale1 = scale_factors[1][i][k];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1316 qindex = alloc_table[j+b];
5032
d47ee2d1d7da add proper prefix to extern mpeg audio data tables
aurel
parents: 5031
diff changeset
1317 bits = ff_mpa_quant_bits[qindex];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1318 if (bits < 0) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1319 /* 3 values at the same time */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1320 v = get_bits(&s->gb, -bits);
5032
d47ee2d1d7da add proper prefix to extern mpeg audio data tables
aurel
parents: 5031
diff changeset
1321 steps = ff_mpa_quant_steps[qindex];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1322 mant = v % steps;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1323 v = v / steps;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1324 s->sb_samples[0][k * 12 + l + 0][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1325 l2_unscale_group(steps, mant, scale0);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1326 s->sb_samples[1][k * 12 + l + 0][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1327 l2_unscale_group(steps, mant, scale1);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1328 mant = v % steps;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1329 v = v / steps;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1330 s->sb_samples[0][k * 12 + l + 1][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1331 l2_unscale_group(steps, mant, scale0);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1332 s->sb_samples[1][k * 12 + l + 1][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1333 l2_unscale_group(steps, mant, scale1);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1334 s->sb_samples[0][k * 12 + l + 2][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1335 l2_unscale_group(steps, v, scale0);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1336 s->sb_samples[1][k * 12 + l + 2][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1337 l2_unscale_group(steps, v, scale1);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1338 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1339 for(m=0;m<3;m++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1340 mant = get_bits(&s->gb, bits);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1341 s->sb_samples[0][k * 12 + l + m][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1342 l1_unscale(bits - 1, mant, scale0);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1343 s->sb_samples[1][k * 12 + l + m][i] =
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1344 l1_unscale(bits - 1, mant, scale1);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1345 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1346 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1347 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1348 s->sb_samples[0][k * 12 + l + 0][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1349 s->sb_samples[0][k * 12 + l + 1][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1350 s->sb_samples[0][k * 12 + l + 2][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1351 s->sb_samples[1][k * 12 + l + 0][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1352 s->sb_samples[1][k * 12 + l + 1][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1353 s->sb_samples[1][k * 12 + l + 2][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1354 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1355 /* next subband in alloc table */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1356 j += 1 << bit_alloc_bits;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1357 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1358 /* fill remaining samples to zero */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1359 for(i=sblimit;i<SBLIMIT;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1360 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1361 s->sb_samples[ch][k * 12 + l + 0][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1362 s->sb_samples[ch][k * 12 + l + 1][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1363 s->sb_samples[ch][k * 12 + l + 2][i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1364 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1365 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1366 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1367 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1368 return 3 * 12;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1369 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1370
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1371 static inline void lsf_sf_expand(int *slen,
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1372 int sf, int n1, int n2, int n3)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1373 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1374 if (n3) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1375 slen[3] = sf % n3;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1376 sf /= n3;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1377 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1378 slen[3] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1379 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1380 if (n2) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1381 slen[2] = sf % n2;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1382 sf /= n2;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1383 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1384 slen[2] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1385 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1386 slen[1] = sf % n1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1387 sf /= n1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1388 slen[0] = sf;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1389 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1390
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1391 static void exponents_from_scale_factors(MPADecodeContext *s,
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1392 GranuleDef *g,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1393 int16_t *exponents)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1394 {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1395 const uint8_t *bstab, *pretab;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1396 int len, i, j, k, l, v0, shift, gain, gains[3];
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1397 int16_t *exp_ptr;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1398
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1399 exp_ptr = exponents;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1400 gain = g->global_gain - 210;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1401 shift = g->scalefac_scale + 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1402
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1403 bstab = band_size_long[s->sample_rate_index];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1404 pretab = mpa_pretab[g->preflag];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1405 for(i=0;i<g->long_end;i++) {
3625
8042fcb3a62a move the +400 out of the innermost loop
michael
parents: 3624
diff changeset
1406 v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1407 len = bstab[i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1408 for(j=len;j>0;j--)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1409 *exp_ptr++ = v0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1410 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1411
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1412 if (g->short_start < 13) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1413 bstab = band_size_short[s->sample_rate_index];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1414 gains[0] = gain - (g->subblock_gain[0] << 3);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1415 gains[1] = gain - (g->subblock_gain[1] << 3);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1416 gains[2] = gain - (g->subblock_gain[2] << 3);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1417 k = g->long_end;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1418 for(i=g->short_start;i<13;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1419 len = bstab[i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1420 for(l=0;l<3;l++) {
3625
8042fcb3a62a move the +400 out of the innermost loop
michael
parents: 3624
diff changeset
1421 v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1422 for(j=len;j>0;j--)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1423 *exp_ptr++ = v0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1424 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1425 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1426 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1427 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1428
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1429 /* handle n = 0 too */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1430 static inline int get_bitsz(GetBitContext *s, int n)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1431 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1432 if (n == 0)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1433 return 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1434 else
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1435 return get_bits(s, n);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1436 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1437
4469
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1438
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1439 static void switch_buffer(MPADecodeContext *s, int *pos, int *end_pos, int *end_pos2){
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1440 if(s->in_gb.buffer && *pos >= s->gb.size_in_bits){
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1441 s->gb= s->in_gb;
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1442 s->in_gb.buffer=NULL;
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1443 assert((get_bits_count(&s->gb) & 7) == 0);
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1444 skip_bits_long(&s->gb, *pos - *end_pos);
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1445 *end_pos2=
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1446 *end_pos= *end_pos2 + get_bits_count(&s->gb) - *pos;
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1447 *pos= get_bits_count(&s->gb);
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1448 }
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1449 }
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1450
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1451 static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1452 int16_t *exponents, int end_pos2)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1453 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1454 int s_index;
3626
a6251ee2dfdb move variable declarations so that their scope is smaller
michael
parents: 3625
diff changeset
1455 int i;
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1456 int last_pos, bits_left;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1457 VLC *vlc;
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1458 int end_pos= FFMIN(end_pos2, s->gb.size_in_bits);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1459
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1460 /* low frequencies (called big values) */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1461 s_index = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1462 for(i=0;i<3;i++) {
3626
a6251ee2dfdb move variable declarations so that their scope is smaller
michael
parents: 3625
diff changeset
1463 int j, k, l, linbits;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1464 j = g->region_size[i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1465 if (j == 0)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1466 continue;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1467 /* select vlc table */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1468 k = g->table_select[i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1469 l = mpa_huff_data[k][0];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1470 linbits = mpa_huff_data[k][1];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1471 vlc = &huff_vlc[l];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1472
3609
6560c84eef72 use memset() instead of slow c loops
michael
parents: 3608
diff changeset
1473 if(!l){
3636
031252e99956 another silly typo which surprisingly neither valgrind nor cmp of the file output cought
michael
parents: 3635
diff changeset
1474 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*2*j);
3609
6560c84eef72 use memset() instead of slow c loops
michael
parents: 3608
diff changeset
1475 s_index += 2*j;
6560c84eef72 use memset() instead of slow c loops
michael
parents: 3608
diff changeset
1476 continue;
6560c84eef72 use memset() instead of slow c loops
michael
parents: 3608
diff changeset
1477 }
6560c84eef72 use memset() instead of slow c loops
michael
parents: 3608
diff changeset
1478
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1479 /* read huffcode and compute each couple */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1480 for(;j>0;j--) {
3626
a6251ee2dfdb move variable declarations so that their scope is smaller
michael
parents: 3625
diff changeset
1481 int exponent, x, y, v;
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1482 int pos= get_bits_count(&s->gb);
3624
7d8ef3c542a1 avoid reading exponent twice
michael
parents: 3623
diff changeset
1483
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1484 if (pos >= end_pos){
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1485 // av_log(NULL, AV_LOG_ERROR, "pos: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
4469
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1486 switch_buffer(s, &pos, &end_pos, &end_pos2);
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1487 // av_log(NULL, AV_LOG_ERROR, "new pos: %d %d\n", pos, end_pos);
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1488 if(pos >= end_pos)
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1489 break;
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1490 }
3623
d0242f36a793 reduce size of vlc table, thats slightly faster here
michael
parents: 3622
diff changeset
1491 y = get_vlc2(&s->gb, vlc->table, 7, 3);
3611
a20d179c79c3 faster handling of zero coeffs in the low freq decode
michael
parents: 3610
diff changeset
1492
a20d179c79c3 faster handling of zero coeffs in the low freq decode
michael
parents: 3610
diff changeset
1493 if(!y){
a20d179c79c3 faster handling of zero coeffs in the low freq decode
michael
parents: 3610
diff changeset
1494 g->sb_hybrid[s_index ] =
a20d179c79c3 faster handling of zero coeffs in the low freq decode
michael
parents: 3610
diff changeset
1495 g->sb_hybrid[s_index+1] = 0;
a20d179c79c3 faster handling of zero coeffs in the low freq decode
michael
parents: 3610
diff changeset
1496 s_index += 2;
a20d179c79c3 faster handling of zero coeffs in the low freq decode
michael
parents: 3610
diff changeset
1497 continue;
a20d179c79c3 faster handling of zero coeffs in the low freq decode
michael
parents: 3610
diff changeset
1498 }
a20d179c79c3 faster handling of zero coeffs in the low freq decode
michael
parents: 3610
diff changeset
1499
3624
7d8ef3c542a1 avoid reading exponent twice
michael
parents: 3623
diff changeset
1500 exponent= exponents[s_index];
3609
6560c84eef72 use memset() instead of slow c loops
michael
parents: 3608
diff changeset
1501
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
1502 dprintf(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
3624
7d8ef3c542a1 avoid reading exponent twice
michael
parents: 3623
diff changeset
1503 i, g->region_size[i] - j, x, y, exponent);
3627
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1504 if(y&16){
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1505 x = y >> 5;
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1506 y = y & 0x0f;
3622
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
1507 if (x < 15){
3625
8042fcb3a62a move the +400 out of the innermost loop
michael
parents: 3624
diff changeset
1508 v = expval_table[ exponent ][ x ];
8042fcb3a62a move the +400 out of the innermost loop
michael
parents: 3624
diff changeset
1509 // v = expval_table[ (exponent&3) ][ x ] >> FFMIN(0 - (exponent>>2), 31);
3622
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
1510 }else{
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
1511 x += get_bitsz(&s->gb, linbits);
3624
7d8ef3c542a1 avoid reading exponent twice
michael
parents: 3623
diff changeset
1512 v = l3_unscale(x, exponent);
3622
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
1513 }
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1514 if (get_bits1(&s->gb))
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1515 v = -v;
3627
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1516 g->sb_hybrid[s_index] = v;
3622
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
1517 if (y < 15){
3625
8042fcb3a62a move the +400 out of the innermost loop
michael
parents: 3624
diff changeset
1518 v = expval_table[ exponent ][ y ];
3622
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
1519 }else{
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
1520 y += get_bitsz(&s->gb, linbits);
3624
7d8ef3c542a1 avoid reading exponent twice
michael
parents: 3623
diff changeset
1521 v = l3_unscale(y, exponent);
3622
e88a3910f855 try to avoid l3_unscale() by using a table
michael
parents: 3621
diff changeset
1522 }
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1523 if (get_bits1(&s->gb))
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1524 v = -v;
3627
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1525 g->sb_hybrid[s_index+1] = v;
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1526 }else{
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1527 x = y >> 5;
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1528 y = y & 0x0f;
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1529 x += y;
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1530 if (x < 15){
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1531 v = expval_table[ exponent ][ x ];
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1532 }else{
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1533 x += get_bitsz(&s->gb, linbits);
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1534 v = l3_unscale(x, exponent);
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1535 }
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1536 if (get_bits1(&s->gb))
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1537 v = -v;
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1538 g->sb_hybrid[s_index+!!y] = v;
3635
0087dc6b306c 10l found by valgrind
michael
parents: 3634
diff changeset
1539 g->sb_hybrid[s_index+ !y] = 0;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1540 }
3627
8624a5c2824d avoid branch
michael
parents: 3626
diff changeset
1541 s_index+=2;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1542 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1543 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1544
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1545 /* high frequencies */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1546 vlc = &huff_quad_vlc[g->count1table_select];
3612
9283f094680e dont copy the whole GetBitContext around
michael
parents: 3611
diff changeset
1547 last_pos=0;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1548 while (s_index <= 572) {
3626
a6251ee2dfdb move variable declarations so that their scope is smaller
michael
parents: 3625
diff changeset
1549 int pos, code;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1550 pos = get_bits_count(&s->gb);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1551 if (pos >= end_pos) {
3647
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
1552 if (pos > end_pos2 && last_pos){
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
1553 /* some encoders generate an incorrect size for this
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
1554 part. We must go back into the data */
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
1555 s_index -= 4;
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
1556 skip_bits_long(&s->gb, last_pos - pos);
7329
104a00d9abfa Supply context argument to av_log() in mpeg audio decoder.
andoma
parents: 7256
diff changeset
1557 av_log(s->avctx, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
7831
8195c970d077 Rename error_resilience to error_recognition.
michael
parents: 7763
diff changeset
1558 if(s->error_recognition >= FF_ER_COMPLIANT)
4205
8c28f03cfdd5 detect a few more errors (fixes libmp3-bug.avi again)
michael
parents: 4204
diff changeset
1559 s_index=0;
3647
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
1560 break;
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
1561 }
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1562 // av_log(NULL, AV_LOG_ERROR, "pos2: %d %d %d %d\n", pos, end_pos, end_pos2, s_index);
4469
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1563 switch_buffer(s, &pos, &end_pos, &end_pos2);
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1564 // av_log(NULL, AV_LOG_ERROR, "new pos2: %d %d %d\n", pos, end_pos, s_index);
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1565 if(pos >= end_pos)
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1566 break;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1567 }
3612
9283f094680e dont copy the whole GetBitContext around
michael
parents: 3611
diff changeset
1568 last_pos= pos;
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 468
diff changeset
1569
3610
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1570 code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
1571 dprintf(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
3610
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1572 g->sb_hybrid[s_index+0]=
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1573 g->sb_hybrid[s_index+1]=
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1574 g->sb_hybrid[s_index+2]=
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1575 g->sb_hybrid[s_index+3]= 0;
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1576 while(code){
4908
777f250df232 Fix multiple "¡Æinline/static¡Ç is not at beginning of declaration" warnings.
diego
parents: 4796
diff changeset
1577 static const int idxtab[16]={3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0};
3626
a6251ee2dfdb move variable declarations so that their scope is smaller
michael
parents: 3625
diff changeset
1578 int v;
3610
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1579 int pos= s_index+idxtab[code];
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1580 code ^= 8>>idxtab[code];
3625
8042fcb3a62a move the +400 out of the innermost loop
michael
parents: 3624
diff changeset
1581 v = exp_table[ exponents[pos] ];
8042fcb3a62a move the +400 out of the innermost loop
michael
parents: 3624
diff changeset
1582 // v = exp_table[ (exponents[pos]&3) ] >> FFMIN(0 - (exponents[pos]>>2), 31);
3610
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1583 if(get_bits1(&s->gb))
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1584 v = -v;
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1585 g->sb_hybrid[pos] = v;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1586 }
3610
d97b4709aaf0 optimizing high freq decode
michael
parents: 3609
diff changeset
1587 s_index+=4;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1588 }
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1589 /* skip extension bits */
4468
5455cb5a759c fix decoding of takethat.mp3
michael
parents: 4295
diff changeset
1590 bits_left = end_pos2 - get_bits_count(&s->gb);
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1591 //av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer);
7867
2a611af7bcbe Make decoder more robust by default against broken encoders.
michael
parents: 7831
diff changeset
1592 if (bits_left < 0 && s->error_recognition >= FF_ER_COMPLIANT) {
7329
104a00d9abfa Supply context argument to av_log() in mpeg audio decoder.
andoma
parents: 7256
diff changeset
1593 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
4205
8c28f03cfdd5 detect a few more errors (fixes libmp3-bug.avi again)
michael
parents: 4204
diff changeset
1594 s_index=0;
7831
8195c970d077 Rename error_resilience to error_recognition.
michael
parents: 7763
diff changeset
1595 }else if(bits_left > 0 && s->error_recognition >= FF_ER_AGGRESSIVE){
7329
104a00d9abfa Supply context argument to av_log() in mpeg audio decoder.
andoma
parents: 7256
diff changeset
1596 av_log(s->avctx, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
4205
8c28f03cfdd5 detect a few more errors (fixes libmp3-bug.avi again)
michael
parents: 4204
diff changeset
1597 s_index=0;
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1598 }
4205
8c28f03cfdd5 detect a few more errors (fixes libmp3-bug.avi again)
michael
parents: 4204
diff changeset
1599 memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*(576 - s_index));
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1600 skip_bits_long(&s->gb, bits_left);
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1601
4468
5455cb5a759c fix decoding of takethat.mp3
michael
parents: 4295
diff changeset
1602 i= get_bits_count(&s->gb);
4469
a2e82396193c factorize switch_buffer()
michael
parents: 4468
diff changeset
1603 switch_buffer(s, &i, &end_pos, &end_pos2);
4468
5455cb5a759c fix decoding of takethat.mp3
michael
parents: 4295
diff changeset
1604
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1605 return 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1606 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1607
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1608 /* Reorder short blocks from bitstream order to interleaved order. It
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1609 would be faster to do it in parsing, but the code would be far more
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1610 complicated */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1611 static void reorder_block(MPADecodeContext *s, GranuleDef *g)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1612 {
3614
d0310d1cce13 optimize reorder_block() though this function seems to be executed too rarely for this to make much difference
michael
parents: 3613
diff changeset
1613 int i, j, len;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1614 int32_t *ptr, *dst, *ptr1;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1615 int32_t tmp[576];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1616
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1617 if (g->block_type != 2)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1618 return;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1619
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1620 if (g->switch_point) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1621 if (s->sample_rate_index != 8) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1622 ptr = g->sb_hybrid + 36;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1623 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1624 ptr = g->sb_hybrid + 48;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1625 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1626 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1627 ptr = g->sb_hybrid;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1628 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1629
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1630 for(i=g->short_start;i<13;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1631 len = band_size_short[s->sample_rate_index][i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1632 ptr1 = ptr;
3614
d0310d1cce13 optimize reorder_block() though this function seems to be executed too rarely for this to make much difference
michael
parents: 3613
diff changeset
1633 dst = tmp;
d0310d1cce13 optimize reorder_block() though this function seems to be executed too rarely for this to make much difference
michael
parents: 3613
diff changeset
1634 for(j=len;j>0;j--) {
d0310d1cce13 optimize reorder_block() though this function seems to be executed too rarely for this to make much difference
michael
parents: 3613
diff changeset
1635 *dst++ = ptr[0*len];
d0310d1cce13 optimize reorder_block() though this function seems to be executed too rarely for this to make much difference
michael
parents: 3613
diff changeset
1636 *dst++ = ptr[1*len];
d0310d1cce13 optimize reorder_block() though this function seems to be executed too rarely for this to make much difference
michael
parents: 3613
diff changeset
1637 *dst++ = ptr[2*len];
d0310d1cce13 optimize reorder_block() though this function seems to be executed too rarely for this to make much difference
michael
parents: 3613
diff changeset
1638 ptr++;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1639 }
3614
d0310d1cce13 optimize reorder_block() though this function seems to be executed too rarely for this to make much difference
michael
parents: 3613
diff changeset
1640 ptr+=2*len;
d0310d1cce13 optimize reorder_block() though this function seems to be executed too rarely for this to make much difference
michael
parents: 3613
diff changeset
1641 memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1642 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1643 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1644
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1645 #define ISQRT2 FIXR(0.70710678118654752440)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1646
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1647 static void compute_stereo(MPADecodeContext *s,
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1648 GranuleDef *g0, GranuleDef *g1)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1649 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1650 int i, j, k, l;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1651 int32_t v1, v2;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1652 int sf_max, tmp0, tmp1, sf, len, non_zero_found;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1653 int32_t (*is_tab)[16];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1654 int32_t *tab0, *tab1;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1655 int non_zero_found_short[3];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1656
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1657 /* intensity stereo */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1658 if (s->mode_ext & MODE_EXT_I_STEREO) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1659 if (!s->lsf) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1660 is_tab = is_table;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1661 sf_max = 7;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1662 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1663 is_tab = is_table_lsf[g1->scalefac_compress & 1];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1664 sf_max = 16;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1665 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1666
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1667 tab0 = g0->sb_hybrid + 576;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1668 tab1 = g1->sb_hybrid + 576;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1669
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1670 non_zero_found_short[0] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1671 non_zero_found_short[1] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1672 non_zero_found_short[2] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1673 k = (13 - g1->short_start) * 3 + g1->long_end - 3;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1674 for(i = 12;i >= g1->short_start;i--) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1675 /* for last band, use previous scale factor */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1676 if (i != 11)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1677 k -= 3;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1678 len = band_size_short[s->sample_rate_index][i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1679 for(l=2;l>=0;l--) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1680 tab0 -= len;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1681 tab1 -= len;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1682 if (!non_zero_found_short[l]) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1683 /* test if non zero band. if so, stop doing i-stereo */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1684 for(j=0;j<len;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1685 if (tab1[j] != 0) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1686 non_zero_found_short[l] = 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1687 goto found1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1688 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1689 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1690 sf = g1->scale_factors[k + l];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1691 if (sf >= sf_max)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1692 goto found1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1693
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1694 v1 = is_tab[0][sf];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1695 v2 = is_tab[1][sf];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1696 for(j=0;j<len;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1697 tmp0 = tab0[j];
8201
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
1698 tab0[j] = MULL(tmp0, v1, FRAC_BITS);
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
1699 tab1[j] = MULL(tmp0, v2, FRAC_BITS);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1700 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1701 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1702 found1:
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1703 if (s->mode_ext & MODE_EXT_MS_STEREO) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1704 /* lower part of the spectrum : do ms stereo
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1705 if enabled */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1706 for(j=0;j<len;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1707 tmp0 = tab0[j];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1708 tmp1 = tab1[j];
8201
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
1709 tab0[j] = MULL(tmp0 + tmp1, ISQRT2, FRAC_BITS);
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
1710 tab1[j] = MULL(tmp0 - tmp1, ISQRT2, FRAC_BITS);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1711 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1712 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1713 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1714 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1715 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1716
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1717 non_zero_found = non_zero_found_short[0] |
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1718 non_zero_found_short[1] |
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1719 non_zero_found_short[2];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1720
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1721 for(i = g1->long_end - 1;i >= 0;i--) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1722 len = band_size_long[s->sample_rate_index][i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1723 tab0 -= len;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1724 tab1 -= len;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1725 /* test if non zero band. if so, stop doing i-stereo */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1726 if (!non_zero_found) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1727 for(j=0;j<len;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1728 if (tab1[j] != 0) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1729 non_zero_found = 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1730 goto found2;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1731 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1732 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1733 /* for last band, use previous scale factor */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1734 k = (i == 21) ? 20 : i;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1735 sf = g1->scale_factors[k];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1736 if (sf >= sf_max)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1737 goto found2;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1738 v1 = is_tab[0][sf];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1739 v2 = is_tab[1][sf];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1740 for(j=0;j<len;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1741 tmp0 = tab0[j];
8201
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
1742 tab0[j] = MULL(tmp0, v1, FRAC_BITS);
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
1743 tab1[j] = MULL(tmp0, v2, FRAC_BITS);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1744 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1745 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1746 found2:
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1747 if (s->mode_ext & MODE_EXT_MS_STEREO) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1748 /* lower part of the spectrum : do ms stereo
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1749 if enabled */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1750 for(j=0;j<len;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1751 tmp0 = tab0[j];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1752 tmp1 = tab1[j];
8201
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
1753 tab0[j] = MULL(tmp0 + tmp1, ISQRT2, FRAC_BITS);
c6e2ffef3797 Add shift argument to MULL() macro
mru
parents: 8042
diff changeset
1754 tab1[j] = MULL(tmp0 - tmp1, ISQRT2, FRAC_BITS);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1755 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1756 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1757 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1758 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1759 } else if (s->mode_ext & MODE_EXT_MS_STEREO) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1760 /* ms stereo ONLY */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1761 /* NOTE: the 1/sqrt(2) normalization factor is included in the
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1762 global gain */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1763 tab0 = g0->sb_hybrid;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1764 tab1 = g1->sb_hybrid;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1765 for(i=0;i<576;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1766 tmp0 = tab0[i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1767 tmp1 = tab1[i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1768 tab0[i] = tmp0 + tmp1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1769 tab1[i] = tmp0 - tmp1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1770 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1771 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1772 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1773
1733
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1774 static void compute_antialias_integer(MPADecodeContext *s,
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1775 GranuleDef *g)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1776 {
2491
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1777 int32_t *ptr, *csa;
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1778 int n, i;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1779
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1780 /* we antialias only "long" bands */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1781 if (g->block_type == 2) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1782 if (!g->switch_point)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1783 return;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1784 /* XXX: check this for 8000Hz case */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1785 n = 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1786 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1787 n = SBLIMIT - 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1788 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1789
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1790 ptr = g->sb_hybrid + 18;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1791 for(i = n;i > 0;i--) {
2491
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1792 int tmp0, tmp1, tmp2;
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1793 csa = &csa_table[0][0];
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1794 #define INT_AA(j) \
2496
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
1795 tmp0 = ptr[-1-j];\
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
1796 tmp1 = ptr[ j];\
2491
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1797 tmp2= MULH(tmp0 + tmp1, csa[0+4*j]);\
2496
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
1798 ptr[-1-j] = 4*(tmp2 - MULH(tmp1, csa[2+4*j]));\
74d7fd7b49c5 merge a few shifts into the dequantization, faster and more accurate, lets hope it doesnt overflow
michael
parents: 2495
diff changeset
1799 ptr[ j] = 4*(tmp2 + MULH(tmp0, csa[3+4*j]));
2491
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1800
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1801 INT_AA(0)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1802 INT_AA(1)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1803 INT_AA(2)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1804 INT_AA(3)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1805 INT_AA(4)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1806 INT_AA(5)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1807 INT_AA(6)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1808 INT_AA(7)
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1809
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1810 ptr += 18;
1733
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1811 }
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1812 }
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1813
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1814 static void compute_antialias_float(MPADecodeContext *s,
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1815 GranuleDef *g)
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1816 {
2491
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1817 int32_t *ptr;
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1818 int n, i;
1733
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1819
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1820 /* we antialias only "long" bands */
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1821 if (g->block_type == 2) {
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1822 if (!g->switch_point)
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1823 return;
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1824 /* XXX: check this for 8000Hz case */
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1825 n = 1;
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1826 } else {
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1827 n = SBLIMIT - 1;
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1828 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1829
1733
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1830 ptr = g->sb_hybrid + 18;
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
1831 for(i = n;i > 0;i--) {
2491
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1832 float tmp0, tmp1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1833 float *csa = &csa_table_float[0][0];
2491
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1834 #define FLOAT_AA(j)\
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1835 tmp0= ptr[-1-j];\
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1836 tmp1= ptr[ j];\
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1837 ptr[-1-j] = lrintf(tmp0 * csa[0+4*j] - tmp1 * csa[1+4*j]);\
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1838 ptr[ j] = lrintf(tmp0 * csa[1+4*j] + tmp1 * csa[0+4*j]);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1839
2491
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1840 FLOAT_AA(0)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1841 FLOAT_AA(1)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1842 FLOAT_AA(2)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1843 FLOAT_AA(3)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1844 FLOAT_AA(4)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1845 FLOAT_AA(5)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1846 FLOAT_AA(6)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1847 FLOAT_AA(7)
c559ea6e395c optimize antialias
michael
parents: 2490
diff changeset
1848
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1849 ptr += 18;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1850 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1851 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1852
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1853 static void compute_imdct(MPADecodeContext *s,
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1854 GranuleDef *g,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1855 int32_t *sb_samples,
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1856 int32_t *mdct_buf)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1857 {
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1858 int32_t *ptr, *win, *win1, *buf, *out_ptr, *ptr1;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1859 int32_t out2[12];
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1860 int i, j, mdct_long_end, v, sblimit;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1861
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1862 /* find last non zero block */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1863 ptr = g->sb_hybrid + 576;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1864 ptr1 = g->sb_hybrid + 2 * 18;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1865 while (ptr >= ptr1) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1866 ptr -= 6;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1867 v = ptr[0] | ptr[1] | ptr[2] | ptr[3] | ptr[4] | ptr[5];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1868 if (v != 0)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1869 break;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1870 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1871 sblimit = ((ptr - g->sb_hybrid) / 18) + 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1872
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1873 if (g->block_type == 2) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1874 /* XXX: check for 8000 Hz */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1875 if (g->switch_point)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1876 mdct_long_end = 2;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1877 else
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1878 mdct_long_end = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1879 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1880 mdct_long_end = sblimit;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1881 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1882
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1883 buf = mdct_buf;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1884 ptr = g->sb_hybrid;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1885 for(j=0;j<mdct_long_end;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1886 /* apply window & overlap with previous buffer */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1887 out_ptr = sb_samples + j;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1888 /* select window */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1889 if (g->switch_point && j < 2)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1890 win1 = mdct_win[0];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1891 else
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1892 win1 = mdct_win[g->block_type];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1893 /* select frequency inversion */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1894 win = win1 + ((4 * 36) & -(j & 1));
2489
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1895 imdct36(out_ptr, buf, ptr, win);
2e5ae040e92b optimizing imdct36()
michael
parents: 2479
diff changeset
1896 out_ptr += 18*SBLIMIT;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1897 ptr += 18;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1898 buf += 18;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1899 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1900 for(j=mdct_long_end;j<sblimit;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1901 /* select frequency inversion */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1902 win = mdct_win[2] + ((4 * 36) & -(j & 1));
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1903 out_ptr = sb_samples + j;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1904
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1905 for(i=0; i<6; i++){
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1906 *out_ptr = buf[i];
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1907 out_ptr += SBLIMIT;
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1908 }
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1909 imdct12(out2, ptr + 0);
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1910 for(i=0;i<6;i++) {
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1911 *out_ptr = MULH(out2[i], win[i]) + buf[i + 6*1];
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1912 buf[i + 6*2] = MULH(out2[i + 6], win[i + 6]);
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1913 out_ptr += SBLIMIT;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1914 }
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1915 imdct12(out2, ptr + 1);
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1916 for(i=0;i<6;i++) {
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1917 *out_ptr = MULH(out2[i], win[i]) + buf[i + 6*2];
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1918 buf[i + 6*0] = MULH(out2[i + 6], win[i + 6]);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1919 out_ptr += SBLIMIT;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1920 }
2495
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1921 imdct12(out2, ptr + 2);
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1922 for(i=0;i<6;i++) {
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1923 buf[i + 6*0] = MULH(out2[i], win[i]) + buf[i + 6*0];
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1924 buf[i + 6*1] = MULH(out2[i + 6], win[i + 6]);
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1925 buf[i + 6*2] = 0;
7a79cb42eddb optimizing imdct12
michael
parents: 2491
diff changeset
1926 }
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1927 ptr += 18;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1928 buf += 18;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1929 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1930 /* zero bands */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1931 for(j=sblimit;j<SBLIMIT;j++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1932 /* overlap */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1933 out_ptr = sb_samples + j;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1934 for(i=0;i<18;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1935 *out_ptr = buf[i];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1936 buf[i] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1937 out_ptr += SBLIMIT;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1938 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1939 buf += 18;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1940 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1941 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1942
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1943 /* main layer3 decoding function */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1944 static int mp_decode_layer3(MPADecodeContext *s)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1945 {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1946 int nb_granules, main_data_begin, private_bits;
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
1947 int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1948 GranuleDef granules[2][2], *g;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1949 int16_t exponents[576];
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1950
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1951 /* read side info */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1952 if (s->lsf) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1953 main_data_begin = get_bits(&s->gb, 8);
3613
5cb45b2211a0 simplify
michael
parents: 3612
diff changeset
1954 private_bits = get_bits(&s->gb, s->nb_channels);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1955 nb_granules = 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1956 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1957 main_data_begin = get_bits(&s->gb, 9);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1958 if (s->nb_channels == 2)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1959 private_bits = get_bits(&s->gb, 3);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1960 else
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1961 private_bits = get_bits(&s->gb, 5);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1962 nb_granules = 2;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1963 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1964 granules[ch][0].scfsi = 0; /* all scale factors are transmitted */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1965 granules[ch][1].scfsi = get_bits(&s->gb, 4);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1966 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1967 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1968
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1969 for(gr=0;gr<nb_granules;gr++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1970 for(ch=0;ch<s->nb_channels;ch++) {
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
1971 dprintf(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1972 g = &granules[ch][gr];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1973 g->part2_3_length = get_bits(&s->gb, 12);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1974 g->big_values = get_bits(&s->gb, 9);
4202
af24e0fd0d1b more checks and error messages
michael
parents: 4104
diff changeset
1975 if(g->big_values > 288){
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
1976 av_log(s->avctx, AV_LOG_ERROR, "big_values too big\n");
4202
af24e0fd0d1b more checks and error messages
michael
parents: 4104
diff changeset
1977 return -1;
af24e0fd0d1b more checks and error messages
michael
parents: 4104
diff changeset
1978 }
af24e0fd0d1b more checks and error messages
michael
parents: 4104
diff changeset
1979
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1980 g->global_gain = get_bits(&s->gb, 8);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1981 /* if MS stereo only is selected, we precompute the
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1982 1/sqrt(2) renormalization factor */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
1983 if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1984 MODE_EXT_MS_STEREO)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1985 g->global_gain -= 2;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1986 if (s->lsf)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1987 g->scalefac_compress = get_bits(&s->gb, 9);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1988 else
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1989 g->scalefac_compress = get_bits(&s->gb, 4);
5513
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5161
diff changeset
1990 blocksplit_flag = get_bits1(&s->gb);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1991 if (blocksplit_flag) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1992 g->block_type = get_bits(&s->gb, 2);
4202
af24e0fd0d1b more checks and error messages
michael
parents: 4104
diff changeset
1993 if (g->block_type == 0){
7329
104a00d9abfa Supply context argument to av_log() in mpeg audio decoder.
andoma
parents: 7256
diff changeset
1994 av_log(s->avctx, AV_LOG_ERROR, "invalid block type\n");
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1995 return -1;
4202
af24e0fd0d1b more checks and error messages
michael
parents: 4104
diff changeset
1996 }
5513
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5161
diff changeset
1997 g->switch_point = get_bits1(&s->gb);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1998 for(i=0;i<2;i++)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
1999 g->table_select[i] = get_bits(&s->gb, 5);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
2000 for(i=0;i<3;i++)
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2001 g->subblock_gain[i] = get_bits(&s->gb, 3);
6138
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
2002 ff_init_short_region(s, g);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2003 } else {
6138
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
2004 int region_address1, region_address2;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2005 g->block_type = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2006 g->switch_point = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2007 for(i=0;i<3;i++)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2008 g->table_select[i] = get_bits(&s->gb, 5);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2009 /* compute huffman coded region sizes */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2010 region_address1 = get_bits(&s->gb, 4);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2011 region_address2 = get_bits(&s->gb, 3);
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
2012 dprintf(s->avctx, "region1=%d region2=%d\n",
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2013 region_address1, region_address2);
6138
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
2014 ff_init_long_region(s, g, region_address1, region_address2);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2015 }
6138
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
2016 ff_region_offset2size(g);
c7a61f83de73 Factorize some code into functions, had this in my tree and will be
michael
parents: 6137
diff changeset
2017 ff_compute_band_indexes(s, g);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
2018
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2019 g->preflag = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2020 if (!s->lsf)
5513
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5161
diff changeset
2021 g->preflag = get_bits1(&s->gb);
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5161
diff changeset
2022 g->scalefac_scale = get_bits1(&s->gb);
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5161
diff changeset
2023 g->count1table_select = get_bits1(&s->gb);
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
2024 dprintf(s->avctx, "block_type=%d switch_point=%d\n",
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2025 g->block_type, g->switch_point);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2026 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2027 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2028
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2029 if (!s->adu_mode) {
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2030 const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
3647
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
2031 assert((get_bits_count(&s->gb) & 7) == 0);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2032 /* now we get bits from the main_data_begin offset */
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
2033 dprintf(s->avctx, "seekback: %d\n", main_data_begin);
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2034 //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2035
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2036 memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2037 s->in_gb= s->gb;
4204
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2038 init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2039 skip_bits_long(&s->gb, 8*(s->last_buf_size - main_data_begin));
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2040 }
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2041
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2042 for(gr=0;gr<nb_granules;gr++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2043 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2044 g = &granules[ch][gr];
4204
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2045 if(get_bits_count(&s->gb)<0){
7329
104a00d9abfa Supply context argument to av_log() in mpeg audio decoder.
andoma
parents: 7256
diff changeset
2046 av_log(s->avctx, AV_LOG_ERROR, "mdb:%d, lastbuf:%d skipping granule %d\n",
4204
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2047 main_data_begin, s->last_buf_size, gr);
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2048 skip_bits_long(&s->gb, g->part2_3_length);
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2049 memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2050 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->in_gb.buffer){
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2051 skip_bits_long(&s->in_gb, get_bits_count(&s->gb) - s->gb.size_in_bits);
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2052 s->gb= s->in_gb;
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2053 s->in_gb.buffer=NULL;
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2054 }
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2055 continue;
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2056 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
2057
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2058 bits_pos = get_bits_count(&s->gb);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
2059
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2060 if (!s->lsf) {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2061 uint8_t *sc;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2062 int slen, slen1, slen2;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2063
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2064 /* MPEG1 scale factors */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2065 slen1 = slen_table[0][g->scalefac_compress];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2066 slen2 = slen_table[1][g->scalefac_compress];
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
2067 dprintf(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2068 if (g->block_type == 2) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2069 n = g->switch_point ? 17 : 18;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2070 j = 0;
3616
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2071 if(slen1){
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2072 for(i=0;i<n;i++)
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2073 g->scale_factors[j++] = get_bits(&s->gb, slen1);
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2074 }else{
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2075 for(i=0;i<n;i++)
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2076 g->scale_factors[j++] = 0;
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2077 }
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2078 if(slen2){
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2079 for(i=0;i<18;i++)
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2080 g->scale_factors[j++] = get_bits(&s->gb, slen2);
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2081 for(i=0;i<3;i++)
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2082 g->scale_factors[j++] = 0;
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2083 }else{
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2084 for(i=0;i<21;i++)
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2085 g->scale_factors[j++] = 0;
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2086 }
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2087 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2088 sc = granules[ch][0].scale_factors;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2089 j = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2090 for(k=0;k<4;k++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2091 n = (k == 0 ? 6 : 5);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2092 if ((g->scfsi & (0x8 >> k)) == 0) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2093 slen = (k < 2) ? slen1 : slen2;
3616
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2094 if(slen){
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2095 for(i=0;i<n;i++)
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2096 g->scale_factors[j++] = get_bits(&s->gb, slen);
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2097 }else{
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2098 for(i=0;i<n;i++)
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2099 g->scale_factors[j++] = 0;
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2100 }
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2101 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2102 /* simply copy from last granule */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2103 for(i=0;i<n;i++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2104 g->scale_factors[j] = sc[j];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2105 j++;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2106 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2107 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2108 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2109 g->scale_factors[j++] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2110 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2111 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2112 int tindex, tindex2, slen[4], sl, sf;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2113
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2114 /* LSF scale factors */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2115 if (g->block_type == 2) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2116 tindex = g->switch_point ? 2 : 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2117 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2118 tindex = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2119 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2120 sf = g->scalefac_compress;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2121 if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2122 /* intensity stereo case */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2123 sf >>= 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2124 if (sf < 180) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2125 lsf_sf_expand(slen, sf, 6, 6, 0);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2126 tindex2 = 3;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2127 } else if (sf < 244) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2128 lsf_sf_expand(slen, sf - 180, 4, 4, 0);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2129 tindex2 = 4;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2130 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2131 lsf_sf_expand(slen, sf - 244, 3, 0, 0);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2132 tindex2 = 5;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2133 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2134 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2135 /* normal case */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2136 if (sf < 400) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2137 lsf_sf_expand(slen, sf, 5, 4, 4);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2138 tindex2 = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2139 } else if (sf < 500) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2140 lsf_sf_expand(slen, sf - 400, 5, 4, 0);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2141 tindex2 = 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2142 } else {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2143 lsf_sf_expand(slen, sf - 500, 3, 0, 0);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2144 tindex2 = 2;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2145 g->preflag = 1;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2146 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2147 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2148
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2149 j = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2150 for(k=0;k<4;k++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2151 n = lsf_nsf_table[tindex2][tindex][k];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2152 sl = slen[k];
3617
b2a5e44cf957 10l typo
michael
parents: 3616
diff changeset
2153 if(sl){
3616
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2154 for(i=0;i<n;i++)
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2155 g->scale_factors[j++] = get_bits(&s->gb, sl);
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2156 }else{
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2157 for(i=0;i<n;i++)
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2158 g->scale_factors[j++] = 0;
270790578711 avoid a few if(x==0) checks in the inner loops
michael
parents: 3614
diff changeset
2159 }
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2160 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2161 /* XXX: should compute exact size */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2162 for(;j<40;j++)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2163 g->scale_factors[j] = 0;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2164 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2165
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2166 exponents_from_scale_factors(s, g, exponents);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2167
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2168 /* read Huffman coded residue */
4204
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2169 huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2170 } /* ch */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2171
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2172 if (s->nb_channels == 2)
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2173 compute_stereo(s, &granules[0][gr], &granules[1][gr]);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2174
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2175 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2176 g = &granules[ch][gr];
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2177
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2178 reorder_block(s, g);
1733
b47d56b1a049 optimize compute_antialias() and add a floating point based alternative (2x faster)
michael
parents: 1612
diff changeset
2179 s->compute_antialias(s, g);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
2180 compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2181 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2182 } /* gr */
4204
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2183 if(get_bits_count(&s->gb)<0)
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2184 skip_bits_long(&s->gb, -get_bits_count(&s->gb));
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2185 return nb_granules * 18;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2186 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2187
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
2188 static int mp_decode_frame(MPADecodeContext *s,
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2189 OUT_INT *samples, const uint8_t *buf, int buf_size)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2190 {
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2191 int i, nb_frames, ch;
2479
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
2192 OUT_INT *samples_ptr;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2193
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2194 init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE)*8);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2913
diff changeset
2195
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2196 /* skip error protection field */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2197 if (s->error_protection)
5518
d2ef80f5fd7e use skip_bits where appropriate
alex
parents: 5513
diff changeset
2198 skip_bits(&s->gb, 16);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2199
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
2200 dprintf(s->avctx, "frame %d:\n", s->frame_count);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2201 switch(s->layer) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2202 case 1:
6511
b5e9dae2dbc6 omg, fix compilation
bcoudurier
parents: 6510
diff changeset
2203 s->avctx->frame_size = 384;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2204 nb_frames = mp_decode_layer1(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2205 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2206 case 2:
6511
b5e9dae2dbc6 omg, fix compilation
bcoudurier
parents: 6510
diff changeset
2207 s->avctx->frame_size = 1152;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2208 nb_frames = mp_decode_layer2(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2209 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2210 case 3:
6511
b5e9dae2dbc6 omg, fix compilation
bcoudurier
parents: 6510
diff changeset
2211 s->avctx->frame_size = s->lsf ? 576 : 1152;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2212 default:
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2213 nb_frames = mp_decode_layer3(s);
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2214
3643
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2215 s->last_buf_size=0;
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2216 if(s->in_gb.buffer){
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2217 align_get_bits(&s->gb);
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2218 i= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3;
3647
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
2219 if(i >= 0 && i <= BACKSTEP_SIZE){
3643
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2220 memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2221 s->last_buf_size=i;
3647
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
2222 }else
7329
104a00d9abfa Supply context argument to av_log() in mpeg audio decoder.
andoma
parents: 7256
diff changeset
2223 av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2224 s->gb= s->in_gb;
4204
672724df5c9a making decoding more error robust
michael
parents: 4203
diff changeset
2225 s->in_gb.buffer= NULL;
3643
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2226 }
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2227
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2228 align_get_bits(&s->gb);
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2229 assert((get_bits_count(&s->gb) & 7) == 0);
3643
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2230 i= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3;
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2231
3647
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
2232 if(i<0 || i > BACKSTEP_SIZE || nb_frames<0){
7870
08ef30f08a01 Only print "invalid new backstep" when it is really invalid.
michael
parents: 7867
diff changeset
2233 if(i<0)
08ef30f08a01 Only print "invalid new backstep" when it is really invalid.
michael
parents: 7867
diff changeset
2234 av_log(s->avctx, AV_LOG_ERROR, "invalid new backstep %d\n", i);
3647
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
2235 i= FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
2236 }
3643
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2237 assert(i <= buf_size - HEADER_SIZE && i>= 0);
3647
4a93d7102793 fix buffer handling
michael
parents: 3644
diff changeset
2238 memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
3643
ae1dfbbb25bb fix low bitrate mp3
michael
parents: 3641
diff changeset
2239 s->last_buf_size += i;
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2240
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2241 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2242 }
7763
73b10d25cb8d Remove debuging junk that probably hasnt been used by anyone since years.
michael
parents: 7452
diff changeset
2243
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2244 /* apply the synthesis filter */
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2245 for(ch=0;ch<s->nb_channels;ch++) {
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2246 samples_ptr = samples + ch;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2247 for(i=0;i<nb_frames;i++) {
2468
1addaf6facbb exported ff_mpa_synth_filter for upcoming qdm2 decoder
alex
parents: 2432
diff changeset
2248 ff_mpa_synth_filter(s->synth_buf[ch], &(s->synth_buf_offset[ch]),
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2249 window, &s->dither_state,
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2250 samples_ptr, s->nb_channels,
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2251 s->sb_samples[ch][i]);
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2252 samples_ptr += 32 * s->nb_channels;
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2253 }
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2254 }
7763
73b10d25cb8d Remove debuging junk that probably hasnt been used by anyone since years.
michael
parents: 7452
diff changeset
2255
2479
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
2256 return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2257 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2258
986e461dc072 Initial revision
glantau
parents:
diff changeset
2259 static int decode_frame(AVCodecContext * avctx,
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2260 void *data, int *data_size,
6218
michael
parents: 6138
diff changeset
2261 const uint8_t * buf, int buf_size)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2262 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2263 MPADecodeContext *s = avctx->priv_data;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2264 uint32_t header;
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2265 int out_size;
2479
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
2266 OUT_INT *out_samples = data;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2267
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2268 retry:
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2269 if(buf_size < HEADER_SIZE)
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2270 return -1;
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2271
5089
bff60ecc02f9 Use AV_xx throughout libavcodec
ramiro
parents: 5076
diff changeset
2272 header = AV_RB32(buf);
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2273 if(ff_mpa_check_header(header) < 0){
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2274 buf++;
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2275 // buf_size--;
3938
92d8a536268f message typo fixes
diego
parents: 3777
diff changeset
2276 av_log(avctx, AV_LOG_ERROR, "Header missing skipping one byte.\n");
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2277 goto retry;
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2278 }
143
35e3ced6cfd9 * fixed decoding busy loop
kabi
parents: 125
diff changeset
2279
5051
b908c67063c8 add a ff_ prefix to some mpegaudio funcs
aurel
parents: 5050
diff changeset
2280 if (ff_mpegaudio_decode_header(s, header) == 1) {
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2281 /* free format: prepare to compute frame size */
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2282 s->frame_size = -1;
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2283 return -1;
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2284 }
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2285 /* update codec info */
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2286 avctx->channels = s->nb_channels;
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2287 avctx->bit_rate = s->bit_rate;
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2288 avctx->sub_id = s->layer;
82
46ee548e47e4 added completely new mpeg audio decoder (integer only, free format support, lsf/mpeg25 support, high/low precision support, simpler code)
glantau
parents: 0
diff changeset
2289
3687
bfcf76cad06a print more correct error messges
michael
parents: 3666
diff changeset
2290 if(s->frame_size<=0 || s->frame_size > buf_size){
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2291 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2292 return -1;
3687
bfcf76cad06a print more correct error messges
michael
parents: 3666
diff changeset
2293 }else if(s->frame_size < buf_size){
bfcf76cad06a print more correct error messges
michael
parents: 3666
diff changeset
2294 av_log(avctx, AV_LOG_ERROR, "incorrect frame size\n");
5076
796c2a5481ad make decoder decode the first frame properly if theres more than just one
michael
parents: 5052
diff changeset
2295 buf_size= s->frame_size;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2296 }
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2297
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2298 out_size = mp_decode_frame(s, out_samples, buf, buf_size);
4104
04ff8026d9c0 dont set the sampling rate just because 1 mp3 packet header says so (fixes playback speed on some old mencoder generated avis which where then dumped to mp3)
michael
parents: 4103
diff changeset
2299 if(out_size>=0){
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2300 *data_size = out_size;
4104
04ff8026d9c0 dont set the sampling rate just because 1 mp3 packet header says so (fixes playback speed on some old mencoder generated avis which where then dumped to mp3)
michael
parents: 4103
diff changeset
2301 avctx->sample_rate = s->sample_rate;
04ff8026d9c0 dont set the sampling rate just because 1 mp3 packet header says so (fixes playback speed on some old mencoder generated avis which where then dumped to mp3)
michael
parents: 4103
diff changeset
2302 //FIXME maybe move the other codec info stuff from above here too
04ff8026d9c0 dont set the sampling rate just because 1 mp3 packet header says so (fixes playback speed on some old mencoder generated avis which where then dumped to mp3)
michael
parents: 4103
diff changeset
2303 }else
3938
92d8a536268f message typo fixes
diego
parents: 3777
diff changeset
2304 av_log(avctx, AV_LOG_DEBUG, "Error while decoding MPEG audio frame.\n"); //FIXME return -1 / but also return the number of bytes consumed
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2305 s->frame_size = 0;
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2306 return buf_size;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2307 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2308
4203
14250f6ff483 reset internal buffer during seeking
michael
parents: 4202
diff changeset
2309 static void flush(AVCodecContext *avctx){
14250f6ff483 reset internal buffer during seeking
michael
parents: 4202
diff changeset
2310 MPADecodeContext *s = avctx->priv_data;
6137
5ef885b008c0 Clear synth_buf on flush(). Part of a patch by Brian Brice bbrice gmail com.
michael
parents: 6136
diff changeset
2311 memset(s->synth_buf, 0, sizeof(s->synth_buf));
4203
14250f6ff483 reset internal buffer during seeking
michael
parents: 4202
diff changeset
2312 s->last_buf_size= 0;
14250f6ff483 reset internal buffer during seeking
michael
parents: 4202
diff changeset
2313 }
14250f6ff483 reset internal buffer during seeking
michael
parents: 4202
diff changeset
2314
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8586
diff changeset
2315 #if CONFIG_MP3ADU_DECODER
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2316 static int decode_frame_adu(AVCodecContext * avctx,
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2317 void *data, int *data_size,
6218
michael
parents: 6138
diff changeset
2318 const uint8_t * buf, int buf_size)
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2319 {
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2320 MPADecodeContext *s = avctx->priv_data;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2321 uint32_t header;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2322 int len, out_size;
2479
dfdb6bf4b90f support 32bit output for the mpeg audio decoder
michael
parents: 2478
diff changeset
2323 OUT_INT *out_samples = data;
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2324
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2325 len = buf_size;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2326
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2327 // Discard too short frames
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2328 if (buf_size < HEADER_SIZE) {
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2329 *data_size = 0;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2330 return buf_size;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2331 }
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2332
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2333
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2334 if (len > MPA_MAX_CODED_FRAME_SIZE)
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2335 len = MPA_MAX_CODED_FRAME_SIZE;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2336
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2337 // Get header and restore sync word
5089
bff60ecc02f9 Use AV_xx throughout libavcodec
ramiro
parents: 5076
diff changeset
2338 header = AV_RB32(buf) | 0xffe00000;
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2339
2472
021dc26e760f dithering for the mpeg audio decoder
michael
parents: 2468
diff changeset
2340 if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2341 *data_size = 0;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2342 return buf_size;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2343 }
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2344
5051
b908c67063c8 add a ff_ prefix to some mpegaudio funcs
aurel
parents: 5050
diff changeset
2345 ff_mpegaudio_decode_header(s, header);
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2346 /* update codec info */
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2347 avctx->sample_rate = s->sample_rate;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2348 avctx->channels = s->nb_channels;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2349 avctx->bit_rate = s->bit_rate;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2350 avctx->sub_id = s->layer;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2351
6510
771eb7ea8b3f correctly set avctx->frame_size for mp3on4 and mp3adu
bcoudurier
parents: 6350
diff changeset
2352 s->frame_size = len;
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2353
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2354 if (avctx->parse_only) {
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2355 out_size = buf_size;
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2356 } else {
3634
fa4beebb74a6 remove duplicated parser, people who pass random gibblets of the bitstream into the decoder will have to pass it through a AVParser like for all other codecs too
michael
parents: 3627
diff changeset
2357 out_size = mp_decode_frame(s, out_samples, buf, buf_size);
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2358 }
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2359
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2360 *data_size = out_size;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2361 return buf_size;
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2362 }
3777
20545fbb6f7c add some #ifdef CONFIG_ENCODERS/DECODERS
mru
parents: 3776
diff changeset
2363 #endif /* CONFIG_MP3ADU_DECODER */
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2364
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8586
diff changeset
2365 #if CONFIG_MP3ON4_DECODER
6694
a2319e5d8bd3 use mpeg4audio common code
bcoudurier
parents: 6692
diff changeset
2366
6699
99cf02b8f831 move MP3On4DecodeContext def near the code and under ifdef
bcoudurier
parents: 6698
diff changeset
2367 /**
99cf02b8f831 move MP3On4DecodeContext def near the code and under ifdef
bcoudurier
parents: 6698
diff changeset
2368 * Context for MP3On4 decoder
99cf02b8f831 move MP3On4DecodeContext def near the code and under ifdef
bcoudurier
parents: 6698
diff changeset
2369 */
99cf02b8f831 move MP3On4DecodeContext def near the code and under ifdef
bcoudurier
parents: 6698
diff changeset
2370 typedef struct MP3On4DecodeContext {
99cf02b8f831 move MP3On4DecodeContext def near the code and under ifdef
bcoudurier
parents: 6698
diff changeset
2371 int frames; ///< number of mp3 frames per block (number of mp3 decoder instances)
99cf02b8f831 move MP3On4DecodeContext def near the code and under ifdef
bcoudurier
parents: 6698
diff changeset
2372 int syncword; ///< syncword patch
6700
dd38dc6306a8 simplify: remove useless fields and vars
bcoudurier
parents: 6699
diff changeset
2373 const uint8_t *coff; ///< channels offsets in output buffer
6699
99cf02b8f831 move MP3On4DecodeContext def near the code and under ifdef
bcoudurier
parents: 6698
diff changeset
2374 MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
99cf02b8f831 move MP3On4DecodeContext def near the code and under ifdef
bcoudurier
parents: 6698
diff changeset
2375 } MP3On4DecodeContext;
99cf02b8f831 move MP3On4DecodeContext def near the code and under ifdef
bcoudurier
parents: 6698
diff changeset
2376
6694
a2319e5d8bd3 use mpeg4audio common code
bcoudurier
parents: 6692
diff changeset
2377 #include "mpeg4audio.h"
a2319e5d8bd3 use mpeg4audio common code
bcoudurier
parents: 6692
diff changeset
2378
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2379 /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
6696
c3182ffe1689 remove old draft last case not present anymore in iso specs
bcoudurier
parents: 6694
diff changeset
2380 static const uint8_t mp3Frames[8] = {0,1,1,2,3,3,4,5}; /* number of mp3 decoder instances */
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2381 /* offsets into output buffer, assume output order is FL FR BL BR C LFE */
6696
c3182ffe1689 remove old draft last case not present anymore in iso specs
bcoudurier
parents: 6694
diff changeset
2382 static const uint8_t chan_offset[8][5] = {
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2383 {0},
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2384 {0}, // C
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2385 {0}, // FLR
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2386 {2,0}, // C FLR
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2387 {2,0,3}, // C FLR BS
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2388 {4,0,2}, // C FLR BLRS
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2389 {4,0,2,5}, // C FLR BLRS LFE
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2390 {4,0,2,6,5}, // C FLR BLRS BLR LFE
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2391 };
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2392
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2393
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2394 static int decode_init_mp3on4(AVCodecContext * avctx)
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2395 {
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2396 MP3On4DecodeContext *s = avctx->priv_data;
6694
a2319e5d8bd3 use mpeg4audio common code
bcoudurier
parents: 6692
diff changeset
2397 MPEG4AudioConfig cfg;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2398 int i;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2399
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2400 if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2401 av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2402 return -1;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2403 }
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2404
6694
a2319e5d8bd3 use mpeg4audio common code
bcoudurier
parents: 6692
diff changeset
2405 ff_mpeg4audio_get_config(&cfg, avctx->extradata, avctx->extradata_size);
a2319e5d8bd3 use mpeg4audio common code
bcoudurier
parents: 6692
diff changeset
2406 if (!cfg.chan_config || cfg.chan_config > 7) {
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2407 av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2408 return -1;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2409 }
6700
dd38dc6306a8 simplify: remove useless fields and vars
bcoudurier
parents: 6699
diff changeset
2410 s->frames = mp3Frames[cfg.chan_config];
dd38dc6306a8 simplify: remove useless fields and vars
bcoudurier
parents: 6699
diff changeset
2411 s->coff = chan_offset[cfg.chan_config];
dd38dc6306a8 simplify: remove useless fields and vars
bcoudurier
parents: 6699
diff changeset
2412 avctx->channels = ff_mpeg4audio_channels[cfg.chan_config];
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2413
6698
06f422f73ade correctly patch syncword for samples rates < 16000, decoder now fully support all iso ref files
bcoudurier
parents: 6697
diff changeset
2414 if (cfg.sample_rate < 16000)
06f422f73ade correctly patch syncword for samples rates < 16000, decoder now fully support all iso ref files
bcoudurier
parents: 6697
diff changeset
2415 s->syncword = 0xffe00000;
06f422f73ade correctly patch syncword for samples rates < 16000, decoder now fully support all iso ref files
bcoudurier
parents: 6697
diff changeset
2416 else
06f422f73ade correctly patch syncword for samples rates < 16000, decoder now fully support all iso ref files
bcoudurier
parents: 6697
diff changeset
2417 s->syncword = 0xfff00000;
06f422f73ade correctly patch syncword for samples rates < 16000, decoder now fully support all iso ref files
bcoudurier
parents: 6697
diff changeset
2418
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2419 /* Init the first mp3 decoder in standard way, so that all tables get builded
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2420 * We replace avctx->priv_data with the context of the first decoder so that
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2421 * decode_init() does not have to be changed.
6350
8e63d869a904 typo fix: inited --> initialized
diego
parents: 6218
diff changeset
2422 * Other decoders will be initialized here copying data from the first context
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2423 */
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2424 // Allocate zeroed memory for the first decoder context
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2425 s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2426 // Put decoder context in place to make init_decode() happy
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2427 avctx->priv_data = s->mp3decctx[0];
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2428 decode_init(avctx);
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2429 // Restore mp3on4 context pointer
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2430 avctx->priv_data = s;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2431 s->mp3decctx[0]->adu_mode = 1; // Set adu mode
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2432
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2433 /* Create a separate codec/context for each frame (first is already ok).
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2434 * Each frame is 1 or 2 channels - up to 5 frames allowed
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2435 */
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2436 for (i = 1; i < s->frames; i++) {
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2437 s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2438 s->mp3decctx[i]->compute_antialias = s->mp3decctx[0]->compute_antialias;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2439 s->mp3decctx[i]->adu_mode = 1;
4652
6679d37a3338 Give context to dprintf
mbardiaux
parents: 4469
diff changeset
2440 s->mp3decctx[i]->avctx = avctx;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2441 }
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2442
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2443 return 0;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2444 }
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2445
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2446
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2447 static int decode_close_mp3on4(AVCodecContext * avctx)
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2448 {
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2449 MP3On4DecodeContext *s = avctx->priv_data;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2450 int i;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2451
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2452 for (i = 0; i < s->frames; i++)
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2453 if (s->mp3decctx[i])
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2454 av_free(s->mp3decctx[i]);
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2455
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2456 return 0;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2457 }
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2458
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2459
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2460 static int decode_frame_mp3on4(AVCodecContext * avctx,
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2461 void *data, int *data_size,
6218
michael
parents: 6138
diff changeset
2462 const uint8_t * buf, int buf_size)
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2463 {
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2464 MP3On4DecodeContext *s = avctx->priv_data;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2465 MPADecodeContext *m;
6704
2f439a593e56 merge init with declaration
bcoudurier
parents: 6703
diff changeset
2466 int fsize, len = buf_size, out_size = 0;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2467 uint32_t header;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2468 OUT_INT *out_samples = data;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2469 OUT_INT decoded_buf[MPA_FRAME_SIZE * MPA_MAX_CHANNELS];
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2470 OUT_INT *outptr, *bp;
6702
a9a28c8b40fb simplify: merge loops
bcoudurier
parents: 6701
diff changeset
2471 int fr, j, n;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2472
6688
91f5a23d6cd5 return error if buf_size is too small
bcoudurier
parents: 6687
diff changeset
2473 *data_size = 0;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2474 // Discard too short frames
6688
91f5a23d6cd5 return error if buf_size is too small
bcoudurier
parents: 6687
diff changeset
2475 if (buf_size < HEADER_SIZE)
91f5a23d6cd5 return error if buf_size is too small
bcoudurier
parents: 6687
diff changeset
2476 return -1;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2477
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2478 // If only one decoder interleave is not needed
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2479 outptr = s->frames == 1 ? out_samples : decoded_buf;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2480
6702
a9a28c8b40fb simplify: merge loops
bcoudurier
parents: 6701
diff changeset
2481 avctx->bit_rate = 0;
a9a28c8b40fb simplify: merge loops
bcoudurier
parents: 6701
diff changeset
2482
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2483 for (fr = 0; fr < s->frames; fr++) {
6692
25413354a79a simplify
bcoudurier
parents: 6691
diff changeset
2484 fsize = AV_RB16(buf) >> 4;
6689
85cb0c3f8e54 simplify using FFMIN3
bcoudurier
parents: 6688
diff changeset
2485 fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2486 m = s->mp3decctx[fr];
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2487 assert (m != NULL);
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2488
6698
06f422f73ade correctly patch syncword for samples rates < 16000, decoder now fully support all iso ref files
bcoudurier
parents: 6697
diff changeset
2489 header = (AV_RB32(buf) & 0x000fffff) | s->syncword; // patch header
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2490
6705
d5515254fbbd break if error in header so it can output already decoded frames
bcoudurier
parents: 6704
diff changeset
2491 if (ff_mpa_check_header(header) < 0) // Bad header, discard block
d5515254fbbd break if error in header so it can output already decoded frames
bcoudurier
parents: 6704
diff changeset
2492 break;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2493
5051
b908c67063c8 add a ff_ prefix to some mpegaudio funcs
aurel
parents: 5050
diff changeset
2494 ff_mpegaudio_decode_header(m, header);
6697
1310a89b0dcd fix 1 frame config decoding
bcoudurier
parents: 6696
diff changeset
2495 out_size += mp_decode_frame(m, outptr, buf, fsize);
6692
25413354a79a simplify
bcoudurier
parents: 6691
diff changeset
2496 buf += fsize;
25413354a79a simplify
bcoudurier
parents: 6691
diff changeset
2497 len -= fsize;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2498
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2499 if(s->frames > 1) {
6691
863e939331aa correctly compute out_size and samples number
bcoudurier
parents: 6690
diff changeset
2500 n = m->avctx->frame_size*m->nb_channels;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2501 /* interleave output data */
6700
dd38dc6306a8 simplify: remove useless fields and vars
bcoudurier
parents: 6699
diff changeset
2502 bp = out_samples + s->coff[fr];
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2503 if(m->nb_channels == 1) {
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2504 for(j = 0; j < n; j++) {
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2505 *bp = decoded_buf[j];
6701
ef18192d8474 simplify
bcoudurier
parents: 6700
diff changeset
2506 bp += avctx->channels;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2507 }
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2508 } else {
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2509 for(j = 0; j < n; j++) {
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2510 bp[0] = decoded_buf[j++];
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2511 bp[1] = decoded_buf[j];
6701
ef18192d8474 simplify
bcoudurier
parents: 6700
diff changeset
2512 bp += avctx->channels;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2513 }
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2514 }
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2515 }
6702
a9a28c8b40fb simplify: merge loops
bcoudurier
parents: 6701
diff changeset
2516 avctx->bit_rate += m->bit_rate;
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2517 }
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2518
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2519 /* update codec info */
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2520 avctx->sample_rate = s->mp3decctx[0]->sample_rate;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2521
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2522 *data_size = out_size;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2523 return buf_size;
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2524 }
3777
20545fbb6f7c add some #ifdef CONFIG_ENCODERS/DECODERS
mru
parents: 3776
diff changeset
2525 #endif /* CONFIG_MP3ON4_DECODER */
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2526
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8586
diff changeset
2527 #if CONFIG_MP1_DECODER
8586
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2528 AVCodec mp1_decoder =
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2529 {
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2530 "mp1",
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2531 CODEC_TYPE_AUDIO,
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2532 CODEC_ID_MP1,
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2533 sizeof(MPADecodeContext),
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2534 decode_init,
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2535 NULL,
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2536 NULL,
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2537 decode_frame,
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2538 CODEC_CAP_PARSE_ONLY,
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2539 .flush= flush,
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2540 .long_name= NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2541 };
d7d0cde5f308 Add dummy mp1_decoder to complement the existing dummy mp2/mp3 decoders.
michael
parents: 8439
diff changeset
2542 #endif
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8586
diff changeset
2543 #if CONFIG_MP2_DECODER
322
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2544 AVCodec mp2_decoder =
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2545 {
322
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2546 "mp2",
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2547 CODEC_TYPE_AUDIO,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2548 CODEC_ID_MP2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2549 sizeof(MPADecodeContext),
986e461dc072 Initial revision
glantau
parents:
diff changeset
2550 decode_init,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2551 NULL,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2552 NULL,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2553 decode_frame,
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
2554 CODEC_CAP_PARSE_ONLY,
6136
85f3acb225e9 Flush mp2 as well on seeking. Part of a patch by Brian Brice bbrice gmail com.
michael
parents: 5886
diff changeset
2555 .flush= flush,
7040
e943e1409077 Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents: 6712
diff changeset
2556 .long_name= NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2557 };
3777
20545fbb6f7c add some #ifdef CONFIG_ENCODERS/DECODERS
mru
parents: 3776
diff changeset
2558 #endif
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8586
diff changeset
2559 #if CONFIG_MP3_DECODER
322
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2560 AVCodec mp3_decoder =
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2561 {
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2562 "mp3",
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2563 CODEC_TYPE_AUDIO,
1448
317ba7ab73bd CODEC_ID_MP3LAME is obsolete
bellard
parents: 1428
diff changeset
2564 CODEC_ID_MP3,
322
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2565 sizeof(MPADecodeContext),
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2566 decode_init,
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2567 NULL,
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2568 NULL,
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2569 decode_frame,
1428
aece5836c588 fixed audio frame buffering problem (should correct problems on some streams) - faster synthesis filter - prototype 'parse_only' support
bellard
parents: 1414
diff changeset
2570 CODEC_CAP_PARSE_ONLY,
4203
14250f6ff483 reset internal buffer during seeking
michael
parents: 4202
diff changeset
2571 .flush= flush,
7040
e943e1409077 Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents: 6712
diff changeset
2572 .long_name= NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
322
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 313
diff changeset
2573 };
3777
20545fbb6f7c add some #ifdef CONFIG_ENCODERS/DECODERS
mru
parents: 3776
diff changeset
2574 #endif
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8586
diff changeset
2575 #if CONFIG_MP3ADU_DECODER
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2576 AVCodec mp3adu_decoder =
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2577 {
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2578 "mp3adu",
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2579 CODEC_TYPE_AUDIO,
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2580 CODEC_ID_MP3ADU,
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2581 sizeof(MPADecodeContext),
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2582 decode_init,
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2583 NULL,
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2584 NULL,
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2585 decode_frame_adu,
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2586 CODEC_CAP_PARSE_ONLY,
4203
14250f6ff483 reset internal buffer during seeking
michael
parents: 4202
diff changeset
2587 .flush= flush,
7040
e943e1409077 Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents: 6712
diff changeset
2588 .long_name= NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
2432
d9cf90e66883 Decode MP3 in ADU format
rtognimp
parents: 2423
diff changeset
2589 };
3777
20545fbb6f7c add some #ifdef CONFIG_ENCODERS/DECODERS
mru
parents: 3776
diff changeset
2590 #endif
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8586
diff changeset
2591 #if CONFIG_MP3ON4_DECODER
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2592 AVCodec mp3on4_decoder =
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2593 {
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2594 "mp3on4",
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2595 CODEC_TYPE_AUDIO,
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2596 CODEC_ID_MP3ON4,
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2597 sizeof(MP3On4DecodeContext),
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2598 decode_init_mp3on4,
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2599 NULL,
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2600 decode_close_mp3on4,
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2601 decode_frame_mp3on4,
4203
14250f6ff483 reset internal buffer during seeking
michael
parents: 4202
diff changeset
2602 .flush= flush,
7040
e943e1409077 Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents: 6712
diff changeset
2603 .long_name= NULL_IF_CONFIG_SMALL("MP3onMP4"),
2507
0334caf0f0ce Multichannel mp3 in mp4 support ISO/IEC 14496-3:2001/FPDAM 3 (MP3onMP4)
rtognimp
parents: 2496
diff changeset
2604 };
3777
20545fbb6f7c add some #ifdef CONFIG_ENCODERS/DECODERS
mru
parents: 3776
diff changeset
2605 #endif