1 /*
2 * Windows Media Audio Lossless decoder
3 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4 * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
5 * Copyright (c) 2011 Andreas Öman
6 * Copyright (c) 2011 - 2012 Mashiat Sarker Shakkhar
7 *
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 #include <inttypes.h>
26
27 #include "libavutil/attributes.h"
28 #include "libavutil/avassert.h"
29
30 #include "avcodec.h"
31 #include "internal.h"
32 #include "get_bits.h"
33 #include "put_bits.h"
34 #include "lossless_audiodsp.h"
35 #include "wma.h"
36 #include "wma_common.h"
37
38 /** current decoder limitations */
39 #define WMALL_MAX_CHANNELS 8 ///< max number of handled channels
40 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
41 #define MAX_BANDS 29 ///< max number of scale factor bands
42 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
43 #define MAX_ORDER 256
44
45 #define WMALL_BLOCK_MIN_BITS 6 ///< log2 of min block size
46 #define WMALL_BLOCK_MAX_BITS 14 ///< log2 of max block size
47 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS) ///< maximum block size
48 #define WMALL_BLOCK_SIZES (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
49
50 #define WMALL_COEFF_PAD_SIZE 16 ///< pad coef buffers with 0 for use with SIMD
51
52 /**
53 * @brief frame-specific decoder context for a single channel
54 */
55 typedef struct WmallChannelCtx {
56 int16_t prev_block_len; ///< length of the previous block
57 uint8_t transmit_coefs;
58 uint8_t num_subframes;
59 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
60 uint16_t subframe_offsets[MAX_SUBFRAMES]; ///< subframe positions in the current frame
61 uint8_t cur_subframe; ///< current subframe number
62 uint16_t decoded_samples; ///< number of already processed samples
63 int quant_step; ///< quantization step for the current subframe
64 int transient_counter; ///< number of transient samples from the beginning of the transient zone
65 } WmallChannelCtx;
66
67 /**
68 * @brief main decoder context
69 */
70 typedef struct WmallDecodeCtx {
71 /* generic decoder variables */
72 AVCodecContext *avctx;
73 AVFrame *frame;
74 LLAudDSPContext dsp; ///< accelerated DSP functions
75 uint8_t *frame_data; ///< compressed frame data
76 int max_frame_size; ///< max bitstream size
77 PutBitContext pb; ///< context for filling the frame_data buffer
78
79 /* frame size dependent frame information (set during initialization) */
80 uint32_t decode_flags; ///< used compression features
81 int len_prefix; ///< frame is prefixed with its length
82 int dynamic_range_compression; ///< frame contains DRC data
83 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
84 uint16_t samples_per_frame; ///< number of samples to output
85 uint16_t log2_frame_size;
86 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
87 int8_t lfe_channel; ///< lfe channel index
88 uint8_t max_num_subframes;
89 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
90 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
91 uint16_t min_samples_per_subframe;
92
93 /* packet decode state */
94 GetBitContext pgb; ///< bitstream reader context for the packet
95 int next_packet_start; ///< start offset of the next WMA packet in the demuxer packet
96 uint8_t packet_offset; ///< offset to the frame in the packet
97 uint8_t packet_sequence_number; ///< current packet number
98 int num_saved_bits; ///< saved number of bits
99 int frame_offset; ///< frame offset in the bit reservoir
100 int subframe_offset; ///< subframe offset in the bit reservoir
101 uint8_t packet_loss; ///< set in case of bitstream error
102 uint8_t packet_done; ///< set when a packet is fully decoded
103
104 /* frame decode state */
105 uint32_t frame_num; ///< current frame number (not used for decoding)
106 GetBitContext gb; ///< bitstream reader context
107 int buf_bit_size; ///< buffer size in bits
108 int16_t *samples_16[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (16-bit)
109 int32_t *samples_32[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (24-bit)
110 uint8_t drc_gain; ///< gain for the DRC tool
111 int8_t skip_frame; ///< skip output step
112 int8_t parsed_all_subframes; ///< all subframes decoded?
113
114 /* subframe/block decode state */
115 int16_t subframe_len; ///< current subframe length
116 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
117 int8_t channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
118
119 WmallChannelCtx channel[WMALL_MAX_CHANNELS]; ///< per channel data
120
121 // WMA Lossless-specific
122
123 uint8_t do_arith_coding;
124 uint8_t do_ac_filter;
125 uint8_t do_inter_ch_decorr;
126 uint8_t do_mclms;
127 uint8_t do_lpc;
128
129 int8_t acfilter_order;
130 int8_t acfilter_scaling;
131 int16_t acfilter_coeffs[16];
132 int acfilter_prevvalues[WMALL_MAX_CHANNELS][16];
133
134 int8_t mclms_order;
135 int8_t mclms_scaling;
136 int16_t mclms_coeffs[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS * 32];
137 int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS];
138 int32_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
139 int32_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
140 int mclms_recent;
141
142 int movave_scaling;
143 int quant_stepsize;
144
145 struct {
146 int order;
147 int scaling;
148 int coefsend;
149 int bitsend;
150 DECLARE_ALIGNED(16, int16_t, coefs)[MAX_ORDER + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
151 DECLARE_ALIGNED(16, int32_t, lms_prevvalues)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
152 DECLARE_ALIGNED(16, int16_t, lms_updates)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
153 int recent;
154 } cdlms[WMALL_MAX_CHANNELS][9];
155
156 int cdlms_ttl[WMALL_MAX_CHANNELS];
157
158 int bV3RTM;
159
160 int is_channel_coded[WMALL_MAX_CHANNELS];
161 int update_speed[WMALL_MAX_CHANNELS];
162
163 int transient[WMALL_MAX_CHANNELS];
164 int transient_pos[WMALL_MAX_CHANNELS];
165 int seekable_tile;
166
167 unsigned ave_sum[WMALL_MAX_CHANNELS];
168
169 int channel_residues[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE];
170
171 int lpc_coefs[WMALL_MAX_CHANNELS][40];
172 int lpc_order;
173 int lpc_scaling;
174 int lpc_intbits;
175 } WmallDecodeCtx;
176
177 /** Get sign of integer (1 for positive, -1 for negative and 0 for zero) */
178 #define WMASIGN(x) (((x) > 0) - ((x) < 0))
179
decode_init(AVCodecContext * avctx)180 static av_cold int decode_init(AVCodecContext *avctx)
181 {
182 WmallDecodeCtx *s = avctx->priv_data;
183 uint8_t *edata_ptr = avctx->extradata;
184 unsigned int channel_mask;
185 int i, log2_max_num_subframes;
186
187 if (avctx->block_align <= 0 || avctx->block_align > (1<<21)) {
188 av_log(avctx, AV_LOG_ERROR, "block_align is not set or invalid\n");
189 return AVERROR(EINVAL);
190 }
191
192 av_assert0(avctx->channels >= 0);
193 if (avctx->channels > WMALL_MAX_CHANNELS) {
194 avpriv_request_sample(avctx,
195 "More than " AV_STRINGIFY(WMALL_MAX_CHANNELS) " channels");
196 return AVERROR_PATCHWELCOME;
197 }
198
199 s->max_frame_size = MAX_FRAMESIZE * avctx->channels;
200 s->frame_data = av_mallocz(s->max_frame_size + AV_INPUT_BUFFER_PADDING_SIZE);
201 if (!s->frame_data)
202 return AVERROR(ENOMEM);
203
204 s->avctx = avctx;
205 ff_llauddsp_init(&s->dsp);
206 init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
207
208 if (avctx->extradata_size >= 18) {
209 s->decode_flags = AV_RL16(edata_ptr + 14);
210 channel_mask = AV_RL32(edata_ptr + 2);
211 s->bits_per_sample = AV_RL16(edata_ptr);
212 if (s->bits_per_sample == 16)
213 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
214 else if (s->bits_per_sample == 24) {
215 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
216 avctx->bits_per_raw_sample = 24;
217 } else {
218 av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
219 s->bits_per_sample);
220 return AVERROR_INVALIDDATA;
221 }
222 /* dump the extradata */
223 for (i = 0; i < avctx->extradata_size; i++)
224 ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
225 ff_dlog(avctx, "\n");
226
227 } else {
228 avpriv_request_sample(avctx, "Unsupported extradata size");
229 return AVERROR_PATCHWELCOME;
230 }
231
232 /* generic init */
233 s->log2_frame_size = av_log2(avctx->block_align) + 4;
234
235 /* frame info */
236 s->skip_frame = 1; /* skip first frame */
237 s->packet_loss = 1;
238 s->len_prefix = s->decode_flags & 0x40;
239
240 /* get frame len */
241 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
242 3, s->decode_flags);
243 av_assert0(s->samples_per_frame <= WMALL_BLOCK_MAX_SIZE);
244
245 /* init previous block len */
246 for (i = 0; i < avctx->channels; i++)
247 s->channel[i].prev_block_len = s->samples_per_frame;
248
249 /* subframe info */
250 log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
251 s->max_num_subframes = 1 << log2_max_num_subframes;
252 s->max_subframe_len_bit = 0;
253 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
254
255 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
256 s->dynamic_range_compression = s->decode_flags & 0x80;
257 s->bV3RTM = s->decode_flags & 0x100;
258
259 if (s->max_num_subframes > MAX_SUBFRAMES) {
260 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
261 s->max_num_subframes);
262 return AVERROR_INVALIDDATA;
263 }
264
265 s->num_channels = avctx->channels;
266
267 /* extract lfe channel position */
268 s->lfe_channel = -1;
269
270 if (channel_mask & 8) {
271 unsigned int mask;
272 for (mask = 1; mask < 16; mask <<= 1)
273 if (channel_mask & mask)
274 ++s->lfe_channel;
275 }
276
277 s->frame = av_frame_alloc();
278 if (!s->frame)
279 return AVERROR(ENOMEM);
280
281 avctx->channel_layout = channel_mask;
282 return 0;
283 }
284
285 /**
286 * @brief Decode the subframe length.
287 * @param s context
288 * @param offset sample offset in the frame
289 * @return decoded subframe length on success, < 0 in case of an error
290 */
decode_subframe_length(WmallDecodeCtx * s,int offset)291 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
292 {
293 int frame_len_ratio, subframe_len, len;
294
295 /* no need to read from the bitstream when only one length is possible */
296 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
297 return s->min_samples_per_subframe;
298
299 len = av_log2(s->max_num_subframes - 1) + 1;
300 frame_len_ratio = get_bits(&s->gb, len);
301 subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
302
303 /* sanity check the length */
304 if (subframe_len < s->min_samples_per_subframe ||
305 subframe_len > s->samples_per_frame) {
306 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
307 subframe_len);
308 return AVERROR_INVALIDDATA;
309 }
310 return subframe_len;
311 }
312
313 /**
314 * @brief Decode how the data in the frame is split into subframes.
315 * Every WMA frame contains the encoded data for a fixed number of
316 * samples per channel. The data for every channel might be split
317 * into several subframes. This function will reconstruct the list of
318 * subframes for every channel.
319 *
320 * If the subframes are not evenly split, the algorithm estimates the
321 * channels with the lowest number of total samples.
322 * Afterwards, for each of these channels a bit is read from the
323 * bitstream that indicates if the channel contains a subframe with the
324 * next subframe size that is going to be read from the bitstream or not.
325 * If a channel contains such a subframe, the subframe size gets added to
326 * the channel's subframe list.
327 * The algorithm repeats these steps until the frame is properly divided
328 * between the individual channels.
329 *
330 * @param s context
331 * @return 0 on success, < 0 in case of an error
332 */
decode_tilehdr(WmallDecodeCtx * s)333 static int decode_tilehdr(WmallDecodeCtx *s)
334 {
335 uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
336 uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
337 int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
338 int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
339 int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
340 int c, tile_aligned;
341
342 /* reset tiling information */
343 for (c = 0; c < s->num_channels; c++)
344 s->channel[c].num_subframes = 0;
345
346 tile_aligned = get_bits1(&s->gb);
347 if (s->max_num_subframes == 1 || tile_aligned)
348 fixed_channel_layout = 1;
349
350 /* loop until the frame data is split between the subframes */
351 do {
352 int subframe_len, in_use = 0;
353
354 /* check which channels contain the subframe */
355 for (c = 0; c < s->num_channels; c++) {
356 if (num_samples[c] == min_channel_len) {
357 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
358 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
359 contains_subframe[c] = 1;
360 } else {
361 contains_subframe[c] = get_bits1(&s->gb);
362 }
363 in_use |= contains_subframe[c];
364 } else
365 contains_subframe[c] = 0;
366 }
367
368 if (!in_use) {
369 av_log(s->avctx, AV_LOG_ERROR,
370 "Found empty subframe\n");
371 return AVERROR_INVALIDDATA;
372 }
373
374 /* get subframe length, subframe_len == 0 is not allowed */
375 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
376 return AVERROR_INVALIDDATA;
377 /* add subframes to the individual channels and find new min_channel_len */
378 min_channel_len += subframe_len;
379 for (c = 0; c < s->num_channels; c++) {
380 WmallChannelCtx *chan = &s->channel[c];
381
382 if (contains_subframe[c]) {
383 if (chan->num_subframes >= MAX_SUBFRAMES) {
384 av_log(s->avctx, AV_LOG_ERROR,
385 "broken frame: num subframes > 31\n");
386 return AVERROR_INVALIDDATA;
387 }
388 chan->subframe_len[chan->num_subframes] = subframe_len;
389 num_samples[c] += subframe_len;
390 ++chan->num_subframes;
391 if (num_samples[c] > s->samples_per_frame) {
392 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
393 "channel len(%"PRIu16") > samples_per_frame(%"PRIu16")\n",
394 num_samples[c], s->samples_per_frame);
395 return AVERROR_INVALIDDATA;
396 }
397 } else if (num_samples[c] <= min_channel_len) {
398 if (num_samples[c] < min_channel_len) {
399 channels_for_cur_subframe = 0;
400 min_channel_len = num_samples[c];
401 }
402 ++channels_for_cur_subframe;
403 }
404 }
405 } while (min_channel_len < s->samples_per_frame);
406
407 for (c = 0; c < s->num_channels; c++) {
408 int i, offset = 0;
409 for (i = 0; i < s->channel[c].num_subframes; i++) {
410 s->channel[c].subframe_offsets[i] = offset;
411 offset += s->channel[c].subframe_len[i];
412 }
413 }
414
415 return 0;
416 }
417
decode_ac_filter(WmallDecodeCtx * s)418 static void decode_ac_filter(WmallDecodeCtx *s)
419 {
420 int i;
421 s->acfilter_order = get_bits(&s->gb, 4) + 1;
422 s->acfilter_scaling = get_bits(&s->gb, 4);
423
424 for (i = 0; i < s->acfilter_order; i++)
425 s->acfilter_coeffs[i] = get_bitsz(&s->gb, s->acfilter_scaling) + 1;
426 }
427
decode_mclms(WmallDecodeCtx * s)428 static void decode_mclms(WmallDecodeCtx *s)
429 {
430 s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
431 s->mclms_scaling = get_bits(&s->gb, 4);
432 if (get_bits1(&s->gb)) {
433 int i, send_coef_bits;
434 int cbits = av_log2(s->mclms_scaling + 1);
435 if (1 << cbits < s->mclms_scaling + 1)
436 cbits++;
437
438 send_coef_bits = get_bitsz(&s->gb, cbits) + 2;
439
440 for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
441 s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
442
443 for (i = 0; i < s->num_channels; i++) {
444 int c;
445 for (c = 0; c < i; c++)
446 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
447 }
448 }
449 }
450
decode_cdlms(WmallDecodeCtx * s)451 static int decode_cdlms(WmallDecodeCtx *s)
452 {
453 int c, i;
454 int cdlms_send_coef = get_bits1(&s->gb);
455
456 for (c = 0; c < s->num_channels; c++) {
457 s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
458 for (i = 0; i < s->cdlms_ttl[c]; i++) {
459 s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
460 if (s->cdlms[c][i].order > MAX_ORDER) {
461 av_log(s->avctx, AV_LOG_ERROR,
462 "Order[%d][%d] %d > max (%d), not supported\n",
463 c, i, s->cdlms[c][i].order, MAX_ORDER);
464 s->cdlms[0][0].order = 0;
465 return AVERROR_INVALIDDATA;
466 }
467 if(s->cdlms[c][i].order & 8 && s->bits_per_sample == 16) {
468 static int warned;
469 if(!warned)
470 avpriv_request_sample(s->avctx, "CDLMS of order %d",
471 s->cdlms[c][i].order);
472 warned = 1;
473 }
474 }
475
476 for (i = 0; i < s->cdlms_ttl[c]; i++)
477 s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
478
479 if (cdlms_send_coef) {
480 for (i = 0; i < s->cdlms_ttl[c]; i++) {
481 int cbits, shift_l, shift_r, j;
482 cbits = av_log2(s->cdlms[c][i].order);
483 if ((1 << cbits) < s->cdlms[c][i].order)
484 cbits++;
485 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
486
487 cbits = av_log2(s->cdlms[c][i].scaling + 1);
488 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
489 cbits++;
490
491 s->cdlms[c][i].bitsend = get_bitsz(&s->gb, cbits) + 2;
492 shift_l = 32 - s->cdlms[c][i].bitsend;
493 shift_r = 32 - s->cdlms[c][i].scaling - 2;
494 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
495 s->cdlms[c][i].coefs[j] =
496 (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
497 }
498 }
499
500 for (i = 0; i < s->cdlms_ttl[c]; i++)
501 memset(s->cdlms[c][i].coefs + s->cdlms[c][i].order,
502 0, WMALL_COEFF_PAD_SIZE);
503 }
504
505 return 0;
506 }
507
decode_channel_residues(WmallDecodeCtx * s,int ch,int tile_size)508 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
509 {
510 int i = 0;
511 unsigned int ave_mean;
512 s->transient[ch] = get_bits1(&s->gb);
513 if (s->transient[ch]) {
514 s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
515 if (s->transient_pos[ch])
516 s->transient[ch] = 0;
517 s->channel[ch].transient_counter =
518 FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
519 } else if (s->channel[ch].transient_counter)
520 s->transient[ch] = 1;
521
522 if (s->seekable_tile) {
523 ave_mean = get_bits(&s->gb, s->bits_per_sample);
524 s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
525 }
526
527 if (s->seekable_tile) {
528 if (s->do_inter_ch_decorr)
529 s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample + 1);
530 else
531 s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample);
532 i++;
533 }
534 for (; i < tile_size; i++) {
535 int rem, rem_bits;
536 unsigned quo = 0, residue;
537 while(get_bits1(&s->gb)) {
538 quo++;
539 if (get_bits_left(&s->gb) <= 0)
540 return -1;
541 }
542 if (quo >= 32)
543 quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
544
545 ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
546 if (ave_mean <= 1)
547 residue = quo;
548 else {
549 rem_bits = av_ceil_log2(ave_mean);
550 rem = get_bits_long(&s->gb, rem_bits);
551 residue = (quo << rem_bits) + rem;
552 }
553
554 s->ave_sum[ch] = residue + s->ave_sum[ch] -
555 (s->ave_sum[ch] >> s->movave_scaling);
556
557 residue = (residue >> 1) ^ -(residue & 1);
558 s->channel_residues[ch][i] = residue;
559 }
560
561 return 0;
562
563 }
564
decode_lpc(WmallDecodeCtx * s)565 static void decode_lpc(WmallDecodeCtx *s)
566 {
567 int ch, i, cbits;
568 s->lpc_order = get_bits(&s->gb, 5) + 1;
569 s->lpc_scaling = get_bits(&s->gb, 4);
570 s->lpc_intbits = get_bits(&s->gb, 3) + 1;
571 cbits = s->lpc_scaling + s->lpc_intbits;
572 for (ch = 0; ch < s->num_channels; ch++)
573 for (i = 0; i < s->lpc_order; i++)
574 s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
575 }
576
clear_codec_buffers(WmallDecodeCtx * s)577 static void clear_codec_buffers(WmallDecodeCtx *s)
578 {
579 int ich, ilms;
580
581 memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
582 memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
583 memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
584
585 memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
586 memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
587 memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
588 memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
589
590 for (ich = 0; ich < s->num_channels; ich++) {
591 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
592 memset(s->cdlms[ich][ilms].coefs, 0,
593 sizeof(s->cdlms[ich][ilms].coefs));
594 memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
595 sizeof(s->cdlms[ich][ilms].lms_prevvalues));
596 memset(s->cdlms[ich][ilms].lms_updates, 0,
597 sizeof(s->cdlms[ich][ilms].lms_updates));
598 }
599 s->ave_sum[ich] = 0;
600 }
601 }
602
603 /**
604 * @brief Reset filter parameters and transient area at new seekable tile.
605 */
reset_codec(WmallDecodeCtx * s)606 static void reset_codec(WmallDecodeCtx *s)
607 {
608 int ich, ilms;
609 s->mclms_recent = s->mclms_order * s->num_channels;
610 for (ich = 0; ich < s->num_channels; ich++) {
611 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
612 s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
613 /* first sample of a seekable subframe is considered as the starting of
614 a transient area which is samples_per_frame samples long */
615 s->channel[ich].transient_counter = s->samples_per_frame;
616 s->transient[ich] = 1;
617 s->transient_pos[ich] = 0;
618 }
619 }
620
mclms_update(WmallDecodeCtx * s,int icoef,int * pred)621 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
622 {
623 int i, j, ich, pred_error;
624 int order = s->mclms_order;
625 int num_channels = s->num_channels;
626 int range = 1 << (s->bits_per_sample - 1);
627
628 for (ich = 0; ich < num_channels; ich++) {
629 pred_error = s->channel_residues[ich][icoef] - (unsigned)pred[ich];
630 if (pred_error > 0) {
631 for (i = 0; i < order * num_channels; i++)
632 s->mclms_coeffs[i + ich * order * num_channels] +=
633 s->mclms_updates[s->mclms_recent + i];
634 for (j = 0; j < ich; j++)
635 s->mclms_coeffs_cur[ich * num_channels + j] += WMASIGN(s->channel_residues[j][icoef]);
636 } else if (pred_error < 0) {
637 for (i = 0; i < order * num_channels; i++)
638 s->mclms_coeffs[i + ich * order * num_channels] -=
639 s->mclms_updates[s->mclms_recent + i];
640 for (j = 0; j < ich; j++)
641 s->mclms_coeffs_cur[ich * num_channels + j] -= WMASIGN(s->channel_residues[j][icoef]);
642 }
643 }
644
645 for (ich = num_channels - 1; ich >= 0; ich--) {
646 s->mclms_recent--;
647 s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
648 -range, range - 1);
649 s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
650 }
651
652 if (s->mclms_recent == 0) {
653 memcpy(&s->mclms_prevvalues[order * num_channels],
654 s->mclms_prevvalues,
655 sizeof(int32_t) * order * num_channels);
656 memcpy(&s->mclms_updates[order * num_channels],
657 s->mclms_updates,
658 sizeof(int32_t) * order * num_channels);
659 s->mclms_recent = num_channels * order;
660 }
661 }
662
mclms_predict(WmallDecodeCtx * s,int icoef,int * pred)663 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
664 {
665 int ich, i;
666 int order = s->mclms_order;
667 int num_channels = s->num_channels;
668
669 for (ich = 0; ich < num_channels; ich++) {
670 pred[ich] = 0;
671 if (!s->is_channel_coded[ich])
672 continue;
673 for (i = 0; i < order * num_channels; i++)
674 pred[ich] += (uint32_t)s->mclms_prevvalues[i + s->mclms_recent] *
675 s->mclms_coeffs[i + order * num_channels * ich];
676 for (i = 0; i < ich; i++)
677 pred[ich] += (uint32_t)s->channel_residues[i][icoef] *
678 s->mclms_coeffs_cur[i + num_channels * ich];
679 pred[ich] += (1U << s->mclms_scaling) >> 1;
680 pred[ich] >>= s->mclms_scaling;
681 s->channel_residues[ich][icoef] += (unsigned)pred[ich];
682 }
683 }
684
revert_mclms(WmallDecodeCtx * s,int tile_size)685 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
686 {
687 int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
688 for (icoef = 0; icoef < tile_size; icoef++) {
689 mclms_predict(s, icoef, pred);
690 mclms_update(s, icoef, pred);
691 }
692 }
693
use_high_update_speed(WmallDecodeCtx * s,int ich)694 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
695 {
696 int ilms, recent, icoef;
697 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
698 recent = s->cdlms[ich][ilms].recent;
699 if (s->update_speed[ich] == 16)
700 continue;
701 if (s->bV3RTM) {
702 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
703 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
704 } else {
705 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
706 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
707 }
708 }
709 s->update_speed[ich] = 16;
710 }
711
use_normal_update_speed(WmallDecodeCtx * s,int ich)712 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
713 {
714 int ilms, recent, icoef;
715 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
716 recent = s->cdlms[ich][ilms].recent;
717 if (s->update_speed[ich] == 8)
718 continue;
719 if (s->bV3RTM)
720 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
721 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
722 else
723 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
724 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
725 }
726 s->update_speed[ich] = 8;
727 }
728
729 #define CD_LMS(bits, ROUND) \
730 static void lms_update ## bits (WmallDecodeCtx *s, int ich, int ilms, int input) \
731 { \
732 int recent = s->cdlms[ich][ilms].recent; \
733 int range = 1 << s->bits_per_sample - 1; \
734 int order = s->cdlms[ich][ilms].order; \
735 int ##bits##_t *prev = (int##bits##_t *)s->cdlms[ich][ilms].lms_prevvalues; \
736 \
737 if (recent) \
738 recent--; \
739 else { \
740 memcpy(prev + order, prev, (bits/8) * order); \
741 memcpy(s->cdlms[ich][ilms].lms_updates + order, \
742 s->cdlms[ich][ilms].lms_updates, \
743 sizeof(*s->cdlms[ich][ilms].lms_updates) * order); \
744 recent = order - 1; \
745 } \
746 \
747 prev[recent] = av_clip(input, -range, range - 1); \
748 s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich]; \
749 \
750 s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2; \
751 s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1; \
752 s->cdlms[ich][ilms].recent = recent; \
753 memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0, \
754 sizeof(s->cdlms[ich][ilms].lms_updates) - \
755 sizeof(*s->cdlms[ich][ilms].lms_updates)*(recent+order)); \
756 } \
757 \
758 static void revert_cdlms ## bits (WmallDecodeCtx *s, int ch, \
759 int coef_begin, int coef_end) \
760 { \
761 int icoef, ilms, num_lms, residue, input; \
762 unsigned pred;\
763 \
764 num_lms = s->cdlms_ttl[ch]; \
765 for (ilms = num_lms - 1; ilms >= 0; ilms--) { \
766 for (icoef = coef_begin; icoef < coef_end; icoef++) { \
767 int##bits##_t *prevvalues = (int##bits##_t *)s->cdlms[ch][ilms].lms_prevvalues; \
768 pred = (1 << s->cdlms[ch][ilms].scaling) >> 1; \
769 residue = s->channel_residues[ch][icoef]; \
770 pred += s->dsp.scalarproduct_and_madd_int## bits (s->cdlms[ch][ilms].coefs, \
771 prevvalues + s->cdlms[ch][ilms].recent, \
772 s->cdlms[ch][ilms].lms_updates + \
773 s->cdlms[ch][ilms].recent, \
774 FFALIGN(s->cdlms[ch][ilms].order, ROUND), \
775 WMASIGN(residue)); \
776 input = residue + (unsigned)((int)pred >> s->cdlms[ch][ilms].scaling); \
777 lms_update ## bits(s, ch, ilms, input); \
778 s->channel_residues[ch][icoef] = input; \
779 } \
780 } \
781 if (bits <= 16) emms_c(); \
782 }
783
784 CD_LMS(16, WMALL_COEFF_PAD_SIZE)
785 CD_LMS(32, 8)
786
revert_inter_ch_decorr(WmallDecodeCtx * s,int tile_size)787 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
788 {
789 if (s->num_channels != 2)
790 return;
791 else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
792 int icoef;
793 for (icoef = 0; icoef < tile_size; icoef++) {
794 s->channel_residues[0][icoef] -= (unsigned)(s->channel_residues[1][icoef] >> 1);
795 s->channel_residues[1][icoef] += (unsigned) s->channel_residues[0][icoef];
796 }
797 }
798 }
799
revert_acfilter(WmallDecodeCtx * s,int tile_size)800 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
801 {
802 int ich, pred, i, j;
803 int16_t *filter_coeffs = s->acfilter_coeffs;
804 int scaling = s->acfilter_scaling;
805 int order = s->acfilter_order;
806
807 for (ich = 0; ich < s->num_channels; ich++) {
808 int *prevvalues = s->acfilter_prevvalues[ich];
809 for (i = 0; i < order; i++) {
810 pred = 0;
811 for (j = 0; j < order; j++) {
812 if (i <= j)
813 pred += (uint32_t)filter_coeffs[j] * prevvalues[j - i];
814 else
815 pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
816 }
817 pred >>= scaling;
818 s->channel_residues[ich][i] += (unsigned)pred;
819 }
820 for (i = order; i < tile_size; i++) {
821 pred = 0;
822 for (j = 0; j < order; j++)
823 pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
824 pred >>= scaling;
825 s->channel_residues[ich][i] += (unsigned)pred;
826 }
827 for (j = order - 1; j >= 0; j--)
828 if (tile_size <= j) {
829 prevvalues[j] = prevvalues[j - tile_size];
830 }else
831 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
832 }
833 }
834
decode_subframe(WmallDecodeCtx * s)835 static int decode_subframe(WmallDecodeCtx *s)
836 {
837 int offset = s->samples_per_frame;
838 int subframe_len = s->samples_per_frame;
839 int total_samples = s->samples_per_frame * s->num_channels;
840 int i, j, rawpcm_tile, padding_zeroes, res;
841
842 s->subframe_offset = get_bits_count(&s->gb);
843
844 /* reset channel context and find the next block offset and size
845 == the next block of the channel with the smallest number of
846 decoded samples */
847 for (i = 0; i < s->num_channels; i++) {
848 if (offset > s->channel[i].decoded_samples) {
849 offset = s->channel[i].decoded_samples;
850 subframe_len =
851 s->channel[i].subframe_len[s->channel[i].cur_subframe];
852 }
853 }
854
855 /* get a list of all channels that contain the estimated block */
856 s->channels_for_cur_subframe = 0;
857 for (i = 0; i < s->num_channels; i++) {
858 const int cur_subframe = s->channel[i].cur_subframe;
859 /* subtract already processed samples */
860 total_samples -= s->channel[i].decoded_samples;
861
862 /* and count if there are multiple subframes that match our profile */
863 if (offset == s->channel[i].decoded_samples &&
864 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
865 total_samples -= s->channel[i].subframe_len[cur_subframe];
866 s->channel[i].decoded_samples +=
867 s->channel[i].subframe_len[cur_subframe];
868 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
869 ++s->channels_for_cur_subframe;
870 }
871 }
872
873 /* check if the frame will be complete after processing the
874 estimated block */
875 if (!total_samples)
876 s->parsed_all_subframes = 1;
877
878
879 s->seekable_tile = get_bits1(&s->gb);
880 if (s->seekable_tile) {
881 clear_codec_buffers(s);
882
883 s->do_arith_coding = get_bits1(&s->gb);
884 if (s->do_arith_coding) {
885 avpriv_request_sample(s->avctx, "Arithmetic coding");
886 return AVERROR_PATCHWELCOME;
887 }
888 s->do_ac_filter = get_bits1(&s->gb);
889 s->do_inter_ch_decorr = get_bits1(&s->gb);
890 s->do_mclms = get_bits1(&s->gb);
891
892 if (s->do_ac_filter)
893 decode_ac_filter(s);
894
895 if (s->do_mclms)
896 decode_mclms(s);
897
898 if ((res = decode_cdlms(s)) < 0)
899 return res;
900 s->movave_scaling = get_bits(&s->gb, 3);
901 s->quant_stepsize = get_bits(&s->gb, 8) + 1;
902
903 reset_codec(s);
904 }
905
906 rawpcm_tile = get_bits1(&s->gb);
907
908 if (!rawpcm_tile && !s->cdlms[0][0].order) {
909 av_log(s->avctx, AV_LOG_DEBUG,
910 "Waiting for seekable tile\n");
911 av_frame_unref(s->frame);
912 return -1;
913 }
914
915
916 for (i = 0; i < s->num_channels; i++)
917 s->is_channel_coded[i] = 1;
918
919 if (!rawpcm_tile) {
920 for (i = 0; i < s->num_channels; i++)
921 s->is_channel_coded[i] = get_bits1(&s->gb);
922
923 if (s->bV3RTM) {
924 // LPC
925 s->do_lpc = get_bits1(&s->gb);
926 if (s->do_lpc) {
927 decode_lpc(s);
928 avpriv_request_sample(s->avctx, "Expect wrong output since "
929 "inverse LPC filter");
930 }
931 } else
932 s->do_lpc = 0;
933 }
934
935 if (get_bits_left(&s->gb) < 1)
936 return AVERROR_INVALIDDATA;
937
938 if (get_bits1(&s->gb))
939 padding_zeroes = get_bits(&s->gb, 5);
940 else
941 padding_zeroes = 0;
942
943 if (rawpcm_tile) {
944 int bits = s->bits_per_sample - padding_zeroes;
945 if (bits <= 0) {
946 av_log(s->avctx, AV_LOG_ERROR,
947 "Invalid number of padding bits in raw PCM tile\n");
948 return AVERROR_INVALIDDATA;
949 }
950 ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
951 "total %d bits, remain=%d\n", bits,
952 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
953 for (i = 0; i < s->num_channels; i++)
954 for (j = 0; j < subframe_len; j++)
955 s->channel_residues[i][j] = get_sbits_long(&s->gb, bits);
956 } else {
957 if (s->bits_per_sample < padding_zeroes)
958 return AVERROR_INVALIDDATA;
959 for (i = 0; i < s->num_channels; i++) {
960 if (s->is_channel_coded[i]) {
961 decode_channel_residues(s, i, subframe_len);
962 if (s->seekable_tile)
963 use_high_update_speed(s, i);
964 else
965 use_normal_update_speed(s, i);
966 if (s->bits_per_sample > 16)
967 revert_cdlms32(s, i, 0, subframe_len);
968 else
969 revert_cdlms16(s, i, 0, subframe_len);
970 } else {
971 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
972 }
973 }
974
975 if (s->do_mclms)
976 revert_mclms(s, subframe_len);
977 if (s->do_inter_ch_decorr)
978 revert_inter_ch_decorr(s, subframe_len);
979 if (s->do_ac_filter)
980 revert_acfilter(s, subframe_len);
981
982 /* Dequantize */
983 if (s->quant_stepsize != 1)
984 for (i = 0; i < s->num_channels; i++)
985 for (j = 0; j < subframe_len; j++)
986 s->channel_residues[i][j] *= (unsigned)s->quant_stepsize;
987 }
988
989 /* Write to proper output buffer depending on bit-depth */
990 for (i = 0; i < s->channels_for_cur_subframe; i++) {
991 int c = s->channel_indexes_for_cur_subframe[i];
992 int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
993
994 for (j = 0; j < subframe_len; j++) {
995 if (s->bits_per_sample == 16) {
996 *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] * (1 << padding_zeroes);
997 } else {
998 *s->samples_32[c]++ = s->channel_residues[c][j] * (256U << padding_zeroes);
999 }
1000 }
1001 }
1002
1003 /* handled one subframe */
1004 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1005 int c = s->channel_indexes_for_cur_subframe[i];
1006 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1007 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1008 return AVERROR_INVALIDDATA;
1009 }
1010 ++s->channel[c].cur_subframe;
1011 }
1012 return 0;
1013 }
1014
1015 /**
1016 * @brief Decode one WMA frame.
1017 * @param s codec context
1018 * @return 0 if the trailer bit indicates that this is the last frame,
1019 * 1 if there are additional frames
1020 */
decode_frame(WmallDecodeCtx * s)1021 static int decode_frame(WmallDecodeCtx *s)
1022 {
1023 GetBitContext* gb = &s->gb;
1024 int more_frames = 0, len = 0, i, ret;
1025
1026 s->frame->nb_samples = s->samples_per_frame;
1027 if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1028 /* return an error if no frame could be decoded at all */
1029 s->packet_loss = 1;
1030 s->frame->nb_samples = 0;
1031 return ret;
1032 }
1033 for (i = 0; i < s->num_channels; i++) {
1034 s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1035 s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1036 }
1037
1038 /* get frame length */
1039 if (s->len_prefix)
1040 len = get_bits(gb, s->log2_frame_size);
1041
1042 /* decode tile information */
1043 if ((ret = decode_tilehdr(s))) {
1044 s->packet_loss = 1;
1045 av_frame_unref(s->frame);
1046 return ret;
1047 }
1048
1049 /* read drc info */
1050 if (s->dynamic_range_compression)
1051 s->drc_gain = get_bits(gb, 8);
1052
1053 /* no idea what these are for, might be the number of samples
1054 that need to be skipped at the beginning or end of a stream */
1055 if (get_bits1(gb)) {
1056 int av_unused skip;
1057
1058 /* usually true for the first frame */
1059 if (get_bits1(gb)) {
1060 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1061 ff_dlog(s->avctx, "start skip: %i\n", skip);
1062 }
1063
1064 /* sometimes true for the last frame */
1065 if (get_bits1(gb)) {
1066 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1067 ff_dlog(s->avctx, "end skip: %i\n", skip);
1068 s->frame->nb_samples -= skip;
1069 if (s->frame->nb_samples <= 0)
1070 return AVERROR_INVALIDDATA;
1071 }
1072
1073 }
1074
1075 /* reset subframe states */
1076 s->parsed_all_subframes = 0;
1077 for (i = 0; i < s->num_channels; i++) {
1078 s->channel[i].decoded_samples = 0;
1079 s->channel[i].cur_subframe = 0;
1080 }
1081
1082 /* decode all subframes */
1083 while (!s->parsed_all_subframes) {
1084 int decoded_samples = s->channel[0].decoded_samples;
1085 if (decode_subframe(s) < 0) {
1086 s->packet_loss = 1;
1087 if (s->frame->nb_samples)
1088 s->frame->nb_samples = decoded_samples;
1089 return 0;
1090 }
1091 }
1092
1093 ff_dlog(s->avctx, "Frame done\n");
1094
1095 s->skip_frame = 0;
1096
1097 if (s->len_prefix) {
1098 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1099 /* FIXME: not sure if this is always an error */
1100 av_log(s->avctx, AV_LOG_ERROR,
1101 "frame[%"PRIu32"] would have to skip %i bits\n",
1102 s->frame_num,
1103 len - (get_bits_count(gb) - s->frame_offset) - 1);
1104 s->packet_loss = 1;
1105 return 0;
1106 }
1107
1108 /* skip the rest of the frame data */
1109 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1110 }
1111
1112 /* decode trailer bit */
1113 more_frames = get_bits1(gb);
1114 ++s->frame_num;
1115 return more_frames;
1116 }
1117
1118 /**
1119 * @brief Calculate remaining input buffer length.
1120 * @param s codec context
1121 * @param gb bitstream reader context
1122 * @return remaining size in bits
1123 */
remaining_bits(WmallDecodeCtx * s,GetBitContext * gb)1124 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1125 {
1126 return s->buf_bit_size - get_bits_count(gb);
1127 }
1128
1129 /**
1130 * @brief Fill the bit reservoir with a (partial) frame.
1131 * @param s codec context
1132 * @param gb bitstream reader context
1133 * @param len length of the partial frame
1134 * @param append decides whether to reset the buffer or not
1135 */
save_bits(WmallDecodeCtx * s,GetBitContext * gb,int len,int append)1136 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1137 int append)
1138 {
1139 int buflen;
1140 PutBitContext tmp;
1141
1142 /* when the frame data does not need to be concatenated, the input buffer
1143 is reset and additional bits from the previous frame are copied
1144 and skipped later so that a fast byte copy is possible */
1145
1146 if (!append) {
1147 s->frame_offset = get_bits_count(gb) & 7;
1148 s->num_saved_bits = s->frame_offset;
1149 init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1150 }
1151
1152 buflen = (s->num_saved_bits + len + 8) >> 3;
1153
1154 if (len <= 0 || buflen > s->max_frame_size) {
1155 avpriv_request_sample(s->avctx, "Too small input buffer");
1156 s->packet_loss = 1;
1157 s->num_saved_bits = 0;
1158 return;
1159 }
1160
1161 s->num_saved_bits += len;
1162 if (!append) {
1163 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1164 s->num_saved_bits);
1165 } else {
1166 int align = 8 - (get_bits_count(gb) & 7);
1167 align = FFMIN(align, len);
1168 put_bits(&s->pb, align, get_bits(gb, align));
1169 len -= align;
1170 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1171 }
1172 skip_bits_long(gb, len);
1173
1174 tmp = s->pb;
1175 flush_put_bits(&tmp);
1176
1177 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1178 skip_bits(&s->gb, s->frame_offset);
1179 }
1180
decode_packet(AVCodecContext * avctx,void * data,int * got_frame_ptr,AVPacket * avpkt)1181 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1182 AVPacket* avpkt)
1183 {
1184 WmallDecodeCtx *s = avctx->priv_data;
1185 GetBitContext* gb = &s->pgb;
1186 const uint8_t* buf = avpkt->data;
1187 int buf_size = avpkt->size;
1188 int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1189
1190 s->frame->nb_samples = 0;
1191
1192 if (!buf_size && s->num_saved_bits > get_bits_count(&s->gb)) {
1193 s->packet_done = 0;
1194 if (!decode_frame(s))
1195 s->num_saved_bits = 0;
1196 } else if (s->packet_done || s->packet_loss) {
1197 s->packet_done = 0;
1198
1199 if (!buf_size)
1200 return 0;
1201
1202 s->next_packet_start = buf_size - FFMIN(avctx->block_align, buf_size);
1203 buf_size = FFMIN(avctx->block_align, buf_size);
1204 s->buf_bit_size = buf_size << 3;
1205
1206 /* parse packet header */
1207 init_get_bits(gb, buf, s->buf_bit_size);
1208 packet_sequence_number = get_bits(gb, 4);
1209 skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently unused
1210 spliced_packet = get_bits1(gb);
1211 if (spliced_packet)
1212 avpriv_request_sample(avctx, "Bitstream splicing");
1213
1214 /* get number of bits that need to be added to the previous frame */
1215 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1216
1217 /* check for packet loss */
1218 if (!s->packet_loss &&
1219 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1220 s->packet_loss = 1;
1221 av_log(avctx, AV_LOG_ERROR,
1222 "Packet loss detected! seq %"PRIx8" vs %x\n",
1223 s->packet_sequence_number, packet_sequence_number);
1224 }
1225 s->packet_sequence_number = packet_sequence_number;
1226
1227 if (num_bits_prev_frame > 0) {
1228 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1229 if (num_bits_prev_frame >= remaining_packet_bits) {
1230 num_bits_prev_frame = remaining_packet_bits;
1231 s->packet_done = 1;
1232 }
1233
1234 /* Append the previous frame data to the remaining data from the
1235 * previous packet to create a full frame. */
1236 save_bits(s, gb, num_bits_prev_frame, 1);
1237
1238 /* decode the cross packet frame if it is valid */
1239 if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1240 decode_frame(s);
1241 } else if (s->num_saved_bits - s->frame_offset) {
1242 ff_dlog(avctx, "ignoring %x previously saved bits\n",
1243 s->num_saved_bits - s->frame_offset);
1244 }
1245
1246 if (s->packet_loss) {
1247 /* Reset number of saved bits so that the decoder does not start
1248 * to decode incomplete frames in the s->len_prefix == 0 case. */
1249 s->num_saved_bits = 0;
1250 s->packet_loss = 0;
1251 init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1252 }
1253
1254 } else {
1255 int frame_size;
1256
1257 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1258 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1259 skip_bits(gb, s->packet_offset);
1260
1261 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1262 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1263 frame_size <= remaining_bits(s, gb)) {
1264 save_bits(s, gb, frame_size, 0);
1265
1266 if (!s->packet_loss)
1267 s->packet_done = !decode_frame(s);
1268 } else if (!s->len_prefix
1269 && s->num_saved_bits > get_bits_count(&s->gb)) {
1270 /* when the frames do not have a length prefix, we don't know the
1271 * compressed length of the individual frames however, we know what
1272 * part of a new packet belongs to the previous frame therefore we
1273 * save the incoming packet first, then we append the "previous
1274 * frame" data from the next packet so that we get a buffer that
1275 * only contains full frames */
1276 s->packet_done = !decode_frame(s);
1277 } else {
1278 s->packet_done = 1;
1279 }
1280 }
1281
1282 if (remaining_bits(s, gb) < 0) {
1283 av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1284 s->packet_loss = 1;
1285 }
1286
1287 if (s->packet_done && !s->packet_loss &&
1288 remaining_bits(s, gb) > 0) {
1289 /* save the rest of the data so that it can be decoded
1290 * with the next packet */
1291 save_bits(s, gb, remaining_bits(s, gb), 0);
1292 }
1293
1294 *got_frame_ptr = s->frame->nb_samples > 0;
1295 av_frame_move_ref(data, s->frame);
1296
1297 s->packet_offset = get_bits_count(gb) & 7;
1298
1299 return (s->packet_loss) ? AVERROR_INVALIDDATA : buf_size ? get_bits_count(gb) >> 3 : 0;
1300 }
1301
flush(AVCodecContext * avctx)1302 static void flush(AVCodecContext *avctx)
1303 {
1304 WmallDecodeCtx *s = avctx->priv_data;
1305 s->packet_loss = 1;
1306 s->packet_done = 0;
1307 s->num_saved_bits = 0;
1308 s->frame_offset = 0;
1309 s->next_packet_start = 0;
1310 s->cdlms[0][0].order = 0;
1311 s->frame->nb_samples = 0;
1312 init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1313 }
1314
decode_close(AVCodecContext * avctx)1315 static av_cold int decode_close(AVCodecContext *avctx)
1316 {
1317 WmallDecodeCtx *s = avctx->priv_data;
1318
1319 av_frame_free(&s->frame);
1320 av_freep(&s->frame_data);
1321
1322 return 0;
1323 }
1324
1325 AVCodec ff_wmalossless_decoder = {
1326 .name = "wmalossless",
1327 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1328 .type = AVMEDIA_TYPE_AUDIO,
1329 .id = AV_CODEC_ID_WMALOSSLESS,
1330 .priv_data_size = sizeof(WmallDecodeCtx),
1331 .init = decode_init,
1332 .close = decode_close,
1333 .decode = decode_packet,
1334 .flush = flush,
1335 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1336 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1337 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1338 AV_SAMPLE_FMT_S32P,
1339 AV_SAMPLE_FMT_NONE },
1340 };
1341