FFmpeg coverage

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