FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/wmaprodec.c
Date: 2024-07-17 14:05:47
Exec Total Coverage
Lines: 617 934 66.1%
Functions: 20 27 74.1%
Branches: 353 624 56.6%

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