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 av_log(avctx, AV_LOG_WARNING, "Decoding audio at 24 bit-depth\n");
205 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
206 avctx->bits_per_raw_sample = 24;
208 av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
210 return AVERROR_INVALIDDATA;
212 /* dump the extradata */
213 for (i = 0; i < avctx->extradata_size; i++)
214 ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
215 ff_dlog(avctx, "\n");
218 avpriv_request_sample(avctx, "Unsupported extradata size");
219 return AVERROR_PATCHWELCOME;
223 s->log2_frame_size = av_log2(avctx->block_align) + 4;
226 s->skip_frame = 1; /* skip first frame */
228 s->len_prefix = s->decode_flags & 0x40;
231 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
233 av_assert0(s->samples_per_frame <= WMALL_BLOCK_MAX_SIZE);
235 /* init previous block len */
236 for (i = 0; i < avctx->channels; i++)
237 s->channel[i].prev_block_len = s->samples_per_frame;
240 log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
241 s->max_num_subframes = 1 << log2_max_num_subframes;
242 s->max_subframe_len_bit = 0;
243 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
245 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
246 s->dynamic_range_compression = s->decode_flags & 0x80;
247 s->bV3RTM = s->decode_flags & 0x100;
249 if (s->max_num_subframes > MAX_SUBFRAMES) {
250 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
251 s->max_num_subframes);
252 return AVERROR_INVALIDDATA;
255 s->num_channels = avctx->channels;
257 /* extract lfe channel position */
260 if (channel_mask & 8) {
262 for (mask = 1; mask < 16; mask <<= 1)
263 if (channel_mask & mask)
267 if (s->num_channels < 0) {
268 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %"PRId8"\n",
270 return AVERROR_INVALIDDATA;
271 } else if (s->num_channels > WMALL_MAX_CHANNELS) {
272 avpriv_request_sample(avctx,
273 "More than %d channels", WMALL_MAX_CHANNELS);
274 return AVERROR_PATCHWELCOME;
277 s->frame = av_frame_alloc();
279 return AVERROR(ENOMEM);
281 avctx->channel_layout = channel_mask;
286 * @brief Decode the subframe length.
288 * @param offset sample offset in the frame
289 * @return decoded subframe length on success, < 0 in case of an error
291 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
293 int frame_len_ratio, subframe_len, len;
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;
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);
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",
308 return AVERROR_INVALIDDATA;
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.
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.
331 * @return 0 on success, < 0 in case of an error
333 static int decode_tilehdr(WmallDecodeCtx *s)
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) */
342 /* reset tiling information */
343 for (c = 0; c < s->num_channels; c++)
344 s->channel[c].num_subframes = 0;
346 tile_aligned = get_bits1(&s->gb);
347 if (s->max_num_subframes == 1 || tile_aligned)
348 fixed_channel_layout = 1;
350 /* loop until the frame data is split between the subframes */
352 int subframe_len, in_use = 0;
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;
361 contains_subframe[c] = get_bits1(&s->gb);
363 in_use |= contains_subframe[c];
365 contains_subframe[c] = 0;
369 av_log(s->avctx, AV_LOG_ERROR,
370 "Found empty subframe\n");
371 return AVERROR_INVALIDDATA;
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];
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;
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;
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];
402 ++channels_for_cur_subframe;
405 } while (min_channel_len < s->samples_per_frame);
407 for (c = 0; c < s->num_channels; c++) {
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];
418 static void decode_ac_filter(WmallDecodeCtx *s)
421 s->acfilter_order = get_bits(&s->gb, 4) + 1;
422 s->acfilter_scaling = get_bits(&s->gb, 4);
424 for (i = 0; i < s->acfilter_order; i++)
425 s->acfilter_coeffs[i] = (s->acfilter_scaling ?
426 get_bits(&s->gb, s->acfilter_scaling) : 0) + 1;
429 static void decode_mclms(WmallDecodeCtx *s)
431 s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
432 s->mclms_scaling = get_bits(&s->gb, 4);
433 if (get_bits1(&s->gb)) {
434 int i, send_coef_bits;
435 int cbits = av_log2(s->mclms_scaling + 1);
436 if (1 << cbits < s->mclms_scaling + 1)
439 send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
441 for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
442 s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
444 for (i = 0; i < s->num_channels; i++) {
446 for (c = 0; c < i; c++)
447 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
452 static int decode_cdlms(WmallDecodeCtx *s)
455 int cdlms_send_coef = get_bits1(&s->gb);
457 for (c = 0; c < s->num_channels; c++) {
458 s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
459 for (i = 0; i < s->cdlms_ttl[c]; i++) {
460 s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
461 if (s->cdlms[c][i].order > MAX_ORDER) {
462 av_log(s->avctx, AV_LOG_ERROR,
463 "Order[%d][%d] %d > max (%d), not supported\n",
464 c, i, s->cdlms[c][i].order, MAX_ORDER);
465 s->cdlms[0][0].order = 0;
466 return AVERROR_INVALIDDATA;
468 if(s->cdlms[c][i].order & 8) {
471 avpriv_request_sample(s->avctx, "CDLMS of order %d",
472 s->cdlms[c][i].order);
477 for (i = 0; i < s->cdlms_ttl[c]; i++)
478 s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
480 if (cdlms_send_coef) {
481 for (i = 0; i < s->cdlms_ttl[c]; i++) {
482 int cbits, shift_l, shift_r, j;
483 cbits = av_log2(s->cdlms[c][i].order);
484 if ((1 << cbits) < s->cdlms[c][i].order)
486 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
488 cbits = av_log2(s->cdlms[c][i].scaling + 1);
489 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
492 s->cdlms[c][i].bitsend = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
493 shift_l = 32 - s->cdlms[c][i].bitsend;
494 shift_r = 32 - s->cdlms[c][i].scaling - 2;
495 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
496 s->cdlms[c][i].coefs[j] =
497 (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
501 for (i = 0; i < s->cdlms_ttl[c]; i++)
502 memset(s->cdlms[c][i].coefs + s->cdlms[c][i].order,
503 0, WMALL_COEFF_PAD_SIZE);
509 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
512 unsigned int ave_mean;
513 s->transient[ch] = get_bits1(&s->gb);
514 if (s->transient[ch]) {
515 s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
516 if (s->transient_pos[ch])
517 s->transient[ch] = 0;
518 s->channel[ch].transient_counter =
519 FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
520 } else if (s->channel[ch].transient_counter)
521 s->transient[ch] = 1;
523 if (s->seekable_tile) {
524 ave_mean = get_bits(&s->gb, s->bits_per_sample);
525 s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
528 if (s->seekable_tile) {
529 if (s->do_inter_ch_decorr)
530 s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample + 1);
532 s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample);
535 for (; i < tile_size; i++) {
536 int quo = 0, rem, rem_bits, residue;
537 while(get_bits1(&s->gb)) {
539 if (get_bits_left(&s->gb) <= 0)
543 quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
545 ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
549 rem_bits = av_ceil_log2(ave_mean);
550 rem = get_bits_long(&s->gb, rem_bits);
551 residue = (quo << rem_bits) + rem;
554 s->ave_sum[ch] = residue + s->ave_sum[ch] -
555 (s->ave_sum[ch] >> s->movave_scaling);
557 residue = (residue >> 1) ^ -(residue & 1);
558 s->channel_residues[ch][i] = residue;
565 static void decode_lpc(WmallDecodeCtx *s)
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);
577 static void clear_codec_buffers(WmallDecodeCtx *s)
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));
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));
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));
604 * @brief Reset filter parameters and transient area at new seekable tile.
606 static void reset_codec(WmallDecodeCtx *s)
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;
621 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
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);
628 for (ich = 0; ich < num_channels; ich++) {
629 pred_error = s->channel_residues[ich][icoef] - 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]);
645 for (ich = num_channels - 1; ich >= 0; ich--) {
647 s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
649 s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
652 if (s->mclms_recent == 0) {
653 memcpy(&s->mclms_prevvalues[order * num_channels],
655 sizeof(int16_t) * order * num_channels);
656 memcpy(&s->mclms_updates[order * num_channels],
658 sizeof(int16_t) * order * num_channels);
659 s->mclms_recent = num_channels * order;
663 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
666 int order = s->mclms_order;
667 int num_channels = s->num_channels;
669 for (ich = 0; ich < num_channels; ich++) {
671 if (!s->is_channel_coded[ich])
673 for (i = 0; i < order * num_channels; i++)
674 pred[ich] += 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] += s->channel_residues[i][icoef] *
678 s->mclms_coeffs_cur[i + num_channels * ich];
679 pred[ich] += 1 << s->mclms_scaling - 1;
680 pred[ich] >>= s->mclms_scaling;
681 s->channel_residues[ich][icoef] += pred[ich];
685 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
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);
694 static void lms_update(WmallDecodeCtx *s, int ich, int ilms, int input)
696 int recent = s->cdlms[ich][ilms].recent;
697 int range = 1 << s->bits_per_sample - 1;
698 int order = s->cdlms[ich][ilms].order;
703 memcpy(s->cdlms[ich][ilms].lms_prevvalues + order,
704 s->cdlms[ich][ilms].lms_prevvalues, sizeof(*s->cdlms[ich][ilms].lms_prevvalues) * order);
705 memcpy(s->cdlms[ich][ilms].lms_updates + order,
706 s->cdlms[ich][ilms].lms_updates, sizeof(*s->cdlms[ich][ilms].lms_updates) * order);
710 s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
711 s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich];
713 s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2;
714 s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1;
715 s->cdlms[ich][ilms].recent = recent;
716 memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0,
717 sizeof(s->cdlms[ich][ilms].lms_updates) - 2*(recent+order));
720 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
722 int ilms, recent, icoef;
723 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
724 recent = s->cdlms[ich][ilms].recent;
725 if (s->update_speed[ich] == 16)
728 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
729 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
731 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
732 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
735 s->update_speed[ich] = 16;
738 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
740 int ilms, recent, icoef;
741 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
742 recent = s->cdlms[ich][ilms].recent;
743 if (s->update_speed[ich] == 8)
746 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
747 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
749 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
750 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
752 s->update_speed[ich] = 8;
755 static void revert_cdlms(WmallDecodeCtx *s, int ch,
756 int coef_begin, int coef_end)
758 int icoef, pred, ilms, num_lms, residue, input;
760 num_lms = s->cdlms_ttl[ch];
761 for (ilms = num_lms - 1; ilms >= 0; ilms--) {
762 for (icoef = coef_begin; icoef < coef_end; icoef++) {
763 pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
764 residue = s->channel_residues[ch][icoef];
765 pred += s->dsp.scalarproduct_and_madd_int16(s->cdlms[ch][ilms].coefs,
766 s->cdlms[ch][ilms].lms_prevvalues
767 + s->cdlms[ch][ilms].recent,
768 s->cdlms[ch][ilms].lms_updates
769 + s->cdlms[ch][ilms].recent,
770 FFALIGN(s->cdlms[ch][ilms].order,
771 WMALL_COEFF_PAD_SIZE),
773 input = residue + (pred >> s->cdlms[ch][ilms].scaling);
774 lms_update(s, ch, ilms, input);
775 s->channel_residues[ch][icoef] = input;
781 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
783 if (s->num_channels != 2)
785 else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
787 for (icoef = 0; icoef < tile_size; icoef++) {
788 s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
789 s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
794 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
797 int16_t *filter_coeffs = s->acfilter_coeffs;
798 int scaling = s->acfilter_scaling;
799 int order = s->acfilter_order;
801 for (ich = 0; ich < s->num_channels; ich++) {
802 int *prevvalues = s->acfilter_prevvalues[ich];
803 for (i = 0; i < order; i++) {
805 for (j = 0; j < order; j++) {
807 pred += filter_coeffs[j] * prevvalues[j - i];
809 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
812 s->channel_residues[ich][i] += pred;
814 for (i = order; i < tile_size; i++) {
816 for (j = 0; j < order; j++)
817 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
819 s->channel_residues[ich][i] += pred;
821 for (j = 0; j < order; j++)
822 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
826 static int decode_subframe(WmallDecodeCtx *s)
828 int offset = s->samples_per_frame;
829 int subframe_len = s->samples_per_frame;
830 int total_samples = s->samples_per_frame * s->num_channels;
831 int i, j, rawpcm_tile, padding_zeroes, res;
833 s->subframe_offset = get_bits_count(&s->gb);
835 /* reset channel context and find the next block offset and size
836 == the next block of the channel with the smallest number of
838 for (i = 0; i < s->num_channels; i++) {
839 if (offset > s->channel[i].decoded_samples) {
840 offset = s->channel[i].decoded_samples;
842 s->channel[i].subframe_len[s->channel[i].cur_subframe];
846 /* get a list of all channels that contain the estimated block */
847 s->channels_for_cur_subframe = 0;
848 for (i = 0; i < s->num_channels; i++) {
849 const int cur_subframe = s->channel[i].cur_subframe;
850 /* subtract already processed samples */
851 total_samples -= s->channel[i].decoded_samples;
853 /* and count if there are multiple subframes that match our profile */
854 if (offset == s->channel[i].decoded_samples &&
855 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
856 total_samples -= s->channel[i].subframe_len[cur_subframe];
857 s->channel[i].decoded_samples +=
858 s->channel[i].subframe_len[cur_subframe];
859 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
860 ++s->channels_for_cur_subframe;
864 /* check if the frame will be complete after processing the
867 s->parsed_all_subframes = 1;
870 s->seekable_tile = get_bits1(&s->gb);
871 if (s->seekable_tile) {
872 clear_codec_buffers(s);
874 s->do_arith_coding = get_bits1(&s->gb);
875 if (s->do_arith_coding) {
876 avpriv_request_sample(s->avctx, "Arithmetic coding");
877 return AVERROR_PATCHWELCOME;
879 s->do_ac_filter = get_bits1(&s->gb);
880 s->do_inter_ch_decorr = get_bits1(&s->gb);
881 s->do_mclms = get_bits1(&s->gb);
889 if ((res = decode_cdlms(s)) < 0)
891 s->movave_scaling = get_bits(&s->gb, 3);
892 s->quant_stepsize = get_bits(&s->gb, 8) + 1;
895 } else if (!s->cdlms[0][0].order) {
896 av_log(s->avctx, AV_LOG_DEBUG,
897 "Waiting for seekable tile\n");
898 av_frame_unref(s->frame);
902 rawpcm_tile = get_bits1(&s->gb);
904 for (i = 0; i < s->num_channels; i++)
905 s->is_channel_coded[i] = 1;
908 for (i = 0; i < s->num_channels; i++)
909 s->is_channel_coded[i] = get_bits1(&s->gb);
913 s->do_lpc = get_bits1(&s->gb);
916 avpriv_request_sample(s->avctx, "Expect wrong output since "
917 "inverse LPC filter");
924 if (get_bits1(&s->gb))
925 padding_zeroes = get_bits(&s->gb, 5);
930 int bits = s->bits_per_sample - padding_zeroes;
932 av_log(s->avctx, AV_LOG_ERROR,
933 "Invalid number of padding bits in raw PCM tile\n");
934 return AVERROR_INVALIDDATA;
936 ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
937 "total %d bits, remain=%d\n", bits,
938 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
939 for (i = 0; i < s->num_channels; i++)
940 for (j = 0; j < subframe_len; j++)
941 s->channel_coeffs[i][j] = get_sbits_long(&s->gb, bits);
943 for (i = 0; i < s->num_channels; i++)
944 if (s->is_channel_coded[i]) {
945 decode_channel_residues(s, i, subframe_len);
946 if (s->seekable_tile)
947 use_high_update_speed(s, i);
949 use_normal_update_speed(s, i);
950 revert_cdlms(s, i, 0, subframe_len);
952 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
956 revert_mclms(s, subframe_len);
957 if (s->do_inter_ch_decorr)
958 revert_inter_ch_decorr(s, subframe_len);
960 revert_acfilter(s, subframe_len);
963 if (s->quant_stepsize != 1)
964 for (i = 0; i < s->num_channels; i++)
965 for (j = 0; j < subframe_len; j++)
966 s->channel_residues[i][j] *= s->quant_stepsize;
968 /* Write to proper output buffer depending on bit-depth */
969 for (i = 0; i < s->channels_for_cur_subframe; i++) {
970 int c = s->channel_indexes_for_cur_subframe[i];
971 int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
973 for (j = 0; j < subframe_len; j++) {
974 if (s->bits_per_sample == 16) {
975 *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] << padding_zeroes;
977 *s->samples_32[c]++ = s->channel_residues[c][j] << (padding_zeroes + 8);
982 /* handled one subframe */
983 for (i = 0; i < s->channels_for_cur_subframe; i++) {
984 int c = s->channel_indexes_for_cur_subframe[i];
985 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
986 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
987 return AVERROR_INVALIDDATA;
989 ++s->channel[c].cur_subframe;
995 * @brief Decode one WMA frame.
996 * @param s codec context
997 * @return 0 if the trailer bit indicates that this is the last frame,
998 * 1 if there are additional frames
1000 static int decode_frame(WmallDecodeCtx *s)
1002 GetBitContext* gb = &s->gb;
1003 int more_frames = 0, len = 0, i, ret;
1005 s->frame->nb_samples = s->samples_per_frame;
1006 if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1007 /* return an error if no frame could be decoded at all */
1009 s->frame->nb_samples = 0;
1012 for (i = 0; i < s->num_channels; i++) {
1013 s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1014 s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1017 /* get frame length */
1019 len = get_bits(gb, s->log2_frame_size);
1021 /* decode tile information */
1022 if ((ret = decode_tilehdr(s))) {
1024 av_frame_unref(s->frame);
1029 if (s->dynamic_range_compression)
1030 s->drc_gain = get_bits(gb, 8);
1032 /* no idea what these are for, might be the number of samples
1033 that need to be skipped at the beginning or end of a stream */
1034 if (get_bits1(gb)) {
1037 /* usually true for the first frame */
1038 if (get_bits1(gb)) {
1039 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1040 ff_dlog(s->avctx, "start skip: %i\n", skip);
1043 /* sometimes true for the last frame */
1044 if (get_bits1(gb)) {
1045 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1046 ff_dlog(s->avctx, "end skip: %i\n", skip);
1051 /* reset subframe states */
1052 s->parsed_all_subframes = 0;
1053 for (i = 0; i < s->num_channels; i++) {
1054 s->channel[i].decoded_samples = 0;
1055 s->channel[i].cur_subframe = 0;
1058 /* decode all subframes */
1059 while (!s->parsed_all_subframes) {
1060 int decoded_samples = s->channel[0].decoded_samples;
1061 if (decode_subframe(s) < 0) {
1063 if (s->frame->nb_samples)
1064 s->frame->nb_samples = decoded_samples;
1069 ff_dlog(s->avctx, "Frame done\n");
1073 if (s->len_prefix) {
1074 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1075 /* FIXME: not sure if this is always an error */
1076 av_log(s->avctx, AV_LOG_ERROR,
1077 "frame[%"PRIu32"] would have to skip %i bits\n",
1079 len - (get_bits_count(gb) - s->frame_offset) - 1);
1084 /* skip the rest of the frame data */
1085 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1088 /* decode trailer bit */
1089 more_frames = get_bits1(gb);
1095 * @brief Calculate remaining input buffer length.
1096 * @param s codec context
1097 * @param gb bitstream reader context
1098 * @return remaining size in bits
1100 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1102 return s->buf_bit_size - get_bits_count(gb);
1106 * @brief Fill the bit reservoir with a (partial) frame.
1107 * @param s codec context
1108 * @param gb bitstream reader context
1109 * @param len length of the partial frame
1110 * @param append decides whether to reset the buffer or not
1112 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1118 /* when the frame data does not need to be concatenated, the input buffer
1119 is reset and additional bits from the previous frame are copied
1120 and skipped later so that a fast byte copy is possible */
1123 s->frame_offset = get_bits_count(gb) & 7;
1124 s->num_saved_bits = s->frame_offset;
1125 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1128 buflen = (s->num_saved_bits + len + 8) >> 3;
1130 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1131 avpriv_request_sample(s->avctx, "Too small input buffer");
1136 s->num_saved_bits += len;
1138 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1141 int align = 8 - (get_bits_count(gb) & 7);
1142 align = FFMIN(align, len);
1143 put_bits(&s->pb, align, get_bits(gb, align));
1145 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1147 skip_bits_long(gb, len);
1150 flush_put_bits(&tmp);
1152 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1153 skip_bits(&s->gb, s->frame_offset);
1156 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1159 WmallDecodeCtx *s = avctx->priv_data;
1160 GetBitContext* gb = &s->pgb;
1161 const uint8_t* buf = avpkt->data;
1162 int buf_size = avpkt->size;
1163 int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1165 s->frame->nb_samples = 0;
1167 if (s->packet_done || s->packet_loss) {
1172 /* sanity check for the buffer length */
1173 if (buf_size < avctx->block_align) {
1174 av_log(avctx, AV_LOG_ERROR, "buf size %d invalid\n", buf_size);
1175 return AVERROR_INVALIDDATA;
1178 s->next_packet_start = buf_size - avctx->block_align;
1179 buf_size = avctx->block_align;
1180 s->buf_bit_size = buf_size << 3;
1182 /* parse packet header */
1183 init_get_bits(gb, buf, s->buf_bit_size);
1184 packet_sequence_number = get_bits(gb, 4);
1185 skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently ununused
1186 spliced_packet = get_bits1(gb);
1188 avpriv_request_sample(avctx, "Bitstream splicing");
1190 /* get number of bits that need to be added to the previous frame */
1191 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1193 /* check for packet loss */
1194 if (!s->packet_loss &&
1195 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1197 av_log(avctx, AV_LOG_ERROR,
1198 "Packet loss detected! seq %"PRIx8" vs %x\n",
1199 s->packet_sequence_number, packet_sequence_number);
1201 s->packet_sequence_number = packet_sequence_number;
1203 if (num_bits_prev_frame > 0) {
1204 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1205 if (num_bits_prev_frame >= remaining_packet_bits) {
1206 num_bits_prev_frame = remaining_packet_bits;
1210 /* Append the previous frame data to the remaining data from the
1211 * previous packet to create a full frame. */
1212 save_bits(s, gb, num_bits_prev_frame, 1);
1214 /* decode the cross packet frame if it is valid */
1215 if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1217 } else if (s->num_saved_bits - s->frame_offset) {
1218 ff_dlog(avctx, "ignoring %x previously saved bits\n",
1219 s->num_saved_bits - s->frame_offset);
1222 if (s->packet_loss) {
1223 /* Reset number of saved bits so that the decoder does not start
1224 * to decode incomplete frames in the s->len_prefix == 0 case. */
1225 s->num_saved_bits = 0;
1227 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1233 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1234 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1235 skip_bits(gb, s->packet_offset);
1237 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1238 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1239 frame_size <= remaining_bits(s, gb)) {
1240 save_bits(s, gb, frame_size, 0);
1241 s->packet_done = !decode_frame(s);
1242 } else if (!s->len_prefix
1243 && s->num_saved_bits > get_bits_count(&s->gb)) {
1244 /* when the frames do not have a length prefix, we don't know the
1245 * compressed length of the individual frames however, we know what
1246 * part of a new packet belongs to the previous frame therefore we
1247 * save the incoming packet first, then we append the "previous
1248 * frame" data from the next packet so that we get a buffer that
1249 * only contains full frames */
1250 s->packet_done = !decode_frame(s);
1256 if (s->packet_done && !s->packet_loss &&
1257 remaining_bits(s, gb) > 0) {
1258 /* save the rest of the data so that it can be decoded
1259 * with the next packet */
1260 save_bits(s, gb, remaining_bits(s, gb), 0);
1263 *got_frame_ptr = s->frame->nb_samples > 0;
1264 av_frame_move_ref(data, s->frame);
1266 s->packet_offset = get_bits_count(gb) & 7;
1268 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1271 static void flush(AVCodecContext *avctx)
1273 WmallDecodeCtx *s = avctx->priv_data;
1276 s->num_saved_bits = 0;
1277 s->frame_offset = 0;
1278 s->next_packet_start = 0;
1279 s->cdlms[0][0].order = 0;
1280 s->frame->nb_samples = 0;
1281 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1284 static av_cold int decode_close(AVCodecContext *avctx)
1286 WmallDecodeCtx *s = avctx->priv_data;
1288 av_frame_free(&s->frame);
1293 AVCodec ff_wmalossless_decoder = {
1294 .name = "wmalossless",
1295 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1296 .type = AVMEDIA_TYPE_AUDIO,
1297 .id = AV_CODEC_ID_WMALOSSLESS,
1298 .priv_data_size = sizeof(WmallDecodeCtx),
1299 .init = decode_init,
1300 .close = decode_close,
1301 .decode = decode_packet,
1303 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1304 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1306 AV_SAMPLE_FMT_NONE },