FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/wmaprodec.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 613 923 66.4%
Branches: 351 618 56.8%

Line Branch Exec Source
1 /*
2 * Wmapro compatible decoder
3 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4 * Copyright (c) 2008 - 2011 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
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
89 #include <inttypes.h>
90
91 #include "libavutil/audio_fifo.h"
92 #include "libavutil/ffmath.h"
93 #include "libavutil/float_dsp.h"
94 #include "libavutil/intfloat.h"
95 #include "libavutil/intreadwrite.h"
96 #include "libavutil/mem_internal.h"
97 #include "libavutil/thread.h"
98
99 #include "avcodec.h"
100 #include "internal.h"
101 #include "get_bits.h"
102 #include "put_bits.h"
103 #include "wmaprodata.h"
104 #include "sinewin.h"
105 #include "wma.h"
106 #include "wma_common.h"
107
108 /** current decoder limitations */
109 #define WMAPRO_MAX_CHANNELS 8 ///< max number of handled channels
110 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
111 #define MAX_BANDS 29 ///< max number of scale factor bands
112 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
113 #define XMA_MAX_STREAMS 8
114 #define XMA_MAX_CHANNELS_STREAM 2
115 #define XMA_MAX_CHANNELS (XMA_MAX_STREAMS * XMA_MAX_CHANNELS_STREAM)
116
117 #define WMAPRO_BLOCK_MIN_BITS 6 ///< log2 of min block size
118 #define WMAPRO_BLOCK_MAX_BITS 13 ///< log2 of max block size
119 #define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS) ///< minimum block size
120 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS) ///< maximum block size
121 #define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
122
123
124 #define VLCBITS 9
125 #define SCALEVLCBITS 8
126 #define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
127 #define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
128 #define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
129 #define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
130 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
131
132 static VLC sf_vlc; ///< scale factor DPCM vlc
133 static VLC sf_rl_vlc; ///< scale factor run length vlc
134 static VLC vec4_vlc; ///< 4 coefficients per symbol
135 static VLC vec2_vlc; ///< 2 coefficients per symbol
136 static VLC vec1_vlc; ///< 1 coefficient per symbol
137 static VLC coef_vlc[2]; ///< coefficient run length vlc codes
138 static float sin64[33]; ///< sine table for decorrelation
139
140 /**
141 * @brief frame specific decoder context for a single channel
142 */
143 typedef struct WMAProChannelCtx {
144 int16_t prev_block_len; ///< length of the previous block
145 uint8_t transmit_coefs;
146 uint8_t num_subframes;
147 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
148 uint16_t subframe_offset[MAX_SUBFRAMES]; ///< subframe positions in the current frame
149 uint8_t cur_subframe; ///< current subframe number
150 uint16_t decoded_samples; ///< number of already processed samples
151 uint8_t grouped; ///< channel is part of a group
152 int quant_step; ///< quantization step for the current subframe
153 int8_t reuse_sf; ///< share scale factors between subframes
154 int8_t scale_factor_step; ///< scaling step for the current subframe
155 int max_scale_factor; ///< maximum scale factor for the current subframe
156 int saved_scale_factors[2][MAX_BANDS]; ///< resampled and (previously) transmitted scale factor values
157 int8_t scale_factor_idx; ///< index for the transmitted scale factor values (used for resampling)
158 int* scale_factors; ///< pointer to the scale factor values used for decoding
159 uint8_t table_idx; ///< index in sf_offsets for the scale factor reference block
160 float* coeffs; ///< pointer to the subframe decode buffer
161 uint16_t num_vec_coeffs; ///< number of vector coded coefficients
162 DECLARE_ALIGNED(32, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; ///< output buffer
163 } WMAProChannelCtx;
164
165 /**
166 * @brief channel group for channel transformations
167 */
168 typedef struct WMAProChannelGrp {
169 uint8_t num_channels; ///< number of channels in the group
170 int8_t transform; ///< transform on / off
171 int8_t transform_band[MAX_BANDS]; ///< controls if the transform is enabled for a certain band
172 float decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
173 float* channel_data[WMAPRO_MAX_CHANNELS]; ///< transformation coefficients
174 } WMAProChannelGrp;
175
176 /**
177 * @brief main decoder context
178 */
179 typedef struct WMAProDecodeCtx {
180 /* generic decoder variables */
181 AVCodecContext* avctx; ///< codec context for av_log
182 AVFloatDSPContext *fdsp;
183 uint8_t frame_data[MAX_FRAMESIZE +
184 AV_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
185 PutBitContext pb; ///< context for filling the frame_data buffer
186 FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size
187 DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer
188 const float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes
189
190 /* frame size dependent frame information (set during initialization) */
191 uint32_t decode_flags; ///< used compression features
192 uint8_t len_prefix; ///< frame is prefixed with its length
193 uint8_t dynamic_range_compression; ///< frame contains DRC data
194 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
195 uint16_t samples_per_frame; ///< number of samples to output
196 uint16_t trim_start; ///< number of samples to skip at start
197 uint16_t trim_end; ///< number of samples to skip at end
198 uint16_t log2_frame_size;
199 int8_t lfe_channel; ///< lfe channel index
200 uint8_t max_num_subframes;
201 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
202 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
203 uint16_t min_samples_per_subframe;
204 int8_t num_sfb[WMAPRO_BLOCK_SIZES]; ///< scale factor bands per block size
205 int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor band offsets (multiples of 4)
206 int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; ///< scale factor resample matrix
207 int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
208
209 /* packet decode state */
210 GetBitContext pgb; ///< bitstream reader context for the packet
211 int next_packet_start; ///< start offset of the next wma packet in the demuxer packet
212 uint8_t packet_offset; ///< frame offset in the packet
213 uint8_t packet_sequence_number; ///< current packet number
214 int num_saved_bits; ///< saved number of bits
215 int frame_offset; ///< frame offset in the bit reservoir
216 int subframe_offset; ///< subframe offset in the bit reservoir
217 uint8_t packet_loss; ///< set in case of bitstream error
218 uint8_t packet_done; ///< set when a packet is fully decoded
219 uint8_t eof_done; ///< set when EOF reached and extra subframe is written (XMA1/2)
220
221 /* frame decode state */
222 uint32_t frame_num; ///< current frame number (not used for decoding)
223 GetBitContext gb; ///< bitstream reader context
224 int buf_bit_size; ///< buffer size in bits
225 uint8_t drc_gain; ///< gain for the DRC tool
226 int8_t skip_frame; ///< skip output step
227 int8_t parsed_all_subframes; ///< all subframes decoded?
228 uint8_t skip_packets; ///< packets to skip to find next packet in a stream (XMA1/2)
229
230 /* subframe/block decode state */
231 int16_t subframe_len; ///< current subframe length
232 int8_t nb_channels; ///< number of channels in stream (XMA1/2)
233 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
234 int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
235 int8_t num_bands; ///< number of scale factor bands
236 int8_t transmit_num_vec_coeffs; ///< number of vector coded coefficients is part of the bitstream
237 int16_t* cur_sfb_offsets; ///< sfb offsets for the current block
238 uint8_t table_idx; ///< index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
239 int8_t esc_len; ///< length of escaped coefficients
240
241 uint8_t num_chgroups; ///< number of channel groups
242 WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]; ///< channel group information
243
244 WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data
245 } WMAProDecodeCtx;
246
247 typedef struct XMADecodeCtx {
248 WMAProDecodeCtx xma[XMA_MAX_STREAMS];
249 AVFrame *frames[XMA_MAX_STREAMS];
250 int current_stream;
251 int num_streams;
252 AVAudioFifo *samples[2][XMA_MAX_STREAMS];
253 int start_channel[XMA_MAX_STREAMS];
254 int trim_start, trim_end;
255 int flushed;
256 } XMADecodeCtx;
257
258 /**
259 *@brief helper function to print the most important members of the context
260 *@param s context
261 */
262 static av_cold void dump_context(WMAProDecodeCtx *s)
263 {
264 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
265 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %"PRIx32"\n", a, b);
266
267 PRINT("ed sample bit depth", s->bits_per_sample);
268 PRINT_HEX("ed decode flags", s->decode_flags);
269 PRINT("samples per frame", s->samples_per_frame);
270 PRINT("log2 frame size", s->log2_frame_size);
271 PRINT("max num subframes", s->max_num_subframes);
272 PRINT("len prefix", s->len_prefix);
273 PRINT("num channels", s->nb_channels);
274 }
275
276 /**
277 *@brief Uninitialize the decoder and free all resources.
278 *@param avctx codec context
279 *@return 0 on success, < 0 otherwise
280 */
281 8 static av_cold int decode_end(WMAProDecodeCtx *s)
282 {
283 int i;
284
285 8 av_freep(&s->fdsp);
286
287
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 8 times.
72 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
288 64 ff_mdct_end(&s->mdct_ctx[i]);
289
290 8 return 0;
291 }
292
293 8 static av_cold int wmapro_decode_end(AVCodecContext *avctx)
294 {
295 8 WMAProDecodeCtx *s = avctx->priv_data;
296
297 8 decode_end(s);
298
299 8 return 0;
300 }
301
302 40 static av_cold int get_rate(AVCodecContext *avctx)
303 {
304
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
40 if (avctx->codec_id != AV_CODEC_ID_WMAPRO) { // XXX: is this really only for XMA?
305 if (avctx->sample_rate > 44100)
306 return 48000;
307 else if (avctx->sample_rate > 32000)
308 return 44100;
309 else if (avctx->sample_rate > 24000)
310 return 32000;
311 return 24000;
312 }
313
314 40 return avctx->sample_rate;
315 }
316
317 5 static av_cold void decode_init_static(void)
318 {
319 5 INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
320 scale_huffbits, 1, 1,
321 scale_huffcodes, 2, 2, 616);
322 5 INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
323 scale_rl_huffbits, 1, 1,
324 scale_rl_huffcodes, 4, 4, 1406);
325 5 INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
326 coef0_huffbits, 1, 1,
327 coef0_huffcodes, 4, 4, 2108);
328 5 INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
329 coef1_huffbits, 1, 1,
330 coef1_huffcodes, 4, 4, 3912);
331 5 INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
332 vec4_huffbits, 1, 1,
333 vec4_huffcodes, 2, 2, 604);
334 5 INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
335 vec2_huffbits, 1, 1,
336 vec2_huffcodes, 2, 2, 562);
337 5 INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
338 vec1_huffbits, 1, 1,
339 vec1_huffcodes, 2, 2, 562);
340
341 /** calculate sine values for the decorrelation matrix */
342
2/2
✓ Branch 0 taken 165 times.
✓ Branch 1 taken 5 times.
170 for (int i = 0; i < 33; i++)
343 165 sin64[i] = sin(i * M_PI / 64.0);
344
345
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 5 times.
45 for (int i = WMAPRO_BLOCK_MIN_BITS; i <= WMAPRO_BLOCK_MAX_BITS; i++)
346 40 ff_init_ff_sine_windows(i);
347 5 }
348
349 /**
350 *@brief Initialize the decoder.
351 *@param avctx codec context
352 *@return 0 on success, -1 otherwise
353 */
354 8 static av_cold int decode_init(WMAProDecodeCtx *s, AVCodecContext *avctx, int num_stream)
355 {
356 static AVOnce init_static_once = AV_ONCE_INIT;
357 8 uint8_t *edata_ptr = avctx->extradata;
358 unsigned int channel_mask;
359 int i, bits, ret;
360 int log2_max_num_subframes;
361 int num_possible_block_sizes;
362
363
2/4
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
8 if (avctx->codec_id == AV_CODEC_ID_XMA1 || avctx->codec_id == AV_CODEC_ID_XMA2)
364 avctx->block_align = 2048;
365
366
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (!avctx->block_align) {
367 av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
368 return AVERROR(EINVAL);
369 }
370
371 8 s->avctx = avctx;
372
373 8 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
374
375 8 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
376
377 /** dump the extradata */
378 8 av_log(avctx, AV_LOG_DEBUG, "extradata:\n");
379
2/2
✓ Branch 0 taken 144 times.
✓ Branch 1 taken 8 times.
152 for (i = 0; i < avctx->extradata_size; i++)
380 144 av_log(avctx, AV_LOG_DEBUG, "[%x] ", avctx->extradata[i]);
381 8 av_log(avctx, AV_LOG_DEBUG, "\n");
382
383
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
8 if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size == 34) { /* XMA2WAVEFORMATEX */
384 s->decode_flags = 0x10d6;
385 s->bits_per_sample = 16;
386 channel_mask = 0; //AV_RL32(edata_ptr+2); /* not always in expected order */
387 if ((num_stream+1) * XMA_MAX_CHANNELS_STREAM > avctx->channels) /* stream config is 2ch + 2ch + ... + 1/2ch */
388 s->nb_channels = 1;
389 else
390 s->nb_channels = 2;
391
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 } else if (avctx->codec_id == AV_CODEC_ID_XMA2) { /* XMA2WAVEFORMAT */
392 s->decode_flags = 0x10d6;
393 s->bits_per_sample = 16;
394 channel_mask = 0; /* would need to aggregate from all streams */
395 s->nb_channels = edata_ptr[32 + ((edata_ptr[0]==3)?0:8) + 4*num_stream + 0]; /* nth stream config */
396
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 } else if (avctx->codec_id == AV_CODEC_ID_XMA1) { /* XMAWAVEFORMAT */
397 s->decode_flags = 0x10d6;
398 s->bits_per_sample = 16;
399 channel_mask = 0; /* would need to aggregate from all streams */
400 s->nb_channels = edata_ptr[8 + 20*num_stream + 17]; /* nth stream config */
401
2/4
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
8 } else if (avctx->codec_id == AV_CODEC_ID_WMAPRO && avctx->extradata_size >= 18) {
402 8 s->decode_flags = AV_RL16(edata_ptr+14);
403 8 channel_mask = AV_RL32(edata_ptr+2);
404 8 s->bits_per_sample = AV_RL16(edata_ptr);
405 8 s->nb_channels = avctx->channels;
406
407
2/4
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
8 if (s->bits_per_sample > 32 || s->bits_per_sample < 1) {
408 avpriv_request_sample(avctx, "bits per sample is %d", s->bits_per_sample);
409 return AVERROR_PATCHWELCOME;
410 }
411 } else {
412 avpriv_request_sample(avctx, "Unknown extradata size");
413 return AVERROR_PATCHWELCOME;
414 }
415
416 /** generic init */
417 8 s->log2_frame_size = av_log2(avctx->block_align) + 4;
418
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (s->log2_frame_size > 25) {
419 avpriv_request_sample(avctx, "Large block align");
420 return AVERROR_PATCHWELCOME;
421 }
422
423 /** frame info */
424 8 s->skip_frame = 1; /* skip first frame */
425
426 8 s->packet_loss = 1;
427 8 s->len_prefix = (s->decode_flags & 0x40);
428
429 /** get frame len */
430
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
8 if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
431 8 bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (bits > WMAPRO_BLOCK_MAX_BITS) {
433 avpriv_request_sample(avctx, "14-bit block sizes");
434 return AVERROR_PATCHWELCOME;
435 }
436 8 s->samples_per_frame = 1 << bits;
437 } else {
438 s->samples_per_frame = 512;
439 }
440
441 /** subframe info */
442 8 log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3);
443 8 s->max_num_subframes = 1 << log2_max_num_subframes;
444
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
8 if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
445 8 s->max_subframe_len_bit = 1;
446 8 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
447
448 8 num_possible_block_sizes = log2_max_num_subframes + 1;
449 8 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
450 8 s->dynamic_range_compression = (s->decode_flags & 0x80);
451
452
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (s->max_num_subframes > MAX_SUBFRAMES) {
453 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRId8"\n",
454 s->max_num_subframes);
455 return AVERROR_INVALIDDATA;
456 }
457
458
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (s->min_samples_per_subframe < WMAPRO_BLOCK_MIN_SIZE) {
459 av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
460 s->min_samples_per_subframe);
461 return AVERROR_INVALIDDATA;
462 }
463
464
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (s->avctx->sample_rate <= 0) {
465 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
466 return AVERROR_INVALIDDATA;
467 }
468
469
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (s->nb_channels <= 0) {
470 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
471 s->nb_channels);
472 return AVERROR_INVALIDDATA;
473
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
8 } else if (avctx->codec_id != AV_CODEC_ID_WMAPRO && s->nb_channels > XMA_MAX_CHANNELS_STREAM) {
474 av_log(avctx, AV_LOG_ERROR, "invalid number of channels per XMA stream %d\n",
475 s->nb_channels);
476 return AVERROR_INVALIDDATA;
477
2/4
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
8 } else if (s->nb_channels > WMAPRO_MAX_CHANNELS || s->nb_channels > avctx->channels) {
478 avpriv_request_sample(avctx,
479 "More than %d channels", WMAPRO_MAX_CHANNELS);
480 return AVERROR_PATCHWELCOME;
481 }
482
483 /** init previous block len */
484
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 8 times.
32 for (i = 0; i < s->nb_channels; i++)
485 24 s->channel[i].prev_block_len = s->samples_per_frame;
486
487 /** extract lfe channel position */
488 8 s->lfe_channel = -1;
489
490
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 6 times.
8 if (channel_mask & 8) {
491 unsigned int mask;
492
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
10 for (mask = 1; mask < 16; mask <<= 1) {
493
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
8 if (channel_mask & mask)
494 8 ++s->lfe_channel;
495 }
496 }
497
498 /** calculate number of scale factor bands and their offsets
499 for every possible block size */
500
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 8 times.
48 for (i = 0; i < num_possible_block_sizes; i++) {
501 40 int subframe_len = s->samples_per_frame >> i;
502 int x;
503 40 int band = 1;
504 40 int rate = get_rate(avctx);
505
506 40 s->sfb_offsets[i][0] = 0;
507
508
2/4
✓ Branch 0 taken 1040 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1040 times.
✗ Branch 3 not taken.
1040 for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
509 1040 int offset = (subframe_len * 2 * critical_freq[x]) / rate + 2;
510 1040 offset &= ~3;
511
2/2
✓ Branch 0 taken 860 times.
✓ Branch 1 taken 180 times.
1040 if (offset > s->sfb_offsets[i][band - 1])
512 860 s->sfb_offsets[i][band++] = offset;
513
514
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 1000 times.
1040 if (offset >= subframe_len)
515 40 break;
516 }
517 40 s->sfb_offsets[i][band - 1] = subframe_len;
518 40 s->num_sfb[i] = band - 1;
519
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
40 if (s->num_sfb[i] <= 0) {
520 av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
521 return AVERROR_INVALIDDATA;
522 }
523 }
524
525
526 /** Scale factors can be shared between blocks of different size
527 as every block has a different scale factor band layout.
528 The matrix sf_offsets is needed to find the correct scale factor.
529 */
530
531
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 8 times.
48 for (i = 0; i < num_possible_block_sizes; i++) {
532 int b;
533
2/2
✓ Branch 0 taken 860 times.
✓ Branch 1 taken 40 times.
900 for (b = 0; b < s->num_sfb[i]; b++) {
534 int x;
535 860 int offset = ((s->sfb_offsets[i][b]
536 860 + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
537
2/2
✓ Branch 0 taken 4300 times.
✓ Branch 1 taken 860 times.
5160 for (x = 0; x < num_possible_block_sizes; x++) {
538 4300 int v = 0;
539
2/2
✓ Branch 0 taken 43876 times.
✓ Branch 1 taken 4300 times.
48176 while (s->sfb_offsets[x][v + 1] << x < offset) {
540 43876 v++;
541
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 43876 times.
43876 av_assert0(v < MAX_BANDS);
542 }
543 4300 s->sf_offsets[i][x][b] = v;
544 }
545 }
546 }
547
548 8 s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
549
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (!s->fdsp)
550 return AVERROR(ENOMEM);
551
552 /** init MDCT, FIXME: only init needed sizes */
553
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 8 times.
72 for (int i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
554 64 ret = ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS + 1 + i, 1,
555 64 1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
556 64 / (1ll << (s->bits_per_sample - 1)));
557
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 64 times.
64 if (ret < 0)
558 return ret;
559 }
560
561 /** init MDCT windows: simple sine window */
562
2/2
✓ Branch 0 taken 64 times.
✓ Branch 1 taken 8 times.
72 for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
563 64 const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
564 64 s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
565 }
566
567 /** calculate subwoofer cutoff values */
568
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 8 times.
48 for (i = 0; i < num_possible_block_sizes; i++) {
569 40 int block_size = s->samples_per_frame >> i;
570 40 int cutoff = (440*block_size + 3LL * (s->avctx->sample_rate >> 1) - 1)
571 40 / s->avctx->sample_rate;
572 40 s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
573 }
574
575
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 if (avctx->debug & FF_DEBUG_BITSTREAM)
576 dump_context(s);
577
578
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
8 if (avctx->codec_id == AV_CODEC_ID_WMAPRO)
579 8 avctx->channel_layout = channel_mask;
580
581 8 ff_thread_once(&init_static_once, decode_init_static);
582
583 8 return 0;
584 }
585
586 /**
587 *@brief Initialize the decoder.
588 *@param avctx codec context
589 *@return 0 on success, -1 otherwise
590 */
591 8 static av_cold int wmapro_decode_init(AVCodecContext *avctx)
592 {
593 8 WMAProDecodeCtx *s = avctx->priv_data;
594
595 8 return decode_init(s, avctx, 0);
596 }
597
598 /**
599 *@brief Decode the subframe length.
600 *@param s context
601 *@param offset sample offset in the frame
602 *@return decoded subframe length on success, < 0 in case of an error
603 */
604 527 static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
605 {
606 527 int frame_len_shift = 0;
607 int subframe_len;
608
609 /** no need to read from the bitstream when only one length is possible */
610
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 518 times.
527 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
611 9 return s->min_samples_per_subframe;
612
613
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 518 times.
518 if (get_bits_left(&s->gb) < 1)
614 return AVERROR_INVALIDDATA;
615
616 /** 1 bit indicates if the subframe is of maximum length */
617
1/2
✓ Branch 0 taken 518 times.
✗ Branch 1 not taken.
518 if (s->max_subframe_len_bit) {
618
2/2
✓ Branch 1 taken 279 times.
✓ Branch 2 taken 239 times.
518 if (get_bits1(&s->gb))
619 279 frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
620 } else
621 frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
622
623 518 subframe_len = s->samples_per_frame >> frame_len_shift;
624
625 /** sanity check the length */
626
1/2
✓ Branch 0 taken 518 times.
✗ Branch 1 not taken.
518 if (subframe_len < s->min_samples_per_subframe ||
627
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 518 times.
518 subframe_len > s->samples_per_frame) {
628 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
629 subframe_len);
630 return AVERROR_INVALIDDATA;
631 }
632 518 return subframe_len;
633 }
634
635 /**
636 *@brief Decode how the data in the frame is split into subframes.
637 * Every WMA frame contains the encoded data for a fixed number of
638 * samples per channel. The data for every channel might be split
639 * into several subframes. This function will reconstruct the list of
640 * subframes for every channel.
641 *
642 * If the subframes are not evenly split, the algorithm estimates the
643 * channels with the lowest number of total samples.
644 * Afterwards, for each of these channels a bit is read from the
645 * bitstream that indicates if the channel contains a subframe with the
646 * next subframe size that is going to be read from the bitstream or not.
647 * If a channel contains such a subframe, the subframe size gets added to
648 * the channel's subframe list.
649 * The algorithm repeats these steps until the frame is properly divided
650 * between the individual channels.
651 *
652 *@param s context
653 *@return 0 on success, < 0 in case of an error
654 */
655 257 static int decode_tilehdr(WMAProDecodeCtx *s)
656 {
657 257 uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
658 uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */
659 257 int channels_for_cur_subframe = s->nb_channels; /**< number of channels that contain the current subframe */
660 257 int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */
661 257 int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */
662 int c;
663
664 /* Should never consume more than 3073 bits (256 iterations for the
665 * while loop when always the minimum amount of 128 samples is subtracted
666 * from missing samples in the 8 channel case).
667 * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS + 4)
668 */
669
670 /** reset tiling information */
671
2/2
✓ Branch 0 taken 926 times.
✓ Branch 1 taken 257 times.
1183 for (c = 0; c < s->nb_channels; c++)
672 926 s->channel[c].num_subframes = 0;
673
674
3/4
✓ Branch 0 taken 257 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 225 times.
✓ Branch 4 taken 32 times.
257 if (s->max_num_subframes == 1 || get_bits1(&s->gb))
675 225 fixed_channel_layout = 1;
676
677 /** loop until the frame data is split between the subframes */
678 do {
679 int subframe_len;
680
681 /** check which channels contain the subframe */
682
2/2
✓ Branch 0 taken 2286 times.
✓ Branch 1 taken 527 times.
2813 for (c = 0; c < s->nb_channels; c++) {
683
2/2
✓ Branch 0 taken 1277 times.
✓ Branch 1 taken 1009 times.
2286 if (num_samples[c] == min_channel_len) {
684
4/4
✓ Branch 0 taken 413 times.
✓ Branch 1 taken 864 times.
✓ Branch 2 taken 224 times.
✓ Branch 3 taken 189 times.
1277 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
685
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 224 times.
224 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
686 1053 contains_subframe[c] = 1;
687 else
688 224 contains_subframe[c] = get_bits1(&s->gb);
689 } else
690 1009 contains_subframe[c] = 0;
691 }
692
693 /** get subframe length, subframe_len == 0 is not allowed */
694
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 527 times.
527 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
695 return AVERROR_INVALIDDATA;
696
697 /** add subframes to the individual channels and find new min_channel_len */
698 527 min_channel_len += subframe_len;
699
2/2
✓ Branch 0 taken 2286 times.
✓ Branch 1 taken 527 times.
2813 for (c = 0; c < s->nb_channels; c++) {
700 2286 WMAProChannelCtx* chan = &s->channel[c];
701
702
2/2
✓ Branch 0 taken 1234 times.
✓ Branch 1 taken 1052 times.
2286 if (contains_subframe[c]) {
703
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1234 times.
1234 if (chan->num_subframes >= MAX_SUBFRAMES) {
704 av_log(s->avctx, AV_LOG_ERROR,
705 "broken frame: num subframes > 31\n");
706 return AVERROR_INVALIDDATA;
707 }
708 1234 chan->subframe_len[chan->num_subframes] = subframe_len;
709 1234 num_samples[c] += subframe_len;
710 1234 ++chan->num_subframes;
711
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1234 times.
1234 if (num_samples[c] > s->samples_per_frame) {
712 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
713 "channel len > samples_per_frame\n");
714 return AVERROR_INVALIDDATA;
715 }
716
2/2
✓ Branch 0 taken 211 times.
✓ Branch 1 taken 841 times.
1052 } else if (num_samples[c] <= min_channel_len) {
717
2/2
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 168 times.
211 if (num_samples[c] < min_channel_len) {
718 43 channels_for_cur_subframe = 0;
719 43 min_channel_len = num_samples[c];
720 }
721 211 ++channels_for_cur_subframe;
722 }
723 }
724
2/2
✓ Branch 0 taken 270 times.
✓ Branch 1 taken 257 times.
527 } while (min_channel_len < s->samples_per_frame);
725
726
2/2
✓ Branch 0 taken 926 times.
✓ Branch 1 taken 257 times.
1183 for (c = 0; c < s->nb_channels; c++) {
727 int i;
728 926 int offset = 0;
729
2/2
✓ Branch 0 taken 1234 times.
✓ Branch 1 taken 926 times.
2160 for (i = 0; i < s->channel[c].num_subframes; i++) {
730 ff_dlog(s->avctx, "frame[%"PRIu32"] channel[%i] subframe[%i]"
731 " len %i\n", s->frame_num, c, i,
732 s->channel[c].subframe_len[i]);
733 1234 s->channel[c].subframe_offset[i] = offset;
734 1234 offset += s->channel[c].subframe_len[i];
735 }
736 }
737
738 257 return 0;
739 }
740
741 /**
742 *@brief Calculate a decorrelation matrix from the bitstream parameters.
743 *@param s codec context
744 *@param chgroup channel group for which the matrix needs to be calculated
745 */
746 79 static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
747 WMAProChannelGrp *chgroup)
748 {
749 int i;
750 79 int offset = 0;
751 int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
752 79 memset(chgroup->decorrelation_matrix, 0, s->nb_channels *
753 79 s->nb_channels * sizeof(*chgroup->decorrelation_matrix));
754
755
2/2
✓ Branch 0 taken 237 times.
✓ Branch 1 taken 79 times.
316 for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
756 237 rotation_offset[i] = get_bits(&s->gb, 6);
757
758
2/2
✓ Branch 0 taken 237 times.
✓ Branch 1 taken 79 times.
316 for (i = 0; i < chgroup->num_channels; i++)
759 237 chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
760
1/2
✓ Branch 1 taken 237 times.
✗ Branch 2 not taken.
237 get_bits1(&s->gb) ? 1.0 : -1.0;
761
762
2/2
✓ Branch 0 taken 158 times.
✓ Branch 1 taken 79 times.
237 for (i = 1; i < chgroup->num_channels; i++) {
763 int x;
764
2/2
✓ Branch 0 taken 237 times.
✓ Branch 1 taken 158 times.
395 for (x = 0; x < i; x++) {
765 int y;
766
2/2
✓ Branch 0 taken 632 times.
✓ Branch 1 taken 237 times.
869 for (y = 0; y < i + 1; y++) {
767 632 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
768 632 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
769 632 int n = rotation_offset[offset + x];
770 float sinv;
771 float cosv;
772
773
2/2
✓ Branch 0 taken 442 times.
✓ Branch 1 taken 190 times.
632 if (n < 32) {
774 442 sinv = sin64[n];
775 442 cosv = sin64[32 - n];
776 } else {
777 190 sinv = sin64[64 - n];
778 190 cosv = -sin64[n - 32];
779 }
780
781 632 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
782 632 (v1 * sinv) - (v2 * cosv);
783 632 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
784 632 (v1 * cosv) + (v2 * sinv);
785 }
786 }
787 158 offset += i;
788 }
789 79 }
790
791 /**
792 *@brief Decode channel transformation parameters
793 *@param s codec context
794 *@return >= 0 in case of success, < 0 in case of bitstream errors
795 */
796 527 static int decode_channel_transform(WMAProDecodeCtx* s)
797 {
798 int i;
799 /* should never consume more than 1921 bits for the 8 channel case
800 * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
801 * + MAX_CHANNELS + MAX_BANDS + 1)
802 */
803
804 /** in the one channel case channel transforms are pointless */
805 527 s->num_chgroups = 0;
806
1/2
✓ Branch 0 taken 527 times.
✗ Branch 1 not taken.
527 if (s->nb_channels > 1) {
807 527 int remaining_channels = s->channels_for_cur_subframe;
808
809
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 527 times.
527 if (get_bits1(&s->gb)) {
810 avpriv_request_sample(s->avctx,
811 "Channel transform bit");
812 return AVERROR_PATCHWELCOME;
813 }
814
815
2/2
✓ Branch 0 taken 629 times.
✓ Branch 1 taken 527 times.
1156 for (s->num_chgroups = 0; remaining_channels &&
816
1/2
✓ Branch 0 taken 629 times.
✗ Branch 1 not taken.
629 s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
817 629 WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
818 629 float** channel_data = chgroup->channel_data;
819 629 chgroup->num_channels = 0;
820 629 chgroup->transform = 0;
821
822 /** decode channel mask */
823
2/2
✓ Branch 0 taken 182 times.
✓ Branch 1 taken 447 times.
629 if (remaining_channels > 2) {
824
2/2
✓ Branch 0 taken 1035 times.
✓ Branch 1 taken 182 times.
1217 for (i = 0; i < s->channels_for_cur_subframe; i++) {
825 1035 int channel_idx = s->channel_indexes_for_cur_subframe[i];
826
2/2
✓ Branch 0 taken 819 times.
✓ Branch 1 taken 216 times.
1035 if (!s->channel[channel_idx].grouped
827
2/2
✓ Branch 1 taken 536 times.
✓ Branch 2 taken 283 times.
819 && get_bits1(&s->gb)) {
828 536 ++chgroup->num_channels;
829 536 s->channel[channel_idx].grouped = 1;
830 536 *channel_data++ = s->channel[channel_idx].coeffs;
831 }
832 }
833 } else {
834 447 chgroup->num_channels = remaining_channels;
835
2/2
✓ Branch 0 taken 775 times.
✓ Branch 1 taken 447 times.
1222 for (i = 0; i < s->channels_for_cur_subframe; i++) {
836 775 int channel_idx = s->channel_indexes_for_cur_subframe[i];
837
2/2
✓ Branch 0 taken 698 times.
✓ Branch 1 taken 77 times.
775 if (!s->channel[channel_idx].grouped)
838 698 *channel_data++ = s->channel[channel_idx].coeffs;
839 775 s->channel[channel_idx].grouped = 1;
840 }
841 }
842
843 /** decode transform type */
844
2/2
✓ Branch 0 taken 276 times.
✓ Branch 1 taken 353 times.
629 if (chgroup->num_channels == 2) {
845
2/2
✓ Branch 1 taken 38 times.
✓ Branch 2 taken 238 times.
276 if (get_bits1(&s->gb)) {
846
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 38 times.
38 if (get_bits1(&s->gb)) {
847 avpriv_request_sample(s->avctx,
848 "Unknown channel transform type");
849 return AVERROR_PATCHWELCOME;
850 }
851 } else {
852 238 chgroup->transform = 1;
853
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 23 times.
238 if (s->nb_channels == 2) {
854 215 chgroup->decorrelation_matrix[0] = 1.0;
855 215 chgroup->decorrelation_matrix[1] = -1.0;
856 215 chgroup->decorrelation_matrix[2] = 1.0;
857 215 chgroup->decorrelation_matrix[3] = 1.0;
858 } else {
859 /** cos(pi/4) */
860 23 chgroup->decorrelation_matrix[0] = 0.70703125;
861 23 chgroup->decorrelation_matrix[1] = -0.70703125;
862 23 chgroup->decorrelation_matrix[2] = 0.70703125;
863 23 chgroup->decorrelation_matrix[3] = 0.70703125;
864 }
865 }
866
2/2
✓ Branch 0 taken 157 times.
✓ Branch 1 taken 196 times.
353 } else if (chgroup->num_channels > 2) {
867
2/2
✓ Branch 1 taken 79 times.
✓ Branch 2 taken 78 times.
157 if (get_bits1(&s->gb)) {
868 79 chgroup->transform = 1;
869
1/2
✓ Branch 1 taken 79 times.
✗ Branch 2 not taken.
79 if (get_bits1(&s->gb)) {
870 79 decode_decorrelation_matrix(s, chgroup);
871 } else {
872 /** FIXME: more than 6 coupled channels not supported */
873 if (chgroup->num_channels > 6) {
874 avpriv_request_sample(s->avctx,
875 "Coupled channels > 6");
876 } else {
877 memcpy(chgroup->decorrelation_matrix,
878 default_decorrelation[chgroup->num_channels],
879 chgroup->num_channels * chgroup->num_channels *
880 sizeof(*chgroup->decorrelation_matrix));
881 }
882 }
883 }
884 }
885
886 /** decode transform on / off */
887
2/2
✓ Branch 0 taken 317 times.
✓ Branch 1 taken 312 times.
629 if (chgroup->transform) {
888
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 317 times.
317 if (!get_bits1(&s->gb)) {
889 int i;
890 /** transform can be enabled for individual bands */
891 for (i = 0; i < s->num_bands; i++) {
892 chgroup->transform_band[i] = get_bits1(&s->gb);
893 }
894 } else {
895 317 memset(chgroup->transform_band, 1, s->num_bands);
896 }
897 }
898 629 remaining_channels -= chgroup->num_channels;
899 }
900 }
901 527 return 0;
902 }
903
904 /**
905 *@brief Extract the coefficients from the bitstream.
906 *@param s codec context
907 *@param c current channel number
908 *@return 0 on success, < 0 in case of bitstream errors
909 */
910 1038 static int decode_coeffs(WMAProDecodeCtx *s, int c)
911 {
912 /* Integers 0..15 as single-precision floats. The table saves a
913 costly int to float conversion, and storing the values as
914 integers allows fast sign-flipping. */
915 static const uint32_t fval_tab[16] = {
916 0x00000000, 0x3f800000, 0x40000000, 0x40400000,
917 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
918 0x41000000, 0x41100000, 0x41200000, 0x41300000,
919 0x41400000, 0x41500000, 0x41600000, 0x41700000,
920 };
921 int vlctable;
922 VLC* vlc;
923 1038 WMAProChannelCtx* ci = &s->channel[c];
924 1038 int rl_mode = 0;
925 1038 int cur_coeff = 0;
926 1038 int num_zeros = 0;
927 const uint16_t* run;
928 const float* level;
929
930 ff_dlog(s->avctx, "decode coefficients for channel %i\n", c);
931
932 1038 vlctable = get_bits1(&s->gb);
933 1038 vlc = &coef_vlc[vlctable];
934
935
2/2
✓ Branch 0 taken 321 times.
✓ Branch 1 taken 717 times.
1038 if (vlctable) {
936 321 run = coef1_run;
937 321 level = coef1_level;
938 } else {
939 717 run = coef0_run;
940 717 level = coef0_level;
941 }
942
943 /** decode vector coefficients (consumes up to 167 bits per iteration for
944 4 vector coded large values) */
945
3/4
✓ Branch 0 taken 39251 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 38213 times.
✓ Branch 3 taken 1038 times.
39251 while ((s->transmit_num_vec_coeffs || !rl_mode) &&
946
1/2
✓ Branch 0 taken 38213 times.
✗ Branch 1 not taken.
38213 (cur_coeff + 3 < ci->num_vec_coeffs)) {
947 uint32_t vals[4];
948 int i;
949 unsigned int idx;
950
951 38213 idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
952
953
2/2
✓ Branch 0 taken 21810 times.
✓ Branch 1 taken 16403 times.
38213 if (idx == HUFF_VEC4_SIZE - 1) {
954
2/2
✓ Branch 0 taken 43620 times.
✓ Branch 1 taken 21810 times.
65430 for (i = 0; i < 4; i += 2) {
955 43620 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
956
2/2
✓ Branch 0 taken 20544 times.
✓ Branch 1 taken 23076 times.
43620 if (idx == HUFF_VEC2_SIZE - 1) {
957 uint32_t v0, v1;
958 20544 v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
959
2/2
✓ Branch 0 taken 1608 times.
✓ Branch 1 taken 18936 times.
20544 if (v0 == HUFF_VEC1_SIZE - 1)
960 1608 v0 += ff_wma_get_large_val(&s->gb);
961 20544 v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
962
2/2
✓ Branch 0 taken 1665 times.
✓ Branch 1 taken 18879 times.
20544 if (v1 == HUFF_VEC1_SIZE - 1)
963 1665 v1 += ff_wma_get_large_val(&s->gb);
964 20544 vals[i ] = av_float2int(v0);
965 20544 vals[i+1] = av_float2int(v1);
966 } else {
967 23076 vals[i] = fval_tab[symbol_to_vec2[idx] >> 4 ];
968 23076 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
969 }
970 }
971 } else {
972 16403 vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12 ];
973 16403 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
974 16403 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
975 16403 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
976 }
977
978 /** decode sign */
979
2/2
✓ Branch 0 taken 152852 times.
✓ Branch 1 taken 38213 times.
191065 for (i = 0; i < 4; i++) {
980
2/2
✓ Branch 0 taken 111800 times.
✓ Branch 1 taken 41052 times.
152852 if (vals[i]) {
981 111800 uint32_t sign = get_bits1(&s->gb) - 1;
982 111800 AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
983 111800 num_zeros = 0;
984 } else {
985 41052 ci->coeffs[cur_coeff] = 0;
986 /** switch to run level mode when subframe_len / 128 zeros
987 were found in a row */
988 41052 rl_mode |= (++num_zeros > s->subframe_len >> 8);
989 }
990 152852 ++cur_coeff;
991 }
992 }
993
994 /** decode run level coded coefficients */
995
1/2
✓ Branch 0 taken 1038 times.
✗ Branch 1 not taken.
1038 if (cur_coeff < s->subframe_len) {
996 int ret;
997
998 1038 memset(&ci->coeffs[cur_coeff], 0,
999 1038 sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
1000 1038 ret = ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
1001 1038 level, run, 1, ci->coeffs,
1002 1038 cur_coeff, s->subframe_len,
1003 1038 s->subframe_len, s->esc_len, 0);
1004
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1038 times.
1038 if (ret < 0)
1005 return ret;
1006 }
1007
1008 1038 return 0;
1009 }
1010
1011 /**
1012 *@brief Extract scale factors from the bitstream.
1013 *@param s codec context
1014 *@return 0 on success, < 0 in case of bitstream errors
1015 */
1016 521 static int decode_scale_factors(WMAProDecodeCtx* s)
1017 {
1018 int i;
1019
1020 /** should never consume more than 5344 bits
1021 * MAX_CHANNELS * (1 + MAX_BANDS * 23)
1022 */
1023
1024
2/2
✓ Branch 0 taken 1224 times.
✓ Branch 1 taken 521 times.
1745 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1025 1224 int c = s->channel_indexes_for_cur_subframe[i];
1026 int* sf;
1027 int* sf_end;
1028 1224 s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
1029 1224 sf_end = s->channel[c].scale_factors + s->num_bands;
1030
1031 /** resample scale factors for the new block size
1032 * as the scale factors might need to be resampled several times
1033 * before some new values are transmitted, a backup of the last
1034 * transmitted scale factors is kept in saved_scale_factors
1035 */
1036
2/2
✓ Branch 0 taken 298 times.
✓ Branch 1 taken 926 times.
1224 if (s->channel[c].reuse_sf) {
1037 298 const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
1038 int b;
1039
2/2
✓ Branch 0 taken 5173 times.
✓ Branch 1 taken 298 times.
5471 for (b = 0; b < s->num_bands; b++)
1040 5173 s->channel[c].scale_factors[b] =
1041 5173 s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
1042 }
1043
1044
4/4
✓ Branch 0 taken 301 times.
✓ Branch 1 taken 923 times.
✓ Branch 3 taken 283 times.
✓ Branch 4 taken 18 times.
1224 if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
1045
1046
2/2
✓ Branch 0 taken 926 times.
✓ Branch 1 taken 280 times.
1206 if (!s->channel[c].reuse_sf) {
1047 int val;
1048 /** decode DPCM coded scale factors */
1049 926 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
1050 926 val = 45 / s->channel[c].scale_factor_step;
1051
2/2
✓ Branch 0 taken 23831 times.
✓ Branch 1 taken 926 times.
24757 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
1052 23831 val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
1053 23831 *sf = val;
1054 }
1055 } else {
1056 int i;
1057 /** run level decode differences to the resampled factors */
1058
1/2
✓ Branch 0 taken 1904 times.
✗ Branch 1 not taken.
1904 for (i = 0; i < s->num_bands; i++) {
1059 int idx;
1060 int skip;
1061 int val;
1062 int sign;
1063
1064 1904 idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
1065
1066
2/2
✓ Branch 0 taken 41 times.
✓ Branch 1 taken 1863 times.
1904 if (!idx) {
1067 41 uint32_t code = get_bits(&s->gb, 14);
1068 41 val = code >> 6;
1069 41 sign = (code & 1) - 1;
1070 41 skip = (code & 0x3f) >> 1;
1071
2/2
✓ Branch 0 taken 280 times.
✓ Branch 1 taken 1583 times.
1863 } else if (idx == 1) {
1072 280 break;
1073 } else {
1074 1583 skip = scale_rl_run[idx];
1075 1583 val = scale_rl_level[idx];
1076 1583 sign = get_bits1(&s->gb)-1;
1077 }
1078
1079 1624 i += skip;
1080
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1624 times.
1624 if (i >= s->num_bands) {
1081 av_log(s->avctx, AV_LOG_ERROR,
1082 "invalid scale factor coding\n");
1083 return AVERROR_INVALIDDATA;
1084 }
1085 1624 s->channel[c].scale_factors[i] += (val ^ sign) - sign;
1086 }
1087 }
1088 /** swap buffers */
1089 1206 s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
1090 1206 s->channel[c].table_idx = s->table_idx;
1091 1206 s->channel[c].reuse_sf = 1;
1092 }
1093
1094 /** calculate new scale factor maximum */
1095 1224 s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
1096
2/2
✓ Branch 0 taken 27780 times.
✓ Branch 1 taken 1224 times.
29004 for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
1097 27780 s->channel[c].max_scale_factor =
1098 27780 FFMAX(s->channel[c].max_scale_factor, *sf);
1099 }
1100
1101 }
1102 521 return 0;
1103 }
1104
1105 /**
1106 *@brief Reconstruct the individual channel data.
1107 *@param s codec context
1108 */
1109 521 static void inverse_channel_transform(WMAProDecodeCtx *s)
1110 {
1111 int i;
1112
1113
2/2
✓ Branch 0 taken 623 times.
✓ Branch 1 taken 521 times.
1144 for (i = 0; i < s->num_chgroups; i++) {
1114
2/2
✓ Branch 0 taken 317 times.
✓ Branch 1 taken 306 times.
623 if (s->chgroup[i].transform) {
1115 float data[WMAPRO_MAX_CHANNELS];
1116 317 const int num_channels = s->chgroup[i].num_channels;
1117 317 float** ch_data = s->chgroup[i].channel_data;
1118 317 float** ch_end = ch_data + num_channels;
1119 317 const int8_t* tb = s->chgroup[i].transform_band;
1120 int16_t* sfb;
1121
1122 /** multichannel decorrelation */
1123 317 for (sfb = s->cur_sfb_offsets;
1124
2/2
✓ Branch 0 taken 7696 times.
✓ Branch 1 taken 317 times.
8013 sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
1125 int y;
1126
1/2
✓ Branch 0 taken 7696 times.
✗ Branch 1 not taken.
7696 if (*tb++ == 1) {
1127 /** multiply values with the decorrelation_matrix */
1128
2/2
✓ Branch 0 taken 522368 times.
✓ Branch 1 taken 7696 times.
530064 for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
1129 522368 const float* mat = s->chgroup[i].decorrelation_matrix;
1130 522368 const float* data_end = data + num_channels;
1131 522368 float* data_ptr = data;
1132 float** ch;
1133
1134
2/2
✓ Branch 0 taken 1206528 times.
✓ Branch 1 taken 522368 times.
1728896 for (ch = ch_data; ch < ch_end; ch++)
1135 1206528 *data_ptr++ = (*ch)[y];
1136
1137
2/2
✓ Branch 0 taken 1206528 times.
✓ Branch 1 taken 522368 times.
1728896 for (ch = ch_data; ch < ch_end; ch++) {
1138 1206528 float sum = 0;
1139 1206528 data_ptr = data;
1140
2/2
✓ Branch 0 taken 2898432 times.
✓ Branch 1 taken 1206528 times.
4104960 while (data_ptr < data_end)
1141 2898432 sum += *data_ptr++ * *mat++;
1142
1143 1206528 (*ch)[y] = sum;
1144 }
1145 }
1146 } else if (s->nb_channels == 2) {
1147 int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
1148 s->fdsp->vector_fmul_scalar(ch_data[0] + sfb[0],
1149 ch_data[0] + sfb[0],
1150 181.0 / 128, len);
1151 s->fdsp->vector_fmul_scalar(ch_data[1] + sfb[0],
1152 ch_data[1] + sfb[0],
1153 181.0 / 128, len);
1154 }
1155 }
1156 }
1157 }
1158 521 }
1159
1160 /**
1161 *@brief Apply sine window and reconstruct the output buffer.
1162 *@param s codec context
1163 */
1164 527 static void wmapro_window(WMAProDecodeCtx *s)
1165 {
1166 int i;
1167
2/2
✓ Branch 0 taken 1234 times.
✓ Branch 1 taken 527 times.
1761 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1168 1234 int c = s->channel_indexes_for_cur_subframe[i];
1169 const float* window;
1170 1234 int winlen = s->channel[c].prev_block_len;
1171 1234 float* start = s->channel[c].coeffs - (winlen >> 1);
1172
1173
2/2
✓ Branch 0 taken 142 times.
✓ Branch 1 taken 1092 times.
1234 if (s->subframe_len < winlen) {
1174 142 start += (winlen - s->subframe_len) >> 1;
1175 142 winlen = s->subframe_len;
1176 }
1177
1178 1234 window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
1179
1180 1234 winlen >>= 1;
1181
1182 1234 s->fdsp->vector_fmul_window(start, start, start + winlen,
1183 window, winlen);
1184
1185 1234 s->channel[c].prev_block_len = s->subframe_len;
1186 }
1187 527 }
1188
1189 /**
1190 *@brief Decode a single subframe (block).
1191 *@param s codec context
1192 *@return 0 on success, < 0 when decoding failed
1193 */
1194 527 static int decode_subframe(WMAProDecodeCtx *s)
1195 {
1196 527 int offset = s->samples_per_frame;
1197 527 int subframe_len = s->samples_per_frame;
1198 int i;
1199 527 int total_samples = s->samples_per_frame * s->nb_channels;
1200 527 int transmit_coeffs = 0;
1201 int cur_subwoofer_cutoff;
1202
1203 527 s->subframe_offset = get_bits_count(&s->gb);
1204
1205 /** reset channel context and find the next block offset and size
1206 == the next block of the channel with the smallest number of
1207 decoded samples
1208 */
1209
2/2
✓ Branch 0 taken 2286 times.
✓ Branch 1 taken 527 times.
2813 for (i = 0; i < s->nb_channels; i++) {
1210 2286 s->channel[i].grouped = 0;
1211
2/2
✓ Branch 0 taken 539 times.
✓ Branch 1 taken 1747 times.
2286 if (offset > s->channel[i].decoded_samples) {
1212 539 offset = s->channel[i].decoded_samples;
1213 539 subframe_len =
1214 539 s->channel[i].subframe_len[s->channel[i].cur_subframe];
1215 }
1216 }
1217
1218 ff_dlog(s->avctx,
1219 "processing subframe with offset %i len %i\n", offset, subframe_len);
1220
1221 /** get a list of all channels that contain the estimated block */
1222 527 s->channels_for_cur_subframe = 0;
1223
2/2
✓ Branch 0 taken 2286 times.
✓ Branch 1 taken 527 times.
2813 for (i = 0; i < s->nb_channels; i++) {
1224 2286 const int cur_subframe = s->channel[i].cur_subframe;
1225 /** subtract already processed samples */
1226 2286 total_samples -= s->channel[i].decoded_samples;
1227
1228 /** and count if there are multiple subframes that match our profile */
1229
2/2
✓ Branch 0 taken 1277 times.
✓ Branch 1 taken 1009 times.
2286 if (offset == s->channel[i].decoded_samples &&
1230
2/2
✓ Branch 0 taken 1234 times.
✓ Branch 1 taken 43 times.
1277 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
1231 1234 total_samples -= s->channel[i].subframe_len[cur_subframe];
1232 1234 s->channel[i].decoded_samples +=
1233 1234 s->channel[i].subframe_len[cur_subframe];
1234 1234 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
1235 1234 ++s->channels_for_cur_subframe;
1236 }
1237 }
1238
1239 /** check if the frame will be complete after processing the
1240 estimated block */
1241
2/2
✓ Branch 0 taken 257 times.
✓ Branch 1 taken 270 times.
527 if (!total_samples)
1242 257 s->parsed_all_subframes = 1;
1243
1244
1245 ff_dlog(s->avctx, "subframe is part of %i channels\n",
1246 s->channels_for_cur_subframe);
1247
1248 /** calculate number of scale factor bands and their offsets */
1249 527 s->table_idx = av_log2(s->samples_per_frame/subframe_len);
1250 527 s->num_bands = s->num_sfb[s->table_idx];
1251 527 s->cur_sfb_offsets = s->sfb_offsets[s->table_idx];
1252 527 cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
1253
1254 /** configure the decoder for the current subframe */
1255 527 offset += s->samples_per_frame >> 1;
1256
1257
2/2
✓ Branch 0 taken 1234 times.
✓ Branch 1 taken 527 times.
1761 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1258 1234 int c = s->channel_indexes_for_cur_subframe[i];
1259
1260 1234 s->channel[c].coeffs = &s->channel[c].out[offset];
1261 }
1262
1263 527 s->subframe_len = subframe_len;
1264 527 s->esc_len = av_log2(s->subframe_len - 1) + 1;
1265
1266 /** skip extended header if any */
1267
2/2
✓ Branch 1 taken 158 times.
✓ Branch 2 taken 369 times.
527 if (get_bits1(&s->gb)) {
1268 int num_fill_bits;
1269
1/2
✓ Branch 1 taken 158 times.
✗ Branch 2 not taken.
158 if (!(num_fill_bits = get_bits(&s->gb, 2))) {
1270 158 int len = get_bits(&s->gb, 4);
1271 158 num_fill_bits = get_bitsz(&s->gb, len) + 1;
1272 }
1273
1274
1/2
✓ Branch 0 taken 158 times.
✗ Branch 1 not taken.
158 if (num_fill_bits >= 0) {
1275
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 158 times.
158 if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
1276 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
1277 return AVERROR_INVALIDDATA;
1278 }
1279
1280 158 skip_bits_long(&s->gb, num_fill_bits);
1281 }
1282 }
1283
1284 /** no idea for what the following bit is used */
1285
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 527 times.
527 if (get_bits1(&s->gb)) {
1286 avpriv_request_sample(s->avctx, "Reserved bit");
1287 return AVERROR_PATCHWELCOME;
1288 }
1289
1290
1291
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 527 times.
527 if (decode_channel_transform(s) < 0)
1292 return AVERROR_INVALIDDATA;
1293
1294
1295
2/2
✓ Branch 0 taken 1234 times.
✓ Branch 1 taken 527 times.
1761 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1296 1234 int c = s->channel_indexes_for_cur_subframe[i];
1297
2/2
✓ Branch 1 taken 1038 times.
✓ Branch 2 taken 196 times.
1234 if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
1298 1038 transmit_coeffs = 1;
1299 }
1300
1301
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 527 times.
527 av_assert0(s->subframe_len <= WMAPRO_BLOCK_MAX_SIZE);
1302
2/2
✓ Branch 0 taken 521 times.
✓ Branch 1 taken 6 times.
527 if (transmit_coeffs) {
1303 int step;
1304 521 int quant_step = 90 * s->bits_per_sample >> 4;
1305
1306 /** decode number of vector coded coefficients */
1307
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 521 times.
521 if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
1308 int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
1309 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1310 int c = s->channel_indexes_for_cur_subframe[i];
1311 int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
1312 if (num_vec_coeffs > s->subframe_len) {
1313 av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
1314 return AVERROR_INVALIDDATA;
1315 }
1316 av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out));
1317 s->channel[c].num_vec_coeffs = num_vec_coeffs;
1318 }
1319 } else {
1320
2/2
✓ Branch 0 taken 1224 times.
✓ Branch 1 taken 521 times.
1745 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1321 1224 int c = s->channel_indexes_for_cur_subframe[i];
1322 1224 s->channel[c].num_vec_coeffs = s->subframe_len;
1323 }
1324 }
1325 /** decode quantization step */
1326 521 step = get_sbits(&s->gb, 6);
1327 521 quant_step += step;
1328
3/4
✓ Branch 0 taken 498 times.
✓ Branch 1 taken 23 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 498 times.
521 if (step == -32 || step == 31) {
1329
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23 times.
23 const int sign = (step == 31) - 1;
1330 23 int quant = 0;
1331
1/2
✓ Branch 1 taken 23 times.
✗ Branch 2 not taken.
23 while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
1332
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
23 (step = get_bits(&s->gb, 5)) == 31) {
1333 quant += 31;
1334 }
1335 23 quant_step += ((quant + step) ^ sign) - sign;
1336 }
1337
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 521 times.
521 if (quant_step < 0) {
1338 av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
1339 }
1340
1341 /** decode quantization step modifiers for every channel */
1342
1343
2/2
✓ Branch 0 taken 194 times.
✓ Branch 1 taken 327 times.
521 if (s->channels_for_cur_subframe == 1) {
1344 194 s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
1345 } else {
1346 327 int modifier_len = get_bits(&s->gb, 3);
1347
2/2
✓ Branch 0 taken 1030 times.
✓ Branch 1 taken 327 times.
1357 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1348 1030 int c = s->channel_indexes_for_cur_subframe[i];
1349 1030 s->channel[c].quant_step = quant_step;
1350
2/2
✓ Branch 1 taken 511 times.
✓ Branch 2 taken 519 times.
1030 if (get_bits1(&s->gb)) {
1351
2/2
✓ Branch 0 taken 458 times.
✓ Branch 1 taken 53 times.
511 if (modifier_len) {
1352 458 s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
1353 } else
1354 53 ++s->channel[c].quant_step;
1355 }
1356 }
1357 }
1358
1359 /** decode scale factors */
1360
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 521 times.
521 if (decode_scale_factors(s) < 0)
1361 return AVERROR_INVALIDDATA;
1362 }
1363
1364 ff_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1365 get_bits_count(&s->gb) - s->subframe_offset);
1366
1367 /** parse coefficients */
1368
2/2
✓ Branch 0 taken 1234 times.
✓ Branch 1 taken 527 times.
1761 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1369 1234 int c = s->channel_indexes_for_cur_subframe[i];
1370
2/2
✓ Branch 0 taken 1038 times.
✓ Branch 1 taken 196 times.
1234 if (s->channel[c].transmit_coefs &&
1371
1/2
✓ Branch 1 taken 1038 times.
✗ Branch 2 not taken.
1038 get_bits_count(&s->gb) < s->num_saved_bits) {
1372 1038 decode_coeffs(s, c);
1373 } else
1374 196 memset(s->channel[c].coeffs, 0,
1375 sizeof(*s->channel[c].coeffs) * subframe_len);
1376 }
1377
1378 ff_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1379 get_bits_count(&s->gb) - s->subframe_offset);
1380
1381
2/2
✓ Branch 0 taken 521 times.
✓ Branch 1 taken 6 times.
527 if (transmit_coeffs) {
1382 521 FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
1383 /** reconstruct the per channel data */
1384 521 inverse_channel_transform(s);
1385
2/2
✓ Branch 0 taken 1224 times.
✓ Branch 1 taken 521 times.
1745 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1386 1224 int c = s->channel_indexes_for_cur_subframe[i];
1387 1224 const int* sf = s->channel[c].scale_factors;
1388 int b;
1389
1390
2/2
✓ Branch 0 taken 103 times.
✓ Branch 1 taken 1121 times.
1224 if (c == s->lfe_channel)
1391 103 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
1392 103 (subframe_len - cur_subwoofer_cutoff));
1393
1394 /** inverse quantization and rescaling */
1395
2/2
✓ Branch 0 taken 29004 times.
✓ Branch 1 taken 1224 times.
30228 for (b = 0; b < s->num_bands; b++) {
1396 29004 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
1397 29004 const int exp = s->channel[c].quant_step -
1398 29004 (s->channel[c].max_scale_factor - *sf++) *
1399 29004 s->channel[c].scale_factor_step;
1400 29004 const float quant = ff_exp10(exp / 20.0);
1401 29004 int start = s->cur_sfb_offsets[b];
1402 29004 s->fdsp->vector_fmul_scalar(s->tmp + start,
1403 29004 s->channel[c].coeffs + start,
1404 quant, end - start);
1405 }
1406
1407 /** apply imdct (imdct_half == DCTIV with reverse) */
1408 1224 mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
1409 }
1410 }
1411
1412 /** window and overlapp-add */
1413 527 wmapro_window(s);
1414
1415 /** handled one subframe */
1416
2/2
✓ Branch 0 taken 1234 times.
✓ Branch 1 taken 527 times.
1761 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1417 1234 int c = s->channel_indexes_for_cur_subframe[i];
1418
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1234 times.
1234 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1419 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1420 return AVERROR_INVALIDDATA;
1421 }
1422 1234 ++s->channel[c].cur_subframe;
1423 }
1424
1425 527 return 0;
1426 }
1427
1428 /**
1429 *@brief Decode one WMA frame.
1430 *@param s codec context
1431 *@return 0 if the trailer bit indicates that this is the last frame,
1432 * 1 if there are additional frames
1433 */
1434 257 static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
1435 {
1436 257 GetBitContext* gb = &s->gb;
1437 257 int more_frames = 0;
1438 257 int len = 0;
1439 int i;
1440
1441 /** get frame length */
1442
1/2
✓ Branch 0 taken 257 times.
✗ Branch 1 not taken.
257 if (s->len_prefix)
1443 257 len = get_bits(gb, s->log2_frame_size);
1444
1445 ff_dlog(s->avctx, "decoding frame with length %x\n", len);
1446
1447 /** decode tile information */
1448
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 257 times.
257 if (decode_tilehdr(s)) {
1449 s->packet_loss = 1;
1450 return 0;
1451 }
1452
1453 /** read postproc transform */
1454
2/4
✓ Branch 0 taken 257 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 257 times.
257 if (s->nb_channels > 1 && get_bits1(gb)) {
1455 if (get_bits1(gb)) {
1456 for (i = 0; i < s->nb_channels * s->nb_channels; i++)
1457 skip_bits(gb, 4);
1458 }
1459 }
1460
1461 /** read drc info */
1462
1/2
✓ Branch 0 taken 257 times.
✗ Branch 1 not taken.
257 if (s->dynamic_range_compression) {
1463 257 s->drc_gain = get_bits(gb, 8);
1464 ff_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1465 }
1466
1467
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 253 times.
257 if (get_bits1(gb)) {
1468
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1 times.
4 if (get_bits1(gb))
1469 3 s->trim_start = get_bits(gb, av_log2(s->samples_per_frame * 2));
1470
1471
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 3 times.
4 if (get_bits1(gb))
1472 1 s->trim_end = get_bits(gb, av_log2(s->samples_per_frame * 2));
1473 } else {
1474 253 s->trim_start = s->trim_end = 0;
1475 }
1476
1477 ff_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1478 get_bits_count(gb) - s->frame_offset);
1479
1480 /** reset subframe states */
1481 257 s->parsed_all_subframes = 0;
1482
2/2
✓ Branch 0 taken 926 times.
✓ Branch 1 taken 257 times.
1183 for (i = 0; i < s->nb_channels; i++) {
1483 926 s->channel[i].decoded_samples = 0;
1484 926 s->channel[i].cur_subframe = 0;
1485 926 s->channel[i].reuse_sf = 0;
1486 }
1487
1488 /** decode all subframes */
1489
2/2
✓ Branch 0 taken 527 times.
✓ Branch 1 taken 257 times.
784 while (!s->parsed_all_subframes) {
1490
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 527 times.
527 if (decode_subframe(s) < 0) {
1491 s->packet_loss = 1;
1492 return 0;
1493 }
1494 }
1495
1496 /** copy samples to the output buffer */
1497
2/2
✓ Branch 0 taken 926 times.
✓ Branch 1 taken 257 times.
1183 for (i = 0; i < s->nb_channels; i++)
1498 926 memcpy(frame->extended_data[i], s->channel[i].out,
1499 926 s->samples_per_frame * sizeof(*s->channel[i].out));
1500
1501
2/2
✓ Branch 0 taken 926 times.
✓ Branch 1 taken 257 times.
1183 for (i = 0; i < s->nb_channels; i++) {
1502 /** reuse second half of the IMDCT output for the next frame */
1503 926 memcpy(&s->channel[i].out[0],
1504 926 &s->channel[i].out[s->samples_per_frame],
1505 926 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1506 }
1507
1508
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 254 times.
257 if (s->skip_frame) {
1509 3 s->skip_frame = 0;
1510 3 *got_frame_ptr = 0;
1511 3 av_frame_unref(frame);
1512 } else {
1513 254 *got_frame_ptr = 1;
1514 }
1515
1516
1/2
✓ Branch 0 taken 257 times.
✗ Branch 1 not taken.
257 if (s->len_prefix) {
1517
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 257 times.
257 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1518 /** FIXME: not sure if this is always an error */
1519 av_log(s->avctx, AV_LOG_ERROR,
1520 "frame[%"PRIu32"] would have to skip %i bits\n",
1521 s->frame_num,
1522 len - (get_bits_count(gb) - s->frame_offset) - 1);
1523 s->packet_loss = 1;
1524 return 0;
1525 }
1526
1527 /** skip the rest of the frame data */
1528 257 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1529 } else {
1530 while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
1531 }
1532 }
1533
1534 /** decode trailer bit */
1535 257 more_frames = get_bits1(gb);
1536
1537 257 ++s->frame_num;
1538 257 return more_frames;
1539 }
1540
1541 /**
1542 *@brief Calculate remaining input buffer length.
1543 *@param s codec context
1544 *@param gb bitstream reader context
1545 *@return remaining size in bits
1546 */
1547 849 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
1548 {
1549 849 return s->buf_bit_size - get_bits_count(gb);
1550 }
1551
1552 /**
1553 *@brief Fill the bit reservoir with a (partial) frame.
1554 *@param s codec context
1555 *@param gb bitstream reader context
1556 *@param len length of the partial frame
1557 *@param append decides whether to reset the buffer or not
1558 */
1559 281 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
1560 int append)
1561 {
1562 int buflen;
1563
1564 /** when the frame data does not need to be concatenated, the input buffer
1565 is reset and additional bits from the previous frame are copied
1566 and skipped later so that a fast byte copy is possible */
1567
1568
2/2
✓ Branch 0 taken 260 times.
✓ Branch 1 taken 21 times.
281 if (!append) {
1569 260 s->frame_offset = get_bits_count(gb) & 7;
1570 260 s->num_saved_bits = s->frame_offset;
1571 260 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1572 260 buflen = (s->num_saved_bits + len + 7) >> 3;
1573 } else
1574 21 buflen = (put_bits_count(&s->pb) + len + 7) >> 3;
1575
1576
2/4
✓ Branch 0 taken 281 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 281 times.
281 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1577 avpriv_request_sample(s->avctx, "Too small input buffer");
1578 s->packet_loss = 1;
1579 return;
1580 }
1581
1582
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 281 times.
281 av_assert0(len <= put_bits_left(&s->pb));
1583
1584 281 s->num_saved_bits += len;
1585
2/2
✓ Branch 0 taken 260 times.
✓ Branch 1 taken 21 times.
281 if (!append) {
1586 260 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1587 s->num_saved_bits);
1588 } else {
1589 21 int align = 8 - (get_bits_count(gb) & 7);
1590 21 align = FFMIN(align, len);
1591 21 put_bits(&s->pb, align, get_bits(gb, align));
1592 21 len -= align;
1593 21 ff_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1594 }
1595 281 skip_bits_long(gb, len);
1596
1597 {
1598 281 PutBitContext tmp = s->pb;
1599 281 flush_put_bits(&tmp);
1600 }
1601
1602 281 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1603 281 skip_bits(&s->gb, s->frame_offset);
1604 }
1605
1606 283 static int decode_packet(AVCodecContext *avctx, WMAProDecodeCtx *s,
1607 void *data, int *got_frame_ptr, AVPacket *avpkt)
1608 {
1609 283 GetBitContext* gb = &s->pgb;
1610 283 const uint8_t* buf = avpkt->data;
1611 283 int buf_size = avpkt->size;
1612 int num_bits_prev_frame;
1613 int packet_sequence_number;
1614 int ret;
1615
1616 283 *got_frame_ptr = 0;
1617
1618
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 283 times.
283 if (!buf_size) {
1619 AVFrame *frame = data;
1620 int i;
1621
1622 /** Must output remaining samples after stream end. WMAPRO 5.1 created
1623 * by XWMA encoder don't though (maybe only 1/2ch streams need it). */
1624 s->packet_done = 0;
1625 if (s->eof_done)
1626 return 0;
1627
1628 /** clean output buffer and copy last IMDCT samples */
1629 for (i = 0; i < s->nb_channels; i++) {
1630 memset(frame->extended_data[i], 0,
1631 s->samples_per_frame * sizeof(*s->channel[i].out));
1632
1633 memcpy(frame->extended_data[i], s->channel[i].out,
1634 s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
1635 }
1636
1637 s->eof_done = 1;
1638 s->packet_done = 1;
1639 *got_frame_ptr = 1;
1640 return 0;
1641 }
1642
4/4
✓ Branch 0 taken 262 times.
✓ Branch 1 taken 21 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 259 times.
283 else if (s->packet_done || s->packet_loss) {
1643 24 s->packet_done = 0;
1644
1645 /** sanity check for the buffer length */
1646
2/4
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 24 times.
24 if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) {
1647 av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
1648 buf_size, avctx->block_align);
1649 s->packet_loss = 1;
1650 return AVERROR_INVALIDDATA;
1651 }
1652
1653
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
24 if (avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1654 24 s->next_packet_start = buf_size - avctx->block_align;
1655 24 buf_size = avctx->block_align;
1656 } else {
1657 s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align);
1658 buf_size = FFMIN(buf_size, avctx->block_align);
1659 }
1660 24 s->buf_bit_size = buf_size << 3;
1661
1662 /** parse packet header */
1663 24 ret = init_get_bits8(gb, buf, buf_size);
1664
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
24 if (ret < 0)
1665 return ret;
1666
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
24 if (avctx->codec_id != AV_CODEC_ID_XMA2) {
1667 24 packet_sequence_number = get_bits(gb, 4);
1668 24 skip_bits(gb, 2);
1669 } else {
1670 int num_frames = get_bits(gb, 6);
1671 ff_dlog(avctx, "packet[%d]: number of frames %d\n", avctx->frame_number, num_frames);
1672 packet_sequence_number = 0;
1673 }
1674
1675 /** get number of bits that need to be added to the previous frame */
1676 24 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1677
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
24 if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
1678 skip_bits(gb, 3);
1679 s->skip_packets = get_bits(gb, 8);
1680 ff_dlog(avctx, "packet[%d]: skip packets %d\n", avctx->frame_number, s->skip_packets);
1681 }
1682
1683 ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1684 num_bits_prev_frame);
1685
1686 /** check for packet loss */
1687
3/4
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 3 times.
24 if (avctx->codec_id == AV_CODEC_ID_WMAPRO && !s->packet_loss &&
1688
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
21 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1689 s->packet_loss = 1;
1690 av_log(avctx, AV_LOG_ERROR,
1691 "Packet loss detected! seq %"PRIx8" vs %x\n",
1692 s->packet_sequence_number, packet_sequence_number);
1693 }
1694 24 s->packet_sequence_number = packet_sequence_number;
1695
1696
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 3 times.
24 if (num_bits_prev_frame > 0) {
1697 21 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1698
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
21 if (num_bits_prev_frame >= remaining_packet_bits) {
1699 num_bits_prev_frame = remaining_packet_bits;
1700 s->packet_done = 1;
1701 }
1702
1703 /** append the previous frame data to the remaining data from the
1704 previous packet to create a full frame */
1705 21 save_bits(s, gb, num_bits_prev_frame, 1);
1706 ff_dlog(avctx, "accumulated %x bits of frame data\n",
1707 s->num_saved_bits - s->frame_offset);
1708
1709 /** decode the cross packet frame if it is valid */
1710
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
21 if (!s->packet_loss)
1711 21 decode_frame(s, data, got_frame_ptr);
1712 3 } else if (s->num_saved_bits - s->frame_offset) {
1713 ff_dlog(avctx, "ignoring %x previously saved bits\n",
1714 s->num_saved_bits - s->frame_offset);
1715 }
1716
1717
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 21 times.
24 if (s->packet_loss) {
1718 /** reset number of saved bits so that the decoder
1719 does not start to decode incomplete frames in the
1720 s->len_prefix == 0 case */
1721 3 s->num_saved_bits = 0;
1722 3 s->packet_loss = 0;
1723 }
1724 } else {
1725 int frame_size;
1726
1727
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 259 times.
259 if (avpkt->size < s->next_packet_start) {
1728 s->packet_loss = 1;
1729 return AVERROR_INVALIDDATA;
1730 }
1731
1732 259 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1733 259 ret = init_get_bits8(gb, avpkt->data, avpkt->size - s->next_packet_start);
1734
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 259 times.
259 if (ret < 0)
1735 return ret;
1736 259 skip_bits(gb, s->packet_offset);
1737
2/4
✓ Branch 0 taken 259 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 259 times.
✗ Branch 4 not taken.
259 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1738
3/4
✓ Branch 1 taken 259 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 236 times.
✓ Branch 4 taken 23 times.
518 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1739 259 frame_size <= remaining_bits(s, gb)) {
1740 236 save_bits(s, gb, frame_size, 0);
1741
1/2
✓ Branch 0 taken 236 times.
✗ Branch 1 not taken.
236 if (!s->packet_loss)
1742 236 s->packet_done = !decode_frame(s, data, got_frame_ptr);
1743
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23 times.
23 } else if (!s->len_prefix
1744 && s->num_saved_bits > get_bits_count(&s->gb)) {
1745 /** when the frames do not have a length prefix, we don't know
1746 the compressed length of the individual frames
1747 however, we know what part of a new packet belongs to the
1748 previous frame
1749 therefore we save the incoming packet first, then we append
1750 the "previous frame" data from the next packet so that
1751 we get a buffer that only contains full frames */
1752 s->packet_done = !decode_frame(s, data, got_frame_ptr);
1753 } else {
1754 23 s->packet_done = 1;
1755 }
1756 }
1757
1758
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 283 times.
283 if (remaining_bits(s, gb) < 0) {
1759 av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1760 s->packet_loss = 1;
1761 }
1762
1763
4/6
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 259 times.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 24 times.
✗ Branch 5 not taken.
307 if (s->packet_done && !s->packet_loss &&
1764 24 remaining_bits(s, gb) > 0) {
1765 /** save the rest of the data so that it can be decoded
1766 with the next packet */
1767 24 save_bits(s, gb, remaining_bits(s, gb), 0);
1768 }
1769
1770 283 s->packet_offset = get_bits_count(gb) & 7;
1771
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 283 times.
283 if (s->packet_loss)
1772 return AVERROR_INVALIDDATA;
1773
1774
3/4
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 280 times.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
283 if (s->trim_start && avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1775 3 AVFrame *frame = data;
1776
1777
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 if (s->trim_start < frame->nb_samples) {
1778 for (int ch = 0; ch < frame->channels; ch++)
1779 frame->extended_data[ch] += s->trim_start * 4;
1780
1781 frame->nb_samples -= s->trim_start;
1782 } else {
1783 3 *got_frame_ptr = 0;
1784 }
1785
1786 3 s->trim_start = 0;
1787 }
1788
1789
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 282 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
283 if (s->trim_end && avctx->codec_id == AV_CODEC_ID_WMAPRO) {
1790 1 AVFrame *frame = data;
1791
1792
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
1 if (s->trim_end < frame->nb_samples) {
1793 1 frame->nb_samples -= s->trim_end;
1794 } else {
1795 *got_frame_ptr = 0;
1796 }
1797
1798 1 s->trim_end = 0;
1799 }
1800
1801 283 return get_bits_count(gb) >> 3;
1802 }
1803
1804 /**
1805 *@brief Decode a single WMA packet.
1806 *@param avctx codec context
1807 *@param data the output buffer
1808 *@param avpkt input packet
1809 *@return number of bytes that were read from the input buffer
1810 */
1811 283 static int wmapro_decode_packet(AVCodecContext *avctx, void *data,
1812 int *got_frame_ptr, AVPacket *avpkt)
1813 {
1814 283 WMAProDecodeCtx *s = avctx->priv_data;
1815 283 AVFrame *frame = data;
1816 int ret;
1817
1818 /* get output buffer */
1819 283 frame->nb_samples = s->samples_per_frame;
1820
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 283 times.
283 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1821 s->packet_loss = 1;
1822 return 0;
1823 }
1824
1825 283 return decode_packet(avctx, s, data, got_frame_ptr, avpkt);
1826 }
1827
1828 static int xma_decode_packet(AVCodecContext *avctx, void *data,
1829 int *got_frame_ptr, AVPacket *avpkt)
1830 {
1831 XMADecodeCtx *s = avctx->priv_data;
1832 int got_stream_frame_ptr = 0;
1833 AVFrame *frame = data;
1834 int i, ret = 0, eof = 0;
1835
1836 if (!s->frames[s->current_stream]->data[0]) {
1837 avctx->internal->skip_samples = 64;
1838 s->frames[s->current_stream]->nb_samples = 512;
1839 if ((ret = ff_get_buffer(avctx, s->frames[s->current_stream], 0)) < 0)
1840 return ret;
1841 } else if (s->frames[s->current_stream]->nb_samples != 512) {
1842 avctx->internal->skip_samples = 64;
1843 av_frame_unref(s->frames[s->current_stream]);
1844 s->frames[s->current_stream]->nb_samples = 512;
1845 if ((ret = ff_get_buffer(avctx, s->frames[s->current_stream], 0)) < 0)
1846 return ret;
1847 }
1848 /* decode current stream packet */
1849 if (!s->xma[s->current_stream].eof_done) {
1850 ret = decode_packet(avctx, &s->xma[s->current_stream], s->frames[s->current_stream],
1851 &got_stream_frame_ptr, avpkt);
1852 }
1853
1854 if (!avpkt->size) {
1855 eof = 1;
1856
1857 for (i = 0; i < s->num_streams; i++) {
1858 if (!s->xma[i].eof_done && s->frames[i]->data[0]) {
1859 ret = decode_packet(avctx, &s->xma[i], s->frames[i],
1860 &got_stream_frame_ptr, avpkt);
1861 }
1862
1863 eof &= s->xma[i].eof_done;
1864 }
1865 }
1866
1867 if (s->xma[0].trim_start)
1868 s->trim_start = s->xma[0].trim_start;
1869 if (s->xma[0].trim_end)
1870 s->trim_end = s->xma[0].trim_end;
1871
1872 /* copy stream samples (1/2ch) to sample buffer (Nch) */
1873 if (got_stream_frame_ptr) {
1874 const int nb_samples = s->frames[s->current_stream]->nb_samples;
1875 void *left[1] = { s->frames[s->current_stream]->extended_data[0] };
1876 void *right[1] = { s->frames[s->current_stream]->extended_data[1] };
1877
1878 av_audio_fifo_write(s->samples[0][s->current_stream], left, nb_samples);
1879 if (s->xma[s->current_stream].nb_channels > 1)
1880 av_audio_fifo_write(s->samples[1][s->current_stream], right, nb_samples);
1881 } else if (ret < 0) {
1882 s->current_stream = 0;
1883 return ret;
1884 }
1885
1886 /* find next XMA packet's owner stream, and update.
1887 * XMA streams find their packets following packet_skips
1888 * (at start there is one packet per stream, then interleave non-linearly). */
1889 if (s->xma[s->current_stream].packet_done ||
1890 s->xma[s->current_stream].packet_loss) {
1891 int nb_samples = INT_MAX;
1892
1893 /* select stream with 0 skip_packets (= uses next packet) */
1894 if (s->xma[s->current_stream].skip_packets != 0) {
1895 int min[2];
1896
1897 min[0] = s->xma[0].skip_packets;
1898 min[1] = i = 0;
1899
1900 for (i = 1; i < s->num_streams; i++) {
1901 if (s->xma[i].skip_packets < min[0]) {
1902 min[0] = s->xma[i].skip_packets;
1903 min[1] = i;
1904 }
1905 }
1906
1907 s->current_stream = min[1];
1908 }
1909
1910 /* all other streams skip next packet */
1911 for (i = 0; i < s->num_streams; i++) {
1912 s->xma[i].skip_packets = FFMAX(0, s->xma[i].skip_packets - 1);
1913 nb_samples = FFMIN(nb_samples, av_audio_fifo_size(s->samples[0][i]));
1914 }
1915
1916 if (!eof && avpkt->size)
1917 nb_samples -= FFMIN(nb_samples, 4096);
1918
1919 /* copy samples from buffer to output if possible */
1920 if ((nb_samples > 0 || eof || !avpkt->size) && !s->flushed) {
1921 int bret;
1922
1923 if (eof) {
1924 nb_samples -= av_clip(s->trim_end + s->trim_start - 128 - 64, 0, nb_samples);
1925 s->flushed = 1;
1926 }
1927
1928 frame->nb_samples = nb_samples;
1929 if ((bret = ff_get_buffer(avctx, frame, 0)) < 0)
1930 return bret;
1931
1932 for (i = 0; i < s->num_streams; i++) {
1933 const int start_ch = s->start_channel[i];
1934 void *left[1] = { frame->extended_data[start_ch + 0] };
1935 void *right[1] = { frame->extended_data[start_ch + 1] };
1936
1937 av_audio_fifo_read(s->samples[0][i], left, nb_samples);
1938 if (s->xma[i].nb_channels > 1)
1939 av_audio_fifo_read(s->samples[1][i], right, nb_samples);
1940 }
1941
1942 *got_frame_ptr = nb_samples > 0;
1943 }
1944 }
1945
1946 return ret;
1947 }
1948
1949 static av_cold int xma_decode_init(AVCodecContext *avctx)
1950 {
1951 XMADecodeCtx *s = avctx->priv_data;
1952 int i, ret, start_channels = 0;
1953
1954 if (avctx->channels <= 0 || avctx->extradata_size == 0)
1955 return AVERROR_INVALIDDATA;
1956
1957 /* get stream config */
1958 if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size == 34) { /* XMA2WAVEFORMATEX */
1959 s->num_streams = AV_RL16(avctx->extradata);
1960 avctx->channel_layout = AV_RL32(avctx->extradata + 2);
1961 } else if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size >= 2) { /* XMA2WAVEFORMAT */
1962 s->num_streams = avctx->extradata[1];
1963 if (avctx->extradata_size != (32 + ((avctx->extradata[0]==3)?0:8) + 4*s->num_streams)) {
1964 av_log(avctx, AV_LOG_ERROR, "Incorrect XMA2 extradata size\n");
1965 s->num_streams = 0;
1966 return AVERROR(EINVAL);
1967 }
1968 } else if (avctx->codec_id == AV_CODEC_ID_XMA1 && avctx->extradata_size >= 4) { /* XMAWAVEFORMAT */
1969 s->num_streams = avctx->extradata[4];
1970 if (avctx->extradata_size != (8 + 20*s->num_streams)) {
1971 av_log(avctx, AV_LOG_ERROR, "Incorrect XMA1 extradata size\n");
1972 s->num_streams = 0;
1973 return AVERROR(EINVAL);
1974 }
1975 } else {
1976 av_log(avctx, AV_LOG_ERROR, "Incorrect XMA config\n");
1977 return AVERROR(EINVAL);
1978 }
1979
1980 /* encoder supports up to 64 streams / 64*2 channels (would have to alloc arrays) */
1981 if (avctx->channels > XMA_MAX_CHANNELS || s->num_streams > XMA_MAX_STREAMS ||
1982 s->num_streams <= 0
1983 ) {
1984 avpriv_request_sample(avctx, "More than %d channels in %d streams", XMA_MAX_CHANNELS, s->num_streams);
1985 s->num_streams = 0;
1986 return AVERROR_PATCHWELCOME;
1987 }
1988
1989 /* init all streams (several streams of 1/2ch make Nch files) */
1990 for (i = 0; i < s->num_streams; i++) {
1991 ret = decode_init(&s->xma[i], avctx, i);
1992 if (ret < 0)
1993 return ret;
1994 s->frames[i] = av_frame_alloc();
1995 if (!s->frames[i])
1996 return AVERROR(ENOMEM);
1997
1998 s->start_channel[i] = start_channels;
1999 start_channels += s->xma[i].nb_channels;
2000 }
2001 if (start_channels != avctx->channels)
2002 return AVERROR_INVALIDDATA;
2003
2004 for (int i = 0; i < XMA_MAX_STREAMS; i++) {
2005 s->samples[0][i] = av_audio_fifo_alloc(avctx->sample_fmt, 1, 64 * 512);
2006 s->samples[1][i] = av_audio_fifo_alloc(avctx->sample_fmt, 1, 64 * 512);
2007 if (!s->samples[0][i] || !s->samples[1][i])
2008 return AVERROR(ENOMEM);
2009 }
2010
2011 return ret;
2012 }
2013
2014 static av_cold int xma_decode_end(AVCodecContext *avctx)
2015 {
2016 XMADecodeCtx *s = avctx->priv_data;
2017 int i;
2018
2019 for (i = 0; i < s->num_streams; i++) {
2020 decode_end(&s->xma[i]);
2021 av_frame_free(&s->frames[i]);
2022 }
2023 s->num_streams = 0;
2024
2025 for (i = 0; i < XMA_MAX_STREAMS; i++) {
2026 av_audio_fifo_free(s->samples[0][i]);
2027 av_audio_fifo_free(s->samples[1][i]);
2028 }
2029
2030 return 0;
2031 }
2032
2033 static void flush(WMAProDecodeCtx *s)
2034 {
2035 int i;
2036 /** reset output buffer as a part of it is used during the windowing of a
2037 new frame */
2038 for (i = 0; i < s->nb_channels; i++)
2039 memset(s->channel[i].out, 0, s->samples_per_frame *
2040 sizeof(*s->channel[i].out));
2041 s->packet_loss = 1;
2042 s->skip_packets = 0;
2043 s->eof_done = 0;
2044 s->skip_frame = 1;
2045 }
2046
2047 /**
2048 *@brief Clear decoder buffers (for seeking).
2049 *@param avctx codec context
2050 */
2051 static void wmapro_flush(AVCodecContext *avctx)
2052 {
2053 WMAProDecodeCtx *s = avctx->priv_data;
2054
2055 flush(s);
2056 }
2057
2058 static void xma_flush(AVCodecContext *avctx)
2059 {
2060 XMADecodeCtx *s = avctx->priv_data;
2061 int i;
2062
2063 for (i = 0; i < XMA_MAX_STREAMS; i++) {
2064 av_audio_fifo_reset(s->samples[0][i]);
2065 av_audio_fifo_reset(s->samples[1][i]);
2066 }
2067
2068 for (i = 0; i < s->num_streams; i++)
2069 flush(&s->xma[i]);
2070
2071 s->current_stream = 0;
2072 s->flushed = 0;
2073 }
2074
2075 /**
2076 *@brief wmapro decoder
2077 */
2078 const AVCodec ff_wmapro_decoder = {
2079 .name = "wmapro",
2080 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
2081 .type = AVMEDIA_TYPE_AUDIO,
2082 .id = AV_CODEC_ID_WMAPRO,
2083 .priv_data_size = sizeof(WMAProDecodeCtx),
2084 .init = wmapro_decode_init,
2085 .close = wmapro_decode_end,
2086 .decode = wmapro_decode_packet,
2087 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
2088 .flush = wmapro_flush,
2089 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2090 AV_SAMPLE_FMT_NONE },
2091 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
2092 };
2093
2094 const AVCodec ff_xma1_decoder = {
2095 .name = "xma1",
2096 .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"),
2097 .type = AVMEDIA_TYPE_AUDIO,
2098 .id = AV_CODEC_ID_XMA1,
2099 .priv_data_size = sizeof(XMADecodeCtx),
2100 .init = xma_decode_init,
2101 .close = xma_decode_end,
2102 .decode = xma_decode_packet,
2103 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
2104 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2105 AV_SAMPLE_FMT_NONE },
2106 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
2107 };
2108
2109 const AVCodec ff_xma2_decoder = {
2110 .name = "xma2",
2111 .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"),
2112 .type = AVMEDIA_TYPE_AUDIO,
2113 .id = AV_CODEC_ID_XMA2,
2114 .priv_data_size = sizeof(XMADecodeCtx),
2115 .init = xma_decode_init,
2116 .close = xma_decode_end,
2117 .decode = xma_decode_packet,
2118 .flush = xma_flush,
2119 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
2120 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
2121 AV_SAMPLE_FMT_NONE },
2122 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
2123 };
2124