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
8 * This file is part of FFmpeg.
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.
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.
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
27 #include "libavutil/attributes.h"
28 #include "libavutil/avassert.h"
34 #include "lossless_audiodsp.h"
36 #include "wma_common.h"
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
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
50 #define WMALL_COEFF_PAD_SIZE 16 ///< pad coef buffers with 0 for use with SIMD
53 * @brief frame-specific decoder context for a single channel
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
68 * @brief main decoder context
70 typedef struct WmallDecodeCtx {
71 /* generic decoder variables */
72 AVCodecContext *avctx;
74 LLAudDSPContext dsp; ///< accelerated DSP functions
75 uint8_t frame_data[MAX_FRAMESIZE + AV_INPUT_BUFFER_PADDING_SIZE]; ///< compressed frame data
76 PutBitContext pb; ///< context for filling the frame_data buffer
78 /* frame size dependent frame information (set during initialization) */
79 uint32_t decode_flags; ///< used compression features
80 int len_prefix; ///< frame is prefixed with its length
81 int dynamic_range_compression; ///< frame contains DRC data
82 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
83 uint16_t samples_per_frame; ///< number of samples to output
84 uint16_t log2_frame_size;
85 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
86 int8_t lfe_channel; ///< lfe channel index
87 uint8_t max_num_subframes;
88 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
89 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
90 uint16_t min_samples_per_subframe;
92 /* packet decode state */
93 GetBitContext pgb; ///< bitstream reader context for the packet
94 int next_packet_start; ///< start offset of the next WMA packet in the demuxer packet
95 uint8_t packet_offset; ///< offset to the frame in the packet
96 uint8_t packet_sequence_number; ///< current packet number
97 int num_saved_bits; ///< saved number of bits
98 int frame_offset; ///< frame offset in the bit reservoir
99 int subframe_offset; ///< subframe offset in the bit reservoir
100 uint8_t packet_loss; ///< set in case of bitstream error
101 uint8_t packet_done; ///< set when a packet is fully decoded
103 /* frame decode state */
104 uint32_t frame_num; ///< current frame number (not used for decoding)
105 GetBitContext gb; ///< bitstream reader context
106 int buf_bit_size; ///< buffer size in bits
107 int16_t *samples_16[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (16-bit)
108 int32_t *samples_32[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (24-bit)
109 uint8_t drc_gain; ///< gain for the DRC tool
110 int8_t skip_frame; ///< skip output step
111 int8_t parsed_all_subframes; ///< all subframes decoded?
113 /* subframe/block decode state */
114 int16_t subframe_len; ///< current subframe length
115 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
116 int8_t channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
118 WmallChannelCtx channel[WMALL_MAX_CHANNELS]; ///< per channel data
120 // WMA Lossless-specific
122 uint8_t do_arith_coding;
123 uint8_t do_ac_filter;
124 uint8_t do_inter_ch_decorr;
128 int8_t acfilter_order;
129 int8_t acfilter_scaling;
130 int16_t acfilter_coeffs[16];
131 int acfilter_prevvalues[WMALL_MAX_CHANNELS][16];
134 int8_t mclms_scaling;
135 int16_t mclms_coeffs[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS * 32];
136 int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS];
137 int16_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
138 int16_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
149 DECLARE_ALIGNED(16, int16_t, coefs)[MAX_ORDER + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
150 DECLARE_ALIGNED(16, int16_t, lms_prevvalues)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
151 DECLARE_ALIGNED(16, int16_t, lms_updates)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
153 } cdlms[WMALL_MAX_CHANNELS][9];
155 int cdlms_ttl[WMALL_MAX_CHANNELS];
159 int is_channel_coded[WMALL_MAX_CHANNELS];
160 int update_speed[WMALL_MAX_CHANNELS];
162 int transient[WMALL_MAX_CHANNELS];
163 int transient_pos[WMALL_MAX_CHANNELS];
166 int ave_sum[WMALL_MAX_CHANNELS];
168 int channel_residues[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE];
170 int lpc_coefs[WMALL_MAX_CHANNELS][40];
175 int channel_coeffs[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE];
178 /** Get sign of integer (1 for positive, -1 for negative and 0 for zero) */
179 #define WMASIGN(x) (((x) > 0) - ((x) < 0))
181 static av_cold int decode_init(AVCodecContext *avctx)
183 WmallDecodeCtx *s = avctx->priv_data;
184 uint8_t *edata_ptr = avctx->extradata;
185 unsigned int channel_mask;
186 int i, log2_max_num_subframes;
188 if (!avctx->block_align) {
189 av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
190 return AVERROR(EINVAL);
194 ff_llauddsp_init(&s->dsp);
195 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
197 if (avctx->extradata_size >= 18) {
198 s->decode_flags = AV_RL16(edata_ptr + 14);
199 channel_mask = AV_RL32(edata_ptr + 2);
200 s->bits_per_sample = AV_RL16(edata_ptr);
201 if (s->bits_per_sample == 16)
202 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
203 else if (s->bits_per_sample == 24) {
204 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
205 avctx->bits_per_raw_sample = 24;
207 av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
209 return AVERROR_INVALIDDATA;
211 /* dump the extradata */
212 for (i = 0; i < avctx->extradata_size; i++)
213 ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
214 ff_dlog(avctx, "\n");
217 avpriv_request_sample(avctx, "Unsupported extradata size");
218 return AVERROR_PATCHWELCOME;
222 s->log2_frame_size = av_log2(avctx->block_align) + 4;
225 s->skip_frame = 1; /* skip first frame */
227 s->len_prefix = s->decode_flags & 0x40;
230 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
232 av_assert0(s->samples_per_frame <= WMALL_BLOCK_MAX_SIZE);
234 /* init previous block len */
235 for (i = 0; i < avctx->channels; i++)
236 s->channel[i].prev_block_len = s->samples_per_frame;
239 log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
240 s->max_num_subframes = 1 << log2_max_num_subframes;
241 s->max_subframe_len_bit = 0;
242 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
244 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
245 s->dynamic_range_compression = s->decode_flags & 0x80;
246 s->bV3RTM = s->decode_flags & 0x100;
248 if (s->max_num_subframes > MAX_SUBFRAMES) {
249 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
250 s->max_num_subframes);
251 return AVERROR_INVALIDDATA;
254 s->num_channels = avctx->channels;
256 /* extract lfe channel position */
259 if (channel_mask & 8) {
261 for (mask = 1; mask < 16; mask <<= 1)
262 if (channel_mask & mask)
266 if (s->num_channels < 0) {
267 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %"PRId8"\n",
269 return AVERROR_INVALIDDATA;
270 } else if (s->num_channels > WMALL_MAX_CHANNELS) {
271 avpriv_request_sample(avctx,
272 "More than %d channels", WMALL_MAX_CHANNELS);
273 return AVERROR_PATCHWELCOME;
276 s->frame = av_frame_alloc();
278 return AVERROR(ENOMEM);
280 avctx->channel_layout = channel_mask;
285 * @brief Decode the subframe length.
287 * @param offset sample offset in the frame
288 * @return decoded subframe length on success, < 0 in case of an error
290 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
292 int frame_len_ratio, subframe_len, len;
294 /* no need to read from the bitstream when only one length is possible */
295 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
296 return s->min_samples_per_subframe;
298 len = av_log2(s->max_num_subframes - 1) + 1;
299 frame_len_ratio = get_bits(&s->gb, len);
300 subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
302 /* sanity check the length */
303 if (subframe_len < s->min_samples_per_subframe ||
304 subframe_len > s->samples_per_frame) {
305 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
307 return AVERROR_INVALIDDATA;
313 * @brief Decode how the data in the frame is split into subframes.
314 * Every WMA frame contains the encoded data for a fixed number of
315 * samples per channel. The data for every channel might be split
316 * into several subframes. This function will reconstruct the list of
317 * subframes for every channel.
319 * If the subframes are not evenly split, the algorithm estimates the
320 * channels with the lowest number of total samples.
321 * Afterwards, for each of these channels a bit is read from the
322 * bitstream that indicates if the channel contains a subframe with the
323 * next subframe size that is going to be read from the bitstream or not.
324 * If a channel contains such a subframe, the subframe size gets added to
325 * the channel's subframe list.
326 * The algorithm repeats these steps until the frame is properly divided
327 * between the individual channels.
330 * @return 0 on success, < 0 in case of an error
332 static int decode_tilehdr(WmallDecodeCtx *s)
334 uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
335 uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
336 int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
337 int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
338 int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
341 /* reset tiling information */
342 for (c = 0; c < s->num_channels; c++)
343 s->channel[c].num_subframes = 0;
345 tile_aligned = get_bits1(&s->gb);
346 if (s->max_num_subframes == 1 || tile_aligned)
347 fixed_channel_layout = 1;
349 /* loop until the frame data is split between the subframes */
351 int subframe_len, in_use = 0;
353 /* check which channels contain the subframe */
354 for (c = 0; c < s->num_channels; c++) {
355 if (num_samples[c] == min_channel_len) {
356 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
357 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
358 contains_subframe[c] = 1;
360 contains_subframe[c] = get_bits1(&s->gb);
362 in_use |= contains_subframe[c];
364 contains_subframe[c] = 0;
368 av_log(s->avctx, AV_LOG_ERROR,
369 "Found empty subframe\n");
370 return AVERROR_INVALIDDATA;
373 /* get subframe length, subframe_len == 0 is not allowed */
374 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
375 return AVERROR_INVALIDDATA;
376 /* add subframes to the individual channels and find new min_channel_len */
377 min_channel_len += subframe_len;
378 for (c = 0; c < s->num_channels; c++) {
379 WmallChannelCtx *chan = &s->channel[c];
381 if (contains_subframe[c]) {
382 if (chan->num_subframes >= MAX_SUBFRAMES) {
383 av_log(s->avctx, AV_LOG_ERROR,
384 "broken frame: num subframes > 31\n");
385 return AVERROR_INVALIDDATA;
387 chan->subframe_len[chan->num_subframes] = subframe_len;
388 num_samples[c] += subframe_len;
389 ++chan->num_subframes;
390 if (num_samples[c] > s->samples_per_frame) {
391 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
392 "channel len(%"PRIu16") > samples_per_frame(%"PRIu16")\n",
393 num_samples[c], s->samples_per_frame);
394 return AVERROR_INVALIDDATA;
396 } else if (num_samples[c] <= min_channel_len) {
397 if (num_samples[c] < min_channel_len) {
398 channels_for_cur_subframe = 0;
399 min_channel_len = num_samples[c];
401 ++channels_for_cur_subframe;
404 } while (min_channel_len < s->samples_per_frame);
406 for (c = 0; c < s->num_channels; c++) {
408 for (i = 0; i < s->channel[c].num_subframes; i++) {
409 s->channel[c].subframe_offsets[i] = offset;
410 offset += s->channel[c].subframe_len[i];
417 static void decode_ac_filter(WmallDecodeCtx *s)
420 s->acfilter_order = get_bits(&s->gb, 4) + 1;
421 s->acfilter_scaling = get_bits(&s->gb, 4);
423 for (i = 0; i < s->acfilter_order; i++)
424 s->acfilter_coeffs[i] = (s->acfilter_scaling ?
425 get_bits(&s->gb, s->acfilter_scaling) : 0) + 1;
428 static void decode_mclms(WmallDecodeCtx *s)
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)
438 send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
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);
443 for (i = 0; i < s->num_channels; i++) {
445 for (c = 0; c < i; c++)
446 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
451 static int decode_cdlms(WmallDecodeCtx *s)
454 int cdlms_send_coef = get_bits1(&s->gb);
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;
467 if(s->cdlms[c][i].order & 8) {
470 avpriv_request_sample(s->avctx, "CDLMS of order %d",
471 s->cdlms[c][i].order);
476 for (i = 0; i < s->cdlms_ttl[c]; i++)
477 s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
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)
485 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
487 cbits = av_log2(s->cdlms[c][i].scaling + 1);
488 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
491 s->cdlms[c][i].bitsend = (cbits ? get_bits(&s->gb, cbits) : 0) + 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;
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);
508 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
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;
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);
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);
531 s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample);
534 for (; i < tile_size; i++) {
535 int quo = 0, rem, rem_bits, residue;
536 while(get_bits1(&s->gb)) {
538 if (get_bits_left(&s->gb) <= 0)
542 quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
544 ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
548 rem_bits = av_ceil_log2(ave_mean);
549 rem = get_bits_long(&s->gb, rem_bits);
550 residue = (quo << rem_bits) + rem;
553 s->ave_sum[ch] = residue + s->ave_sum[ch] -
554 (s->ave_sum[ch] >> s->movave_scaling);
556 residue = (residue >> 1) ^ -(residue & 1);
557 s->channel_residues[ch][i] = residue;
564 static void decode_lpc(WmallDecodeCtx *s)
567 s->lpc_order = get_bits(&s->gb, 5) + 1;
568 s->lpc_scaling = get_bits(&s->gb, 4);
569 s->lpc_intbits = get_bits(&s->gb, 3) + 1;
570 cbits = s->lpc_scaling + s->lpc_intbits;
571 for (ch = 0; ch < s->num_channels; ch++)
572 for (i = 0; i < s->lpc_order; i++)
573 s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
576 static void clear_codec_buffers(WmallDecodeCtx *s)
580 memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
581 memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
582 memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
584 memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
585 memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
586 memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
587 memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
589 for (ich = 0; ich < s->num_channels; ich++) {
590 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
591 memset(s->cdlms[ich][ilms].coefs, 0,
592 sizeof(s->cdlms[ich][ilms].coefs));
593 memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
594 sizeof(s->cdlms[ich][ilms].lms_prevvalues));
595 memset(s->cdlms[ich][ilms].lms_updates, 0,
596 sizeof(s->cdlms[ich][ilms].lms_updates));
603 * @brief Reset filter parameters and transient area at new seekable tile.
605 static void reset_codec(WmallDecodeCtx *s)
608 s->mclms_recent = s->mclms_order * s->num_channels;
609 for (ich = 0; ich < s->num_channels; ich++) {
610 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
611 s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
612 /* first sample of a seekable subframe is considered as the starting of
613 a transient area which is samples_per_frame samples long */
614 s->channel[ich].transient_counter = s->samples_per_frame;
615 s->transient[ich] = 1;
616 s->transient_pos[ich] = 0;
620 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
622 int i, j, ich, pred_error;
623 int order = s->mclms_order;
624 int num_channels = s->num_channels;
625 int range = 1 << (s->bits_per_sample - 1);
627 for (ich = 0; ich < num_channels; ich++) {
628 pred_error = s->channel_residues[ich][icoef] - pred[ich];
629 if (pred_error > 0) {
630 for (i = 0; i < order * num_channels; i++)
631 s->mclms_coeffs[i + ich * order * num_channels] +=
632 s->mclms_updates[s->mclms_recent + i];
633 for (j = 0; j < ich; j++)
634 s->mclms_coeffs_cur[ich * num_channels + j] += WMASIGN(s->channel_residues[j][icoef]);
635 } else if (pred_error < 0) {
636 for (i = 0; i < order * num_channels; i++)
637 s->mclms_coeffs[i + ich * order * num_channels] -=
638 s->mclms_updates[s->mclms_recent + i];
639 for (j = 0; j < ich; j++)
640 s->mclms_coeffs_cur[ich * num_channels + j] -= WMASIGN(s->channel_residues[j][icoef]);
644 for (ich = num_channels - 1; ich >= 0; ich--) {
646 s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
648 s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
651 if (s->mclms_recent == 0) {
652 memcpy(&s->mclms_prevvalues[order * num_channels],
654 sizeof(int16_t) * order * num_channels);
655 memcpy(&s->mclms_updates[order * num_channels],
657 sizeof(int16_t) * order * num_channels);
658 s->mclms_recent = num_channels * order;
662 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
665 int order = s->mclms_order;
666 int num_channels = s->num_channels;
668 for (ich = 0; ich < num_channels; ich++) {
670 if (!s->is_channel_coded[ich])
672 for (i = 0; i < order * num_channels; i++)
673 pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
674 s->mclms_coeffs[i + order * num_channels * ich];
675 for (i = 0; i < ich; i++)
676 pred[ich] += s->channel_residues[i][icoef] *
677 s->mclms_coeffs_cur[i + num_channels * ich];
678 pred[ich] += 1 << s->mclms_scaling - 1;
679 pred[ich] >>= s->mclms_scaling;
680 s->channel_residues[ich][icoef] += pred[ich];
684 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
686 int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
687 for (icoef = 0; icoef < tile_size; icoef++) {
688 mclms_predict(s, icoef, pred);
689 mclms_update(s, icoef, pred);
693 static void lms_update(WmallDecodeCtx *s, int ich, int ilms, int input)
695 int recent = s->cdlms[ich][ilms].recent;
696 int range = 1 << s->bits_per_sample - 1;
697 int order = s->cdlms[ich][ilms].order;
702 memcpy(s->cdlms[ich][ilms].lms_prevvalues + order,
703 s->cdlms[ich][ilms].lms_prevvalues, sizeof(*s->cdlms[ich][ilms].lms_prevvalues) * order);
704 memcpy(s->cdlms[ich][ilms].lms_updates + order,
705 s->cdlms[ich][ilms].lms_updates, sizeof(*s->cdlms[ich][ilms].lms_updates) * order);
709 s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
710 s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich];
712 s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2;
713 s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1;
714 s->cdlms[ich][ilms].recent = recent;
715 memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0,
716 sizeof(s->cdlms[ich][ilms].lms_updates) - 2*(recent+order));
719 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
721 int ilms, recent, icoef;
722 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
723 recent = s->cdlms[ich][ilms].recent;
724 if (s->update_speed[ich] == 16)
727 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
728 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
730 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
731 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
734 s->update_speed[ich] = 16;
737 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
739 int ilms, recent, icoef;
740 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
741 recent = s->cdlms[ich][ilms].recent;
742 if (s->update_speed[ich] == 8)
745 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
746 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
748 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
749 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
751 s->update_speed[ich] = 8;
754 static void revert_cdlms(WmallDecodeCtx *s, int ch,
755 int coef_begin, int coef_end)
757 int icoef, pred, ilms, num_lms, residue, input;
759 num_lms = s->cdlms_ttl[ch];
760 for (ilms = num_lms - 1; ilms >= 0; ilms--) {
761 for (icoef = coef_begin; icoef < coef_end; icoef++) {
762 pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
763 residue = s->channel_residues[ch][icoef];
764 pred += s->dsp.scalarproduct_and_madd_int16(s->cdlms[ch][ilms].coefs,
765 s->cdlms[ch][ilms].lms_prevvalues
766 + s->cdlms[ch][ilms].recent,
767 s->cdlms[ch][ilms].lms_updates
768 + s->cdlms[ch][ilms].recent,
769 FFALIGN(s->cdlms[ch][ilms].order,
770 WMALL_COEFF_PAD_SIZE),
772 input = residue + (pred >> s->cdlms[ch][ilms].scaling);
773 lms_update(s, ch, ilms, input);
774 s->channel_residues[ch][icoef] = input;
780 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
782 if (s->num_channels != 2)
784 else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
786 for (icoef = 0; icoef < tile_size; icoef++) {
787 s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
788 s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
793 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
796 int16_t *filter_coeffs = s->acfilter_coeffs;
797 int scaling = s->acfilter_scaling;
798 int order = s->acfilter_order;
800 for (ich = 0; ich < s->num_channels; ich++) {
801 int *prevvalues = s->acfilter_prevvalues[ich];
802 for (i = 0; i < order; i++) {
804 for (j = 0; j < order; j++) {
806 pred += filter_coeffs[j] * prevvalues[j - i];
808 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
811 s->channel_residues[ich][i] += pred;
813 for (i = order; i < tile_size; i++) {
815 for (j = 0; j < order; j++)
816 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
818 s->channel_residues[ich][i] += pred;
820 for (j = 0; j < order; j++)
821 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
825 static int decode_subframe(WmallDecodeCtx *s)
827 int offset = s->samples_per_frame;
828 int subframe_len = s->samples_per_frame;
829 int total_samples = s->samples_per_frame * s->num_channels;
830 int i, j, rawpcm_tile, padding_zeroes, res;
832 s->subframe_offset = get_bits_count(&s->gb);
834 /* reset channel context and find the next block offset and size
835 == the next block of the channel with the smallest number of
837 for (i = 0; i < s->num_channels; i++) {
838 if (offset > s->channel[i].decoded_samples) {
839 offset = s->channel[i].decoded_samples;
841 s->channel[i].subframe_len[s->channel[i].cur_subframe];
845 /* get a list of all channels that contain the estimated block */
846 s->channels_for_cur_subframe = 0;
847 for (i = 0; i < s->num_channels; i++) {
848 const int cur_subframe = s->channel[i].cur_subframe;
849 /* subtract already processed samples */
850 total_samples -= s->channel[i].decoded_samples;
852 /* and count if there are multiple subframes that match our profile */
853 if (offset == s->channel[i].decoded_samples &&
854 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
855 total_samples -= s->channel[i].subframe_len[cur_subframe];
856 s->channel[i].decoded_samples +=
857 s->channel[i].subframe_len[cur_subframe];
858 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
859 ++s->channels_for_cur_subframe;
863 /* check if the frame will be complete after processing the
866 s->parsed_all_subframes = 1;
869 s->seekable_tile = get_bits1(&s->gb);
870 if (s->seekable_tile) {
871 clear_codec_buffers(s);
873 s->do_arith_coding = get_bits1(&s->gb);
874 if (s->do_arith_coding) {
875 avpriv_request_sample(s->avctx, "Arithmetic coding");
876 return AVERROR_PATCHWELCOME;
878 s->do_ac_filter = get_bits1(&s->gb);
879 s->do_inter_ch_decorr = get_bits1(&s->gb);
880 s->do_mclms = get_bits1(&s->gb);
888 if ((res = decode_cdlms(s)) < 0)
890 s->movave_scaling = get_bits(&s->gb, 3);
891 s->quant_stepsize = get_bits(&s->gb, 8) + 1;
894 } else if (!s->cdlms[0][0].order) {
895 av_log(s->avctx, AV_LOG_DEBUG,
896 "Waiting for seekable tile\n");
897 av_frame_unref(s->frame);
901 rawpcm_tile = get_bits1(&s->gb);
903 for (i = 0; i < s->num_channels; i++)
904 s->is_channel_coded[i] = 1;
907 for (i = 0; i < s->num_channels; i++)
908 s->is_channel_coded[i] = get_bits1(&s->gb);
912 s->do_lpc = get_bits1(&s->gb);
915 avpriv_request_sample(s->avctx, "Expect wrong output since "
916 "inverse LPC filter");
923 if (get_bits1(&s->gb))
924 padding_zeroes = get_bits(&s->gb, 5);
929 int bits = s->bits_per_sample - padding_zeroes;
931 av_log(s->avctx, AV_LOG_ERROR,
932 "Invalid number of padding bits in raw PCM tile\n");
933 return AVERROR_INVALIDDATA;
935 ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
936 "total %d bits, remain=%d\n", bits,
937 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
938 for (i = 0; i < s->num_channels; i++)
939 for (j = 0; j < subframe_len; j++)
940 s->channel_coeffs[i][j] = get_sbits_long(&s->gb, bits);
942 for (i = 0; i < s->num_channels; i++)
943 if (s->is_channel_coded[i]) {
944 decode_channel_residues(s, i, subframe_len);
945 if (s->seekable_tile)
946 use_high_update_speed(s, i);
948 use_normal_update_speed(s, i);
949 revert_cdlms(s, i, 0, subframe_len);
951 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
955 revert_mclms(s, subframe_len);
956 if (s->do_inter_ch_decorr)
957 revert_inter_ch_decorr(s, subframe_len);
959 revert_acfilter(s, subframe_len);
962 if (s->quant_stepsize != 1)
963 for (i = 0; i < s->num_channels; i++)
964 for (j = 0; j < subframe_len; j++)
965 s->channel_residues[i][j] *= s->quant_stepsize;
967 /* Write to proper output buffer depending on bit-depth */
968 for (i = 0; i < s->channels_for_cur_subframe; i++) {
969 int c = s->channel_indexes_for_cur_subframe[i];
970 int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
972 for (j = 0; j < subframe_len; j++) {
973 if (s->bits_per_sample == 16) {
974 *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] << padding_zeroes;
976 *s->samples_32[c]++ = s->channel_residues[c][j] << (padding_zeroes + 8);
981 /* handled one subframe */
982 for (i = 0; i < s->channels_for_cur_subframe; i++) {
983 int c = s->channel_indexes_for_cur_subframe[i];
984 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
985 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
986 return AVERROR_INVALIDDATA;
988 ++s->channel[c].cur_subframe;
994 * @brief Decode one WMA frame.
995 * @param s codec context
996 * @return 0 if the trailer bit indicates that this is the last frame,
997 * 1 if there are additional frames
999 static int decode_frame(WmallDecodeCtx *s)
1001 GetBitContext* gb = &s->gb;
1002 int more_frames = 0, len = 0, i, ret;
1004 s->frame->nb_samples = s->samples_per_frame;
1005 if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1006 /* return an error if no frame could be decoded at all */
1008 s->frame->nb_samples = 0;
1011 for (i = 0; i < s->num_channels; i++) {
1012 s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1013 s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1016 /* get frame length */
1018 len = get_bits(gb, s->log2_frame_size);
1020 /* decode tile information */
1021 if ((ret = decode_tilehdr(s))) {
1023 av_frame_unref(s->frame);
1028 if (s->dynamic_range_compression)
1029 s->drc_gain = get_bits(gb, 8);
1031 /* no idea what these are for, might be the number of samples
1032 that need to be skipped at the beginning or end of a stream */
1033 if (get_bits1(gb)) {
1036 /* usually true for the first frame */
1037 if (get_bits1(gb)) {
1038 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1039 ff_dlog(s->avctx, "start skip: %i\n", skip);
1042 /* sometimes true for the last frame */
1043 if (get_bits1(gb)) {
1044 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1045 ff_dlog(s->avctx, "end skip: %i\n", skip);
1050 /* reset subframe states */
1051 s->parsed_all_subframes = 0;
1052 for (i = 0; i < s->num_channels; i++) {
1053 s->channel[i].decoded_samples = 0;
1054 s->channel[i].cur_subframe = 0;
1057 /* decode all subframes */
1058 while (!s->parsed_all_subframes) {
1059 int decoded_samples = s->channel[0].decoded_samples;
1060 if (decode_subframe(s) < 0) {
1062 if (s->frame->nb_samples)
1063 s->frame->nb_samples = decoded_samples;
1068 ff_dlog(s->avctx, "Frame done\n");
1072 if (s->len_prefix) {
1073 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1074 /* FIXME: not sure if this is always an error */
1075 av_log(s->avctx, AV_LOG_ERROR,
1076 "frame[%"PRIu32"] would have to skip %i bits\n",
1078 len - (get_bits_count(gb) - s->frame_offset) - 1);
1083 /* skip the rest of the frame data */
1084 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1087 /* decode trailer bit */
1088 more_frames = get_bits1(gb);
1094 * @brief Calculate remaining input buffer length.
1095 * @param s codec context
1096 * @param gb bitstream reader context
1097 * @return remaining size in bits
1099 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1101 return s->buf_bit_size - get_bits_count(gb);
1105 * @brief Fill the bit reservoir with a (partial) frame.
1106 * @param s codec context
1107 * @param gb bitstream reader context
1108 * @param len length of the partial frame
1109 * @param append decides whether to reset the buffer or not
1111 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1117 /* when the frame data does not need to be concatenated, the input buffer
1118 is reset and additional bits from the previous frame are copied
1119 and skipped later so that a fast byte copy is possible */
1122 s->frame_offset = get_bits_count(gb) & 7;
1123 s->num_saved_bits = s->frame_offset;
1124 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1127 buflen = (s->num_saved_bits + len + 8) >> 3;
1129 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1130 avpriv_request_sample(s->avctx, "Too small input buffer");
1135 s->num_saved_bits += len;
1137 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1140 int align = 8 - (get_bits_count(gb) & 7);
1141 align = FFMIN(align, len);
1142 put_bits(&s->pb, align, get_bits(gb, align));
1144 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1146 skip_bits_long(gb, len);
1149 flush_put_bits(&tmp);
1151 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1152 skip_bits(&s->gb, s->frame_offset);
1155 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1158 WmallDecodeCtx *s = avctx->priv_data;
1159 GetBitContext* gb = &s->pgb;
1160 const uint8_t* buf = avpkt->data;
1161 int buf_size = avpkt->size;
1162 int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1164 s->frame->nb_samples = 0;
1166 if (s->packet_done || s->packet_loss) {
1171 /* sanity check for the buffer length */
1172 if (buf_size < avctx->block_align) {
1173 av_log(avctx, AV_LOG_ERROR, "buf size %d invalid\n", buf_size);
1174 return AVERROR_INVALIDDATA;
1177 s->next_packet_start = buf_size - avctx->block_align;
1178 buf_size = avctx->block_align;
1179 s->buf_bit_size = buf_size << 3;
1181 /* parse packet header */
1182 init_get_bits(gb, buf, s->buf_bit_size);
1183 packet_sequence_number = get_bits(gb, 4);
1184 skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently ununused
1185 spliced_packet = get_bits1(gb);
1187 avpriv_request_sample(avctx, "Bitstream splicing");
1189 /* get number of bits that need to be added to the previous frame */
1190 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1192 /* check for packet loss */
1193 if (!s->packet_loss &&
1194 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1196 av_log(avctx, AV_LOG_ERROR,
1197 "Packet loss detected! seq %"PRIx8" vs %x\n",
1198 s->packet_sequence_number, packet_sequence_number);
1200 s->packet_sequence_number = packet_sequence_number;
1202 if (num_bits_prev_frame > 0) {
1203 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1204 if (num_bits_prev_frame >= remaining_packet_bits) {
1205 num_bits_prev_frame = remaining_packet_bits;
1209 /* Append the previous frame data to the remaining data from the
1210 * previous packet to create a full frame. */
1211 save_bits(s, gb, num_bits_prev_frame, 1);
1213 /* decode the cross packet frame if it is valid */
1214 if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1216 } else if (s->num_saved_bits - s->frame_offset) {
1217 ff_dlog(avctx, "ignoring %x previously saved bits\n",
1218 s->num_saved_bits - s->frame_offset);
1221 if (s->packet_loss) {
1222 /* Reset number of saved bits so that the decoder does not start
1223 * to decode incomplete frames in the s->len_prefix == 0 case. */
1224 s->num_saved_bits = 0;
1226 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1232 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1233 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1234 skip_bits(gb, s->packet_offset);
1236 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1237 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1238 frame_size <= remaining_bits(s, gb)) {
1239 save_bits(s, gb, frame_size, 0);
1240 s->packet_done = !decode_frame(s);
1241 } else if (!s->len_prefix
1242 && s->num_saved_bits > get_bits_count(&s->gb)) {
1243 /* when the frames do not have a length prefix, we don't know the
1244 * compressed length of the individual frames however, we know what
1245 * part of a new packet belongs to the previous frame therefore we
1246 * save the incoming packet first, then we append the "previous
1247 * frame" data from the next packet so that we get a buffer that
1248 * only contains full frames */
1249 s->packet_done = !decode_frame(s);
1255 if (s->packet_done && !s->packet_loss &&
1256 remaining_bits(s, gb) > 0) {
1257 /* save the rest of the data so that it can be decoded
1258 * with the next packet */
1259 save_bits(s, gb, remaining_bits(s, gb), 0);
1262 *got_frame_ptr = s->frame->nb_samples > 0;
1263 av_frame_move_ref(data, s->frame);
1265 s->packet_offset = get_bits_count(gb) & 7;
1267 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1270 static void flush(AVCodecContext *avctx)
1272 WmallDecodeCtx *s = avctx->priv_data;
1275 s->num_saved_bits = 0;
1276 s->frame_offset = 0;
1277 s->next_packet_start = 0;
1278 s->cdlms[0][0].order = 0;
1279 s->frame->nb_samples = 0;
1280 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1283 static av_cold int decode_close(AVCodecContext *avctx)
1285 WmallDecodeCtx *s = avctx->priv_data;
1287 av_frame_free(&s->frame);
1292 AVCodec ff_wmalossless_decoder = {
1293 .name = "wmalossless",
1294 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1295 .type = AVMEDIA_TYPE_AUDIO,
1296 .id = AV_CODEC_ID_WMALOSSLESS,
1297 .priv_data_size = sizeof(WmallDecodeCtx),
1298 .init = decode_init,
1299 .close = decode_close,
1300 .decode = decode_packet,
1302 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1303 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1305 AV_SAMPLE_FMT_NONE },