FFmpeg coverage

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