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 Libav.
10 * Libav 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 * Libav 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 Libav; 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"
31 #include "bitstream.h"
35 #include "wma_common.h"
37 /** current decoder limitations */
38 #define WMALL_MAX_CHANNELS 8 ///< max number of handled channels
39 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
40 #define MAX_BANDS 29 ///< max number of scale factor bands
41 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
44 #define WMALL_BLOCK_MIN_BITS 6 ///< log2 of min block size
45 #define WMALL_BLOCK_MAX_BITS 14 ///< log2 of max block size
46 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS) ///< maximum block size
47 #define WMALL_BLOCK_SIZES (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
51 * @brief frame-specific decoder context for a single channel
53 typedef struct WmallChannelCtx {
54 int16_t prev_block_len; ///< length of the previous block
55 uint8_t transmit_coefs;
56 uint8_t num_subframes;
57 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
58 uint16_t subframe_offsets[MAX_SUBFRAMES]; ///< subframe positions in the current frame
59 uint8_t cur_subframe; ///< current subframe number
60 uint16_t decoded_samples; ///< number of already processed samples
61 int quant_step; ///< quantization step for the current subframe
62 int transient_counter; ///< number of transient samples from the beginning of the transient zone
66 * @brief main decoder context
68 typedef struct WmallDecodeCtx {
69 /* generic decoder variables */
70 AVCodecContext *avctx;
72 uint8_t frame_data[MAX_FRAMESIZE + AV_INPUT_BUFFER_PADDING_SIZE]; ///< compressed frame data
73 PutBitContext pb; ///< context for filling the frame_data buffer
75 /* frame size dependent frame information (set during initialization) */
76 uint32_t decode_flags; ///< used compression features
77 int len_prefix; ///< frame is prefixed with its length
78 int dynamic_range_compression; ///< frame contains DRC data
79 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
80 uint16_t samples_per_frame; ///< number of samples to output
81 uint16_t log2_frame_size;
82 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
83 int8_t lfe_channel; ///< lfe channel index
84 uint8_t max_num_subframes;
85 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
86 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
87 uint16_t min_samples_per_subframe;
89 /* packet decode state */
90 BitstreamContext pbc; ///< bitstream reader context for the packet
91 int next_packet_start; ///< start offset of the next WMA packet in the demuxer packet
92 uint8_t packet_offset; ///< offset to the frame in the packet
93 uint8_t packet_sequence_number; ///< current packet number
94 int num_saved_bits; ///< saved number of bits
95 int frame_offset; ///< frame offset in the bit reservoir
96 int subframe_offset; ///< subframe offset in the bit reservoir
97 uint8_t packet_loss; ///< set in case of bitstream error
98 uint8_t packet_done; ///< set when a packet is fully decoded
100 /* frame decode state */
101 uint32_t frame_num; ///< current frame number (not used for decoding)
102 BitstreamContext bc; ///< bitstream reader context
103 int buf_bit_size; ///< buffer size in bits
104 int16_t *samples_16[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (16-bit)
105 int32_t *samples_32[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (24-bit)
106 uint8_t drc_gain; ///< gain for the DRC tool
107 int8_t skip_frame; ///< skip output step
108 int8_t parsed_all_subframes; ///< all subframes decoded?
110 /* subframe/block decode state */
111 int16_t subframe_len; ///< current subframe length
112 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
113 int8_t channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
115 WmallChannelCtx channel[WMALL_MAX_CHANNELS]; ///< per channel data
117 // WMA Lossless-specific
119 uint8_t do_arith_coding;
120 uint8_t do_ac_filter;
121 uint8_t do_inter_ch_decorr;
125 int8_t acfilter_order;
126 int8_t acfilter_scaling;
127 int64_t acfilter_coeffs[16];
128 int acfilter_prevvalues[2][16];
131 int8_t mclms_scaling;
132 int16_t mclms_coeffs[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS * 32];
133 int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS];
134 int16_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
135 int16_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
146 int16_t coefs[MAX_ORDER];
147 int16_t lms_prevvalues[MAX_ORDER * 2];
148 int16_t lms_updates[MAX_ORDER * 2];
156 int is_channel_coded[2];
160 int transient_pos[2];
165 int channel_residues[2][WMALL_BLOCK_MAX_SIZE];
167 int lpc_coefs[2][40];
172 int channel_coeffs[2][WMALL_BLOCK_MAX_SIZE];
176 static av_cold int decode_init(AVCodecContext *avctx)
178 WmallDecodeCtx *s = avctx->priv_data;
179 uint8_t *edata_ptr = avctx->extradata;
180 unsigned int channel_mask;
181 int i, log2_max_num_subframes;
184 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
186 if (avctx->extradata_size >= 18) {
187 s->decode_flags = AV_RL16(edata_ptr + 14);
188 channel_mask = AV_RL32(edata_ptr + 2);
189 s->bits_per_sample = AV_RL16(edata_ptr);
190 if (s->bits_per_sample == 16)
191 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
192 else if (s->bits_per_sample == 24) {
193 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
194 avpriv_report_missing_feature(avctx, "Bit-depth higher than 16");
195 return AVERROR_PATCHWELCOME;
197 av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
199 return AVERROR_INVALIDDATA;
201 /* dump the extradata */
202 for (i = 0; i < avctx->extradata_size; i++)
203 ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
204 ff_dlog(avctx, "\n");
207 avpriv_request_sample(avctx, "Unsupported extradata size");
208 return AVERROR_PATCHWELCOME;
212 s->log2_frame_size = av_log2(avctx->block_align) + 4;
215 s->skip_frame = 1; /* skip first frame */
217 s->len_prefix = s->decode_flags & 0x40;
220 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
222 av_assert0(s->samples_per_frame <= WMALL_BLOCK_MAX_SIZE);
224 /* init previous block len */
225 for (i = 0; i < avctx->channels; i++)
226 s->channel[i].prev_block_len = s->samples_per_frame;
229 log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
230 s->max_num_subframes = 1 << log2_max_num_subframes;
231 s->max_subframe_len_bit = 0;
232 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
234 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
235 s->dynamic_range_compression = s->decode_flags & 0x80;
236 s->bV3RTM = s->decode_flags & 0x100;
238 if (s->max_num_subframes > MAX_SUBFRAMES) {
239 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
240 s->max_num_subframes);
241 return AVERROR_INVALIDDATA;
244 s->num_channels = avctx->channels;
246 /* extract lfe channel position */
249 if (channel_mask & 8) {
251 for (mask = 1; mask < 16; mask <<= 1)
252 if (channel_mask & mask)
256 if (s->num_channels < 0) {
257 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %"PRId8"\n",
259 return AVERROR_INVALIDDATA;
260 } else if (s->num_channels > WMALL_MAX_CHANNELS) {
261 avpriv_request_sample(avctx,
262 "More than %d channels", WMALL_MAX_CHANNELS);
263 return AVERROR_PATCHWELCOME;
266 s->frame = av_frame_alloc();
268 return AVERROR(ENOMEM);
270 avctx->channel_layout = channel_mask;
275 * @brief Decode the subframe length.
277 * @param offset sample offset in the frame
278 * @return decoded subframe length on success, < 0 in case of an error
280 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
282 int frame_len_ratio, subframe_len, len;
284 /* no need to read from the bitstream when only one length is possible */
285 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
286 return s->min_samples_per_subframe;
288 len = av_log2(s->max_num_subframes - 1) + 1;
289 frame_len_ratio = bitstream_read(&s->bc, len);
290 subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
292 /* sanity check the length */
293 if (subframe_len < s->min_samples_per_subframe ||
294 subframe_len > s->samples_per_frame) {
295 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
297 return AVERROR_INVALIDDATA;
303 * @brief Decode how the data in the frame is split into subframes.
304 * Every WMA frame contains the encoded data for a fixed number of
305 * samples per channel. The data for every channel might be split
306 * into several subframes. This function will reconstruct the list of
307 * subframes for every channel.
309 * If the subframes are not evenly split, the algorithm estimates the
310 * channels with the lowest number of total samples.
311 * Afterwards, for each of these channels a bit is read from the
312 * bitstream that indicates if the channel contains a subframe with the
313 * next subframe size that is going to be read from the bitstream or not.
314 * If a channel contains such a subframe, the subframe size gets added to
315 * the channel's subframe list.
316 * The algorithm repeats these steps until the frame is properly divided
317 * between the individual channels.
320 * @return 0 on success, < 0 in case of an error
322 static int decode_tilehdr(WmallDecodeCtx *s)
324 uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
325 uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
326 int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
327 int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
328 int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
331 /* reset tiling information */
332 for (c = 0; c < s->num_channels; c++)
333 s->channel[c].num_subframes = 0;
335 tile_aligned = bitstream_read_bit(&s->bc);
336 if (s->max_num_subframes == 1 || tile_aligned)
337 fixed_channel_layout = 1;
339 /* loop until the frame data is split between the subframes */
341 int subframe_len, in_use = 0;
343 /* check which channels contain the subframe */
344 for (c = 0; c < s->num_channels; c++) {
345 if (num_samples[c] == min_channel_len) {
346 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
347 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
348 contains_subframe[c] = in_use = 1;
350 if (bitstream_read_bit(&s->bc))
351 contains_subframe[c] = in_use = 1;
354 contains_subframe[c] = 0;
358 av_log(s->avctx, AV_LOG_ERROR,
359 "Found empty subframe\n");
360 return AVERROR_INVALIDDATA;
363 /* get subframe length, subframe_len == 0 is not allowed */
364 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
365 return AVERROR_INVALIDDATA;
366 /* add subframes to the individual channels and find new min_channel_len */
367 min_channel_len += subframe_len;
368 for (c = 0; c < s->num_channels; c++) {
369 WmallChannelCtx *chan = &s->channel[c];
371 if (contains_subframe[c]) {
372 if (chan->num_subframes >= MAX_SUBFRAMES) {
373 av_log(s->avctx, AV_LOG_ERROR,
374 "broken frame: num subframes > 31\n");
375 return AVERROR_INVALIDDATA;
377 chan->subframe_len[chan->num_subframes] = subframe_len;
378 num_samples[c] += subframe_len;
379 ++chan->num_subframes;
380 if (num_samples[c] > s->samples_per_frame) {
381 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
382 "channel len(%"PRIu16") > samples_per_frame(%"PRIu16")\n",
383 num_samples[c], s->samples_per_frame);
384 return AVERROR_INVALIDDATA;
386 } else if (num_samples[c] <= min_channel_len) {
387 if (num_samples[c] < min_channel_len) {
388 channels_for_cur_subframe = 0;
389 min_channel_len = num_samples[c];
391 ++channels_for_cur_subframe;
394 } while (min_channel_len < s->samples_per_frame);
396 for (c = 0; c < s->num_channels; c++) {
398 for (i = 0; i < s->channel[c].num_subframes; i++) {
399 s->channel[c].subframe_offsets[i] = offset;
400 offset += s->channel[c].subframe_len[i];
407 static void decode_ac_filter(WmallDecodeCtx *s)
410 s->acfilter_order = bitstream_read(&s->bc, 4) + 1;
411 s->acfilter_scaling = bitstream_read(&s->bc, 4);
413 for (i = 0; i < s->acfilter_order; i++)
414 s->acfilter_coeffs[i] = bitstream_read(&s->bc, s->acfilter_scaling) + 1;
417 static void decode_mclms(WmallDecodeCtx *s)
419 s->mclms_order = (bitstream_read(&s->bc, 4) + 1) * 2;
420 s->mclms_scaling = bitstream_read(&s->bc, 4);
421 if (bitstream_read_bit(&s->bc)) {
422 int i, send_coef_bits;
423 int cbits = av_log2(s->mclms_scaling + 1);
424 if (1 << cbits < s->mclms_scaling + 1)
427 send_coef_bits = bitstream_read(&s->bc, cbits) + 2;
429 for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
430 s->mclms_coeffs[i] = bitstream_read(&s->bc, send_coef_bits);
432 for (i = 0; i < s->num_channels; i++) {
434 for (c = 0; c < i; c++)
435 s->mclms_coeffs_cur[i * s->num_channels + c] = bitstream_read(&s->bc, send_coef_bits);
440 static int decode_cdlms(WmallDecodeCtx *s)
443 int cdlms_send_coef = bitstream_read_bit(&s->bc);
445 for (c = 0; c < s->num_channels; c++) {
446 s->cdlms_ttl[c] = bitstream_read(&s->bc, 3) + 1;
447 for (i = 0; i < s->cdlms_ttl[c]; i++) {
448 s->cdlms[c][i].order = (bitstream_read(&s->bc, 7) + 1) * 8;
449 if (s->cdlms[c][i].order > MAX_ORDER) {
450 av_log(s->avctx, AV_LOG_ERROR,
451 "Order[%d][%d] %d > max (%d), not supported\n",
452 c, i, s->cdlms[c][i].order, MAX_ORDER);
453 s->cdlms[0][0].order = 0;
454 return AVERROR_INVALIDDATA;
458 for (i = 0; i < s->cdlms_ttl[c]; i++)
459 s->cdlms[c][i].scaling = bitstream_read(&s->bc, 4);
461 if (cdlms_send_coef) {
462 for (i = 0; i < s->cdlms_ttl[c]; i++) {
463 int cbits, shift_l, shift_r, j;
464 cbits = av_log2(s->cdlms[c][i].order);
465 if ((1 << cbits) < s->cdlms[c][i].order)
467 s->cdlms[c][i].coefsend = bitstream_read(&s->bc, cbits) + 1;
469 cbits = av_log2(s->cdlms[c][i].scaling + 1);
470 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
473 s->cdlms[c][i].bitsend = bitstream_read(&s->bc, cbits) + 2;
474 shift_l = 32 - s->cdlms[c][i].bitsend;
475 shift_r = 32 - s->cdlms[c][i].scaling - 2;
476 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
477 s->cdlms[c][i].coefs[j] =
478 (bitstream_read(&s->bc, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
486 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
489 unsigned int ave_mean;
490 s->transient[ch] = bitstream_read_bit(&s->bc);
491 if (s->transient[ch]) {
492 s->transient_pos[ch] = bitstream_read(&s->bc, av_log2(tile_size));
493 if (s->transient_pos[ch])
494 s->transient[ch] = 0;
495 s->channel[ch].transient_counter =
496 FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
497 } else if (s->channel[ch].transient_counter)
498 s->transient[ch] = 1;
500 if (s->seekable_tile) {
501 ave_mean = bitstream_read(&s->bc, s->bits_per_sample);
502 s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
505 if (s->seekable_tile) {
506 if (s->do_inter_ch_decorr)
507 s->channel_residues[ch][0] = bitstream_read_signed(&s->bc, s->bits_per_sample + 1);
509 s->channel_residues[ch][0] = bitstream_read_signed(&s->bc, s->bits_per_sample);
512 for (; i < tile_size; i++) {
513 int quo = 0, rem, rem_bits, residue;
514 while (bitstream_read_bit(&s->bc)) {
516 if (bitstream_bits_left(&s->bc) <= 0)
520 quo += bitstream_read(&s->bc, bitstream_read(&s->bc, 5) + 1);
522 ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
526 rem_bits = av_ceil_log2(ave_mean);
527 rem = rem_bits ? bitstream_read(&s->bc, rem_bits) : 0;
528 residue = (quo << rem_bits) + rem;
531 s->ave_sum[ch] = residue + s->ave_sum[ch] -
532 (s->ave_sum[ch] >> s->movave_scaling);
535 residue = -(residue >> 1) - 1;
537 residue = residue >> 1;
538 s->channel_residues[ch][i] = residue;
545 static void decode_lpc(WmallDecodeCtx *s)
548 s->lpc_order = bitstream_read(&s->bc, 5) + 1;
549 s->lpc_scaling = bitstream_read(&s->bc, 4);
550 s->lpc_intbits = bitstream_read(&s->bc, 3) + 1;
551 cbits = s->lpc_scaling + s->lpc_intbits;
552 for (ch = 0; ch < s->num_channels; ch++)
553 for (i = 0; i < s->lpc_order; i++)
554 s->lpc_coefs[ch][i] = bitstream_read_signed(&s->bc, cbits);
557 static void clear_codec_buffers(WmallDecodeCtx *s)
561 memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
562 memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
563 memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
565 memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
566 memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
567 memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
568 memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
570 for (ich = 0; ich < s->num_channels; ich++) {
571 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
572 memset(s->cdlms[ich][ilms].coefs, 0,
573 sizeof(s->cdlms[ich][ilms].coefs));
574 memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
575 sizeof(s->cdlms[ich][ilms].lms_prevvalues));
576 memset(s->cdlms[ich][ilms].lms_updates, 0,
577 sizeof(s->cdlms[ich][ilms].lms_updates));
584 * @brief Reset filter parameters and transient area at new seekable tile.
586 static void reset_codec(WmallDecodeCtx *s)
589 s->mclms_recent = s->mclms_order * s->num_channels;
590 for (ich = 0; ich < s->num_channels; ich++) {
591 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
592 s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
593 /* first sample of a seekable subframe is considered as the starting of
594 a transient area which is samples_per_frame samples long */
595 s->channel[ich].transient_counter = s->samples_per_frame;
596 s->transient[ich] = 1;
597 s->transient_pos[ich] = 0;
601 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
603 int i, j, ich, pred_error;
604 int order = s->mclms_order;
605 int num_channels = s->num_channels;
606 int range = 1 << (s->bits_per_sample - 1);
608 for (ich = 0; ich < num_channels; ich++) {
609 pred_error = s->channel_residues[ich][icoef] - pred[ich];
610 if (pred_error > 0) {
611 for (i = 0; i < order * num_channels; i++)
612 s->mclms_coeffs[i + ich * order * num_channels] +=
613 s->mclms_updates[s->mclms_recent + i];
614 for (j = 0; j < ich; j++) {
615 if (s->channel_residues[j][icoef] > 0)
616 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
617 else if (s->channel_residues[j][icoef] < 0)
618 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
620 } else if (pred_error < 0) {
621 for (i = 0; i < order * num_channels; i++)
622 s->mclms_coeffs[i + ich * order * num_channels] -=
623 s->mclms_updates[s->mclms_recent + i];
624 for (j = 0; j < ich; j++) {
625 if (s->channel_residues[j][icoef] > 0)
626 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
627 else if (s->channel_residues[j][icoef] < 0)
628 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
633 for (ich = num_channels - 1; ich >= 0; ich--) {
635 s->mclms_prevvalues[s->mclms_recent] = s->channel_residues[ich][icoef];
636 if (s->channel_residues[ich][icoef] > range - 1)
637 s->mclms_prevvalues[s->mclms_recent] = range - 1;
638 else if (s->channel_residues[ich][icoef] < -range)
639 s->mclms_prevvalues[s->mclms_recent] = -range;
641 s->mclms_updates[s->mclms_recent] = 0;
642 if (s->channel_residues[ich][icoef] > 0)
643 s->mclms_updates[s->mclms_recent] = 1;
644 else if (s->channel_residues[ich][icoef] < 0)
645 s->mclms_updates[s->mclms_recent] = -1;
648 if (s->mclms_recent == 0) {
649 memcpy(&s->mclms_prevvalues[order * num_channels],
651 2 * order * num_channels);
652 memcpy(&s->mclms_updates[order * num_channels],
654 2 * order * num_channels);
655 s->mclms_recent = num_channels * order;
659 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
662 int order = s->mclms_order;
663 int num_channels = s->num_channels;
665 for (ich = 0; ich < num_channels; ich++) {
667 if (!s->is_channel_coded[ich])
669 for (i = 0; i < order * num_channels; i++)
670 pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
671 s->mclms_coeffs[i + order * num_channels * ich];
672 for (i = 0; i < ich; i++)
673 pred[ich] += s->channel_residues[i][icoef] *
674 s->mclms_coeffs_cur[i + num_channels * ich];
675 pred[ich] += 1 << s->mclms_scaling - 1;
676 pred[ich] >>= s->mclms_scaling;
677 s->channel_residues[ich][icoef] += pred[ich];
681 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
683 int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
684 for (icoef = 0; icoef < tile_size; icoef++) {
685 mclms_predict(s, icoef, pred);
686 mclms_update(s, icoef, pred);
690 static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
693 int recent = s->cdlms[ich][ilms].recent;
695 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
696 pred += s->cdlms[ich][ilms].coefs[icoef] *
697 s->cdlms[ich][ilms].lms_prevvalues[icoef + recent];
702 static void lms_update(WmallDecodeCtx *s, int ich, int ilms,
703 int input, int residue)
706 int recent = s->cdlms[ich][ilms].recent;
707 int range = 1 << s->bits_per_sample - 1;
710 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
711 s->cdlms[ich][ilms].coefs[icoef] -=
712 s->cdlms[ich][ilms].lms_updates[icoef + recent];
713 } else if (residue > 0) {
714 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
715 s->cdlms[ich][ilms].coefs[icoef] +=
716 s->cdlms[ich][ilms].lms_updates[icoef + recent];
722 memcpy(&s->cdlms[ich][ilms].lms_prevvalues[s->cdlms[ich][ilms].order],
723 s->cdlms[ich][ilms].lms_prevvalues,
724 2 * s->cdlms[ich][ilms].order);
725 memcpy(&s->cdlms[ich][ilms].lms_updates[s->cdlms[ich][ilms].order],
726 s->cdlms[ich][ilms].lms_updates,
727 2 * s->cdlms[ich][ilms].order);
728 recent = s->cdlms[ich][ilms].order - 1;
731 s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
733 s->cdlms[ich][ilms].lms_updates[recent] = 0;
735 s->cdlms[ich][ilms].lms_updates[recent] = -s->update_speed[ich];
737 s->cdlms[ich][ilms].lms_updates[recent] = s->update_speed[ich];
739 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 4)] >>= 2;
740 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 3)] >>= 1;
741 s->cdlms[ich][ilms].recent = recent;
744 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
746 int ilms, recent, icoef;
747 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
748 recent = s->cdlms[ich][ilms].recent;
749 if (s->update_speed[ich] == 16)
752 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
753 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
755 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
756 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
759 s->update_speed[ich] = 16;
762 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
764 int ilms, recent, icoef;
765 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
766 recent = s->cdlms[ich][ilms].recent;
767 if (s->update_speed[ich] == 8)
770 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
771 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
773 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
774 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
776 s->update_speed[ich] = 8;
779 static void revert_cdlms(WmallDecodeCtx *s, int ch,
780 int coef_begin, int coef_end)
782 int icoef, pred, ilms, num_lms, residue, input;
784 num_lms = s->cdlms_ttl[ch];
785 for (ilms = num_lms - 1; ilms >= 0; ilms--) {
786 for (icoef = coef_begin; icoef < coef_end; icoef++) {
787 pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
788 residue = s->channel_residues[ch][icoef];
789 pred += lms_predict(s, ch, ilms);
790 input = residue + (pred >> s->cdlms[ch][ilms].scaling);
791 lms_update(s, ch, ilms, input, residue);
792 s->channel_residues[ch][icoef] = input;
797 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
799 if (s->num_channels != 2)
801 else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
803 for (icoef = 0; icoef < tile_size; icoef++) {
804 s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
805 s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
810 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
813 int64_t *filter_coeffs = s->acfilter_coeffs;
814 int scaling = s->acfilter_scaling;
815 int order = s->acfilter_order;
817 for (ich = 0; ich < s->num_channels; ich++) {
818 int *prevvalues = s->acfilter_prevvalues[ich];
819 for (i = 0; i < order; i++) {
821 for (j = 0; j < order; j++) {
823 pred += filter_coeffs[j] * prevvalues[j - i];
825 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
828 s->channel_residues[ich][i] += pred;
830 for (i = order; i < tile_size; i++) {
832 for (j = 0; j < order; j++)
833 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
835 s->channel_residues[ich][i] += pred;
837 for (j = 0; j < order; j++)
838 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
842 static int decode_subframe(WmallDecodeCtx *s)
844 int offset = s->samples_per_frame;
845 int subframe_len = s->samples_per_frame;
846 int total_samples = s->samples_per_frame * s->num_channels;
847 int i, j, rawpcm_tile, padding_zeroes, res;
849 s->subframe_offset = bitstream_tell(&s->bc);
851 /* reset channel context and find the next block offset and size
852 == the next block of the channel with the smallest number of
854 for (i = 0; i < s->num_channels; i++) {
855 if (offset > s->channel[i].decoded_samples) {
856 offset = s->channel[i].decoded_samples;
858 s->channel[i].subframe_len[s->channel[i].cur_subframe];
862 /* get a list of all channels that contain the estimated block */
863 s->channels_for_cur_subframe = 0;
864 for (i = 0; i < s->num_channels; i++) {
865 const int cur_subframe = s->channel[i].cur_subframe;
866 /* subtract already processed samples */
867 total_samples -= s->channel[i].decoded_samples;
869 /* and count if there are multiple subframes that match our profile */
870 if (offset == s->channel[i].decoded_samples &&
871 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
872 total_samples -= s->channel[i].subframe_len[cur_subframe];
873 s->channel[i].decoded_samples +=
874 s->channel[i].subframe_len[cur_subframe];
875 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
876 ++s->channels_for_cur_subframe;
880 /* check if the frame will be complete after processing the
883 s->parsed_all_subframes = 1;
886 s->seekable_tile = bitstream_read_bit(&s->bc);
887 if (s->seekable_tile) {
888 clear_codec_buffers(s);
890 s->do_arith_coding = bitstream_read_bit(&s->bc);
891 if (s->do_arith_coding) {
892 avpriv_request_sample(s->avctx, "Arithmetic coding");
893 return AVERROR_PATCHWELCOME;
895 s->do_ac_filter = bitstream_read_bit(&s->bc);
896 s->do_inter_ch_decorr = bitstream_read_bit(&s->bc);
897 s->do_mclms = bitstream_read_bit(&s->bc);
905 if ((res = decode_cdlms(s)) < 0)
907 s->movave_scaling = bitstream_read(&s->bc, 3);
908 s->quant_stepsize = bitstream_read(&s->bc, 8) + 1;
911 } else if (!s->cdlms[0][0].order) {
912 av_log(s->avctx, AV_LOG_DEBUG,
913 "Waiting for seekable tile\n");
914 av_frame_unref(s->frame);
918 rawpcm_tile = bitstream_read_bit(&s->bc);
920 for (i = 0; i < s->num_channels; i++)
921 s->is_channel_coded[i] = 1;
924 for (i = 0; i < s->num_channels; i++)
925 s->is_channel_coded[i] = bitstream_read_bit(&s->bc);
929 s->do_lpc = bitstream_read_bit(&s->bc);
932 avpriv_request_sample(s->avctx, "Expect wrong output since "
933 "inverse LPC filter");
940 if (bitstream_read_bit(&s->bc))
941 padding_zeroes = bitstream_read(&s->bc, 5);
946 int bits = s->bits_per_sample - padding_zeroes;
948 av_log(s->avctx, AV_LOG_ERROR,
949 "Invalid number of padding bits in raw PCM tile\n");
950 return AVERROR_INVALIDDATA;
952 ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
953 "total %d bits, remain=%d\n", bits,
954 bits * s->num_channels * subframe_len, bitstream_tell(&s->bc));
955 for (i = 0; i < s->num_channels; i++)
956 for (j = 0; j < subframe_len; j++)
957 s->channel_coeffs[i][j] = bitstream_read_signed(&s->bc, bits);
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);
965 use_normal_update_speed(s, i);
966 revert_cdlms(s, i, 0, subframe_len);
968 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
972 revert_mclms(s, subframe_len);
973 if (s->do_inter_ch_decorr)
974 revert_inter_ch_decorr(s, subframe_len);
976 revert_acfilter(s, subframe_len);
979 if (s->quant_stepsize != 1)
980 for (i = 0; i < s->num_channels; i++)
981 for (j = 0; j < subframe_len; j++)
982 s->channel_residues[i][j] *= s->quant_stepsize;
984 /* Write to proper output buffer depending on bit-depth */
985 for (i = 0; i < s->channels_for_cur_subframe; i++) {
986 int c = s->channel_indexes_for_cur_subframe[i];
987 int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
989 for (j = 0; j < subframe_len; j++) {
990 if (s->bits_per_sample == 16) {
991 *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] << padding_zeroes;
993 *s->samples_32[c]++ = s->channel_residues[c][j] << padding_zeroes;
998 /* handled one subframe */
999 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1000 int c = s->channel_indexes_for_cur_subframe[i];
1001 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1002 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1003 return AVERROR_INVALIDDATA;
1005 ++s->channel[c].cur_subframe;
1011 * @brief Decode one WMA frame.
1012 * @param s codec context
1013 * @return 0 if the trailer bit indicates that this is the last frame,
1014 * 1 if there are additional frames
1016 static int decode_frame(WmallDecodeCtx *s)
1018 BitstreamContext *bc = &s->bc;
1019 int more_frames = 0, len = 0, i, ret;
1021 s->frame->nb_samples = s->samples_per_frame;
1022 if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1023 /* return an error if no frame could be decoded at all */
1024 av_log(s->avctx, AV_LOG_ERROR,
1025 "not enough space for the output samples\n");
1029 for (i = 0; i < s->num_channels; i++) {
1030 s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1031 s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1034 /* get frame length */
1036 len = bitstream_read(bc, s->log2_frame_size);
1038 /* decode tile information */
1039 if (decode_tilehdr(s)) {
1045 if (s->dynamic_range_compression)
1046 s->drc_gain = bitstream_read(bc, 8);
1048 /* no idea what these are for, might be the number of samples
1049 that need to be skipped at the beginning or end of a stream */
1050 if (bitstream_read_bit(bc)) {
1053 /* usually true for the first frame */
1054 if (bitstream_read_bit(bc)) {
1055 skip = bitstream_read(bc, av_log2(s->samples_per_frame * 2));
1056 ff_dlog(s->avctx, "start skip: %i\n", skip);
1059 /* sometimes true for the last frame */
1060 if (bitstream_read_bit(bc)) {
1061 skip = bitstream_read(bc, av_log2(s->samples_per_frame * 2));
1062 ff_dlog(s->avctx, "end skip: %i\n", skip);
1067 /* reset subframe states */
1068 s->parsed_all_subframes = 0;
1069 for (i = 0; i < s->num_channels; i++) {
1070 s->channel[i].decoded_samples = 0;
1071 s->channel[i].cur_subframe = 0;
1074 /* decode all subframes */
1075 while (!s->parsed_all_subframes) {
1076 if (decode_subframe(s) < 0) {
1082 ff_dlog(s->avctx, "Frame done\n");
1087 if (s->len_prefix) {
1088 if (len != (bitstream_tell(bc) - s->frame_offset) + 2) {
1089 /* FIXME: not sure if this is always an error */
1090 av_log(s->avctx, AV_LOG_ERROR,
1091 "frame[%"PRIu32"] would have to skip %i bits\n",
1093 len - (bitstream_tell(bc) - s->frame_offset) - 1);
1098 /* skip the rest of the frame data */
1099 bitstream_skip(bc, len - (bitstream_tell(bc) - s->frame_offset) - 1);
1102 /* decode trailer bit */
1103 more_frames = bitstream_read_bit(bc);
1109 * @brief Calculate remaining input buffer length.
1110 * @param s codec context
1111 * @param bc bitstream reader context
1112 * @return remaining size in bits
1114 static int remaining_bits(WmallDecodeCtx *s, BitstreamContext *bc)
1116 return s->buf_bit_size - bitstream_tell(bc);
1120 * @brief Fill the bit reservoir with a (partial) frame.
1121 * @param s codec context
1122 * @param bc bitstream reader context
1123 * @param len length of the partial frame
1124 * @param append decides whether to reset the buffer or not
1126 static void save_bits(WmallDecodeCtx *s, BitstreamContext *bc, int len,
1132 /* when the frame data does not need to be concatenated, the input buffer
1133 is reset and additional bits from the previous frame are copied
1134 and skipped later so that a fast byte copy is possible */
1137 s->frame_offset = bitstream_tell(bc) & 7;
1138 s->num_saved_bits = s->frame_offset;
1139 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1142 buflen = (s->num_saved_bits + len + 8) >> 3;
1144 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1145 avpriv_request_sample(s->avctx, "Too small input buffer");
1150 s->num_saved_bits += len;
1152 avpriv_copy_bits(&s->pb, bc->buffer + (bitstream_tell(bc) >> 3),
1155 int align = 8 - (bitstream_tell(bc) & 7);
1156 align = FFMIN(align, len);
1157 put_bits(&s->pb, align, bitstream_read(bc, align));
1159 avpriv_copy_bits(&s->pb, bc->buffer + (bitstream_tell(bc) >> 3), len);
1161 bitstream_skip(bc, len);
1164 flush_put_bits(&tmp);
1166 bitstream_init(&s->bc, s->frame_data, s->num_saved_bits);
1167 bitstream_skip(&s->bc, s->frame_offset);
1170 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1173 WmallDecodeCtx *s = avctx->priv_data;
1174 BitstreamContext *bc = &s->pbc;
1175 const uint8_t* buf = avpkt->data;
1176 int buf_size = avpkt->size;
1177 int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1179 s->frame->nb_samples = 0;
1181 if (s->packet_done || s->packet_loss) {
1184 /* sanity check for the buffer length */
1185 if (buf_size < avctx->block_align)
1188 s->next_packet_start = buf_size - avctx->block_align;
1189 buf_size = avctx->block_align;
1190 s->buf_bit_size = buf_size << 3;
1192 /* parse packet header */
1193 bitstream_init(bc, buf, s->buf_bit_size);
1194 packet_sequence_number = bitstream_read(bc, 4);
1195 bitstream_skip(bc, 1); // Skip seekable_frame_in_packet, currently ununused
1196 spliced_packet = bitstream_read_bit(bc);
1198 avpriv_request_sample(avctx, "Bitstream splicing");
1200 /* get number of bits that need to be added to the previous frame */
1201 num_bits_prev_frame = bitstream_read(bc, s->log2_frame_size);
1203 /* check for packet loss */
1204 if (!s->packet_loss &&
1205 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1207 av_log(avctx, AV_LOG_ERROR,
1208 "Packet loss detected! seq %"PRIx8" vs %x\n",
1209 s->packet_sequence_number, packet_sequence_number);
1211 s->packet_sequence_number = packet_sequence_number;
1213 if (num_bits_prev_frame > 0) {
1214 int remaining_packet_bits = s->buf_bit_size - bitstream_tell(bc);
1215 if (num_bits_prev_frame >= remaining_packet_bits) {
1216 num_bits_prev_frame = remaining_packet_bits;
1220 /* Append the previous frame data to the remaining data from the
1221 * previous packet to create a full frame. */
1222 save_bits(s, bc, num_bits_prev_frame, 1);
1224 /* decode the cross packet frame if it is valid */
1225 if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1227 } else if (s->num_saved_bits - s->frame_offset) {
1228 ff_dlog(avctx, "ignoring %x previously saved bits\n",
1229 s->num_saved_bits - s->frame_offset);
1232 if (s->packet_loss) {
1233 /* Reset number of saved bits so that the decoder does not start
1234 * to decode incomplete frames in the s->len_prefix == 0 case. */
1235 s->num_saved_bits = 0;
1237 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1243 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1244 bitstream_init(bc, avpkt->data, s->buf_bit_size);
1245 bitstream_skip(bc, s->packet_offset);
1247 if (s->len_prefix && remaining_bits(s, bc) > s->log2_frame_size &&
1248 (frame_size = bitstream_peek(bc, s->log2_frame_size)) &&
1249 frame_size <= remaining_bits(s, bc)) {
1250 save_bits(s, bc, frame_size, 0);
1251 s->packet_done = !decode_frame(s);
1252 } else if (!s->len_prefix
1253 && s->num_saved_bits > bitstream_tell(&s->bc)) {
1254 /* when the frames do not have a length prefix, we don't know the
1255 * compressed length of the individual frames however, we know what
1256 * part of a new packet belongs to the previous frame therefore we
1257 * save the incoming packet first, then we append the "previous
1258 * frame" data from the next packet so that we get a buffer that
1259 * only contains full frames */
1260 s->packet_done = !decode_frame(s);
1266 if (s->packet_done && !s->packet_loss &&
1267 remaining_bits(s, bc) > 0) {
1268 /* save the rest of the data so that it can be decoded
1269 * with the next packet */
1270 save_bits(s, bc, remaining_bits(s, bc), 0);
1273 *got_frame_ptr = s->frame->nb_samples > 0;
1274 av_frame_move_ref(data, s->frame);
1276 s->packet_offset = bitstream_tell(bc) & 7;
1278 return (s->packet_loss) ? AVERROR_INVALIDDATA : bitstream_tell(bc) >> 3;
1281 static void flush(AVCodecContext *avctx)
1283 WmallDecodeCtx *s = avctx->priv_data;
1286 s->num_saved_bits = 0;
1287 s->frame_offset = 0;
1288 s->next_packet_start = 0;
1289 s->cdlms[0][0].order = 0;
1290 s->frame->nb_samples = 0;
1291 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1294 static av_cold int decode_close(AVCodecContext *avctx)
1296 WmallDecodeCtx *s = avctx->priv_data;
1298 av_frame_free(&s->frame);
1303 AVCodec ff_wmalossless_decoder = {
1304 .name = "wmalossless",
1305 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1306 .type = AVMEDIA_TYPE_AUDIO,
1307 .id = AV_CODEC_ID_WMALOSSLESS,
1308 .priv_data_size = sizeof(WmallDecodeCtx),
1309 .init = decode_init,
1310 .close = decode_close,
1311 .decode = decode_packet,
1313 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1314 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1316 AV_SAMPLE_FMT_NONE },