Mercurial > libavcodec.hg
annotate wmaprodec.c @ 11352:6e0af2cfdcfe libavcodec
Do MC and IDCT in coding (hilbert) order
This increases the slice size to 64 pixels, due to having to decode an
entire chroma superblock row per slice.
This can be up to 6% slower depending on clip and CPU, but is necessary
for future optimizations that gain significantly more than was lost.
author | conrad |
---|---|
date | Wed, 03 Mar 2010 23:27:40 +0000 |
parents | 34a65026fa06 |
children | 98970e51365a |
rev | line source |
---|---|
10073 | 1 /* |
2 * Wmapro compatible decoder | |
3 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion | |
4 * Copyright (c) 2008 - 2009 Sascha Sommer, Benjamin Larsson | |
5 * | |
6 * This file is part of FFmpeg. | |
7 * | |
8 * FFmpeg is free software; you can redistribute it and/or | |
9 * modify it under the terms of the GNU Lesser General Public | |
10 * License as published by the Free Software Foundation; either | |
11 * version 2.1 of the License, or (at your option) any later version. | |
12 * | |
13 * FFmpeg is distributed in the hope that it will be useful, | |
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 * Lesser General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU Lesser General Public | |
19 * License along with FFmpeg; if not, write to the Free Software | |
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
21 */ | |
22 | |
23 /** | |
24 * @file libavcodec/wmaprodec.c | |
25 * @brief wmapro decoder implementation | |
26 * Wmapro is an MDCT based codec comparable to wma standard or AAC. | |
27 * The decoding therefore consists of the following steps: | |
28 * - bitstream decoding | |
29 * - reconstruction of per-channel data | |
30 * - rescaling and inverse quantization | |
31 * - IMDCT | |
32 * - windowing and overlapp-add | |
33 * | |
34 * The compressed wmapro bitstream is split into individual packets. | |
35 * Every such packet contains one or more wma frames. | |
36 * The compressed frames may have a variable length and frames may | |
37 * cross packet boundaries. | |
38 * Common to all wmapro frames is the number of samples that are stored in | |
39 * a frame. | |
40 * The number of samples and a few other decode flags are stored | |
41 * as extradata that has to be passed to the decoder. | |
42 * | |
43 * The wmapro frames themselves are again split into a variable number of | |
44 * subframes. Every subframe contains the data for 2^N time domain samples | |
45 * where N varies between 7 and 12. | |
46 * | |
47 * Example wmapro bitstream (in samples): | |
48 * | |
49 * || packet 0 || packet 1 || packet 2 packets | |
50 * --------------------------------------------------- | |
51 * || frame 0 || frame 1 || frame 2 || frames | |
52 * --------------------------------------------------- | |
53 * || | | || | | | || || subframes of channel 0 | |
54 * --------------------------------------------------- | |
55 * || | | || | | | || || subframes of channel 1 | |
56 * --------------------------------------------------- | |
57 * | |
58 * The frame layouts for the individual channels of a wma frame does not need | |
59 * to be the same. | |
60 * | |
61 * However, if the offsets and lengths of several subframes of a frame are the | |
62 * same, the subframes of the channels can be grouped. | |
63 * Every group may then use special coding techniques like M/S stereo coding | |
64 * to improve the compression ratio. These channel transformations do not | |
65 * need to be applied to a whole subframe. Instead, they can also work on | |
66 * individual scale factor bands (see below). | |
67 * The coefficients that carry the audio signal in the frequency domain | |
68 * are transmitted as huffman-coded vectors with 4, 2 and 1 elements. | |
69 * In addition to that, the encoder can switch to a runlevel coding scheme | |
70 * by transmitting subframe_length / 128 zero coefficients. | |
71 * | |
72 * Before the audio signal can be converted to the time domain, the | |
73 * coefficients have to be rescaled and inverse quantized. | |
74 * A subframe is therefore split into several scale factor bands that get | |
75 * scaled individually. | |
76 * Scale factors are submitted for every frame but they might be shared | |
77 * between the subframes of a channel. Scale factors are initially DPCM-coded. | |
78 * Once scale factors are shared, the differences are transmitted as runlevel | |
79 * codes. | |
80 * Every subframe length and offset combination in the frame layout shares a | |
81 * common quantization factor that can be adjusted for every channel by a | |
82 * modifier. | |
83 * After the inverse quantization, the coefficients get processed by an IMDCT. | |
84 * The resulting values are then windowed with a sine window and the first half | |
85 * of the values are added to the second half of the output from the previous | |
86 * subframe in order to reconstruct the output samples. | |
87 */ | |
88 | |
10122 | 89 #include "avcodec.h" |
90 #include "internal.h" | |
91 #include "get_bits.h" | |
92 #include "put_bits.h" | |
93 #include "wmaprodata.h" | |
94 #include "dsputil.h" | |
95 #include "wma.h" | |
96 | |
97 /** current decoder limitations */ | |
98 #define WMAPRO_MAX_CHANNELS 8 ///< max number of handled channels | |
99 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel | |
100 #define MAX_BANDS 29 ///< max number of scale factor bands | |
10353 | 101 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size |
10122 | 102 |
103 #define WMAPRO_BLOCK_MAX_BITS 12 ///< log2 of max block size | |
104 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS) ///< maximum block size | |
105 #define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS - BLOCK_MIN_BITS + 1) ///< possible block sizes | |
106 | |
107 | |
108 #define VLCBITS 9 | |
109 #define SCALEVLCBITS 8 | |
110 #define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS) | |
111 #define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS) | |
112 #define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS) | |
113 #define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS) | |
114 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS) | |
115 | |
116 static VLC sf_vlc; ///< scale factor DPCM vlc | |
117 static VLC sf_rl_vlc; ///< scale factor run length vlc | |
118 static VLC vec4_vlc; ///< 4 coefficients per symbol | |
119 static VLC vec2_vlc; ///< 2 coefficients per symbol | |
120 static VLC vec1_vlc; ///< 1 coefficient per symbol | |
121 static VLC coef_vlc[2]; ///< coefficient run length vlc codes | |
122 static float sin64[33]; ///< sinus table for decorrelation | |
123 | |
124 /** | |
125 * @brief frame specific decoder context for a single channel | |
126 */ | |
127 typedef struct { | |
128 int16_t prev_block_len; ///< length of the previous block | |
129 uint8_t transmit_coefs; | |
130 uint8_t num_subframes; | |
131 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples | |
132 uint16_t subframe_offset[MAX_SUBFRAMES]; ///< subframe positions in the current frame | |
133 uint8_t cur_subframe; ///< current subframe number | |
134 uint16_t decoded_samples; ///< number of already processed samples | |
135 uint8_t grouped; ///< channel is part of a group | |
136 int quant_step; ///< quantization step for the current subframe | |
137 int8_t reuse_sf; ///< share scale factors between subframes | |
138 int8_t scale_factor_step; ///< scaling step for the current subframe | |
139 int max_scale_factor; ///< maximum scale factor for the current subframe | |
10138 | 140 int saved_scale_factors[2][MAX_BANDS]; ///< resampled and (previously) transmitted scale factor values |
141 int8_t scale_factor_idx; ///< index for the transmitted scale factor values (used for resampling) | |
142 int* scale_factors; ///< pointer to the scale factor values used for decoding | |
10122 | 143 uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block |
144 float* coeffs; ///< pointer to the subframe decode buffer | |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10827
diff
changeset
|
145 DECLARE_ALIGNED_16(float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer |
10122 | 146 } WMAProChannelCtx; |
147 | |
148 /** | |
149 * @brief channel group for channel transformations | |
150 */ | |
151 typedef struct { | |
152 uint8_t num_channels; ///< number of channels in the group | |
153 int8_t transform; ///< transform on / off | |
154 int8_t transform_band[MAX_BANDS]; ///< controls if the transform is enabled for a certain band | |
155 float decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS]; | |
156 float* channel_data[WMAPRO_MAX_CHANNELS]; ///< transformation coefficients | |
157 } WMAProChannelGrp; | |
158 | |
159 /** | |
160 * @brief main decoder context | |
161 */ | |
162 typedef struct WMAProDecodeCtx { | |
163 /* generic decoder variables */ | |
164 AVCodecContext* avctx; ///< codec context for av_log | |
165 DSPContext dsp; ///< accelerated DSP functions | |
166 uint8_t frame_data[MAX_FRAMESIZE + | |
167 FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data | |
168 PutBitContext pb; ///< context for filling the frame_data buffer | |
10199 | 169 FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10827
diff
changeset
|
170 DECLARE_ALIGNED_16(float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer |
10122 | 171 float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes |
172 | |
173 /* frame size dependent frame information (set during initialization) */ | |
174 uint32_t decode_flags; ///< used compression features | |
175 uint8_t len_prefix; ///< frame is prefixed with its length | |
176 uint8_t dynamic_range_compression; ///< frame contains DRC data | |
177 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0]) | |
178 uint16_t samples_per_frame; ///< number of samples to output | |
179 uint16_t log2_frame_size; | |
180 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels) | |
181 int8_t lfe_channel; ///< lfe channel index | |
182 uint8_t max_num_subframes; | |
183 uint8_t subframe_len_bits; ///< number of bits used for the subframe length | |
184 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1 | |
185 uint16_t min_samples_per_subframe; | |
186 int8_t num_sfb[WMAPRO_BLOCK_SIZES]; ///< scale factor bands per block size | |
187 int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor band offsets (multiples of 4) | |
188 int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix | |
189 int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values | |
190 | |
191 /* packet decode state */ | |
10126 | 192 GetBitContext pgb; ///< bitstream reader context for the packet |
10165 | 193 uint8_t packet_offset; ///< frame offset in the packet |
10122 | 194 uint8_t packet_sequence_number; ///< current packet number |
195 int num_saved_bits; ///< saved number of bits | |
196 int frame_offset; ///< frame offset in the bit reservoir | |
197 int subframe_offset; ///< subframe offset in the bit reservoir | |
198 uint8_t packet_loss; ///< set in case of bitstream error | |
10139
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
199 uint8_t packet_done; ///< set when a packet is fully decoded |
10122 | 200 |
201 /* frame decode state */ | |
202 uint32_t frame_num; ///< current frame number (not used for decoding) | |
203 GetBitContext gb; ///< bitstream reader context | |
204 int buf_bit_size; ///< buffer size in bits | |
205 float* samples; ///< current samplebuffer pointer | |
206 float* samples_end; ///< maximum samplebuffer pointer | |
207 uint8_t drc_gain; ///< gain for the DRC tool | |
208 int8_t skip_frame; ///< skip output step | |
209 int8_t parsed_all_subframes; ///< all subframes decoded? | |
210 | |
211 /* subframe/block decode state */ | |
212 int16_t subframe_len; ///< current subframe length | |
213 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe | |
214 int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS]; | |
215 int8_t num_bands; ///< number of scale factor bands | |
216 int16_t* cur_sfb_offsets; ///< sfb offsets for the current block | |
217 uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables | |
218 int8_t esc_len; ///< length of escaped coefficients | |
219 | |
220 uint8_t num_chgroups; ///< number of channel groups | |
221 WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information | |
222 | |
223 WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data | |
224 } WMAProDecodeCtx; | |
225 | |
226 | |
227 /** | |
228 *@brief helper function to print the most important members of the context | |
229 *@param s context | |
230 */ | |
231 static void av_cold dump_context(WMAProDecodeCtx *s) | |
232 { | |
233 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b); | |
234 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b); | |
235 | |
236 PRINT("ed sample bit depth", s->bits_per_sample); | |
237 PRINT_HEX("ed decode flags", s->decode_flags); | |
238 PRINT("samples per frame", s->samples_per_frame); | |
239 PRINT("log2 frame size", s->log2_frame_size); | |
240 PRINT("max num subframes", s->max_num_subframes); | |
241 PRINT("len prefix", s->len_prefix); | |
242 PRINT("num channels", s->num_channels); | |
243 } | |
244 | |
10005 | 245 /** |
246 *@brief Uninitialize the decoder and free all resources. | |
247 *@param avctx codec context | |
248 *@return 0 on success, < 0 otherwise | |
249 */ | |
250 static av_cold int decode_end(AVCodecContext *avctx) | |
251 { | |
10122 | 252 WMAProDecodeCtx *s = avctx->priv_data; |
10005 | 253 int i; |
254 | |
10084 | 255 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) |
10005 | 256 ff_mdct_end(&s->mdct_ctx[i]); |
257 | |
258 return 0; | |
259 } | |
260 | |
261 /** | |
10122 | 262 *@brief Initialize the decoder. |
263 *@param avctx codec context | |
264 *@return 0 on success, -1 otherwise | |
265 */ | |
266 static av_cold int decode_init(AVCodecContext *avctx) | |
267 { | |
268 WMAProDecodeCtx *s = avctx->priv_data; | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
269 uint8_t *edata_ptr = avctx->extradata; |
10122 | 270 unsigned int channel_mask; |
271 int i; | |
272 int log2_max_num_subframes; | |
273 int num_possible_block_sizes; | |
274 | |
275 s->avctx = avctx; | |
276 dsputil_init(&s->dsp, avctx); | |
277 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE); | |
278 | |
279 avctx->sample_fmt = SAMPLE_FMT_FLT; | |
280 | |
281 if (avctx->extradata_size >= 18) { | |
282 s->decode_flags = AV_RL16(edata_ptr+14); | |
283 channel_mask = AV_RL32(edata_ptr+2); | |
284 s->bits_per_sample = AV_RL16(edata_ptr); | |
285 /** dump the extradata */ | |
286 for (i = 0; i < avctx->extradata_size; i++) | |
287 dprintf(avctx, "[%x] ", avctx->extradata[i]); | |
288 dprintf(avctx, "\n"); | |
289 | |
290 } else { | |
291 av_log_ask_for_sample(avctx, "Unknown extradata size\n"); | |
292 return AVERROR_INVALIDDATA; | |
293 } | |
294 | |
295 /** generic init */ | |
296 s->log2_frame_size = av_log2(avctx->block_align) + 4; | |
297 | |
298 /** frame info */ | |
299 s->skip_frame = 1; /** skip first frame */ | |
300 s->packet_loss = 1; | |
301 s->len_prefix = (s->decode_flags & 0x40); | |
302 | |
303 if (!s->len_prefix) { | |
304 av_log_ask_for_sample(avctx, "no length prefix\n"); | |
305 return AVERROR_INVALIDDATA; | |
306 } | |
307 | |
308 /** get frame len */ | |
309 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate, | |
310 3, s->decode_flags); | |
311 | |
312 /** init previous block len */ | |
313 for (i = 0; i < avctx->channels; i++) | |
314 s->channel[i].prev_block_len = s->samples_per_frame; | |
315 | |
316 /** subframe info */ | |
317 log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3); | |
318 s->max_num_subframes = 1 << log2_max_num_subframes; | |
319 if (s->max_num_subframes == 16) | |
320 s->max_subframe_len_bit = 1; | |
321 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1; | |
322 | |
323 num_possible_block_sizes = log2_max_num_subframes + 1; | |
324 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes; | |
325 s->dynamic_range_compression = (s->decode_flags & 0x80); | |
326 | |
327 if (s->max_num_subframes > MAX_SUBFRAMES) { | |
328 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n", | |
329 s->max_num_subframes); | |
330 return AVERROR_INVALIDDATA; | |
331 } | |
332 | |
333 s->num_channels = avctx->channels; | |
334 | |
335 /** extract lfe channel position */ | |
336 s->lfe_channel = -1; | |
337 | |
338 if (channel_mask & 8) { | |
339 unsigned int mask; | |
340 for (mask = 1; mask < 16; mask <<= 1) { | |
341 if (channel_mask & mask) | |
342 ++s->lfe_channel; | |
343 } | |
344 } | |
345 | |
346 if (s->num_channels < 0 || s->num_channels > WMAPRO_MAX_CHANNELS) { | |
347 av_log_ask_for_sample(avctx, "invalid number of channels\n"); | |
348 return AVERROR_NOTSUPP; | |
349 } | |
350 | |
351 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE, | |
352 scale_huffbits, 1, 1, | |
353 scale_huffcodes, 2, 2, 616); | |
354 | |
355 INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE, | |
356 scale_rl_huffbits, 1, 1, | |
357 scale_rl_huffcodes, 4, 4, 1406); | |
358 | |
359 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE, | |
360 coef0_huffbits, 1, 1, | |
361 coef0_huffcodes, 4, 4, 2108); | |
362 | |
363 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE, | |
364 coef1_huffbits, 1, 1, | |
365 coef1_huffcodes, 4, 4, 3912); | |
366 | |
367 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE, | |
368 vec4_huffbits, 1, 1, | |
369 vec4_huffcodes, 2, 2, 604); | |
370 | |
371 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE, | |
372 vec2_huffbits, 1, 1, | |
373 vec2_huffcodes, 2, 2, 562); | |
374 | |
375 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE, | |
376 vec1_huffbits, 1, 1, | |
377 vec1_huffcodes, 2, 2, 562); | |
378 | |
379 /** calculate number of scale factor bands and their offsets | |
380 for every possible block size */ | |
381 for (i = 0; i < num_possible_block_sizes; i++) { | |
382 int subframe_len = s->samples_per_frame >> i; | |
383 int x; | |
384 int band = 1; | |
385 | |
386 s->sfb_offsets[i][0] = 0; | |
387 | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
388 for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) { |
10122 | 389 int offset = (subframe_len * 2 * critical_freq[x]) |
390 / s->avctx->sample_rate + 2; | |
391 offset &= ~3; | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
392 if (offset > s->sfb_offsets[i][band - 1]) |
10122 | 393 s->sfb_offsets[i][band++] = offset; |
394 } | |
395 s->sfb_offsets[i][band - 1] = subframe_len; | |
396 s->num_sfb[i] = band - 1; | |
397 } | |
398 | |
399 | |
400 /** Scale factors can be shared between blocks of different size | |
401 as every block has a different scale factor band layout. | |
402 The matrix sf_offsets is needed to find the correct scale factor. | |
403 */ | |
404 | |
405 for (i = 0; i < num_possible_block_sizes; i++) { | |
406 int b; | |
407 for (b = 0; b < s->num_sfb[i]; b++) { | |
408 int x; | |
409 int offset = ((s->sfb_offsets[i][b] | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
410 + s->sfb_offsets[i][b + 1] - 1) << i) >> 1; |
10122 | 411 for (x = 0; x < num_possible_block_sizes; x++) { |
412 int v = 0; | |
413 while (s->sfb_offsets[x][v + 1] << x < offset) | |
414 ++v; | |
415 s->sf_offsets[i][x][b] = v; | |
416 } | |
417 } | |
418 } | |
419 | |
420 /** init MDCT, FIXME: only init needed sizes */ | |
421 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) | |
422 ff_mdct_init(&s->mdct_ctx[i], BLOCK_MIN_BITS+1+i, 1, | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
423 1.0 / (1 << (BLOCK_MIN_BITS + i - 1)) |
10122 | 424 / (1 << (s->bits_per_sample - 1))); |
425 | |
426 /** init MDCT windows: simple sinus window */ | |
427 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) { | |
10174
89cd870ca180
Add two more sizes to ff_sine_windows[] and also pad it with NULLs so
vitor
parents:
10165
diff
changeset
|
428 const int win_idx = WMAPRO_BLOCK_MAX_BITS - i; |
10827
3d011a01a6a0
Add support for hard-coded MDCT-related ff_sine_windows tables.
reimar
parents:
10428
diff
changeset
|
429 ff_init_ff_sine_windows(win_idx); |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
430 s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx]; |
10122 | 431 } |
432 | |
433 /** calculate subwoofer cutoff values */ | |
434 for (i = 0; i < num_possible_block_sizes; i++) { | |
435 int block_size = s->samples_per_frame >> i; | |
436 int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1) | |
437 / s->avctx->sample_rate; | |
438 s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size); | |
439 } | |
440 | |
441 /** calculate sine values for the decorrelation matrix */ | |
442 for (i = 0; i < 33; i++) | |
443 sin64[i] = sin(i*M_PI / 64.0); | |
444 | |
445 if (avctx->debug & FF_DEBUG_BITSTREAM) | |
446 dump_context(s); | |
447 | |
448 avctx->channel_layout = channel_mask; | |
449 return 0; | |
450 } | |
451 | |
452 /** | |
453 *@brief Decode the subframe length. | |
454 *@param s context | |
455 *@param offset sample offset in the frame | |
456 *@return decoded subframe length on success, < 0 in case of an error | |
457 */ | |
458 static int decode_subframe_length(WMAProDecodeCtx *s, int offset) | |
459 { | |
460 int frame_len_shift = 0; | |
461 int subframe_len; | |
462 | |
463 /** no need to read from the bitstream when only one length is possible */ | |
464 if (offset == s->samples_per_frame - s->min_samples_per_subframe) | |
465 return s->min_samples_per_subframe; | |
466 | |
467 /** 1 bit indicates if the subframe is of maximum length */ | |
468 if (s->max_subframe_len_bit) { | |
469 if (get_bits1(&s->gb)) | |
470 frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1); | |
471 } else | |
472 frame_len_shift = get_bits(&s->gb, s->subframe_len_bits); | |
473 | |
474 subframe_len = s->samples_per_frame >> frame_len_shift; | |
475 | |
476 /** sanity check the length */ | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
477 if (subframe_len < s->min_samples_per_subframe || |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
478 subframe_len > s->samples_per_frame) { |
10122 | 479 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n", |
480 subframe_len); | |
481 return AVERROR_INVALIDDATA; | |
482 } | |
483 return subframe_len; | |
484 } | |
485 | |
486 /** | |
487 *@brief Decode how the data in the frame is split into subframes. | |
488 * Every WMA frame contains the encoded data for a fixed number of | |
489 * samples per channel. The data for every channel might be split | |
490 * into several subframes. This function will reconstruct the list of | |
491 * subframes for every channel. | |
492 * | |
493 * If the subframes are not evenly split, the algorithm estimates the | |
494 * channels with the lowest number of total samples. | |
495 * Afterwards, for each of these channels a bit is read from the | |
496 * bitstream that indicates if the channel contains a subframe with the | |
497 * next subframe size that is going to be read from the bitstream or not. | |
498 * If a channel contains such a subframe, the subframe size gets added to | |
499 * the channel's subframe list. | |
500 * The algorithm repeats these steps until the frame is properly divided | |
501 * between the individual channels. | |
502 * | |
503 *@param s context | |
504 *@return 0 on success, < 0 in case of an error | |
505 */ | |
506 static int decode_tilehdr(WMAProDecodeCtx *s) | |
507 { | |
508 uint16_t num_samples[WMAPRO_MAX_CHANNELS]; /** sum of samples for all currently known subframes of a channel */ | |
509 uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /** flag indicating if a channel contains the current subframe */ | |
510 int channels_for_cur_subframe = s->num_channels; /** number of channels that contain the current subframe */ | |
511 int fixed_channel_layout = 0; /** flag indicating that all channels use the same subframe offsets and sizes */ | |
512 int min_channel_len = 0; /** smallest sum of samples (channels with this length will be processed first) */ | |
513 int c; | |
514 | |
515 /* Should never consume more than 3073 bits (256 iterations for the | |
516 * while loop when always the minimum amount of 128 samples is substracted | |
517 * from missing samples in the 8 channel case). | |
518 * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4) | |
519 */ | |
520 | |
521 /** reset tiling information */ | |
522 for (c = 0; c < s->num_channels; c++) | |
523 s->channel[c].num_subframes = 0; | |
524 | |
525 memset(num_samples, 0, sizeof(num_samples)); | |
526 | |
527 if (s->max_num_subframes == 1 || get_bits1(&s->gb)) | |
528 fixed_channel_layout = 1; | |
529 | |
530 /** loop until the frame data is split between the subframes */ | |
531 do { | |
532 int subframe_len; | |
533 | |
534 /** check which channels contain the subframe */ | |
535 for (c = 0; c < s->num_channels; c++) { | |
536 if (num_samples[c] == min_channel_len) { | |
537 if (fixed_channel_layout || channels_for_cur_subframe == 1 || | |
538 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) | |
539 contains_subframe[c] = 1; | |
540 else | |
541 contains_subframe[c] = get_bits1(&s->gb); | |
542 } else | |
543 contains_subframe[c] = 0; | |
544 } | |
545 | |
546 /** get subframe length, subframe_len == 0 is not allowed */ | |
547 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0) | |
548 return AVERROR_INVALIDDATA; | |
549 | |
550 /** add subframes to the individual channels and find new min_channel_len */ | |
551 min_channel_len += subframe_len; | |
552 for (c = 0; c < s->num_channels; c++) { | |
553 WMAProChannelCtx* chan = &s->channel[c]; | |
554 | |
555 if (contains_subframe[c]) { | |
556 if (chan->num_subframes >= MAX_SUBFRAMES) { | |
557 av_log(s->avctx, AV_LOG_ERROR, | |
558 "broken frame: num subframes > 31\n"); | |
559 return AVERROR_INVALIDDATA; | |
560 } | |
561 chan->subframe_len[chan->num_subframes] = subframe_len; | |
562 num_samples[c] += subframe_len; | |
563 ++chan->num_subframes; | |
564 if (num_samples[c] > s->samples_per_frame) { | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
565 av_log(s->avctx, AV_LOG_ERROR, "broken frame: " |
10122 | 566 "channel len > samples_per_frame\n"); |
567 return AVERROR_INVALIDDATA; | |
568 } | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
569 } else if (num_samples[c] <= min_channel_len) { |
10122 | 570 if (num_samples[c] < min_channel_len) { |
571 channels_for_cur_subframe = 0; | |
572 min_channel_len = num_samples[c]; | |
573 } | |
574 ++channels_for_cur_subframe; | |
575 } | |
576 } | |
577 } while (min_channel_len < s->samples_per_frame); | |
578 | |
579 for (c = 0; c < s->num_channels; c++) { | |
580 int i; | |
581 int offset = 0; | |
582 for (i = 0; i < s->channel[c].num_subframes; i++) { | |
583 dprintf(s->avctx, "frame[%i] channel[%i] subframe[%i]" | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
584 " len %i\n", s->frame_num, c, i, |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
585 s->channel[c].subframe_len[i]); |
10122 | 586 s->channel[c].subframe_offset[i] = offset; |
587 offset += s->channel[c].subframe_len[i]; | |
588 } | |
589 } | |
590 | |
591 return 0; | |
592 } | |
593 | |
594 /** | |
10005 | 595 *@brief Calculate a decorrelation matrix from the bitstream parameters. |
596 *@param s codec context | |
597 *@param chgroup channel group for which the matrix needs to be calculated | |
598 */ | |
10122 | 599 static void decode_decorrelation_matrix(WMAProDecodeCtx *s, |
600 WMAProChannelGrp *chgroup) | |
10005 | 601 { |
602 int i; | |
603 int offset = 0; | |
604 int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS]; | |
10122 | 605 memset(chgroup->decorrelation_matrix, 0, s->num_channels * |
606 s->num_channels * sizeof(*chgroup->decorrelation_matrix)); | |
10005 | 607 |
10006 | 608 for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++) |
10084 | 609 rotation_offset[i] = get_bits(&s->gb, 6); |
10005 | 610 |
10006 | 611 for (i = 0; i < chgroup->num_channels; i++) |
10005 | 612 chgroup->decorrelation_matrix[chgroup->num_channels * i + i] = |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
613 get_bits1(&s->gb) ? 1.0 : -1.0; |
10005 | 614 |
10006 | 615 for (i = 1; i < chgroup->num_channels; i++) { |
10005 | 616 int x; |
10006 | 617 for (x = 0; x < i; x++) { |
10005 | 618 int y; |
10084 | 619 for (y = 0; y < i + 1; y++) { |
10005 | 620 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y]; |
621 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y]; | |
622 int n = rotation_offset[offset + x]; | |
623 float sinv; | |
624 float cosv; | |
625 | |
10006 | 626 if (n < 32) { |
10005 | 627 sinv = sin64[n]; |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
628 cosv = sin64[32 - n]; |
10005 | 629 } else { |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
630 sinv = sin64[64 - n]; |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
631 cosv = -sin64[n - 32]; |
10005 | 632 } |
633 | |
634 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] = | |
635 (v1 * sinv) - (v2 * cosv); | |
636 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] = | |
637 (v1 * cosv) + (v2 * sinv); | |
638 } | |
639 } | |
640 offset += i; | |
641 } | |
642 } | |
643 | |
644 /** | |
10122 | 645 *@brief Decode channel transformation parameters |
646 *@param s codec context | |
647 *@return 0 in case of success, < 0 in case of bitstream errors | |
648 */ | |
649 static int decode_channel_transform(WMAProDecodeCtx* s) | |
650 { | |
651 int i; | |
652 /* should never consume more than 1921 bits for the 8 channel case | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
653 * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS |
10122 | 654 * + MAX_CHANNELS + MAX_BANDS + 1) |
655 */ | |
656 | |
657 /** in the one channel case channel transforms are pointless */ | |
658 s->num_chgroups = 0; | |
659 if (s->num_channels > 1) { | |
660 int remaining_channels = s->channels_for_cur_subframe; | |
661 | |
662 if (get_bits1(&s->gb)) { | |
663 av_log_ask_for_sample(s->avctx, | |
664 "unsupported channel transform bit\n"); | |
665 return AVERROR_INVALIDDATA; | |
666 } | |
667 | |
668 for (s->num_chgroups = 0; remaining_channels && | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
669 s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) { |
10122 | 670 WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups]; |
671 float** channel_data = chgroup->channel_data; | |
672 chgroup->num_channels = 0; | |
673 chgroup->transform = 0; | |
674 | |
675 /** decode channel mask */ | |
676 if (remaining_channels > 2) { | |
677 for (i = 0; i < s->channels_for_cur_subframe; i++) { | |
678 int channel_idx = s->channel_indexes_for_cur_subframe[i]; | |
679 if (!s->channel[channel_idx].grouped | |
680 && get_bits1(&s->gb)) { | |
681 ++chgroup->num_channels; | |
682 s->channel[channel_idx].grouped = 1; | |
683 *channel_data++ = s->channel[channel_idx].coeffs; | |
684 } | |
685 } | |
686 } else { | |
687 chgroup->num_channels = remaining_channels; | |
688 for (i = 0; i < s->channels_for_cur_subframe; i++) { | |
689 int channel_idx = s->channel_indexes_for_cur_subframe[i]; | |
690 if (!s->channel[channel_idx].grouped) | |
691 *channel_data++ = s->channel[channel_idx].coeffs; | |
692 s->channel[channel_idx].grouped = 1; | |
693 } | |
694 } | |
695 | |
696 /** decode transform type */ | |
697 if (chgroup->num_channels == 2) { | |
698 if (get_bits1(&s->gb)) { | |
699 if (get_bits1(&s->gb)) { | |
700 av_log_ask_for_sample(s->avctx, | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
701 "unsupported channel transform type\n"); |
10122 | 702 } |
703 } else { | |
704 chgroup->transform = 1; | |
705 if (s->num_channels == 2) { | |
706 chgroup->decorrelation_matrix[0] = 1.0; | |
707 chgroup->decorrelation_matrix[1] = -1.0; | |
708 chgroup->decorrelation_matrix[2] = 1.0; | |
709 chgroup->decorrelation_matrix[3] = 1.0; | |
710 } else { | |
711 /** cos(pi/4) */ | |
712 chgroup->decorrelation_matrix[0] = 0.70703125; | |
713 chgroup->decorrelation_matrix[1] = -0.70703125; | |
714 chgroup->decorrelation_matrix[2] = 0.70703125; | |
715 chgroup->decorrelation_matrix[3] = 0.70703125; | |
716 } | |
717 } | |
718 } else if (chgroup->num_channels > 2) { | |
719 if (get_bits1(&s->gb)) { | |
720 chgroup->transform = 1; | |
721 if (get_bits1(&s->gb)) { | |
722 decode_decorrelation_matrix(s, chgroup); | |
723 } else { | |
724 /** FIXME: more than 6 coupled channels not supported */ | |
725 if (chgroup->num_channels > 6) { | |
726 av_log_ask_for_sample(s->avctx, | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
727 "coupled channels > 6\n"); |
10122 | 728 } else { |
729 memcpy(chgroup->decorrelation_matrix, | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
730 default_decorrelation[chgroup->num_channels], |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
731 chgroup->num_channels * chgroup->num_channels * |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
732 sizeof(*chgroup->decorrelation_matrix)); |
10122 | 733 } |
734 } | |
735 } | |
736 } | |
737 | |
738 /** decode transform on / off */ | |
739 if (chgroup->transform) { | |
740 if (!get_bits1(&s->gb)) { | |
741 int i; | |
742 /** transform can be enabled for individual bands */ | |
743 for (i = 0; i < s->num_bands; i++) { | |
744 chgroup->transform_band[i] = get_bits1(&s->gb); | |
745 } | |
746 } else { | |
747 memset(chgroup->transform_band, 1, s->num_bands); | |
748 } | |
749 } | |
750 remaining_channels -= chgroup->num_channels; | |
751 } | |
752 } | |
753 return 0; | |
754 } | |
755 | |
756 /** | |
10097 | 757 *@brief Extract the coefficients from the bitstream. |
758 *@param s codec context | |
759 *@param c current channel number | |
760 *@return 0 on success, < 0 in case of bitstream errors | |
761 */ | |
10122 | 762 static int decode_coeffs(WMAProDecodeCtx *s, int c) |
10097 | 763 { |
10428 | 764 /* Integers 0..15 as single-precision floats. The table saves a |
765 costly int to float conversion, and storing the values as | |
766 integers allows fast sign-flipping. */ | |
767 static const int fval_tab[16] = { | |
768 0x00000000, 0x3f800000, 0x40000000, 0x40400000, | |
769 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000, | |
770 0x41000000, 0x41100000, 0x41200000, 0x41300000, | |
771 0x41400000, 0x41500000, 0x41600000, 0x41700000, | |
772 }; | |
10097 | 773 int vlctable; |
774 VLC* vlc; | |
10122 | 775 WMAProChannelCtx* ci = &s->channel[c]; |
10097 | 776 int rl_mode = 0; |
777 int cur_coeff = 0; | |
778 int num_zeros = 0; | |
779 const uint16_t* run; | |
10314
ab687351bfef
WMA: store level_table as floats, use type punning for sign flip in decode
mru
parents:
10298
diff
changeset
|
780 const float* level; |
10097 | 781 |
782 dprintf(s->avctx, "decode coefficients for channel %i\n", c); | |
783 | |
784 vlctable = get_bits1(&s->gb); | |
785 vlc = &coef_vlc[vlctable]; | |
786 | |
787 if (vlctable) { | |
788 run = coef1_run; | |
789 level = coef1_level; | |
790 } else { | |
791 run = coef0_run; | |
792 level = coef0_level; | |
793 } | |
794 | |
795 /** decode vector coefficients (consumes up to 167 bits per iteration for | |
796 4 vector coded large values) */ | |
797 while (!rl_mode && cur_coeff + 3 < s->subframe_len) { | |
798 int vals[4]; | |
799 int i; | |
800 unsigned int idx; | |
801 | |
802 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH); | |
803 | |
10101 | 804 if (idx == HUFF_VEC4_SIZE - 1) { |
10097 | 805 for (i = 0; i < 4; i += 2) { |
806 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH); | |
10101 | 807 if (idx == HUFF_VEC2_SIZE - 1) { |
10428 | 808 int v0, v1; |
809 v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); | |
810 if (v0 == HUFF_VEC1_SIZE - 1) | |
811 v0 += ff_wma_get_large_val(&s->gb); | |
812 v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); | |
813 if (v1 == HUFF_VEC1_SIZE - 1) | |
814 v1 += ff_wma_get_large_val(&s->gb); | |
815 ((float*)vals)[i ] = v0; | |
816 ((float*)vals)[i+1] = v1; | |
10097 | 817 } else { |
10428 | 818 vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ]; |
819 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF]; | |
10097 | 820 } |
821 } | |
822 } else { | |
10428 | 823 vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ]; |
824 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF]; | |
825 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF]; | |
826 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF]; | |
10097 | 827 } |
828 | |
829 /** decode sign */ | |
830 for (i = 0; i < 4; i++) { | |
831 if (vals[i]) { | |
832 int sign = get_bits1(&s->gb) - 1; | |
10428 | 833 *(uint32_t*)&ci->coeffs[cur_coeff] = vals[i] ^ sign<<31; |
10097 | 834 num_zeros = 0; |
835 } else { | |
10122 | 836 ci->coeffs[cur_coeff] = 0; |
10097 | 837 /** switch to run level mode when subframe_len / 128 zeros |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
838 were found in a row */ |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
839 rl_mode |= (++num_zeros > s->subframe_len >> 8); |
10097 | 840 } |
841 ++cur_coeff; | |
842 } | |
843 } | |
844 | |
845 /** decode run level coded coefficients */ | |
846 if (rl_mode) { | |
10122 | 847 memset(&ci->coeffs[cur_coeff], 0, |
848 sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff)); | |
10101 | 849 if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc, |
850 level, run, 1, ci->coeffs, | |
851 cur_coeff, s->subframe_len, | |
852 s->subframe_len, s->esc_len, 0)) | |
10097 | 853 return AVERROR_INVALIDDATA; |
854 } | |
855 | |
856 return 0; | |
857 } | |
858 | |
859 /** | |
10122 | 860 *@brief Extract scale factors from the bitstream. |
861 *@param s codec context | |
862 *@return 0 on success, < 0 in case of bitstream errors | |
863 */ | |
864 static int decode_scale_factors(WMAProDecodeCtx* s) | |
865 { | |
866 int i; | |
867 | |
868 /** should never consume more than 5344 bits | |
869 * MAX_CHANNELS * (1 + MAX_BANDS * 23) | |
870 */ | |
871 | |
872 for (i = 0; i < s->channels_for_cur_subframe; i++) { | |
873 int c = s->channel_indexes_for_cur_subframe[i]; | |
874 int* sf; | |
10138 | 875 int* sf_end; |
876 s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx]; | |
877 sf_end = s->channel[c].scale_factors + s->num_bands; | |
10122 | 878 |
879 /** resample scale factors for the new block size | |
880 * as the scale factors might need to be resampled several times | |
881 * before some new values are transmitted, a backup of the last | |
882 * transmitted scale factors is kept in saved_scale_factors | |
883 */ | |
884 if (s->channel[c].reuse_sf) { | |
885 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx]; | |
886 int b; | |
887 for (b = 0; b < s->num_bands; b++) | |
888 s->channel[c].scale_factors[b] = | |
10138 | 889 s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++]; |
10122 | 890 } |
891 | |
892 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) { | |
893 | |
894 if (!s->channel[c].reuse_sf) { | |
895 int val; | |
896 /** decode DPCM coded scale factors */ | |
897 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1; | |
898 val = 45 / s->channel[c].scale_factor_step; | |
899 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) { | |
900 val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60; | |
901 *sf = val; | |
902 } | |
903 } else { | |
904 int i; | |
905 /** run level decode differences to the resampled factors */ | |
906 for (i = 0; i < s->num_bands; i++) { | |
907 int idx; | |
908 int skip; | |
909 int val; | |
910 int sign; | |
911 | |
912 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH); | |
913 | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
914 if (!idx) { |
10122 | 915 uint32_t code = get_bits(&s->gb, 14); |
916 val = code >> 6; | |
917 sign = (code & 1) - 1; | |
918 skip = (code & 0x3f) >> 1; | |
919 } else if (idx == 1) { | |
920 break; | |
921 } else { | |
922 skip = scale_rl_run[idx]; | |
923 val = scale_rl_level[idx]; | |
924 sign = get_bits1(&s->gb)-1; | |
925 } | |
926 | |
927 i += skip; | |
928 if (i >= s->num_bands) { | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
929 av_log(s->avctx, AV_LOG_ERROR, |
10122 | 930 "invalid scale factor coding\n"); |
931 return AVERROR_INVALIDDATA; | |
932 } | |
933 s->channel[c].scale_factors[i] += (val ^ sign) - sign; | |
934 } | |
935 } | |
10138 | 936 /** swap buffers */ |
937 s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx; | |
10122 | 938 s->channel[c].table_idx = s->table_idx; |
939 s->channel[c].reuse_sf = 1; | |
940 } | |
941 | |
942 /** calculate new scale factor maximum */ | |
943 s->channel[c].max_scale_factor = s->channel[c].scale_factors[0]; | |
944 for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) { | |
945 s->channel[c].max_scale_factor = | |
946 FFMAX(s->channel[c].max_scale_factor, *sf); | |
947 } | |
948 | |
949 } | |
950 return 0; | |
951 } | |
952 | |
953 /** | |
10005 | 954 *@brief Reconstruct the individual channel data. |
955 *@param s codec context | |
956 */ | |
10122 | 957 static void inverse_channel_transform(WMAProDecodeCtx *s) |
10005 | 958 { |
959 int i; | |
960 | |
10006 | 961 for (i = 0; i < s->num_chgroups; i++) { |
10096
071d6d272a77
merge 2-channel M/S stereo decoding code with the multichannel version
faust3
parents:
10084
diff
changeset
|
962 if (s->chgroup[i].transform) { |
10005 | 963 float data[WMAPRO_MAX_CHANNELS]; |
964 const int num_channels = s->chgroup[i].num_channels; | |
965 float** ch_data = s->chgroup[i].channel_data; | |
966 float** ch_end = ch_data + num_channels; | |
967 const int8_t* tb = s->chgroup[i].transform_band; | |
968 int16_t* sfb; | |
969 | |
970 /** multichannel decorrelation */ | |
10084 | 971 for (sfb = s->cur_sfb_offsets; |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
972 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) { |
10096
071d6d272a77
merge 2-channel M/S stereo decoding code with the multichannel version
faust3
parents:
10084
diff
changeset
|
973 int y; |
10005 | 974 if (*tb++ == 1) { |
975 /** multiply values with the decorrelation_matrix */ | |
10006 | 976 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) { |
10005 | 977 const float* mat = s->chgroup[i].decorrelation_matrix; |
10006 | 978 const float* data_end = data + num_channels; |
979 float* data_ptr = data; | |
10005 | 980 float** ch; |
981 | |
10084 | 982 for (ch = ch_data; ch < ch_end; ch++) |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
983 *data_ptr++ = (*ch)[y]; |
10005 | 984 |
985 for (ch = ch_data; ch < ch_end; ch++) { | |
986 float sum = 0; | |
987 data_ptr = data; | |
988 while (data_ptr < data_end) | |
989 sum += *data_ptr++ * *mat++; | |
990 | |
991 (*ch)[y] = sum; | |
992 } | |
993 } | |
10096
071d6d272a77
merge 2-channel M/S stereo decoding code with the multichannel version
faust3
parents:
10084
diff
changeset
|
994 } else if (s->num_channels == 2) { |
10298
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
995 int len = FFMIN(sfb[1], s->subframe_len) - sfb[0]; |
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
996 s->dsp.vector_fmul_scalar(ch_data[0] + sfb[0], |
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
997 ch_data[0] + sfb[0], |
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
998 181.0 / 128, len); |
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
999 s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0], |
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
1000 ch_data[1] + sfb[0], |
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
1001 181.0 / 128, len); |
10005 | 1002 } |
1003 } | |
1004 } | |
1005 } | |
1006 } | |
1007 | |
10122 | 1008 /** |
1009 *@brief Apply sine window and reconstruct the output buffer. | |
1010 *@param s codec context | |
1011 */ | |
1012 static void wmapro_window(WMAProDecodeCtx *s) | |
1013 { | |
1014 int i; | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1015 for (i = 0; i < s->channels_for_cur_subframe; i++) { |
10122 | 1016 int c = s->channel_indexes_for_cur_subframe[i]; |
1017 float* window; | |
1018 int winlen = s->channel[c].prev_block_len; | |
1019 float* start = s->channel[c].coeffs - (winlen >> 1); | |
1020 | |
1021 if (s->subframe_len < winlen) { | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1022 start += (winlen - s->subframe_len) >> 1; |
10122 | 1023 winlen = s->subframe_len; |
1024 } | |
1025 | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1026 window = s->windows[av_log2(winlen) - BLOCK_MIN_BITS]; |
10122 | 1027 |
1028 winlen >>= 1; | |
1029 | |
1030 s->dsp.vector_fmul_window(start, start, start + winlen, | |
1031 window, 0, winlen); | |
1032 | |
1033 s->channel[c].prev_block_len = s->subframe_len; | |
1034 } | |
1035 } | |
1036 | |
1037 /** | |
1038 *@brief Decode a single subframe (block). | |
1039 *@param s codec context | |
1040 *@return 0 on success, < 0 when decoding failed | |
1041 */ | |
1042 static int decode_subframe(WMAProDecodeCtx *s) | |
1043 { | |
1044 int offset = s->samples_per_frame; | |
1045 int subframe_len = s->samples_per_frame; | |
1046 int i; | |
1047 int total_samples = s->samples_per_frame * s->num_channels; | |
1048 int transmit_coeffs = 0; | |
1049 int cur_subwoofer_cutoff; | |
1050 | |
1051 s->subframe_offset = get_bits_count(&s->gb); | |
1052 | |
1053 /** reset channel context and find the next block offset and size | |
1054 == the next block of the channel with the smallest number of | |
1055 decoded samples | |
1056 */ | |
1057 for (i = 0; i < s->num_channels; i++) { | |
1058 s->channel[i].grouped = 0; | |
1059 if (offset > s->channel[i].decoded_samples) { | |
1060 offset = s->channel[i].decoded_samples; | |
1061 subframe_len = | |
1062 s->channel[i].subframe_len[s->channel[i].cur_subframe]; | |
1063 } | |
1064 } | |
1065 | |
1066 dprintf(s->avctx, | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1067 "processing subframe with offset %i len %i\n", offset, subframe_len); |
10122 | 1068 |
1069 /** get a list of all channels that contain the estimated block */ | |
1070 s->channels_for_cur_subframe = 0; | |
1071 for (i = 0; i < s->num_channels; i++) { | |
1072 const int cur_subframe = s->channel[i].cur_subframe; | |
1073 /** substract already processed samples */ | |
1074 total_samples -= s->channel[i].decoded_samples; | |
1075 | |
1076 /** and count if there are multiple subframes that match our profile */ | |
1077 if (offset == s->channel[i].decoded_samples && | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1078 subframe_len == s->channel[i].subframe_len[cur_subframe]) { |
10122 | 1079 total_samples -= s->channel[i].subframe_len[cur_subframe]; |
1080 s->channel[i].decoded_samples += | |
1081 s->channel[i].subframe_len[cur_subframe]; | |
1082 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i; | |
1083 ++s->channels_for_cur_subframe; | |
1084 } | |
1085 } | |
1086 | |
1087 /** check if the frame will be complete after processing the | |
1088 estimated block */ | |
1089 if (!total_samples) | |
1090 s->parsed_all_subframes = 1; | |
1091 | |
1092 | |
1093 dprintf(s->avctx, "subframe is part of %i channels\n", | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1094 s->channels_for_cur_subframe); |
10122 | 1095 |
1096 /** calculate number of scale factor bands and their offsets */ | |
1097 s->table_idx = av_log2(s->samples_per_frame/subframe_len); | |
1098 s->num_bands = s->num_sfb[s->table_idx]; | |
1099 s->cur_sfb_offsets = s->sfb_offsets[s->table_idx]; | |
1100 cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx]; | |
1101 | |
1102 /** configure the decoder for the current subframe */ | |
1103 for (i = 0; i < s->channels_for_cur_subframe; i++) { | |
1104 int c = s->channel_indexes_for_cur_subframe[i]; | |
1105 | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1106 s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1) |
10122 | 1107 + offset]; |
1108 } | |
1109 | |
1110 s->subframe_len = subframe_len; | |
1111 s->esc_len = av_log2(s->subframe_len - 1) + 1; | |
1112 | |
1113 /** skip extended header if any */ | |
1114 if (get_bits1(&s->gb)) { | |
1115 int num_fill_bits; | |
1116 if (!(num_fill_bits = get_bits(&s->gb, 2))) { | |
1117 int len = get_bits(&s->gb, 4); | |
1118 num_fill_bits = get_bits(&s->gb, len) + 1; | |
1119 } | |
1120 | |
1121 if (num_fill_bits >= 0) { | |
1122 if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) { | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1123 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n"); |
10122 | 1124 return AVERROR_INVALIDDATA; |
1125 } | |
1126 | |
1127 skip_bits_long(&s->gb, num_fill_bits); | |
1128 } | |
1129 } | |
1130 | |
1131 /** no idea for what the following bit is used */ | |
1132 if (get_bits1(&s->gb)) { | |
1133 av_log_ask_for_sample(s->avctx, "reserved bit set\n"); | |
1134 return AVERROR_INVALIDDATA; | |
1135 } | |
1136 | |
1137 | |
1138 if (decode_channel_transform(s) < 0) | |
1139 return AVERROR_INVALIDDATA; | |
1140 | |
1141 | |
1142 for (i = 0; i < s->channels_for_cur_subframe; i++) { | |
1143 int c = s->channel_indexes_for_cur_subframe[i]; | |
1144 if ((s->channel[c].transmit_coefs = get_bits1(&s->gb))) | |
1145 transmit_coeffs = 1; | |
1146 } | |
1147 | |
1148 if (transmit_coeffs) { | |
1149 int step; | |
1150 int quant_step = 90 * s->bits_per_sample >> 4; | |
1151 if ((get_bits1(&s->gb))) { | |
1152 /** FIXME: might change run level mode decision */ | |
1153 av_log_ask_for_sample(s->avctx, "unsupported quant step coding\n"); | |
1154 return AVERROR_INVALIDDATA; | |
1155 } | |
1156 /** decode quantization step */ | |
1157 step = get_sbits(&s->gb, 6); | |
1158 quant_step += step; | |
1159 if (step == -32 || step == 31) { | |
1160 const int sign = (step == 31) - 1; | |
1161 int quant = 0; | |
1162 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits && | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1163 (step = get_bits(&s->gb, 5)) == 31) { |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1164 quant += 31; |
10122 | 1165 } |
1166 quant_step += ((quant + step) ^ sign) - sign; | |
1167 } | |
1168 if (quant_step < 0) { | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1169 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n"); |
10122 | 1170 } |
1171 | |
1172 /** decode quantization step modifiers for every channel */ | |
1173 | |
1174 if (s->channels_for_cur_subframe == 1) { | |
1175 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step; | |
1176 } else { | |
1177 int modifier_len = get_bits(&s->gb, 3); | |
1178 for (i = 0; i < s->channels_for_cur_subframe; i++) { | |
1179 int c = s->channel_indexes_for_cur_subframe[i]; | |
1180 s->channel[c].quant_step = quant_step; | |
1181 if (get_bits1(&s->gb)) { | |
1182 if (modifier_len) { | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1183 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1; |
10122 | 1184 } else |
1185 ++s->channel[c].quant_step; | |
1186 } | |
1187 } | |
1188 } | |
1189 | |
1190 /** decode scale factors */ | |
1191 if (decode_scale_factors(s) < 0) | |
1192 return AVERROR_INVALIDDATA; | |
1193 } | |
1194 | |
1195 dprintf(s->avctx, "BITSTREAM: subframe header length was %i\n", | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1196 get_bits_count(&s->gb) - s->subframe_offset); |
10122 | 1197 |
1198 /** parse coefficients */ | |
1199 for (i = 0; i < s->channels_for_cur_subframe; i++) { | |
1200 int c = s->channel_indexes_for_cur_subframe[i]; | |
1201 if (s->channel[c].transmit_coefs && | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1202 get_bits_count(&s->gb) < s->num_saved_bits) { |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1203 decode_coeffs(s, c); |
10122 | 1204 } else |
1205 memset(s->channel[c].coeffs, 0, | |
1206 sizeof(*s->channel[c].coeffs) * subframe_len); | |
1207 } | |
1208 | |
1209 dprintf(s->avctx, "BITSTREAM: subframe length was %i\n", | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1210 get_bits_count(&s->gb) - s->subframe_offset); |
10122 | 1211 |
1212 if (transmit_coeffs) { | |
1213 /** reconstruct the per channel data */ | |
1214 inverse_channel_transform(s); | |
1215 for (i = 0; i < s->channels_for_cur_subframe; i++) { | |
1216 int c = s->channel_indexes_for_cur_subframe[i]; | |
1217 const int* sf = s->channel[c].scale_factors; | |
1218 int b; | |
1219 | |
1220 if (c == s->lfe_channel) | |
1221 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) * | |
1222 (subframe_len - cur_subwoofer_cutoff)); | |
1223 | |
1224 /** inverse quantization and rescaling */ | |
1225 for (b = 0; b < s->num_bands; b++) { | |
1226 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len); | |
1227 const int exp = s->channel[c].quant_step - | |
1228 (s->channel[c].max_scale_factor - *sf++) * | |
1229 s->channel[c].scale_factor_step; | |
1230 const float quant = pow(10.0, exp / 20.0); | |
10298
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
1231 int start = s->cur_sfb_offsets[b]; |
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
1232 s->dsp.vector_fmul_scalar(s->tmp + start, |
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
1233 s->channel[c].coeffs + start, |
9699e4499f2d
WMAPRO: use vector_fmul_scalar from dsputil where possible
mru
parents:
10199
diff
changeset
|
1234 quant, end - start); |
10122 | 1235 } |
1236 | |
1237 /** apply imdct (ff_imdct_half == DCTIV with reverse) */ | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1238 ff_imdct_half(&s->mdct_ctx[av_log2(subframe_len) - BLOCK_MIN_BITS], |
10122 | 1239 s->channel[c].coeffs, s->tmp); |
1240 } | |
1241 } | |
1242 | |
1243 /** window and overlapp-add */ | |
1244 wmapro_window(s); | |
1245 | |
1246 /** handled one subframe */ | |
1247 for (i = 0; i < s->channels_for_cur_subframe; i++) { | |
1248 int c = s->channel_indexes_for_cur_subframe[i]; | |
1249 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) { | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1250 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n"); |
10122 | 1251 return AVERROR_INVALIDDATA; |
1252 } | |
1253 ++s->channel[c].cur_subframe; | |
1254 } | |
1255 | |
1256 return 0; | |
1257 } | |
1258 | |
1259 /** | |
1260 *@brief Decode one WMA frame. | |
1261 *@param s codec context | |
1262 *@return 0 if the trailer bit indicates that this is the last frame, | |
1263 * 1 if there are additional frames | |
1264 */ | |
1265 static int decode_frame(WMAProDecodeCtx *s) | |
1266 { | |
1267 GetBitContext* gb = &s->gb; | |
1268 int more_frames = 0; | |
1269 int len = 0; | |
1270 int i; | |
1271 | |
1272 /** check for potential output buffer overflow */ | |
1273 if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) { | |
10127 | 1274 /** return an error if no frame could be decoded at all */ |
10139
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1275 av_log(s->avctx, AV_LOG_ERROR, |
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1276 "not enough space for the output samples\n"); |
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1277 s->packet_loss = 1; |
10122 | 1278 return 0; |
1279 } | |
1280 | |
1281 /** get frame length */ | |
1282 if (s->len_prefix) | |
1283 len = get_bits(gb, s->log2_frame_size); | |
1284 | |
1285 dprintf(s->avctx, "decoding frame with length %x\n", len); | |
1286 | |
1287 /** decode tile information */ | |
1288 if (decode_tilehdr(s)) { | |
1289 s->packet_loss = 1; | |
1290 return 0; | |
1291 } | |
1292 | |
1293 /** read postproc transform */ | |
1294 if (s->num_channels > 1 && get_bits1(gb)) { | |
1295 av_log_ask_for_sample(s->avctx, "Unsupported postproc transform found\n"); | |
1296 s->packet_loss = 1; | |
1297 return 0; | |
1298 } | |
1299 | |
1300 /** read drc info */ | |
1301 if (s->dynamic_range_compression) { | |
1302 s->drc_gain = get_bits(gb, 8); | |
1303 dprintf(s->avctx, "drc_gain %i\n", s->drc_gain); | |
1304 } | |
1305 | |
1306 /** no idea what these are for, might be the number of samples | |
1307 that need to be skipped at the beginning or end of a stream */ | |
1308 if (get_bits1(gb)) { | |
1309 int skip; | |
1310 | |
1311 /** usually true for the first frame */ | |
1312 if (get_bits1(gb)) { | |
1313 skip = get_bits(gb, av_log2(s->samples_per_frame * 2)); | |
1314 dprintf(s->avctx, "start skip: %i\n", skip); | |
1315 } | |
1316 | |
1317 /** sometimes true for the last frame */ | |
1318 if (get_bits1(gb)) { | |
1319 skip = get_bits(gb, av_log2(s->samples_per_frame * 2)); | |
1320 dprintf(s->avctx, "end skip: %i\n", skip); | |
1321 } | |
1322 | |
1323 } | |
1324 | |
1325 dprintf(s->avctx, "BITSTREAM: frame header length was %i\n", | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1326 get_bits_count(gb) - s->frame_offset); |
10122 | 1327 |
1328 /** reset subframe states */ | |
1329 s->parsed_all_subframes = 0; | |
1330 for (i = 0; i < s->num_channels; i++) { | |
1331 s->channel[i].decoded_samples = 0; | |
1332 s->channel[i].cur_subframe = 0; | |
1333 s->channel[i].reuse_sf = 0; | |
1334 } | |
1335 | |
1336 /** decode all subframes */ | |
1337 while (!s->parsed_all_subframes) { | |
1338 if (decode_subframe(s) < 0) { | |
1339 s->packet_loss = 1; | |
1340 return 0; | |
1341 } | |
1342 } | |
1343 | |
1344 /** interleave samples and write them to the output buffer */ | |
1345 for (i = 0; i < s->num_channels; i++) { | |
1346 float* ptr; | |
1347 int incr = s->num_channels; | |
1348 float* iptr = s->channel[i].out; | |
1349 int x; | |
1350 | |
1351 ptr = s->samples + i; | |
1352 | |
1353 for (x = 0; x < s->samples_per_frame; x++) { | |
1354 *ptr = av_clipf(*iptr++, -1.0, 32767.0 / 32768.0); | |
1355 ptr += incr; | |
1356 } | |
1357 | |
1358 /** reuse second half of the IMDCT output for the next frame */ | |
1359 memcpy(&s->channel[i].out[0], | |
1360 &s->channel[i].out[s->samples_per_frame], | |
1361 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1); | |
1362 } | |
1363 | |
1364 if (s->skip_frame) { | |
1365 s->skip_frame = 0; | |
1366 } else | |
1367 s->samples += s->num_channels * s->samples_per_frame; | |
1368 | |
1369 if (len != (get_bits_count(gb) - s->frame_offset) + 2) { | |
1370 /** FIXME: not sure if this is always an error */ | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1371 av_log(s->avctx, AV_LOG_ERROR, "frame[%i] would have to skip %i bits\n", |
10122 | 1372 s->frame_num, len - (get_bits_count(gb) - s->frame_offset) - 1); |
1373 s->packet_loss = 1; | |
1374 return 0; | |
1375 } | |
1376 | |
1377 /** skip the rest of the frame data */ | |
1378 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1); | |
1379 | |
1380 /** decode trailer bit */ | |
1381 more_frames = get_bits1(gb); | |
1382 | |
1383 ++s->frame_num; | |
1384 return more_frames; | |
1385 } | |
1386 | |
1387 /** | |
1388 *@brief Calculate remaining input buffer length. | |
1389 *@param s codec context | |
1390 *@param gb bitstream reader context | |
1391 *@return remaining size in bits | |
1392 */ | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1393 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb) |
10122 | 1394 { |
1395 return s->buf_bit_size - get_bits_count(gb); | |
1396 } | |
1397 | |
1398 /** | |
1399 *@brief Fill the bit reservoir with a (partial) frame. | |
1400 *@param s codec context | |
1401 *@param gb bitstream reader context | |
1402 *@param len length of the partial frame | |
1403 *@param append decides wether to reset the buffer or not | |
1404 */ | |
1405 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len, | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1406 int append) |
10122 | 1407 { |
1408 int buflen; | |
1409 | |
1410 /** when the frame data does not need to be concatenated, the input buffer | |
1411 is resetted and additional bits from the previous frame are copyed | |
1412 and skipped later so that a fast byte copy is possible */ | |
1413 | |
1414 if (!append) { | |
1415 s->frame_offset = get_bits_count(gb) & 7; | |
1416 s->num_saved_bits = s->frame_offset; | |
1417 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE); | |
1418 } | |
1419 | |
1420 buflen = (s->num_saved_bits + len + 8) >> 3; | |
1421 | |
1422 if (len <= 0 || buflen > MAX_FRAMESIZE) { | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1423 av_log_ask_for_sample(s->avctx, "input buffer too small\n"); |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1424 s->packet_loss = 1; |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1425 return; |
10122 | 1426 } |
1427 | |
1428 s->num_saved_bits += len; | |
1429 if (!append) { | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1430 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1431 s->num_saved_bits); |
10122 | 1432 } else { |
1433 int align = 8 - (get_bits_count(gb) & 7); | |
1434 align = FFMIN(align, len); | |
1435 put_bits(&s->pb, align, get_bits(gb, align)); | |
1436 len -= align; | |
1437 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len); | |
1438 } | |
1439 skip_bits_long(gb, len); | |
1440 | |
1441 { | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1442 PutBitContext tmp = s->pb; |
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1443 flush_put_bits(&tmp); |
10122 | 1444 } |
1445 | |
1446 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits); | |
1447 skip_bits(&s->gb, s->frame_offset); | |
1448 } | |
1449 | |
1450 /** | |
1451 *@brief Decode a single WMA packet. | |
1452 *@param avctx codec context | |
1453 *@param data the output buffer | |
1454 *@param data_size number of bytes that were written to the output buffer | |
1455 *@param avpkt input packet | |
1456 *@return number of bytes that were read from the input buffer | |
1457 */ | |
1458 static int decode_packet(AVCodecContext *avctx, | |
10123
e1bd75a1eab2
cosmetics: indentation and other prettyprinting fixes
diego
parents:
10122
diff
changeset
|
1459 void *data, int *data_size, AVPacket* avpkt) |
10122 | 1460 { |
1461 WMAProDecodeCtx *s = avctx->priv_data; | |
10129 | 1462 GetBitContext* gb = &s->pgb; |
1463 const uint8_t* buf = avpkt->data; | |
1464 int buf_size = avpkt->size; | |
10122 | 1465 int num_bits_prev_frame; |
1466 int packet_sequence_number; | |
1467 | |
10129 | 1468 s->samples = data; |
1469 s->samples_end = (float*)((int8_t*)data + *data_size); | |
10127 | 1470 *data_size = 0; |
10122 | 1471 |
10139
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1472 if (s->packet_done || s->packet_loss) { |
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1473 s->packet_done = 0; |
10129 | 1474 s->buf_bit_size = buf_size << 3; |
10122 | 1475 |
10129 | 1476 /** sanity check for the buffer length */ |
1477 if (buf_size < avctx->block_align) | |
1478 return 0; | |
10122 | 1479 |
10129 | 1480 buf_size = avctx->block_align; |
10122 | 1481 |
10129 | 1482 /** parse packet header */ |
1483 init_get_bits(gb, buf, s->buf_bit_size); | |
1484 packet_sequence_number = get_bits(gb, 4); | |
1485 skip_bits(gb, 2); | |
10122 | 1486 |
10129 | 1487 /** get number of bits that need to be added to the previous frame */ |
1488 num_bits_prev_frame = get_bits(gb, s->log2_frame_size); | |
1489 dprintf(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number, | |
1490 num_bits_prev_frame); | |
10122 | 1491 |
10129 | 1492 /** check for packet loss */ |
1493 if (!s->packet_loss && | |
1494 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) { | |
1495 s->packet_loss = 1; | |
1496 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n", | |
1497 s->packet_sequence_number, packet_sequence_number); | |
1498 } | |
1499 s->packet_sequence_number = packet_sequence_number; | |
10122 | 1500 |
10129 | 1501 if (num_bits_prev_frame > 0) { |
1502 /** append the previous frame data to the remaining data from the | |
1503 previous packet to create a full frame */ | |
1504 save_bits(s, gb, num_bits_prev_frame, 1); | |
1505 dprintf(avctx, "accumulated %x bits of frame data\n", | |
1506 s->num_saved_bits - s->frame_offset); | |
10122 | 1507 |
10129 | 1508 /** decode the cross packet frame if it is valid */ |
1509 if (!s->packet_loss) | |
1510 decode_frame(s); | |
1511 } else if (s->num_saved_bits - s->frame_offset) { | |
1512 dprintf(avctx, "ignoring %x previously saved bits\n", | |
1513 s->num_saved_bits - s->frame_offset); | |
1514 } | |
10122 | 1515 |
10129 | 1516 s->packet_loss = 0; |
10127 | 1517 |
1518 } else { | |
10139
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1519 int frame_size; |
10165 | 1520 s->buf_bit_size = avpkt->size << 3; |
1521 init_get_bits(gb, avpkt->data, s->buf_bit_size); | |
1522 skip_bits(gb, s->packet_offset); | |
10139
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1523 if (remaining_bits(s, gb) > s->log2_frame_size && |
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1524 (frame_size = show_bits(gb, s->log2_frame_size)) && |
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1525 frame_size <= remaining_bits(s, gb)) { |
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1526 save_bits(s, gb, frame_size, 0); |
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1527 s->packet_done = !decode_frame(s); |
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1528 } else |
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1529 s->packet_done = 1; |
10127 | 1530 } |
1531 | |
10139
de9335d4b6b1
do not decode more than one audio frame in a decode packet call
faust3
parents:
10138
diff
changeset
|
1532 if (s->packet_done && !s->packet_loss && |
10127 | 1533 remaining_bits(s, gb) > 0) { |
10122 | 1534 /** save the rest of the data so that it can be decoded |
1535 with the next packet */ | |
10126 | 1536 save_bits(s, gb, remaining_bits(s, gb), 0); |
10122 | 1537 } |
1538 | |
1539 *data_size = (int8_t *)s->samples - (int8_t *)data; | |
10165 | 1540 s->packet_offset = get_bits_count(gb) & 7; |
10122 | 1541 |
10352
8eb51d3eccdf
return AVERROR_INVALIDDATA when the bitstream could not be decoded
faust3
parents:
10314
diff
changeset
|
1542 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3; |
10122 | 1543 } |
1544 | |
1545 /** | |
1546 *@brief Clear decoder buffers (for seeking). | |
1547 *@param avctx codec context | |
1548 */ | |
1549 static void flush(AVCodecContext *avctx) | |
1550 { | |
1551 WMAProDecodeCtx *s = avctx->priv_data; | |
1552 int i; | |
1553 /** reset output buffer as a part of it is used during the windowing of a | |
1554 new frame */ | |
1555 for (i = 0; i < s->num_channels; i++) | |
1556 memset(s->channel[i].out, 0, s->samples_per_frame * | |
1557 sizeof(*s->channel[i].out)); | |
1558 s->packet_loss = 1; | |
1559 } | |
1560 | |
1561 | |
1562 /** | |
1563 *@brief wmapro decoder | |
1564 */ | |
1565 AVCodec wmapro_decoder = { | |
1566 "wmapro", | |
1567 CODEC_TYPE_AUDIO, | |
1568 CODEC_ID_WMAPRO, | |
1569 sizeof(WMAProDecodeCtx), | |
1570 decode_init, | |
1571 NULL, | |
1572 decode_end, | |
1573 decode_packet, | |
10180
a514a601bf26
Add CODEC_CAP_SUBFRAMES for codecs that output multiple subframes
faust3
parents:
10174
diff
changeset
|
1574 .capabilities = CODEC_CAP_SUBFRAMES, |
10122 | 1575 .flush= flush, |
1576 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"), | |
1577 }; |