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
30 #include "wma_common.h"
32 /** current decoder limitations */
33 #define WMALL_MAX_CHANNELS 8 ///< max number of handled channels
34 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
35 #define MAX_BANDS 29 ///< max number of scale factor bands
36 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
39 #define WMALL_BLOCK_MIN_BITS 6 ///< log2 of min block size
40 #define WMALL_BLOCK_MAX_BITS 12 ///< log2 of max block size
41 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS) ///< maximum block size
42 #define WMALL_BLOCK_SIZES (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
46 * @brief frame-specific decoder context for a single channel
49 int16_t prev_block_len; ///< length of the previous block
50 uint8_t transmit_coefs;
51 uint8_t num_subframes;
52 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
53 uint16_t subframe_offsets[MAX_SUBFRAMES]; ///< subframe positions in the current frame
54 uint8_t cur_subframe; ///< current subframe number
55 uint16_t decoded_samples; ///< number of already processed samples
56 int quant_step; ///< quantization step for the current subframe
57 int transient_counter; ///< number of transient samples from the beginning of the transient zone
61 * @brief main decoder context
63 typedef struct WmallDecodeCtx {
64 /* generic decoder variables */
65 AVCodecContext *avctx;
67 uint8_t frame_data[MAX_FRAMESIZE + FF_INPUT_BUFFER_PADDING_SIZE]; ///< compressed frame data
68 PutBitContext pb; ///< context for filling the frame_data buffer
70 /* frame size dependent frame information (set during initialization) */
71 uint32_t decode_flags; ///< used compression features
72 int len_prefix; ///< frame is prefixed with its length
73 int dynamic_range_compression; ///< frame contains DRC data
74 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
75 uint16_t samples_per_frame; ///< number of samples to output
76 uint16_t log2_frame_size;
77 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
78 int8_t lfe_channel; ///< lfe channel index
79 uint8_t max_num_subframes;
80 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
81 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
82 uint16_t min_samples_per_subframe;
84 /* packet decode state */
85 GetBitContext pgb; ///< bitstream reader context for the packet
86 int next_packet_start; ///< start offset of the next WMA packet in the demuxer packet
87 uint8_t packet_offset; ///< offset to the frame in the packet
88 uint8_t packet_sequence_number; ///< current packet number
89 int num_saved_bits; ///< saved number of bits
90 int frame_offset; ///< frame offset in the bit reservoir
91 int subframe_offset; ///< subframe offset in the bit reservoir
92 uint8_t packet_loss; ///< set in case of bitstream error
93 uint8_t packet_done; ///< set when a packet is fully decoded
95 /* frame decode state */
96 uint32_t frame_num; ///< current frame number (not used for decoding)
97 GetBitContext gb; ///< bitstream reader context
98 int buf_bit_size; ///< buffer size in bits
99 int16_t *samples_16[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (16-bit)
100 int32_t *samples_32[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (24-bit)
101 uint8_t drc_gain; ///< gain for the DRC tool
102 int8_t skip_frame; ///< skip output step
103 int8_t parsed_all_subframes; ///< all subframes decoded?
105 /* subframe/block decode state */
106 int16_t subframe_len; ///< current subframe length
107 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
108 int8_t channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
110 WmallChannelCtx channel[WMALL_MAX_CHANNELS]; ///< per channel data
112 // WMA Lossless-specific
114 uint8_t do_arith_coding;
115 uint8_t do_ac_filter;
116 uint8_t do_inter_ch_decorr;
120 int8_t acfilter_order;
121 int8_t acfilter_scaling;
122 int64_t acfilter_coeffs[16];
123 int acfilter_prevvalues[2][16];
126 int8_t mclms_scaling;
127 int16_t mclms_coeffs[128];
128 int16_t mclms_coeffs_cur[4];
129 int16_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
130 int16_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
141 int16_t coefs[MAX_ORDER];
142 int16_t lms_prevvalues[MAX_ORDER * 2];
143 int16_t lms_updates[MAX_ORDER * 2];
151 int is_channel_coded[2];
155 int transient_pos[2];
160 int channel_residues[2][WMALL_BLOCK_MAX_SIZE];
162 int lpc_coefs[2][40];
167 int channel_coeffs[2][WMALL_BLOCK_MAX_SIZE];
171 static av_cold int decode_init(AVCodecContext *avctx)
173 WmallDecodeCtx *s = avctx->priv_data;
174 uint8_t *edata_ptr = avctx->extradata;
175 unsigned int channel_mask;
176 int i, bits, log2_max_num_subframes, num_possible_block_sizes;
179 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
181 if (avctx->extradata_size >= 18) {
182 s->decode_flags = AV_RL16(edata_ptr + 14);
183 channel_mask = AV_RL32(edata_ptr + 2);
184 s->bits_per_sample = AV_RL16(edata_ptr);
185 if (s->bits_per_sample == 16)
186 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
187 else if (s->bits_per_sample == 24) {
188 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
189 av_log_missing_feature(avctx, "bit-depth higher than 16", 0);
190 return AVERROR_PATCHWELCOME;
192 av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %d\n",
194 return AVERROR_INVALIDDATA;
196 /* dump the extradata */
197 for (i = 0; i < avctx->extradata_size; i++)
198 av_dlog(avctx, "[%x] ", avctx->extradata[i]);
199 av_dlog(avctx, "\n");
202 av_log_ask_for_sample(avctx, "Unsupported extradata size\n");
203 return AVERROR_INVALIDDATA;
207 s->log2_frame_size = av_log2(avctx->block_align) + 4;
210 s->skip_frame = 1; /* skip first frame */
212 s->len_prefix = s->decode_flags & 0x40;
215 bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags);
216 if (bits > WMALL_BLOCK_MAX_BITS) {
217 av_log_missing_feature(avctx, "big-bits block sizes", 1);
218 return AVERROR_INVALIDDATA;
220 s->samples_per_frame = 1 << bits;
222 /* init previous block len */
223 for (i = 0; i < avctx->channels; i++)
224 s->channel[i].prev_block_len = s->samples_per_frame;
227 log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
228 s->max_num_subframes = 1 << log2_max_num_subframes;
229 s->max_subframe_len_bit = 0;
230 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
232 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
233 s->dynamic_range_compression = s->decode_flags & 0x80;
234 s->bV3RTM = s->decode_flags & 0x100;
236 if (s->max_num_subframes > MAX_SUBFRAMES) {
237 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
238 s->max_num_subframes);
239 return AVERROR_INVALIDDATA;
242 s->num_channels = avctx->channels;
244 /* extract lfe channel position */
247 if (channel_mask & 8) {
249 for (mask = 1; mask < 16; mask <<= 1)
250 if (channel_mask & mask)
254 if (s->num_channels < 0) {
255 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
257 return AVERROR_INVALIDDATA;
258 } else if (s->num_channels > WMALL_MAX_CHANNELS) {
259 av_log_ask_for_sample(avctx, "unsupported number of channels\n");
260 return AVERROR_PATCHWELCOME;
263 avcodec_get_frame_defaults(&s->frame);
264 avctx->coded_frame = &s->frame;
265 avctx->channel_layout = channel_mask;
270 * @brief Decode the subframe length.
272 * @param offset sample offset in the frame
273 * @return decoded subframe length on success, < 0 in case of an error
275 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
277 int frame_len_ratio, subframe_len, len;
279 /* no need to read from the bitstream when only one length is possible */
280 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
281 return s->min_samples_per_subframe;
283 len = av_log2(s->max_num_subframes - 1) + 1;
284 frame_len_ratio = get_bits(&s->gb, len);
285 subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
287 /* sanity check the length */
288 if (subframe_len < s->min_samples_per_subframe ||
289 subframe_len > s->samples_per_frame) {
290 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
292 return AVERROR_INVALIDDATA;
298 * @brief Decode how the data in the frame is split into subframes.
299 * Every WMA frame contains the encoded data for a fixed number of
300 * samples per channel. The data for every channel might be split
301 * into several subframes. This function will reconstruct the list of
302 * subframes for every channel.
304 * If the subframes are not evenly split, the algorithm estimates the
305 * channels with the lowest number of total samples.
306 * Afterwards, for each of these channels a bit is read from the
307 * bitstream that indicates if the channel contains a subframe with the
308 * next subframe size that is going to be read from the bitstream or not.
309 * If a channel contains such a subframe, the subframe size gets added to
310 * the channel's subframe list.
311 * The algorithm repeats these steps until the frame is properly divided
312 * between the individual channels.
315 * @return 0 on success, < 0 in case of an error
317 static int decode_tilehdr(WmallDecodeCtx *s)
319 uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
320 uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
321 int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
322 int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
323 int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
326 /* reset tiling information */
327 for (c = 0; c < s->num_channels; c++)
328 s->channel[c].num_subframes = 0;
330 tile_aligned = get_bits1(&s->gb);
331 if (s->max_num_subframes == 1 || tile_aligned)
332 fixed_channel_layout = 1;
334 /* loop until the frame data is split between the subframes */
336 int subframe_len, in_use = 0;
338 /* check which channels contain the subframe */
339 for (c = 0; c < s->num_channels; c++) {
340 if (num_samples[c] == min_channel_len) {
341 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
342 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
343 contains_subframe[c] = in_use = 1;
345 if (get_bits1(&s->gb))
346 contains_subframe[c] = in_use = 1;
349 contains_subframe[c] = 0;
353 av_log(s->avctx, AV_LOG_ERROR,
354 "Found empty subframe\n");
355 return AVERROR_INVALIDDATA;
358 /* get subframe length, subframe_len == 0 is not allowed */
359 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
360 return AVERROR_INVALIDDATA;
361 /* add subframes to the individual channels and find new min_channel_len */
362 min_channel_len += subframe_len;
363 for (c = 0; c < s->num_channels; c++) {
364 WmallChannelCtx *chan = &s->channel[c];
366 if (contains_subframe[c]) {
367 if (chan->num_subframes >= MAX_SUBFRAMES) {
368 av_log(s->avctx, AV_LOG_ERROR,
369 "broken frame: num subframes > 31\n");
370 return AVERROR_INVALIDDATA;
372 chan->subframe_len[chan->num_subframes] = subframe_len;
373 num_samples[c] += subframe_len;
374 ++chan->num_subframes;
375 if (num_samples[c] > s->samples_per_frame) {
376 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
377 "channel len(%d) > samples_per_frame(%d)\n",
378 num_samples[c], s->samples_per_frame);
379 return AVERROR_INVALIDDATA;
381 } else if (num_samples[c] <= min_channel_len) {
382 if (num_samples[c] < min_channel_len) {
383 channels_for_cur_subframe = 0;
384 min_channel_len = num_samples[c];
386 ++channels_for_cur_subframe;
389 } while (min_channel_len < s->samples_per_frame);
391 for (c = 0; c < s->num_channels; c++) {
393 for (i = 0; i < s->channel[c].num_subframes; i++) {
394 s->channel[c].subframe_offsets[i] = offset;
395 offset += s->channel[c].subframe_len[i];
402 static void decode_ac_filter(WmallDecodeCtx *s)
405 s->acfilter_order = get_bits(&s->gb, 4) + 1;
406 s->acfilter_scaling = get_bits(&s->gb, 4);
408 for (i = 0; i < s->acfilter_order; i++)
409 s->acfilter_coeffs[i] = (s->acfilter_scaling ? get_bits(&s->gb, s->acfilter_scaling) : 0) + 1;
412 static void decode_mclms(WmallDecodeCtx *s)
414 s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
415 s->mclms_scaling = get_bits(&s->gb, 4);
416 if (get_bits1(&s->gb)) {
417 int i, send_coef_bits;
418 int cbits = av_log2(s->mclms_scaling + 1);
419 if (1 << cbits < s->mclms_scaling + 1)
422 send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
424 for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
425 s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
427 for (i = 0; i < s->num_channels; i++) {
429 for (c = 0; c < i; c++)
430 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
435 static int decode_cdlms(WmallDecodeCtx *s)
438 int cdlms_send_coef = get_bits1(&s->gb);
440 for (c = 0; c < s->num_channels; c++) {
441 s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
442 for (i = 0; i < s->cdlms_ttl[c]; i++) {
443 s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
444 if (s->cdlms[c][i].order > MAX_ORDER) {
445 av_log(s->avctx, AV_LOG_ERROR,
446 "Order[%d][%d] %d > max (%d), not supported\n",
447 c, i, s->cdlms[c][i].order, MAX_ORDER);
448 s->cdlms[0][0].order = 0;
449 return AVERROR_INVALIDDATA;
453 for (i = 0; i < s->cdlms_ttl[c]; i++)
454 s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
456 if (cdlms_send_coef) {
457 for (i = 0; i < s->cdlms_ttl[c]; i++) {
458 int cbits, shift_l, shift_r, j;
459 cbits = av_log2(s->cdlms[c][i].order);
460 if ((1 << cbits) < s->cdlms[c][i].order)
462 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
464 cbits = av_log2(s->cdlms[c][i].scaling + 1);
465 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
468 s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
469 shift_l = 32 - s->cdlms[c][i].bitsend;
470 shift_r = 32 - s->cdlms[c][i].scaling - 2;
471 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
472 s->cdlms[c][i].coefs[j] =
473 (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
481 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
484 unsigned int ave_mean;
485 s->transient[ch] = get_bits1(&s->gb);
486 if (s->transient[ch]) {
487 s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
488 if (s->transient_pos[ch])
489 s->transient[ch] = 0;
490 s->channel[ch].transient_counter =
491 FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
492 } else if (s->channel[ch].transient_counter)
493 s->transient[ch] = 1;
495 if (s->seekable_tile) {
496 ave_mean = get_bits(&s->gb, s->bits_per_sample);
497 s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
500 if (s->seekable_tile) {
501 if (s->do_inter_ch_decorr)
502 s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample + 1);
504 s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample);
507 for (; i < tile_size; i++) {
508 int quo = 0, rem, rem_bits, residue;
509 while(get_bits1(&s->gb)) {
511 if (get_bits_left(&s->gb) <= 0)
515 quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
517 ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
521 rem_bits = av_ceil_log2(ave_mean);
522 rem = get_bits_long(&s->gb, rem_bits);
523 residue = (quo << rem_bits) + rem;
526 s->ave_sum[ch] = residue + s->ave_sum[ch] -
527 (s->ave_sum[ch] >> s->movave_scaling);
530 residue = -(residue >> 1) - 1;
532 residue = residue >> 1;
533 s->channel_residues[ch][i] = residue;
540 static void decode_lpc(WmallDecodeCtx *s)
543 s->lpc_order = get_bits(&s->gb, 5) + 1;
544 s->lpc_scaling = get_bits(&s->gb, 4);
545 s->lpc_intbits = get_bits(&s->gb, 3) + 1;
546 cbits = s->lpc_scaling + s->lpc_intbits;
547 for (ch = 0; ch < s->num_channels; ch++)
548 for (i = 0; i < s->lpc_order; i++)
549 s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
552 static void clear_codec_buffers(WmallDecodeCtx *s)
556 memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
557 memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
558 memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
560 memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
561 memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
562 memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
563 memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
565 for (ich = 0; ich < s->num_channels; ich++) {
566 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
567 memset(s->cdlms[ich][ilms].coefs, 0,
568 sizeof(s->cdlms[ich][ilms].coefs));
569 memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
570 sizeof(s->cdlms[ich][ilms].lms_prevvalues));
571 memset(s->cdlms[ich][ilms].lms_updates, 0,
572 sizeof(s->cdlms[ich][ilms].lms_updates));
579 * @brief Reset filter parameters and transient area at new seekable tile.
581 static void reset_codec(WmallDecodeCtx *s)
584 s->mclms_recent = s->mclms_order * s->num_channels;
585 for (ich = 0; ich < s->num_channels; ich++) {
586 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
587 s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
588 /* first sample of a seekable subframe is considered as the starting of
589 a transient area which is samples_per_frame samples long */
590 s->channel[ich].transient_counter = s->samples_per_frame;
591 s->transient[ich] = 1;
592 s->transient_pos[ich] = 0;
596 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
598 int i, j, ich, pred_error;
599 int order = s->mclms_order;
600 int num_channels = s->num_channels;
601 int range = 1 << (s->bits_per_sample - 1);
603 for (ich = 0; ich < num_channels; ich++) {
604 pred_error = s->channel_residues[ich][icoef] - pred[ich];
605 if (pred_error > 0) {
606 for (i = 0; i < order * num_channels; i++)
607 s->mclms_coeffs[i + ich * order * num_channels] +=
608 s->mclms_updates[s->mclms_recent + i];
609 for (j = 0; j < ich; j++) {
610 if (s->channel_residues[j][icoef] > 0)
611 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
612 else if (s->channel_residues[j][icoef] < 0)
613 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
615 } else if (pred_error < 0) {
616 for (i = 0; i < order * num_channels; i++)
617 s->mclms_coeffs[i + ich * order * num_channels] -=
618 s->mclms_updates[s->mclms_recent + i];
619 for (j = 0; j < ich; j++) {
620 if (s->channel_residues[j][icoef] > 0)
621 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
622 else if (s->channel_residues[j][icoef] < 0)
623 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
628 for (ich = num_channels - 1; ich >= 0; ich--) {
630 s->mclms_prevvalues[s->mclms_recent] = s->channel_residues[ich][icoef];
631 if (s->channel_residues[ich][icoef] > range - 1)
632 s->mclms_prevvalues[s->mclms_recent] = range - 1;
633 else if (s->channel_residues[ich][icoef] < -range)
634 s->mclms_prevvalues[s->mclms_recent] = -range;
636 s->mclms_updates[s->mclms_recent] = 0;
637 if (s->channel_residues[ich][icoef] > 0)
638 s->mclms_updates[s->mclms_recent] = 1;
639 else if (s->channel_residues[ich][icoef] < 0)
640 s->mclms_updates[s->mclms_recent] = -1;
643 if (s->mclms_recent == 0) {
644 memcpy(&s->mclms_prevvalues[order * num_channels],
646 2 * order * num_channels);
647 memcpy(&s->mclms_updates[order * num_channels],
649 2 * order * num_channels);
650 s->mclms_recent = num_channels * order;
654 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
657 int order = s->mclms_order;
658 int num_channels = s->num_channels;
660 for (ich = 0; ich < num_channels; ich++) {
661 if (!s->is_channel_coded[ich])
664 for (i = 0; i < order * num_channels; i++)
665 pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
666 s->mclms_coeffs[i + order * num_channels * ich];
667 for (i = 0; i < ich; i++)
668 pred[ich] += s->channel_residues[i][icoef] *
669 s->mclms_coeffs_cur[i + num_channels * ich];
670 pred[ich] += 1 << s->mclms_scaling - 1;
671 pred[ich] >>= s->mclms_scaling;
672 s->channel_residues[ich][icoef] += pred[ich];
676 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
678 int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
679 for (icoef = 0; icoef < tile_size; icoef++) {
680 mclms_predict(s, icoef, pred);
681 mclms_update(s, icoef, pred);
685 static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
688 int recent = s->cdlms[ich][ilms].recent;
690 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
691 pred += s->cdlms[ich][ilms].coefs[icoef] *
692 s->cdlms[ich][ilms].lms_prevvalues[icoef + recent];
697 static void lms_update(WmallDecodeCtx *s, int ich, int ilms,
698 int input, int residue)
701 int recent = s->cdlms[ich][ilms].recent;
702 int range = 1 << s->bits_per_sample - 1;
705 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
706 s->cdlms[ich][ilms].coefs[icoef] -=
707 s->cdlms[ich][ilms].lms_updates[icoef + recent];
708 } else if (residue > 0) {
709 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
710 s->cdlms[ich][ilms].coefs[icoef] +=
711 s->cdlms[ich][ilms].lms_updates[icoef + recent];
717 memcpy(&s->cdlms[ich][ilms].lms_prevvalues[s->cdlms[ich][ilms].order],
718 s->cdlms[ich][ilms].lms_prevvalues,
719 2 * s->cdlms[ich][ilms].order);
720 memcpy(&s->cdlms[ich][ilms].lms_updates[s->cdlms[ich][ilms].order],
721 s->cdlms[ich][ilms].lms_updates,
722 2 * s->cdlms[ich][ilms].order);
723 recent = s->cdlms[ich][ilms].order - 1;
726 s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
728 s->cdlms[ich][ilms].lms_updates[recent] = 0;
730 s->cdlms[ich][ilms].lms_updates[recent] = -s->update_speed[ich];
732 s->cdlms[ich][ilms].lms_updates[recent] = s->update_speed[ich];
734 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 4)] >>= 2;
735 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 3)] >>= 1;
736 s->cdlms[ich][ilms].recent = recent;
739 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
741 int ilms, recent, icoef;
742 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
743 recent = s->cdlms[ich][ilms].recent;
744 if (s->update_speed[ich] == 16)
747 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
748 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
750 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
751 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
754 s->update_speed[ich] = 16;
757 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
759 int ilms, recent, icoef;
760 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
761 recent = s->cdlms[ich][ilms].recent;
762 if (s->update_speed[ich] == 8)
765 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
766 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
768 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
769 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
771 s->update_speed[ich] = 8;
774 static void revert_cdlms(WmallDecodeCtx *s, int ch,
775 int coef_begin, int coef_end)
777 int icoef, pred, ilms, num_lms, residue, input;
779 num_lms = s->cdlms_ttl[ch];
780 for (ilms = num_lms - 1; ilms >= 0; ilms--) {
781 for (icoef = coef_begin; icoef < coef_end; icoef++) {
782 pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
783 residue = s->channel_residues[ch][icoef];
784 pred += lms_predict(s, ch, ilms);
785 input = residue + (pred >> s->cdlms[ch][ilms].scaling);
786 lms_update(s, ch, ilms, input, residue);
787 s->channel_residues[ch][icoef] = input;
792 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
794 if (s->num_channels != 2)
796 else if (s->is_channel_coded[0] && s->is_channel_coded[1]) {
798 for (icoef = 0; icoef < tile_size; icoef++) {
799 s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
800 s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
805 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
808 int64_t *filter_coeffs = s->acfilter_coeffs;
809 int scaling = s->acfilter_scaling;
810 int order = s->acfilter_order;
812 for (ich = 0; ich < s->num_channels; ich++) {
813 int *prevvalues = s->acfilter_prevvalues[ich];
814 for (i = 0; i < order; i++) {
816 for (j = 0; j < order; j++) {
818 pred += filter_coeffs[j] * prevvalues[j - i];
820 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
823 s->channel_residues[ich][i] += pred;
825 for (i = order; i < tile_size; i++) {
827 for (j = 0; j < order; j++)
828 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
830 s->channel_residues[ich][i] += pred;
832 for (j = 0; j < order; j++)
833 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
837 static int decode_subframe(WmallDecodeCtx *s)
839 int offset = s->samples_per_frame;
840 int subframe_len = s->samples_per_frame;
841 int total_samples = s->samples_per_frame * s->num_channels;
842 int i, j, rawpcm_tile, padding_zeroes, res;
844 s->subframe_offset = get_bits_count(&s->gb);
846 /* reset channel context and find the next block offset and size
847 == the next block of the channel with the smallest number of
849 for (i = 0; i < s->num_channels; i++) {
850 if (offset > s->channel[i].decoded_samples) {
851 offset = s->channel[i].decoded_samples;
853 s->channel[i].subframe_len[s->channel[i].cur_subframe];
857 /* get a list of all channels that contain the estimated block */
858 s->channels_for_cur_subframe = 0;
859 for (i = 0; i < s->num_channels; i++) {
860 const int cur_subframe = s->channel[i].cur_subframe;
861 /* subtract already processed samples */
862 total_samples -= s->channel[i].decoded_samples;
864 /* and count if there are multiple subframes that match our profile */
865 if (offset == s->channel[i].decoded_samples &&
866 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
867 total_samples -= s->channel[i].subframe_len[cur_subframe];
868 s->channel[i].decoded_samples +=
869 s->channel[i].subframe_len[cur_subframe];
870 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
871 ++s->channels_for_cur_subframe;
875 /* check if the frame will be complete after processing the
878 s->parsed_all_subframes = 1;
881 s->seekable_tile = get_bits1(&s->gb);
882 if (s->seekable_tile) {
883 clear_codec_buffers(s);
885 s->do_arith_coding = get_bits1(&s->gb);
886 if (s->do_arith_coding) {
887 av_log_missing_feature(s->avctx, "arithmetic coding", 1);
888 return AVERROR_PATCHWELCOME;
890 s->do_ac_filter = get_bits1(&s->gb);
891 s->do_inter_ch_decorr = get_bits1(&s->gb);
892 s->do_mclms = get_bits1(&s->gb);
900 if ((res = decode_cdlms(s)) < 0)
902 s->movave_scaling = get_bits(&s->gb, 3);
903 s->quant_stepsize = get_bits(&s->gb, 8) + 1;
906 } else if (!s->cdlms[0][0].order) {
907 av_log(s->avctx, AV_LOG_DEBUG,
908 "Waiting for seekable tile\n");
909 s->frame.nb_samples = 0;
913 rawpcm_tile = get_bits1(&s->gb);
915 for (i = 0; i < s->num_channels; i++)
916 s->is_channel_coded[i] = 1;
919 for (i = 0; i < s->num_channels; i++)
920 s->is_channel_coded[i] = get_bits1(&s->gb);
924 s->do_lpc = get_bits1(&s->gb);
927 av_log_ask_for_sample(s->avctx, "Inverse LPC filter not "
928 "implemented. Expect wrong output.\n");
935 if (get_bits1(&s->gb))
936 padding_zeroes = get_bits(&s->gb, 5);
941 int bits = s->bits_per_sample - padding_zeroes;
943 av_log(s->avctx, AV_LOG_ERROR,
944 "Invalid number of padding bits in raw PCM tile\n");
945 return AVERROR_INVALIDDATA;
947 av_dlog(s->avctx, "RAWPCM %d bits per sample. "
948 "total %d bits, remain=%d\n", bits,
949 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
950 for (i = 0; i < s->num_channels; i++)
951 for (j = 0; j < subframe_len; j++)
952 s->channel_coeffs[i][j] = get_sbits_long(&s->gb, bits);
954 for (i = 0; i < s->num_channels; i++)
955 if (s->is_channel_coded[i]) {
956 decode_channel_residues(s, i, subframe_len);
957 if (s->seekable_tile)
958 use_high_update_speed(s, i);
960 use_normal_update_speed(s, i);
961 revert_cdlms(s, i, 0, subframe_len);
963 memset(s->channel_residues[i], 0, sizeof(s->channel_residues[i]));
966 revert_mclms(s, subframe_len);
967 if (s->do_inter_ch_decorr)
968 revert_inter_ch_decorr(s, subframe_len);
970 revert_acfilter(s, subframe_len);
973 if (s->quant_stepsize != 1)
974 for (i = 0; i < s->num_channels; i++)
975 for (j = 0; j < subframe_len; j++)
976 s->channel_residues[i][j] *= s->quant_stepsize;
978 /* Write to proper output buffer depending on bit-depth */
979 for (i = 0; i < s->channels_for_cur_subframe; i++) {
980 int c = s->channel_indexes_for_cur_subframe[i];
981 int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
983 for (j = 0; j < subframe_len; j++) {
984 if (s->bits_per_sample == 16) {
985 *s->samples_16[c] = (int16_t) s->channel_residues[c][j];
986 s->samples_16[c] += s->num_channels;
988 *s->samples_32[c] = s->channel_residues[c][j];
989 s->samples_32[c] += s->num_channels;
994 /* handled one subframe */
995 for (i = 0; i < s->channels_for_cur_subframe; i++) {
996 int c = s->channel_indexes_for_cur_subframe[i];
997 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
998 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
999 return AVERROR_INVALIDDATA;
1001 ++s->channel[c].cur_subframe;
1007 * @brief Decode one WMA frame.
1008 * @param s codec context
1009 * @return 0 if the trailer bit indicates that this is the last frame,
1010 * 1 if there are additional frames
1012 static int decode_frame(WmallDecodeCtx *s)
1014 GetBitContext* gb = &s->gb;
1015 int more_frames = 0, len = 0, i, ret;
1017 s->frame.nb_samples = s->samples_per_frame;
1018 if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1019 /* return an error if no frame could be decoded at all */
1020 av_log(s->avctx, AV_LOG_ERROR,
1021 "not enough space for the output samples\n");
1025 for (i = 0; i < s->num_channels; i++) {
1026 s->samples_16[i] = (int16_t *)s->frame.data[0] + i;
1027 s->samples_32[i] = (int32_t *)s->frame.data[0] + i;
1030 /* get frame length */
1032 len = get_bits(gb, s->log2_frame_size);
1034 /* decode tile information */
1035 if (decode_tilehdr(s)) {
1041 if (s->dynamic_range_compression)
1042 s->drc_gain = get_bits(gb, 8);
1044 /* no idea what these are for, might be the number of samples
1045 that need to be skipped at the beginning or end of a stream */
1046 if (get_bits1(gb)) {
1049 /* usually true for the first frame */
1050 if (get_bits1(gb)) {
1051 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1052 av_dlog(s->avctx, "start skip: %i\n", skip);
1055 /* sometimes true for the last frame */
1056 if (get_bits1(gb)) {
1057 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1058 av_dlog(s->avctx, "end skip: %i\n", skip);
1063 /* reset subframe states */
1064 s->parsed_all_subframes = 0;
1065 for (i = 0; i < s->num_channels; i++) {
1066 s->channel[i].decoded_samples = 0;
1067 s->channel[i].cur_subframe = 0;
1070 /* decode all subframes */
1071 while (!s->parsed_all_subframes) {
1072 if (decode_subframe(s) < 0) {
1078 av_dlog(s->avctx, "Frame done\n");
1083 if (s->len_prefix) {
1084 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1085 /* FIXME: not sure if this is always an error */
1086 av_log(s->avctx, AV_LOG_ERROR,
1087 "frame[%i] would have to skip %i bits\n", s->frame_num,
1088 len - (get_bits_count(gb) - s->frame_offset) - 1);
1093 /* skip the rest of the frame data */
1094 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1097 /* decode trailer bit */
1098 more_frames = get_bits1(gb);
1104 * @brief Calculate remaining input buffer length.
1105 * @param s codec context
1106 * @param gb bitstream reader context
1107 * @return remaining size in bits
1109 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1111 return s->buf_bit_size - get_bits_count(gb);
1115 * @brief Fill the bit reservoir with a (partial) frame.
1116 * @param s codec context
1117 * @param gb bitstream reader context
1118 * @param len length of the partial frame
1119 * @param append decides whether to reset the buffer or not
1121 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1127 /* when the frame data does not need to be concatenated, the input buffer
1128 is reset and additional bits from the previous frame are copied
1129 and skipped later so that a fast byte copy is possible */
1132 s->frame_offset = get_bits_count(gb) & 7;
1133 s->num_saved_bits = s->frame_offset;
1134 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1137 buflen = (s->num_saved_bits + len + 8) >> 3;
1139 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1140 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1145 s->num_saved_bits += len;
1147 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1150 int align = 8 - (get_bits_count(gb) & 7);
1151 align = FFMIN(align, len);
1152 put_bits(&s->pb, align, get_bits(gb, align));
1154 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1156 skip_bits_long(gb, len);
1159 flush_put_bits(&tmp);
1161 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1162 skip_bits(&s->gb, s->frame_offset);
1165 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1168 WmallDecodeCtx *s = avctx->priv_data;
1169 GetBitContext* gb = &s->pgb;
1170 const uint8_t* buf = avpkt->data;
1171 int buf_size = avpkt->size;
1172 int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1174 s->frame.nb_samples = 0;
1176 if (s->packet_done || s->packet_loss) {
1179 /* sanity check for the buffer length */
1180 if (buf_size < avctx->block_align)
1183 s->next_packet_start = buf_size - avctx->block_align;
1184 buf_size = avctx->block_align;
1185 s->buf_bit_size = buf_size << 3;
1187 /* parse packet header */
1188 init_get_bits(gb, buf, s->buf_bit_size);
1189 packet_sequence_number = get_bits(gb, 4);
1190 skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently ununused
1191 spliced_packet = get_bits1(gb);
1193 av_log_missing_feature(avctx, "Bitstream splicing", 1);
1195 /* get number of bits that need to be added to the previous frame */
1196 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1198 /* check for packet loss */
1199 if (!s->packet_loss &&
1200 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1202 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1203 s->packet_sequence_number, packet_sequence_number);
1205 s->packet_sequence_number = packet_sequence_number;
1207 if (num_bits_prev_frame > 0) {
1208 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1209 if (num_bits_prev_frame >= remaining_packet_bits) {
1210 num_bits_prev_frame = remaining_packet_bits;
1214 /* Append the previous frame data to the remaining data from the
1215 * previous packet to create a full frame. */
1216 save_bits(s, gb, num_bits_prev_frame, 1);
1218 /* decode the cross packet frame if it is valid */
1219 if (!s->packet_loss)
1221 } else if (s->num_saved_bits - s->frame_offset) {
1222 av_dlog(avctx, "ignoring %x previously saved bits\n",
1223 s->num_saved_bits - s->frame_offset);
1226 if (s->packet_loss) {
1227 /* Reset number of saved bits so that the decoder does not start
1228 * to decode incomplete frames in the s->len_prefix == 0 case. */
1229 s->num_saved_bits = 0;
1230 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1237 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1238 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1239 skip_bits(gb, s->packet_offset);
1241 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1242 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1243 frame_size <= remaining_bits(s, gb)) {
1244 save_bits(s, gb, frame_size, 0);
1245 s->packet_done = !decode_frame(s);
1246 } else if (!s->len_prefix
1247 && s->num_saved_bits > get_bits_count(&s->gb)) {
1248 /* when the frames do not have a length prefix, we don't know the
1249 * compressed length of the individual frames however, we know what
1250 * part of a new packet belongs to the previous frame therefore we
1251 * save the incoming packet first, then we append the "previous
1252 * frame" data from the next packet so that we get a buffer that
1253 * only contains full frames */
1254 s->packet_done = !decode_frame(s);
1260 if (s->packet_done && !s->packet_loss &&
1261 remaining_bits(s, gb) > 0) {
1262 /* save the rest of the data so that it can be decoded
1263 * with the next packet */
1264 save_bits(s, gb, remaining_bits(s, gb), 0);
1267 *(AVFrame *)data = s->frame;
1268 *got_frame_ptr = s->frame.nb_samples > 0;
1269 s->packet_offset = get_bits_count(gb) & 7;
1271 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1274 static void flush(AVCodecContext *avctx)
1276 WmallDecodeCtx *s = avctx->priv_data;
1279 s->num_saved_bits = 0;
1280 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1281 s->frame_offset = 0;
1282 s->next_packet_start = 0;
1283 s->cdlms[0][0].order = 0;
1284 s->frame.nb_samples = 0;
1287 AVCodec ff_wmalossless_decoder = {
1288 .name = "wmalossless",
1289 .type = AVMEDIA_TYPE_AUDIO,
1290 .id = CODEC_ID_WMALOSSLESS,
1291 .priv_data_size = sizeof(WmallDecodeCtx),
1292 .init = decode_init,
1293 .decode = decode_packet,
1295 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1296 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),