2 * Windows Media Audio Lossless decoder
3 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4 * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
5 * Copyright (c) 2011 Andreas Ă–man
6 * Copyright (c) 2011 - 2012 Mashiat Sarker Shakkhar
8 * This file is part of Libav.
10 * Libav is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * Libav is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with Libav; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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[64];
130 int16_t mclms_updates[64];
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][2048];
162 int lpc_coefs[2][40];
167 int channel_coeffs[2][2048];
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, log2_max_num_subframes;
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 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
218 /* init previous block len */
219 for (i = 0; i < avctx->channels; i++)
220 s->channel[i].prev_block_len = s->samples_per_frame;
223 log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
224 s->max_num_subframes = 1 << log2_max_num_subframes;
225 s->max_subframe_len_bit = 0;
226 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
228 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
229 s->dynamic_range_compression = s->decode_flags & 0x80;
230 s->bV3RTM = s->decode_flags & 0x100;
232 if (s->max_num_subframes > MAX_SUBFRAMES) {
233 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
234 s->max_num_subframes);
235 return AVERROR_INVALIDDATA;
238 s->num_channels = avctx->channels;
240 /* extract lfe channel position */
243 if (channel_mask & 8) {
245 for (mask = 1; mask < 16; mask <<= 1)
246 if (channel_mask & mask)
250 if (s->num_channels < 0) {
251 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
253 return AVERROR_INVALIDDATA;
254 } else if (s->num_channels > WMALL_MAX_CHANNELS) {
255 av_log_ask_for_sample(avctx, "unsupported number of channels\n");
256 return AVERROR_PATCHWELCOME;
259 avcodec_get_frame_defaults(&s->frame);
260 avctx->coded_frame = &s->frame;
261 avctx->channel_layout = channel_mask;
266 * @brief Decode the subframe length.
268 * @param offset sample offset in the frame
269 * @return decoded subframe length on success, < 0 in case of an error
271 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
273 int frame_len_ratio, subframe_len, len;
275 /* no need to read from the bitstream when only one length is possible */
276 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
277 return s->min_samples_per_subframe;
279 len = av_log2(s->max_num_subframes - 1) + 1;
280 frame_len_ratio = get_bits(&s->gb, len);
281 subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
283 /* sanity check the length */
284 if (subframe_len < s->min_samples_per_subframe ||
285 subframe_len > s->samples_per_frame) {
286 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
288 return AVERROR_INVALIDDATA;
294 * @brief Decode how the data in the frame is split into subframes.
295 * Every WMA frame contains the encoded data for a fixed number of
296 * samples per channel. The data for every channel might be split
297 * into several subframes. This function will reconstruct the list of
298 * subframes for every channel.
300 * If the subframes are not evenly split, the algorithm estimates the
301 * channels with the lowest number of total samples.
302 * Afterwards, for each of these channels a bit is read from the
303 * bitstream that indicates if the channel contains a subframe with the
304 * next subframe size that is going to be read from the bitstream or not.
305 * If a channel contains such a subframe, the subframe size gets added to
306 * the channel's subframe list.
307 * The algorithm repeats these steps until the frame is properly divided
308 * between the individual channels.
311 * @return 0 on success, < 0 in case of an error
313 static int decode_tilehdr(WmallDecodeCtx *s)
315 uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
316 uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
317 int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
318 int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
319 int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
322 /* reset tiling information */
323 for (c = 0; c < s->num_channels; c++)
324 s->channel[c].num_subframes = 0;
326 tile_aligned = get_bits1(&s->gb);
327 if (s->max_num_subframes == 1 || tile_aligned)
328 fixed_channel_layout = 1;
330 /* loop until the frame data is split between the subframes */
332 int subframe_len, in_use = 0;
334 /* check which channels contain the subframe */
335 for (c = 0; c < s->num_channels; c++) {
336 if (num_samples[c] == min_channel_len) {
337 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
338 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
339 contains_subframe[c] = in_use = 1;
341 if (get_bits1(&s->gb))
342 contains_subframe[c] = in_use = 1;
345 contains_subframe[c] = 0;
349 av_log(s->avctx, AV_LOG_ERROR,
350 "Found empty subframe\n");
351 return AVERROR_INVALIDDATA;
354 /* get subframe length, subframe_len == 0 is not allowed */
355 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
356 return AVERROR_INVALIDDATA;
357 /* add subframes to the individual channels and find new min_channel_len */
358 min_channel_len += subframe_len;
359 for (c = 0; c < s->num_channels; c++) {
360 WmallChannelCtx *chan = &s->channel[c];
362 if (contains_subframe[c]) {
363 if (chan->num_subframes >= MAX_SUBFRAMES) {
364 av_log(s->avctx, AV_LOG_ERROR,
365 "broken frame: num subframes > 31\n");
366 return AVERROR_INVALIDDATA;
368 chan->subframe_len[chan->num_subframes] = subframe_len;
369 num_samples[c] += subframe_len;
370 ++chan->num_subframes;
371 if (num_samples[c] > s->samples_per_frame) {
372 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
373 "channel len(%d) > samples_per_frame(%d)\n",
374 num_samples[c], s->samples_per_frame);
375 return AVERROR_INVALIDDATA;
377 } else if (num_samples[c] <= min_channel_len) {
378 if (num_samples[c] < min_channel_len) {
379 channels_for_cur_subframe = 0;
380 min_channel_len = num_samples[c];
382 ++channels_for_cur_subframe;
385 } while (min_channel_len < s->samples_per_frame);
387 for (c = 0; c < s->num_channels; c++) {
389 for (i = 0; i < s->channel[c].num_subframes; i++) {
390 s->channel[c].subframe_offsets[i] = offset;
391 offset += s->channel[c].subframe_len[i];
398 static void decode_ac_filter(WmallDecodeCtx *s)
401 s->acfilter_order = get_bits(&s->gb, 4) + 1;
402 s->acfilter_scaling = get_bits(&s->gb, 4);
404 for (i = 0; i < s->acfilter_order; i++)
405 s->acfilter_coeffs[i] = get_bits(&s->gb, s->acfilter_scaling) + 1;
408 static void decode_mclms(WmallDecodeCtx *s)
410 s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
411 s->mclms_scaling = get_bits(&s->gb, 4);
412 if (get_bits1(&s->gb)) {
413 int i, send_coef_bits;
414 int cbits = av_log2(s->mclms_scaling + 1);
415 if (1 << cbits < s->mclms_scaling + 1)
418 send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
420 for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
421 s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
423 for (i = 0; i < s->num_channels; i++) {
425 for (c = 0; c < i; c++)
426 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
431 static int decode_cdlms(WmallDecodeCtx *s)
434 int cdlms_send_coef = get_bits1(&s->gb);
436 for (c = 0; c < s->num_channels; c++) {
437 s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
438 for (i = 0; i < s->cdlms_ttl[c]; i++) {
439 s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
440 if (s->cdlms[c][i].order > MAX_ORDER) {
441 av_log(s->avctx, AV_LOG_ERROR,
442 "Order[%d][%d] %d > max (%d), not supported\n",
443 c, i, s->cdlms[c][i].order, MAX_ORDER);
444 s->cdlms[0][0].order = 0;
445 return AVERROR_INVALIDDATA;
449 for (i = 0; i < s->cdlms_ttl[c]; i++)
450 s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
452 if (cdlms_send_coef) {
453 for (i = 0; i < s->cdlms_ttl[c]; i++) {
454 int cbits, shift_l, shift_r, j;
455 cbits = av_log2(s->cdlms[c][i].order);
456 if ((1 << cbits) < s->cdlms[c][i].order)
458 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
460 cbits = av_log2(s->cdlms[c][i].scaling + 1);
461 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
464 s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
465 shift_l = 32 - s->cdlms[c][i].bitsend;
466 shift_r = 32 - s->cdlms[c][i].scaling - 2;
467 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
468 s->cdlms[c][i].coefs[j] =
469 (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
477 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
480 unsigned int ave_mean;
481 s->transient[ch] = get_bits1(&s->gb);
482 if (s->transient[ch]) {
483 s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
484 if (s->transient_pos[ch])
485 s->transient[ch] = 0;
486 s->channel[ch].transient_counter =
487 FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
488 } else if (s->channel[ch].transient_counter)
489 s->transient[ch] = 1;
491 if (s->seekable_tile) {
492 ave_mean = get_bits(&s->gb, s->bits_per_sample);
493 s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
496 if (s->seekable_tile) {
497 if (s->do_inter_ch_decorr)
498 s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample + 1);
500 s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample);
503 for (; i < tile_size; i++) {
504 int quo = 0, rem, rem_bits, residue;
505 while(get_bits1(&s->gb)) {
507 if (get_bits_left(&s->gb) <= 0)
511 quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
513 ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
517 rem_bits = av_ceil_log2(ave_mean);
518 rem = rem_bits ? get_bits(&s->gb, rem_bits) : 0;
519 residue = (quo << rem_bits) + rem;
522 s->ave_sum[ch] = residue + s->ave_sum[ch] -
523 (s->ave_sum[ch] >> s->movave_scaling);
526 residue = -(residue >> 1) - 1;
528 residue = residue >> 1;
529 s->channel_residues[ch][i] = residue;
536 static void decode_lpc(WmallDecodeCtx *s)
539 s->lpc_order = get_bits(&s->gb, 5) + 1;
540 s->lpc_scaling = get_bits(&s->gb, 4);
541 s->lpc_intbits = get_bits(&s->gb, 3) + 1;
542 cbits = s->lpc_scaling + s->lpc_intbits;
543 for (ch = 0; ch < s->num_channels; ch++)
544 for (i = 0; i < s->lpc_order; i++)
545 s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
548 static void clear_codec_buffers(WmallDecodeCtx *s)
552 memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
553 memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
554 memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
556 memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
557 memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
558 memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
559 memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
561 for (ich = 0; ich < s->num_channels; ich++) {
562 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
563 memset(s->cdlms[ich][ilms].coefs, 0,
564 sizeof(s->cdlms[ich][ilms].coefs));
565 memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
566 sizeof(s->cdlms[ich][ilms].lms_prevvalues));
567 memset(s->cdlms[ich][ilms].lms_updates, 0,
568 sizeof(s->cdlms[ich][ilms].lms_updates));
575 * @brief Reset filter parameters and transient area at new seekable tile.
577 static void reset_codec(WmallDecodeCtx *s)
580 s->mclms_recent = s->mclms_order * s->num_channels;
581 for (ich = 0; ich < s->num_channels; ich++) {
582 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
583 s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
584 /* first sample of a seekable subframe is considered as the starting of
585 a transient area which is samples_per_frame samples long */
586 s->channel[ich].transient_counter = s->samples_per_frame;
587 s->transient[ich] = 1;
588 s->transient_pos[ich] = 0;
592 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
594 int i, j, ich, pred_error;
595 int order = s->mclms_order;
596 int num_channels = s->num_channels;
597 int range = 1 << (s->bits_per_sample - 1);
599 for (ich = 0; ich < num_channels; ich++) {
600 pred_error = s->channel_residues[ich][icoef] - pred[ich];
601 if (pred_error > 0) {
602 for (i = 0; i < order * num_channels; i++)
603 s->mclms_coeffs[i + ich * order * num_channels] +=
604 s->mclms_updates[s->mclms_recent + i];
605 for (j = 0; j < ich; j++) {
606 if (s->channel_residues[j][icoef] > 0)
607 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
608 else if (s->channel_residues[j][icoef] < 0)
609 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
611 } else if (pred_error < 0) {
612 for (i = 0; i < order * num_channels; i++)
613 s->mclms_coeffs[i + ich * order * num_channels] -=
614 s->mclms_updates[s->mclms_recent + i];
615 for (j = 0; j < ich; j++) {
616 if (s->channel_residues[j][icoef] > 0)
617 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
618 else if (s->channel_residues[j][icoef] < 0)
619 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
624 for (ich = num_channels - 1; ich >= 0; ich--) {
626 s->mclms_prevvalues[s->mclms_recent] = s->channel_residues[ich][icoef];
627 if (s->channel_residues[ich][icoef] > range - 1)
628 s->mclms_prevvalues[s->mclms_recent] = range - 1;
629 else if (s->channel_residues[ich][icoef] < -range)
630 s->mclms_prevvalues[s->mclms_recent] = -range;
632 s->mclms_updates[s->mclms_recent] = 0;
633 if (s->channel_residues[ich][icoef] > 0)
634 s->mclms_updates[s->mclms_recent] = 1;
635 else if (s->channel_residues[ich][icoef] < 0)
636 s->mclms_updates[s->mclms_recent] = -1;
639 if (s->mclms_recent == 0) {
640 memcpy(&s->mclms_prevvalues[order * num_channels],
642 2 * order * num_channels);
643 memcpy(&s->mclms_updates[order * num_channels],
645 2 * order * num_channels);
646 s->mclms_recent = num_channels * order;
650 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
653 int order = s->mclms_order;
654 int num_channels = s->num_channels;
656 for (ich = 0; ich < num_channels; ich++) {
657 if (!s->is_channel_coded[ich])
660 for (i = 0; i < order * num_channels; i++)
661 pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
662 s->mclms_coeffs[i + order * num_channels * ich];
663 for (i = 0; i < ich; i++)
664 pred[ich] += s->channel_residues[i][icoef] *
665 s->mclms_coeffs_cur[i + num_channels * ich];
666 pred[ich] += 1 << s->mclms_scaling - 1;
667 pred[ich] >>= s->mclms_scaling;
668 s->channel_residues[ich][icoef] += pred[ich];
672 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
674 int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
675 for (icoef = 0; icoef < tile_size; icoef++) {
676 mclms_predict(s, icoef, pred);
677 mclms_update(s, icoef, pred);
681 static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
684 int recent = s->cdlms[ich][ilms].recent;
686 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
687 pred += s->cdlms[ich][ilms].coefs[icoef] *
688 s->cdlms[ich][ilms].lms_prevvalues[icoef + recent];
693 static void lms_update(WmallDecodeCtx *s, int ich, int ilms,
694 int input, int residue)
697 int recent = s->cdlms[ich][ilms].recent;
698 int range = 1 << s->bits_per_sample - 1;
701 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
702 s->cdlms[ich][ilms].coefs[icoef] -=
703 s->cdlms[ich][ilms].lms_updates[icoef + recent];
704 } else if (residue > 0) {
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];
713 memcpy(&s->cdlms[ich][ilms].lms_prevvalues[s->cdlms[ich][ilms].order],
714 s->cdlms[ich][ilms].lms_prevvalues,
715 2 * s->cdlms[ich][ilms].order);
716 memcpy(&s->cdlms[ich][ilms].lms_updates[s->cdlms[ich][ilms].order],
717 s->cdlms[ich][ilms].lms_updates,
718 2 * s->cdlms[ich][ilms].order);
719 recent = s->cdlms[ich][ilms].order - 1;
722 s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
724 s->cdlms[ich][ilms].lms_updates[recent] = 0;
726 s->cdlms[ich][ilms].lms_updates[recent] = -s->update_speed[ich];
728 s->cdlms[ich][ilms].lms_updates[recent] = s->update_speed[ich];
730 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 4)] >>= 2;
731 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 3)] >>= 1;
732 s->cdlms[ich][ilms].recent = recent;
735 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
737 int ilms, recent, icoef;
738 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
739 recent = s->cdlms[ich][ilms].recent;
740 if (s->update_speed[ich] == 16)
743 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
744 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
746 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
747 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
750 s->update_speed[ich] = 16;
753 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
755 int ilms, recent, icoef;
756 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
757 recent = s->cdlms[ich][ilms].recent;
758 if (s->update_speed[ich] == 8)
761 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
762 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
764 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
765 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
767 s->update_speed[ich] = 8;
770 static void revert_cdlms(WmallDecodeCtx *s, int ch,
771 int coef_begin, int coef_end)
773 int icoef, pred, ilms, num_lms, residue, input;
775 num_lms = s->cdlms_ttl[ch];
776 for (ilms = num_lms - 1; ilms >= 0; ilms--) {
777 for (icoef = coef_begin; icoef < coef_end; icoef++) {
778 pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
779 residue = s->channel_residues[ch][icoef];
780 pred += lms_predict(s, ch, ilms);
781 input = residue + (pred >> s->cdlms[ch][ilms].scaling);
782 lms_update(s, ch, ilms, input, residue);
783 s->channel_residues[ch][icoef] = input;
788 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
790 if (s->num_channels != 2)
792 else if (s->is_channel_coded[0] && s->is_channel_coded[1]) {
794 for (icoef = 0; icoef < tile_size; icoef++) {
795 s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
796 s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
801 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
804 int64_t *filter_coeffs = s->acfilter_coeffs;
805 int scaling = s->acfilter_scaling;
806 int order = s->acfilter_order;
808 for (ich = 0; ich < s->num_channels; ich++) {
809 int *prevvalues = s->acfilter_prevvalues[ich];
810 for (i = 0; i < order; i++) {
812 for (j = 0; j < order; j++) {
814 pred += filter_coeffs[j] * prevvalues[j - i];
816 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
819 s->channel_residues[ich][i] += pred;
821 for (i = order; i < tile_size; i++) {
823 for (j = 0; j < order; j++)
824 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
826 s->channel_residues[ich][i] += pred;
828 for (j = 0; j < order; j++)
829 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
833 static int decode_subframe(WmallDecodeCtx *s)
835 int offset = s->samples_per_frame;
836 int subframe_len = s->samples_per_frame;
837 int total_samples = s->samples_per_frame * s->num_channels;
838 int i, j, rawpcm_tile, padding_zeroes, res;
840 s->subframe_offset = get_bits_count(&s->gb);
842 /* reset channel context and find the next block offset and size
843 == the next block of the channel with the smallest number of
845 for (i = 0; i < s->num_channels; i++) {
846 if (offset > s->channel[i].decoded_samples) {
847 offset = s->channel[i].decoded_samples;
849 s->channel[i].subframe_len[s->channel[i].cur_subframe];
853 /* get a list of all channels that contain the estimated block */
854 s->channels_for_cur_subframe = 0;
855 for (i = 0; i < s->num_channels; i++) {
856 const int cur_subframe = s->channel[i].cur_subframe;
857 /* subtract already processed samples */
858 total_samples -= s->channel[i].decoded_samples;
860 /* and count if there are multiple subframes that match our profile */
861 if (offset == s->channel[i].decoded_samples &&
862 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
863 total_samples -= s->channel[i].subframe_len[cur_subframe];
864 s->channel[i].decoded_samples +=
865 s->channel[i].subframe_len[cur_subframe];
866 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
867 ++s->channels_for_cur_subframe;
871 /* check if the frame will be complete after processing the
874 s->parsed_all_subframes = 1;
877 s->seekable_tile = get_bits1(&s->gb);
878 if (s->seekable_tile) {
879 clear_codec_buffers(s);
881 s->do_arith_coding = get_bits1(&s->gb);
882 if (s->do_arith_coding) {
883 av_log_missing_feature(s->avctx, "arithmetic coding", 1);
884 return AVERROR_PATCHWELCOME;
886 s->do_ac_filter = get_bits1(&s->gb);
887 s->do_inter_ch_decorr = get_bits1(&s->gb);
888 s->do_mclms = get_bits1(&s->gb);
896 if ((res = decode_cdlms(s)) < 0)
898 s->movave_scaling = get_bits(&s->gb, 3);
899 s->quant_stepsize = get_bits(&s->gb, 8) + 1;
902 } else if (!s->cdlms[0][0].order) {
903 av_log(s->avctx, AV_LOG_DEBUG,
904 "Waiting for seekable tile\n");
905 s->frame.nb_samples = 0;
909 rawpcm_tile = get_bits1(&s->gb);
911 for (i = 0; i < s->num_channels; i++)
912 s->is_channel_coded[i] = 1;
915 for (i = 0; i < s->num_channels; i++)
916 s->is_channel_coded[i] = get_bits1(&s->gb);
920 s->do_lpc = get_bits1(&s->gb);
923 av_log_ask_for_sample(s->avctx, "Inverse LPC filter not "
924 "implemented. Expect wrong output.\n");
931 if (get_bits1(&s->gb))
932 padding_zeroes = get_bits(&s->gb, 5);
937 int bits = s->bits_per_sample - padding_zeroes;
939 av_log(s->avctx, AV_LOG_ERROR,
940 "Invalid number of padding bits in raw PCM tile\n");
941 return AVERROR_INVALIDDATA;
943 av_dlog(s->avctx, "RAWPCM %d bits per sample. "
944 "total %d bits, remain=%d\n", bits,
945 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
946 for (i = 0; i < s->num_channels; i++)
947 for (j = 0; j < subframe_len; j++)
948 s->channel_coeffs[i][j] = get_sbits(&s->gb, bits);
950 for (i = 0; i < s->num_channels; i++)
951 if (s->is_channel_coded[i]) {
952 decode_channel_residues(s, i, subframe_len);
953 if (s->seekable_tile)
954 use_high_update_speed(s, i);
956 use_normal_update_speed(s, i);
957 revert_cdlms(s, i, 0, subframe_len);
961 revert_mclms(s, subframe_len);
962 if (s->do_inter_ch_decorr)
963 revert_inter_ch_decorr(s, subframe_len);
965 revert_acfilter(s, subframe_len);
968 if (s->quant_stepsize != 1)
969 for (i = 0; i < s->num_channels; i++)
970 for (j = 0; j < subframe_len; j++)
971 s->channel_residues[i][j] *= s->quant_stepsize;
973 /* Write to proper output buffer depending on bit-depth */
974 for (i = 0; i < s->channels_for_cur_subframe; i++) {
975 int c = s->channel_indexes_for_cur_subframe[i];
976 int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
978 for (j = 0; j < subframe_len; j++) {
979 if (s->bits_per_sample == 16) {
980 *s->samples_16[c] = (int16_t) s->channel_residues[c][j];
981 s->samples_16[c] += s->num_channels;
983 *s->samples_32[c] = s->channel_residues[c][j];
984 s->samples_32[c] += s->num_channels;
989 /* handled one subframe */
990 for (i = 0; i < s->channels_for_cur_subframe; i++) {
991 int c = s->channel_indexes_for_cur_subframe[i];
992 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
993 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
994 return AVERROR_INVALIDDATA;
996 ++s->channel[c].cur_subframe;
1002 * @brief Decode one WMA frame.
1003 * @param s codec context
1004 * @return 0 if the trailer bit indicates that this is the last frame,
1005 * 1 if there are additional frames
1007 static int decode_frame(WmallDecodeCtx *s)
1009 GetBitContext* gb = &s->gb;
1010 int more_frames = 0, len = 0, i, ret;
1012 s->frame.nb_samples = s->samples_per_frame;
1013 if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1014 /* return an error if no frame could be decoded at all */
1015 av_log(s->avctx, AV_LOG_ERROR,
1016 "not enough space for the output samples\n");
1020 for (i = 0; i < s->num_channels; i++) {
1021 s->samples_16[i] = (int16_t *)s->frame.data[0] + i;
1022 s->samples_32[i] = (int32_t *)s->frame.data[0] + i;
1025 /* get frame length */
1027 len = get_bits(gb, s->log2_frame_size);
1029 /* decode tile information */
1030 if (decode_tilehdr(s)) {
1036 if (s->dynamic_range_compression)
1037 s->drc_gain = get_bits(gb, 8);
1039 /* no idea what these are for, might be the number of samples
1040 that need to be skipped at the beginning or end of a stream */
1041 if (get_bits1(gb)) {
1044 /* usually true for the first frame */
1045 if (get_bits1(gb)) {
1046 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1047 av_dlog(s->avctx, "start skip: %i\n", skip);
1050 /* sometimes true for the last frame */
1051 if (get_bits1(gb)) {
1052 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1053 av_dlog(s->avctx, "end skip: %i\n", skip);
1058 /* reset subframe states */
1059 s->parsed_all_subframes = 0;
1060 for (i = 0; i < s->num_channels; i++) {
1061 s->channel[i].decoded_samples = 0;
1062 s->channel[i].cur_subframe = 0;
1065 /* decode all subframes */
1066 while (!s->parsed_all_subframes) {
1067 if (decode_subframe(s) < 0) {
1073 av_dlog(s->avctx, "Frame done\n");
1078 if (s->len_prefix) {
1079 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1080 /* FIXME: not sure if this is always an error */
1081 av_log(s->avctx, AV_LOG_ERROR,
1082 "frame[%i] would have to skip %i bits\n", s->frame_num,
1083 len - (get_bits_count(gb) - s->frame_offset) - 1);
1088 /* skip the rest of the frame data */
1089 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1092 /* decode trailer bit */
1093 more_frames = get_bits1(gb);
1099 * @brief Calculate remaining input buffer length.
1100 * @param s codec context
1101 * @param gb bitstream reader context
1102 * @return remaining size in bits
1104 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1106 return s->buf_bit_size - get_bits_count(gb);
1110 * @brief Fill the bit reservoir with a (partial) frame.
1111 * @param s codec context
1112 * @param gb bitstream reader context
1113 * @param len length of the partial frame
1114 * @param append decides whether to reset the buffer or not
1116 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1122 /* when the frame data does not need to be concatenated, the input buffer
1123 is reset and additional bits from the previous frame are copied
1124 and skipped later so that a fast byte copy is possible */
1127 s->frame_offset = get_bits_count(gb) & 7;
1128 s->num_saved_bits = s->frame_offset;
1129 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1132 buflen = (s->num_saved_bits + len + 8) >> 3;
1134 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1135 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1140 s->num_saved_bits += len;
1142 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1145 int align = 8 - (get_bits_count(gb) & 7);
1146 align = FFMIN(align, len);
1147 put_bits(&s->pb, align, get_bits(gb, align));
1149 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1151 skip_bits_long(gb, len);
1154 flush_put_bits(&tmp);
1156 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1157 skip_bits(&s->gb, s->frame_offset);
1160 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1163 WmallDecodeCtx *s = avctx->priv_data;
1164 GetBitContext* gb = &s->pgb;
1165 const uint8_t* buf = avpkt->data;
1166 int buf_size = avpkt->size;
1167 int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1169 if (s->packet_done || s->packet_loss) {
1172 /* sanity check for the buffer length */
1173 if (buf_size < avctx->block_align)
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 av_log_missing_feature(avctx, "Bitstream splicing", 1);
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, "Packet loss detected! seq %x vs %x\n",
1196 s->packet_sequence_number, packet_sequence_number);
1198 s->packet_sequence_number = packet_sequence_number;
1200 if (num_bits_prev_frame > 0) {
1201 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1202 if (num_bits_prev_frame >= remaining_packet_bits) {
1203 num_bits_prev_frame = remaining_packet_bits;
1207 /* Append the previous frame data to the remaining data from the
1208 * previous packet to create a full frame. */
1209 save_bits(s, gb, num_bits_prev_frame, 1);
1211 /* decode the cross packet frame if it is valid */
1212 if (!s->packet_loss)
1214 } else if (s->num_saved_bits - s->frame_offset) {
1215 av_dlog(avctx, "ignoring %x previously saved bits\n",
1216 s->num_saved_bits - s->frame_offset);
1219 if (s->packet_loss) {
1220 /* Reset number of saved bits so that the decoder does not start
1221 * to decode incomplete frames in the s->len_prefix == 0 case. */
1222 s->num_saved_bits = 0;
1229 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1230 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1231 skip_bits(gb, s->packet_offset);
1233 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1234 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1235 frame_size <= remaining_bits(s, gb)) {
1236 save_bits(s, gb, frame_size, 0);
1237 s->packet_done = !decode_frame(s);
1238 } else if (!s->len_prefix
1239 && s->num_saved_bits > get_bits_count(&s->gb)) {
1240 /* when the frames do not have a length prefix, we don't know the
1241 * compressed length of the individual frames however, we know what
1242 * part of a new packet belongs to the previous frame therefore we
1243 * save the incoming packet first, then we append the "previous
1244 * frame" data from the next packet so that we get a buffer that
1245 * only contains full frames */
1246 s->packet_done = !decode_frame(s);
1252 if (s->packet_done && !s->packet_loss &&
1253 remaining_bits(s, gb) > 0) {
1254 /* save the rest of the data so that it can be decoded
1255 * with the next packet */
1256 save_bits(s, gb, remaining_bits(s, gb), 0);
1259 *(AVFrame *)data = s->frame;
1260 *got_frame_ptr = s->frame.nb_samples > 0;
1261 s->packet_offset = get_bits_count(gb) & 7;
1263 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1266 static void flush(AVCodecContext *avctx)
1268 WmallDecodeCtx *s = avctx->priv_data;
1271 s->num_saved_bits = 0;
1272 s->frame_offset = 0;
1273 s->next_packet_start = 0;
1274 s->cdlms[0][0].order = 0;
1275 s->frame.nb_samples = 0;
1278 AVCodec ff_wmalossless_decoder = {
1279 .name = "wmalossless",
1280 .type = AVMEDIA_TYPE_AUDIO,
1281 .id = CODEC_ID_WMALOSSLESS,
1282 .priv_data_size = sizeof(WmallDecodeCtx),
1283 .init = decode_init,
1284 .decode = decode_packet,
1286 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1287 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),