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 + FF_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 av_dlog(avctx, "[%x] ", avctx->extradata[i]);
214 av_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 = get_bits(&s->gb, cbits) + 2;
492 shift_l = 32 - s->cdlms[c][i].bitsend;
493 shift_r = 32 - s->cdlms[c][i].scaling - 2;
494 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
495 s->cdlms[c][i].coefs[j] =
496 (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
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 av_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 */
1010 for (i = 0; i < s->num_channels; i++) {
1011 s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1012 s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1015 /* get frame length */
1017 len = get_bits(gb, s->log2_frame_size);
1019 /* decode tile information */
1020 if ((ret = decode_tilehdr(s))) {
1022 av_frame_unref(s->frame);
1027 if (s->dynamic_range_compression)
1028 s->drc_gain = get_bits(gb, 8);
1030 /* no idea what these are for, might be the number of samples
1031 that need to be skipped at the beginning or end of a stream */
1032 if (get_bits1(gb)) {
1035 /* usually true for the first frame */
1036 if (get_bits1(gb)) {
1037 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1038 av_dlog(s->avctx, "start skip: %i\n", skip);
1041 /* sometimes true for the last frame */
1042 if (get_bits1(gb)) {
1043 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1044 av_dlog(s->avctx, "end skip: %i\n", skip);
1049 /* reset subframe states */
1050 s->parsed_all_subframes = 0;
1051 for (i = 0; i < s->num_channels; i++) {
1052 s->channel[i].decoded_samples = 0;
1053 s->channel[i].cur_subframe = 0;
1056 /* decode all subframes */
1057 while (!s->parsed_all_subframes) {
1058 int decoded_samples = s->channel[0].decoded_samples;
1059 if (decode_subframe(s) < 0) {
1061 if (s->frame->nb_samples)
1062 s->frame->nb_samples = decoded_samples;
1067 av_dlog(s->avctx, "Frame done\n");
1071 if (s->len_prefix) {
1072 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1073 /* FIXME: not sure if this is always an error */
1074 av_log(s->avctx, AV_LOG_ERROR,
1075 "frame[%"PRIu32"] would have to skip %i bits\n",
1077 len - (get_bits_count(gb) - s->frame_offset) - 1);
1082 /* skip the rest of the frame data */
1083 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1086 /* decode trailer bit */
1087 more_frames = get_bits1(gb);
1093 * @brief Calculate remaining input buffer length.
1094 * @param s codec context
1095 * @param gb bitstream reader context
1096 * @return remaining size in bits
1098 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1100 return s->buf_bit_size - get_bits_count(gb);
1104 * @brief Fill the bit reservoir with a (partial) frame.
1105 * @param s codec context
1106 * @param gb bitstream reader context
1107 * @param len length of the partial frame
1108 * @param append decides whether to reset the buffer or not
1110 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1116 /* when the frame data does not need to be concatenated, the input buffer
1117 is reset and additional bits from the previous frame are copied
1118 and skipped later so that a fast byte copy is possible */
1121 s->frame_offset = get_bits_count(gb) & 7;
1122 s->num_saved_bits = s->frame_offset;
1123 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1126 buflen = (s->num_saved_bits + len + 8) >> 3;
1128 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1129 avpriv_request_sample(s->avctx, "Too small input buffer");
1134 s->num_saved_bits += len;
1136 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1139 int align = 8 - (get_bits_count(gb) & 7);
1140 align = FFMIN(align, len);
1141 put_bits(&s->pb, align, get_bits(gb, align));
1143 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1145 skip_bits_long(gb, len);
1148 flush_put_bits(&tmp);
1150 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1151 skip_bits(&s->gb, s->frame_offset);
1154 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1157 WmallDecodeCtx *s = avctx->priv_data;
1158 GetBitContext* gb = &s->pgb;
1159 const uint8_t* buf = avpkt->data;
1160 int buf_size = avpkt->size;
1161 int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1163 s->frame->nb_samples = 0;
1165 if (s->packet_done || s->packet_loss) {
1170 /* sanity check for the buffer length */
1171 if (buf_size < avctx->block_align) {
1172 av_log(avctx, AV_LOG_ERROR, "buf size %d invalid\n", buf_size);
1173 return AVERROR_INVALIDDATA;
1176 s->next_packet_start = buf_size - avctx->block_align;
1177 buf_size = avctx->block_align;
1178 s->buf_bit_size = buf_size << 3;
1180 /* parse packet header */
1181 init_get_bits(gb, buf, s->buf_bit_size);
1182 packet_sequence_number = get_bits(gb, 4);
1183 skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently ununused
1184 spliced_packet = get_bits1(gb);
1186 avpriv_request_sample(avctx, "Bitstream splicing");
1188 /* get number of bits that need to be added to the previous frame */
1189 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1191 /* check for packet loss */
1192 if (!s->packet_loss &&
1193 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1195 av_log(avctx, AV_LOG_ERROR,
1196 "Packet loss detected! seq %"PRIx8" vs %x\n",
1197 s->packet_sequence_number, packet_sequence_number);
1199 s->packet_sequence_number = packet_sequence_number;
1201 if (num_bits_prev_frame > 0) {
1202 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1203 if (num_bits_prev_frame >= remaining_packet_bits) {
1204 num_bits_prev_frame = remaining_packet_bits;
1208 /* Append the previous frame data to the remaining data from the
1209 * previous packet to create a full frame. */
1210 save_bits(s, gb, num_bits_prev_frame, 1);
1212 /* decode the cross packet frame if it is valid */
1213 if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1215 } else if (s->num_saved_bits - s->frame_offset) {
1216 av_dlog(avctx, "ignoring %x previously saved bits\n",
1217 s->num_saved_bits - s->frame_offset);
1220 if (s->packet_loss) {
1221 /* Reset number of saved bits so that the decoder does not start
1222 * to decode incomplete frames in the s->len_prefix == 0 case. */
1223 s->num_saved_bits = 0;
1225 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1231 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1232 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1233 skip_bits(gb, s->packet_offset);
1235 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1236 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1237 frame_size <= remaining_bits(s, gb)) {
1238 save_bits(s, gb, frame_size, 0);
1239 s->packet_done = !decode_frame(s);
1240 } else if (!s->len_prefix
1241 && s->num_saved_bits > get_bits_count(&s->gb)) {
1242 /* when the frames do not have a length prefix, we don't know the
1243 * compressed length of the individual frames however, we know what
1244 * part of a new packet belongs to the previous frame therefore we
1245 * save the incoming packet first, then we append the "previous
1246 * frame" data from the next packet so that we get a buffer that
1247 * only contains full frames */
1248 s->packet_done = !decode_frame(s);
1254 if (s->packet_done && !s->packet_loss &&
1255 remaining_bits(s, gb) > 0) {
1256 /* save the rest of the data so that it can be decoded
1257 * with the next packet */
1258 save_bits(s, gb, remaining_bits(s, gb), 0);
1261 *got_frame_ptr = s->frame->nb_samples > 0;
1262 av_frame_move_ref(data, s->frame);
1264 s->packet_offset = get_bits_count(gb) & 7;
1266 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1269 static void flush(AVCodecContext *avctx)
1271 WmallDecodeCtx *s = avctx->priv_data;
1274 s->num_saved_bits = 0;
1275 s->frame_offset = 0;
1276 s->next_packet_start = 0;
1277 s->cdlms[0][0].order = 0;
1278 s->frame->nb_samples = 0;
1279 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1282 static av_cold int decode_close(AVCodecContext *avctx)
1284 WmallDecodeCtx *s = avctx->priv_data;
1286 av_frame_free(&s->frame);
1291 AVCodec ff_wmalossless_decoder = {
1292 .name = "wmalossless",
1293 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1294 .type = AVMEDIA_TYPE_AUDIO,
1295 .id = AV_CODEC_ID_WMALOSSLESS,
1296 .priv_data_size = sizeof(WmallDecodeCtx),
1297 .init = decode_init,
1298 .close = decode_close,
1299 .decode = decode_packet,
1301 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1302 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1304 AV_SAMPLE_FMT_NONE },