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, 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 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 num_possible_block_sizes = log2_max_num_subframes + 1;
229 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
230 s->dynamic_range_compression = s->decode_flags & 0x80;
231 s->bV3RTM = s->decode_flags & 0x100;
233 if (s->max_num_subframes > MAX_SUBFRAMES) {
234 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
235 s->max_num_subframes);
236 return AVERROR_INVALIDDATA;
239 s->num_channels = avctx->channels;
241 /* extract lfe channel position */
244 if (channel_mask & 8) {
246 for (mask = 1; mask < 16; mask <<= 1)
247 if (channel_mask & mask)
251 if (s->num_channels < 0) {
252 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
254 return AVERROR_INVALIDDATA;
255 } else if (s->num_channels > WMALL_MAX_CHANNELS) {
256 av_log_ask_for_sample(avctx, "unsupported number of channels\n");
257 return AVERROR_PATCHWELCOME;
260 avcodec_get_frame_defaults(&s->frame);
261 avctx->coded_frame = &s->frame;
262 avctx->channel_layout = channel_mask;
267 * @brief Decode the subframe length.
269 * @param offset sample offset in the frame
270 * @return decoded subframe length on success, < 0 in case of an error
272 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
274 int frame_len_ratio, subframe_len, len;
276 /* no need to read from the bitstream when only one length is possible */
277 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
278 return s->min_samples_per_subframe;
280 len = av_log2(s->max_num_subframes - 1) + 1;
281 frame_len_ratio = get_bits(&s->gb, len);
282 subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
284 /* sanity check the length */
285 if (subframe_len < s->min_samples_per_subframe ||
286 subframe_len > s->samples_per_frame) {
287 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
289 return AVERROR_INVALIDDATA;
295 * @brief Decode how the data in the frame is split into subframes.
296 * Every WMA frame contains the encoded data for a fixed number of
297 * samples per channel. The data for every channel might be split
298 * into several subframes. This function will reconstruct the list of
299 * subframes for every channel.
301 * If the subframes are not evenly split, the algorithm estimates the
302 * channels with the lowest number of total samples.
303 * Afterwards, for each of these channels a bit is read from the
304 * bitstream that indicates if the channel contains a subframe with the
305 * next subframe size that is going to be read from the bitstream or not.
306 * If a channel contains such a subframe, the subframe size gets added to
307 * the channel's subframe list.
308 * The algorithm repeats these steps until the frame is properly divided
309 * between the individual channels.
312 * @return 0 on success, < 0 in case of an error
314 static int decode_tilehdr(WmallDecodeCtx *s)
316 uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
317 uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
318 int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
319 int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
320 int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
323 /* reset tiling information */
324 for (c = 0; c < s->num_channels; c++)
325 s->channel[c].num_subframes = 0;
327 tile_aligned = get_bits1(&s->gb);
328 if (s->max_num_subframes == 1 || tile_aligned)
329 fixed_channel_layout = 1;
331 /* loop until the frame data is split between the subframes */
333 int subframe_len, in_use = 0;
335 /* check which channels contain the subframe */
336 for (c = 0; c < s->num_channels; c++) {
337 if (num_samples[c] == min_channel_len) {
338 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
339 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
340 contains_subframe[c] = in_use = 1;
342 if (get_bits1(&s->gb))
343 contains_subframe[c] = in_use = 1;
346 contains_subframe[c] = 0;
350 av_log(s->avctx, AV_LOG_ERROR,
351 "Found empty subframe\n");
352 return AVERROR_INVALIDDATA;
355 /* get subframe length, subframe_len == 0 is not allowed */
356 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
357 return AVERROR_INVALIDDATA;
358 /* add subframes to the individual channels and find new min_channel_len */
359 min_channel_len += subframe_len;
360 for (c = 0; c < s->num_channels; c++) {
361 WmallChannelCtx *chan = &s->channel[c];
363 if (contains_subframe[c]) {
364 if (chan->num_subframes >= MAX_SUBFRAMES) {
365 av_log(s->avctx, AV_LOG_ERROR,
366 "broken frame: num subframes > 31\n");
367 return AVERROR_INVALIDDATA;
369 chan->subframe_len[chan->num_subframes] = subframe_len;
370 num_samples[c] += subframe_len;
371 ++chan->num_subframes;
372 if (num_samples[c] > s->samples_per_frame) {
373 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
374 "channel len(%d) > samples_per_frame(%d)\n",
375 num_samples[c], s->samples_per_frame);
376 return AVERROR_INVALIDDATA;
378 } else if (num_samples[c] <= min_channel_len) {
379 if (num_samples[c] < min_channel_len) {
380 channels_for_cur_subframe = 0;
381 min_channel_len = num_samples[c];
383 ++channels_for_cur_subframe;
386 } while (min_channel_len < s->samples_per_frame);
388 for (c = 0; c < s->num_channels; c++) {
390 for (i = 0; i < s->channel[c].num_subframes; i++) {
391 s->channel[c].subframe_offsets[i] = offset;
392 offset += s->channel[c].subframe_len[i];
399 static void decode_ac_filter(WmallDecodeCtx *s)
402 s->acfilter_order = get_bits(&s->gb, 4) + 1;
403 s->acfilter_scaling = get_bits(&s->gb, 4);
405 for (i = 0; i < s->acfilter_order; i++)
406 s->acfilter_coeffs[i] = get_bits(&s->gb, s->acfilter_scaling) + 1;
409 static void decode_mclms(WmallDecodeCtx *s)
411 s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
412 s->mclms_scaling = get_bits(&s->gb, 4);
413 if (get_bits1(&s->gb)) {
414 int i, send_coef_bits;
415 int cbits = av_log2(s->mclms_scaling + 1);
416 if (1 << cbits < s->mclms_scaling + 1)
419 send_coef_bits = (cbits ? get_bits(&s->gb, cbits) : 0) + 2;
421 for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
422 s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
424 for (i = 0; i < s->num_channels; i++) {
426 for (c = 0; c < i; c++)
427 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
432 static int decode_cdlms(WmallDecodeCtx *s)
435 int cdlms_send_coef = get_bits1(&s->gb);
437 for (c = 0; c < s->num_channels; c++) {
438 s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
439 for (i = 0; i < s->cdlms_ttl[c]; i++) {
440 s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
441 if (s->cdlms[c][i].order > MAX_ORDER) {
442 av_log(s->avctx, AV_LOG_ERROR,
443 "Order[%d][%d] %d > max (%d), not supported\n",
444 c, i, s->cdlms[c][i].order, MAX_ORDER);
445 s->cdlms[0][0].order = 0;
446 return AVERROR_INVALIDDATA;
450 for (i = 0; i < s->cdlms_ttl[c]; i++)
451 s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
453 if (cdlms_send_coef) {
454 for (i = 0; i < s->cdlms_ttl[c]; i++) {
455 int cbits, shift_l, shift_r, j;
456 cbits = av_log2(s->cdlms[c][i].order);
457 if ((1 << cbits) < s->cdlms[c][i].order)
459 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
461 cbits = av_log2(s->cdlms[c][i].scaling + 1);
462 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
465 s->cdlms[c][i].bitsend = get_bits(&s->gb, cbits) + 2;
466 shift_l = 32 - s->cdlms[c][i].bitsend;
467 shift_r = 32 - s->cdlms[c][i].scaling - 2;
468 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
469 s->cdlms[c][i].coefs[j] =
470 (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
478 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
481 unsigned int ave_mean;
482 s->transient[ch] = get_bits1(&s->gb);
483 if (s->transient[ch]) {
484 s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
485 if (s->transient_pos[ch])
486 s->transient[ch] = 0;
487 s->channel[ch].transient_counter =
488 FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
489 } else if (s->channel[ch].transient_counter)
490 s->transient[ch] = 1;
492 if (s->seekable_tile) {
493 ave_mean = get_bits(&s->gb, s->bits_per_sample);
494 s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
497 if (s->seekable_tile) {
498 if (s->do_inter_ch_decorr)
499 s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample + 1);
501 s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample);
504 for (; i < tile_size; i++) {
505 int quo = 0, rem, rem_bits, residue;
506 while(get_bits1(&s->gb)) {
508 if (get_bits_left(&s->gb) <= 0)
512 quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
514 ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
518 rem_bits = av_ceil_log2(ave_mean);
519 rem = rem_bits ? get_bits(&s->gb, rem_bits) : 0;
520 residue = (quo << rem_bits) + rem;
523 s->ave_sum[ch] = residue + s->ave_sum[ch] -
524 (s->ave_sum[ch] >> s->movave_scaling);
527 residue = -(residue >> 1) - 1;
529 residue = residue >> 1;
530 s->channel_residues[ch][i] = residue;
537 static void decode_lpc(WmallDecodeCtx *s)
540 s->lpc_order = get_bits(&s->gb, 5) + 1;
541 s->lpc_scaling = get_bits(&s->gb, 4);
542 s->lpc_intbits = get_bits(&s->gb, 3) + 1;
543 cbits = s->lpc_scaling + s->lpc_intbits;
544 for (ch = 0; ch < s->num_channels; ch++)
545 for (i = 0; i < s->lpc_order; i++)
546 s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
549 static void clear_codec_buffers(WmallDecodeCtx *s)
553 memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
554 memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
555 memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
557 memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
558 memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
559 memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
560 memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
562 for (ich = 0; ich < s->num_channels; ich++) {
563 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
564 memset(s->cdlms[ich][ilms].coefs, 0,
565 sizeof(s->cdlms[ich][ilms].coefs));
566 memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
567 sizeof(s->cdlms[ich][ilms].lms_prevvalues));
568 memset(s->cdlms[ich][ilms].lms_updates, 0,
569 sizeof(s->cdlms[ich][ilms].lms_updates));
576 * @brief Reset filter parameters and transient area at new seekable tile.
578 static void reset_codec(WmallDecodeCtx *s)
581 s->mclms_recent = s->mclms_order * s->num_channels;
582 for (ich = 0; ich < s->num_channels; ich++) {
583 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
584 s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
585 /* first sample of a seekable subframe is considered as the starting of
586 a transient area which is samples_per_frame samples long */
587 s->channel[ich].transient_counter = s->samples_per_frame;
588 s->transient[ich] = 1;
589 s->transient_pos[ich] = 0;
593 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
595 int i, j, ich, pred_error;
596 int order = s->mclms_order;
597 int num_channels = s->num_channels;
598 int range = 1 << (s->bits_per_sample - 1);
600 for (ich = 0; ich < num_channels; ich++) {
601 pred_error = s->channel_residues[ich][icoef] - pred[ich];
602 if (pred_error > 0) {
603 for (i = 0; i < order * num_channels; i++)
604 s->mclms_coeffs[i + ich * order * num_channels] +=
605 s->mclms_updates[s->mclms_recent + i];
606 for (j = 0; j < ich; j++) {
607 if (s->channel_residues[j][icoef] > 0)
608 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
609 else if (s->channel_residues[j][icoef] < 0)
610 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
612 } else if (pred_error < 0) {
613 for (i = 0; i < order * num_channels; i++)
614 s->mclms_coeffs[i + ich * order * num_channels] -=
615 s->mclms_updates[s->mclms_recent + i];
616 for (j = 0; j < ich; j++) {
617 if (s->channel_residues[j][icoef] > 0)
618 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
619 else if (s->channel_residues[j][icoef] < 0)
620 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
625 for (ich = num_channels - 1; ich >= 0; ich--) {
627 s->mclms_prevvalues[s->mclms_recent] = s->channel_residues[ich][icoef];
628 if (s->channel_residues[ich][icoef] > range - 1)
629 s->mclms_prevvalues[s->mclms_recent] = range - 1;
630 else if (s->channel_residues[ich][icoef] < -range)
631 s->mclms_prevvalues[s->mclms_recent] = -range;
633 s->mclms_updates[s->mclms_recent] = 0;
634 if (s->channel_residues[ich][icoef] > 0)
635 s->mclms_updates[s->mclms_recent] = 1;
636 else if (s->channel_residues[ich][icoef] < 0)
637 s->mclms_updates[s->mclms_recent] = -1;
640 if (s->mclms_recent == 0) {
641 memcpy(&s->mclms_prevvalues[order * num_channels],
643 2 * order * num_channels);
644 memcpy(&s->mclms_updates[order * num_channels],
646 2 * order * num_channels);
647 s->mclms_recent = num_channels * order;
651 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
654 int order = s->mclms_order;
655 int num_channels = s->num_channels;
657 for (ich = 0; ich < num_channels; ich++) {
658 if (!s->is_channel_coded[ich])
661 for (i = 0; i < order * num_channels; i++)
662 pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
663 s->mclms_coeffs[i + order * num_channels * ich];
664 for (i = 0; i < ich; i++)
665 pred[ich] += s->channel_residues[i][icoef] *
666 s->mclms_coeffs_cur[i + num_channels * ich];
667 pred[ich] += 1 << s->mclms_scaling - 1;
668 pred[ich] >>= s->mclms_scaling;
669 s->channel_residues[ich][icoef] += pred[ich];
673 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
675 int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
676 for (icoef = 0; icoef < tile_size; icoef++) {
677 mclms_predict(s, icoef, pred);
678 mclms_update(s, icoef, pred);
682 static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
685 int recent = s->cdlms[ich][ilms].recent;
687 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
688 pred += s->cdlms[ich][ilms].coefs[icoef] *
689 s->cdlms[ich][ilms].lms_prevvalues[icoef + recent];
694 static void lms_update(WmallDecodeCtx *s, int ich, int ilms,
695 int input, int residue)
698 int recent = s->cdlms[ich][ilms].recent;
699 int range = 1 << s->bits_per_sample - 1;
702 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
703 s->cdlms[ich][ilms].coefs[icoef] -=
704 s->cdlms[ich][ilms].lms_updates[icoef + recent];
705 } else if (residue > 0) {
706 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
707 s->cdlms[ich][ilms].coefs[icoef] +=
708 s->cdlms[ich][ilms].lms_updates[icoef + recent];
714 memcpy(&s->cdlms[ich][ilms].lms_prevvalues[s->cdlms[ich][ilms].order],
715 s->cdlms[ich][ilms].lms_prevvalues,
716 2 * s->cdlms[ich][ilms].order);
717 memcpy(&s->cdlms[ich][ilms].lms_updates[s->cdlms[ich][ilms].order],
718 s->cdlms[ich][ilms].lms_updates,
719 2 * s->cdlms[ich][ilms].order);
720 recent = s->cdlms[ich][ilms].order - 1;
723 s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
725 s->cdlms[ich][ilms].lms_updates[recent] = 0;
727 s->cdlms[ich][ilms].lms_updates[recent] = -s->update_speed[ich];
729 s->cdlms[ich][ilms].lms_updates[recent] = s->update_speed[ich];
731 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 4)] >>= 2;
732 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 3)] >>= 1;
733 s->cdlms[ich][ilms].recent = recent;
736 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
738 int ilms, recent, icoef;
739 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
740 recent = s->cdlms[ich][ilms].recent;
741 if (s->update_speed[ich] == 16)
744 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
745 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
747 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
748 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
751 s->update_speed[ich] = 16;
754 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
756 int ilms, recent, icoef;
757 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
758 recent = s->cdlms[ich][ilms].recent;
759 if (s->update_speed[ich] == 8)
762 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
763 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
765 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
766 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
768 s->update_speed[ich] = 8;
771 static void revert_cdlms(WmallDecodeCtx *s, int ch,
772 int coef_begin, int coef_end)
774 int icoef, pred, ilms, num_lms, residue, input;
776 num_lms = s->cdlms_ttl[ch];
777 for (ilms = num_lms - 1; ilms >= 0; ilms--) {
778 for (icoef = coef_begin; icoef < coef_end; icoef++) {
779 pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
780 residue = s->channel_residues[ch][icoef];
781 pred += lms_predict(s, ch, ilms);
782 input = residue + (pred >> s->cdlms[ch][ilms].scaling);
783 lms_update(s, ch, ilms, input, residue);
784 s->channel_residues[ch][icoef] = input;
789 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
791 if (s->num_channels != 2)
793 else if (s->is_channel_coded[0] && s->is_channel_coded[1]) {
795 for (icoef = 0; icoef < tile_size; icoef++) {
796 s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
797 s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
802 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
805 int64_t *filter_coeffs = s->acfilter_coeffs;
806 int scaling = s->acfilter_scaling;
807 int order = s->acfilter_order;
809 for (ich = 0; ich < s->num_channels; ich++) {
810 int *prevvalues = s->acfilter_prevvalues[ich];
811 for (i = 0; i < order; i++) {
813 for (j = 0; j < order; j++) {
815 pred += filter_coeffs[j] * prevvalues[j - i];
817 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
820 s->channel_residues[ich][i] += pred;
822 for (i = order; i < tile_size; i++) {
824 for (j = 0; j < order; j++)
825 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
827 s->channel_residues[ich][i] += pred;
829 for (j = 0; j < order; j++)
830 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
834 static int decode_subframe(WmallDecodeCtx *s)
836 int offset = s->samples_per_frame;
837 int subframe_len = s->samples_per_frame;
838 int total_samples = s->samples_per_frame * s->num_channels;
839 int i, j, rawpcm_tile, padding_zeroes, res;
841 s->subframe_offset = get_bits_count(&s->gb);
843 /* reset channel context and find the next block offset and size
844 == the next block of the channel with the smallest number of
846 for (i = 0; i < s->num_channels; i++) {
847 if (offset > s->channel[i].decoded_samples) {
848 offset = s->channel[i].decoded_samples;
850 s->channel[i].subframe_len[s->channel[i].cur_subframe];
854 /* get a list of all channels that contain the estimated block */
855 s->channels_for_cur_subframe = 0;
856 for (i = 0; i < s->num_channels; i++) {
857 const int cur_subframe = s->channel[i].cur_subframe;
858 /* subtract already processed samples */
859 total_samples -= s->channel[i].decoded_samples;
861 /* and count if there are multiple subframes that match our profile */
862 if (offset == s->channel[i].decoded_samples &&
863 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
864 total_samples -= s->channel[i].subframe_len[cur_subframe];
865 s->channel[i].decoded_samples +=
866 s->channel[i].subframe_len[cur_subframe];
867 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
868 ++s->channels_for_cur_subframe;
872 /* check if the frame will be complete after processing the
875 s->parsed_all_subframes = 1;
878 s->seekable_tile = get_bits1(&s->gb);
879 if (s->seekable_tile) {
880 clear_codec_buffers(s);
882 s->do_arith_coding = get_bits1(&s->gb);
883 if (s->do_arith_coding) {
884 av_log_missing_feature(s->avctx, "arithmetic coding", 1);
885 return AVERROR_PATCHWELCOME;
887 s->do_ac_filter = get_bits1(&s->gb);
888 s->do_inter_ch_decorr = get_bits1(&s->gb);
889 s->do_mclms = get_bits1(&s->gb);
897 if ((res = decode_cdlms(s)) < 0)
899 s->movave_scaling = get_bits(&s->gb, 3);
900 s->quant_stepsize = get_bits(&s->gb, 8) + 1;
903 } else if (!s->cdlms[0][0].order) {
904 av_log(s->avctx, AV_LOG_DEBUG,
905 "Waiting for seekable tile\n");
906 s->frame.nb_samples = 0;
910 rawpcm_tile = get_bits1(&s->gb);
912 for (i = 0; i < s->num_channels; i++)
913 s->is_channel_coded[i] = 1;
916 for (i = 0; i < s->num_channels; i++)
917 s->is_channel_coded[i] = get_bits1(&s->gb);
921 s->do_lpc = get_bits1(&s->gb);
924 av_log_ask_for_sample(s->avctx, "Inverse LPC filter not "
925 "implemented. Expect wrong output.\n");
932 if (get_bits1(&s->gb))
933 padding_zeroes = get_bits(&s->gb, 5);
938 int bits = s->bits_per_sample - padding_zeroes;
939 av_dlog(s->avctx, "RAWPCM %d bits per sample. "
940 "total %d bits, remain=%d\n", bits,
941 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
942 for (i = 0; i < s->num_channels; i++)
943 for (j = 0; j < subframe_len; j++)
944 s->channel_coeffs[i][j] = get_sbits(&s->gb, bits);
946 for (i = 0; i < s->num_channels; i++)
947 if (s->is_channel_coded[i]) {
948 decode_channel_residues(s, i, subframe_len);
949 if (s->seekable_tile)
950 use_high_update_speed(s, i);
952 use_normal_update_speed(s, i);
953 revert_cdlms(s, i, 0, subframe_len);
957 revert_mclms(s, subframe_len);
958 if (s->do_inter_ch_decorr)
959 revert_inter_ch_decorr(s, subframe_len);
961 revert_acfilter(s, subframe_len);
964 if (s->quant_stepsize != 1)
965 for (i = 0; i < s->num_channels; i++)
966 for (j = 0; j < subframe_len; j++)
967 s->channel_residues[i][j] *= s->quant_stepsize;
969 /* Write to proper output buffer depending on bit-depth */
970 for (i = 0; i < s->channels_for_cur_subframe; i++) {
971 int c = s->channel_indexes_for_cur_subframe[i];
972 int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
974 for (j = 0; j < subframe_len; j++) {
975 if (s->bits_per_sample == 16) {
976 *s->samples_16[c] = (int16_t) s->channel_residues[c][j];
977 s->samples_16[c] += s->num_channels;
979 *s->samples_32[c] = s->channel_residues[c][j];
980 s->samples_32[c] += s->num_channels;
985 /* handled one subframe */
986 for (i = 0; i < s->channels_for_cur_subframe; i++) {
987 int c = s->channel_indexes_for_cur_subframe[i];
988 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
989 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
990 return AVERROR_INVALIDDATA;
992 ++s->channel[c].cur_subframe;
998 * @brief Decode one WMA frame.
999 * @param s codec context
1000 * @return 0 if the trailer bit indicates that this is the last frame,
1001 * 1 if there are additional frames
1003 static int decode_frame(WmallDecodeCtx *s)
1005 GetBitContext* gb = &s->gb;
1006 int more_frames = 0, len = 0, i, ret;
1008 s->frame.nb_samples = s->samples_per_frame;
1009 if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
1010 /* return an error if no frame could be decoded at all */
1011 av_log(s->avctx, AV_LOG_ERROR,
1012 "not enough space for the output samples\n");
1016 for (i = 0; i < s->num_channels; i++) {
1017 s->samples_16[i] = (int16_t *)s->frame.data[0] + i;
1018 s->samples_32[i] = (int32_t *)s->frame.data[0] + i;
1021 /* get frame length */
1023 len = get_bits(gb, s->log2_frame_size);
1025 /* decode tile information */
1026 if (decode_tilehdr(s)) {
1032 if (s->dynamic_range_compression)
1033 s->drc_gain = get_bits(gb, 8);
1035 /* no idea what these are for, might be the number of samples
1036 that need to be skipped at the beginning or end of a stream */
1037 if (get_bits1(gb)) {
1040 /* usually true for the first frame */
1041 if (get_bits1(gb)) {
1042 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1043 av_dlog(s->avctx, "start skip: %i\n", skip);
1046 /* sometimes true for the last frame */
1047 if (get_bits1(gb)) {
1048 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1049 av_dlog(s->avctx, "end skip: %i\n", skip);
1054 /* reset subframe states */
1055 s->parsed_all_subframes = 0;
1056 for (i = 0; i < s->num_channels; i++) {
1057 s->channel[i].decoded_samples = 0;
1058 s->channel[i].cur_subframe = 0;
1061 /* decode all subframes */
1062 while (!s->parsed_all_subframes) {
1063 if (decode_subframe(s) < 0) {
1069 av_dlog(s->avctx, "Frame done\n");
1074 if (s->len_prefix) {
1075 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1076 /* FIXME: not sure if this is always an error */
1077 av_log(s->avctx, AV_LOG_ERROR,
1078 "frame[%i] would have to skip %i bits\n", s->frame_num,
1079 len - (get_bits_count(gb) - s->frame_offset) - 1);
1084 /* skip the rest of the frame data */
1085 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1088 /* decode trailer bit */
1089 more_frames = get_bits1(gb);
1095 * @brief Calculate remaining input buffer length.
1096 * @param s codec context
1097 * @param gb bitstream reader context
1098 * @return remaining size in bits
1100 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1102 return s->buf_bit_size - get_bits_count(gb);
1106 * @brief Fill the bit reservoir with a (partial) frame.
1107 * @param s codec context
1108 * @param gb bitstream reader context
1109 * @param len length of the partial frame
1110 * @param append decides whether to reset the buffer or not
1112 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1118 /* when the frame data does not need to be concatenated, the input buffer
1119 is reset and additional bits from the previous frame are copied
1120 and skipped later so that a fast byte copy is possible */
1123 s->frame_offset = get_bits_count(gb) & 7;
1124 s->num_saved_bits = s->frame_offset;
1125 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1128 buflen = (s->num_saved_bits + len + 8) >> 3;
1130 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1131 av_log_ask_for_sample(s->avctx, "input buffer too small\n");
1136 s->num_saved_bits += len;
1138 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1141 int align = 8 - (get_bits_count(gb) & 7);
1142 align = FFMIN(align, len);
1143 put_bits(&s->pb, align, get_bits(gb, align));
1145 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1147 skip_bits_long(gb, len);
1150 flush_put_bits(&tmp);
1152 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1153 skip_bits(&s->gb, s->frame_offset);
1156 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1159 WmallDecodeCtx *s = avctx->priv_data;
1160 GetBitContext* gb = &s->pgb;
1161 const uint8_t* buf = avpkt->data;
1162 int buf_size = avpkt->size;
1163 int num_bits_prev_frame, packet_sequence_number,
1164 seekable_frame_in_packet, spliced_packet;
1166 if (s->packet_done || s->packet_loss) {
1169 /* sanity check for the buffer length */
1170 if (buf_size < avctx->block_align)
1173 s->next_packet_start = buf_size - avctx->block_align;
1174 buf_size = avctx->block_align;
1175 s->buf_bit_size = buf_size << 3;
1177 /* parse packet header */
1178 init_get_bits(gb, buf, s->buf_bit_size);
1179 packet_sequence_number = get_bits(gb, 4);
1180 seekable_frame_in_packet = get_bits1(gb);
1181 spliced_packet = get_bits1(gb);
1183 /* get number of bits that need to be added to the previous frame */
1184 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1186 /* check for packet loss */
1187 if (!s->packet_loss &&
1188 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1190 av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
1191 s->packet_sequence_number, packet_sequence_number);
1193 s->packet_sequence_number = packet_sequence_number;
1195 if (num_bits_prev_frame > 0) {
1196 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1197 if (num_bits_prev_frame >= remaining_packet_bits) {
1198 num_bits_prev_frame = remaining_packet_bits;
1202 /* Append the previous frame data to the remaining data from the
1203 * previous packet to create a full frame. */
1204 save_bits(s, gb, num_bits_prev_frame, 1);
1206 /* decode the cross packet frame if it is valid */
1207 if (!s->packet_loss)
1209 } else if (s->num_saved_bits - s->frame_offset) {
1210 av_dlog(avctx, "ignoring %x previously saved bits\n",
1211 s->num_saved_bits - s->frame_offset);
1214 if (s->packet_loss) {
1215 /* Reset number of saved bits so that the decoder does not start
1216 * to decode incomplete frames in the s->len_prefix == 0 case. */
1217 s->num_saved_bits = 0;
1224 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1225 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1226 skip_bits(gb, s->packet_offset);
1228 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1229 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1230 frame_size <= remaining_bits(s, gb)) {
1231 save_bits(s, gb, frame_size, 0);
1232 s->packet_done = !decode_frame(s);
1233 } else if (!s->len_prefix
1234 && s->num_saved_bits > get_bits_count(&s->gb)) {
1235 /* when the frames do not have a length prefix, we don't know the
1236 * compressed length of the individual frames however, we know what
1237 * part of a new packet belongs to the previous frame therefore we
1238 * save the incoming packet first, then we append the "previous
1239 * frame" data from the next packet so that we get a buffer that
1240 * only contains full frames */
1241 s->packet_done = !decode_frame(s);
1247 if (s->packet_done && !s->packet_loss &&
1248 remaining_bits(s, gb) > 0) {
1249 /* save the rest of the data so that it can be decoded
1250 * with the next packet */
1251 save_bits(s, gb, remaining_bits(s, gb), 0);
1254 *(AVFrame *)data = s->frame;
1255 *got_frame_ptr = s->frame.nb_samples > 0;
1256 s->packet_offset = get_bits_count(gb) & 7;
1258 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1261 static void flush(AVCodecContext *avctx)
1263 WmallDecodeCtx *s = avctx->priv_data;
1266 s->num_saved_bits = 0;
1267 s->frame_offset = 0;
1268 s->next_packet_start = 0;
1269 s->cdlms[0][0].order = 0;
1270 s->frame.nb_samples = 0;
1273 AVCodec ff_wmalossless_decoder = {
1274 .name = "wmalossless",
1275 .type = AVMEDIA_TYPE_AUDIO,
1276 .id = CODEC_ID_WMALOSSLESS,
1277 .priv_data_size = sizeof(WmallDecodeCtx),
1278 .init = decode_init,
1279 .decode = decode_packet,
1281 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1282 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),