2 * Windows Media Audio Lossless decoder
3 * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
4 * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
5 * Copyright (c) 2011 Andreas Ă–man
6 * Copyright (c) 2011 - 2012 Mashiat Sarker Shakkhar
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/attributes.h"
28 #include "libavutil/avassert.h"
34 #include "lossless_audiodsp.h"
36 #include "wma_common.h"
38 /** current decoder limitations */
39 #define WMALL_MAX_CHANNELS 8 ///< max number of handled channels
40 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
41 #define MAX_BANDS 29 ///< max number of scale factor bands
42 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
45 #define WMALL_BLOCK_MIN_BITS 6 ///< log2 of min block size
46 #define WMALL_BLOCK_MAX_BITS 14 ///< log2 of max block size
47 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS) ///< maximum block size
48 #define WMALL_BLOCK_SIZES (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
50 #define WMALL_COEFF_PAD_SIZE 16 ///< pad coef buffers with 0 for use with SIMD
53 * @brief frame-specific decoder context for a single channel
55 typedef struct WmallChannelCtx {
56 int16_t prev_block_len; ///< length of the previous block
57 uint8_t transmit_coefs;
58 uint8_t num_subframes;
59 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
60 uint16_t subframe_offsets[MAX_SUBFRAMES]; ///< subframe positions in the current frame
61 uint8_t cur_subframe; ///< current subframe number
62 uint16_t decoded_samples; ///< number of already processed samples
63 int quant_step; ///< quantization step for the current subframe
64 int transient_counter; ///< number of transient samples from the beginning of the transient zone
68 * @brief main decoder context
70 typedef struct WmallDecodeCtx {
71 /* generic decoder variables */
72 AVCodecContext *avctx;
74 LLAudDSPContext dsp; ///< accelerated DSP functions
75 uint8_t *frame_data; ///< compressed frame data
76 int max_frame_size; ///< max bitstream size
77 PutBitContext pb; ///< context for filling the frame_data buffer
79 /* frame size dependent frame information (set during initialization) */
80 uint32_t decode_flags; ///< used compression features
81 int len_prefix; ///< frame is prefixed with its length
82 int dynamic_range_compression; ///< frame contains DRC data
83 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
84 uint16_t samples_per_frame; ///< number of samples to output
85 uint16_t log2_frame_size;
86 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
87 int8_t lfe_channel; ///< lfe channel index
88 uint8_t max_num_subframes;
89 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
90 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
91 uint16_t min_samples_per_subframe;
93 /* packet decode state */
94 GetBitContext pgb; ///< bitstream reader context for the packet
95 int next_packet_start; ///< start offset of the next WMA packet in the demuxer packet
96 uint8_t packet_offset; ///< offset to the frame in the packet
97 uint8_t packet_sequence_number; ///< current packet number
98 int num_saved_bits; ///< saved number of bits
99 int frame_offset; ///< frame offset in the bit reservoir
100 int subframe_offset; ///< subframe offset in the bit reservoir
101 uint8_t packet_loss; ///< set in case of bitstream error
102 uint8_t packet_done; ///< set when a packet is fully decoded
104 /* frame decode state */
105 uint32_t frame_num; ///< current frame number (not used for decoding)
106 GetBitContext gb; ///< bitstream reader context
107 int buf_bit_size; ///< buffer size in bits
108 int16_t *samples_16[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (16-bit)
109 int32_t *samples_32[WMALL_MAX_CHANNELS]; ///< current sample buffer pointer (24-bit)
110 uint8_t drc_gain; ///< gain for the DRC tool
111 int8_t skip_frame; ///< skip output step
112 int8_t parsed_all_subframes; ///< all subframes decoded?
114 /* subframe/block decode state */
115 int16_t subframe_len; ///< current subframe length
116 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
117 int8_t channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
119 WmallChannelCtx channel[WMALL_MAX_CHANNELS]; ///< per channel data
121 // WMA Lossless-specific
123 uint8_t do_arith_coding;
124 uint8_t do_ac_filter;
125 uint8_t do_inter_ch_decorr;
129 int8_t acfilter_order;
130 int8_t acfilter_scaling;
131 int16_t acfilter_coeffs[16];
132 int acfilter_prevvalues[WMALL_MAX_CHANNELS][16];
135 int8_t mclms_scaling;
136 int16_t mclms_coeffs[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS * 32];
137 int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS];
138 int32_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
139 int32_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
150 DECLARE_ALIGNED(16, int16_t, coefs)[MAX_ORDER + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
151 DECLARE_ALIGNED(16, int32_t, lms_prevvalues)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
152 DECLARE_ALIGNED(16, int16_t, lms_updates)[MAX_ORDER * 2 + WMALL_COEFF_PAD_SIZE/sizeof(int16_t)];
154 } cdlms[WMALL_MAX_CHANNELS][9];
156 int cdlms_ttl[WMALL_MAX_CHANNELS];
160 int is_channel_coded[WMALL_MAX_CHANNELS];
161 int update_speed[WMALL_MAX_CHANNELS];
163 int transient[WMALL_MAX_CHANNELS];
164 int transient_pos[WMALL_MAX_CHANNELS];
167 int ave_sum[WMALL_MAX_CHANNELS];
169 int channel_residues[WMALL_MAX_CHANNELS][WMALL_BLOCK_MAX_SIZE];
171 int lpc_coefs[WMALL_MAX_CHANNELS][40];
177 /** Get sign of integer (1 for positive, -1 for negative and 0 for zero) */
178 #define WMASIGN(x) (((x) > 0) - ((x) < 0))
180 static av_cold int decode_init(AVCodecContext *avctx)
182 WmallDecodeCtx *s = avctx->priv_data;
183 uint8_t *edata_ptr = avctx->extradata;
184 unsigned int channel_mask;
185 int i, log2_max_num_subframes;
187 if (avctx->block_align <= 0) {
188 av_log(avctx, AV_LOG_ERROR, "block_align is not set or invalid\n");
189 return AVERROR(EINVAL);
192 av_assert0(avctx->channels >= 0);
193 if (avctx->channels > WMALL_MAX_CHANNELS) {
194 avpriv_request_sample(avctx,
195 "More than %d channels", WMALL_MAX_CHANNELS);
196 return AVERROR_PATCHWELCOME;
199 s->max_frame_size = MAX_FRAMESIZE * avctx->channels;
200 s->frame_data = av_mallocz(s->max_frame_size + AV_INPUT_BUFFER_PADDING_SIZE);
202 return AVERROR(ENOMEM);
205 ff_llauddsp_init(&s->dsp);
206 init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
208 if (avctx->extradata_size >= 18) {
209 s->decode_flags = AV_RL16(edata_ptr + 14);
210 channel_mask = AV_RL32(edata_ptr + 2);
211 s->bits_per_sample = AV_RL16(edata_ptr);
212 if (s->bits_per_sample == 16)
213 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
214 else if (s->bits_per_sample == 24) {
215 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
216 avctx->bits_per_raw_sample = 24;
218 av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
220 return AVERROR_INVALIDDATA;
222 /* dump the extradata */
223 for (i = 0; i < avctx->extradata_size; i++)
224 ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
225 ff_dlog(avctx, "\n");
228 avpriv_request_sample(avctx, "Unsupported extradata size");
229 return AVERROR_PATCHWELCOME;
233 s->log2_frame_size = av_log2(avctx->block_align) + 4;
236 s->skip_frame = 1; /* skip first frame */
238 s->len_prefix = s->decode_flags & 0x40;
241 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
243 av_assert0(s->samples_per_frame <= WMALL_BLOCK_MAX_SIZE);
245 /* init previous block len */
246 for (i = 0; i < avctx->channels; i++)
247 s->channel[i].prev_block_len = s->samples_per_frame;
250 log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
251 s->max_num_subframes = 1 << log2_max_num_subframes;
252 s->max_subframe_len_bit = 0;
253 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
255 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
256 s->dynamic_range_compression = s->decode_flags & 0x80;
257 s->bV3RTM = s->decode_flags & 0x100;
259 if (s->max_num_subframes > MAX_SUBFRAMES) {
260 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
261 s->max_num_subframes);
262 return AVERROR_INVALIDDATA;
265 s->num_channels = avctx->channels;
267 /* extract lfe channel position */
270 if (channel_mask & 8) {
272 for (mask = 1; mask < 16; mask <<= 1)
273 if (channel_mask & mask)
277 s->frame = av_frame_alloc();
279 return AVERROR(ENOMEM);
281 avctx->channel_layout = channel_mask;
286 * @brief Decode the subframe length.
288 * @param offset sample offset in the frame
289 * @return decoded subframe length on success, < 0 in case of an error
291 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
293 int frame_len_ratio, subframe_len, len;
295 /* no need to read from the bitstream when only one length is possible */
296 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
297 return s->min_samples_per_subframe;
299 len = av_log2(s->max_num_subframes - 1) + 1;
300 frame_len_ratio = get_bits(&s->gb, len);
301 subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
303 /* sanity check the length */
304 if (subframe_len < s->min_samples_per_subframe ||
305 subframe_len > s->samples_per_frame) {
306 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
308 return AVERROR_INVALIDDATA;
314 * @brief Decode how the data in the frame is split into subframes.
315 * Every WMA frame contains the encoded data for a fixed number of
316 * samples per channel. The data for every channel might be split
317 * into several subframes. This function will reconstruct the list of
318 * subframes for every channel.
320 * If the subframes are not evenly split, the algorithm estimates the
321 * channels with the lowest number of total samples.
322 * Afterwards, for each of these channels a bit is read from the
323 * bitstream that indicates if the channel contains a subframe with the
324 * next subframe size that is going to be read from the bitstream or not.
325 * If a channel contains such a subframe, the subframe size gets added to
326 * the channel's subframe list.
327 * The algorithm repeats these steps until the frame is properly divided
328 * between the individual channels.
331 * @return 0 on success, < 0 in case of an error
333 static int decode_tilehdr(WmallDecodeCtx *s)
335 uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
336 uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
337 int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
338 int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
339 int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
342 /* reset tiling information */
343 for (c = 0; c < s->num_channels; c++)
344 s->channel[c].num_subframes = 0;
346 tile_aligned = get_bits1(&s->gb);
347 if (s->max_num_subframes == 1 || tile_aligned)
348 fixed_channel_layout = 1;
350 /* loop until the frame data is split between the subframes */
352 int subframe_len, in_use = 0;
354 /* check which channels contain the subframe */
355 for (c = 0; c < s->num_channels; c++) {
356 if (num_samples[c] == min_channel_len) {
357 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
358 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
359 contains_subframe[c] = 1;
361 contains_subframe[c] = get_bits1(&s->gb);
363 in_use |= contains_subframe[c];
365 contains_subframe[c] = 0;
369 av_log(s->avctx, AV_LOG_ERROR,
370 "Found empty subframe\n");
371 return AVERROR_INVALIDDATA;
374 /* get subframe length, subframe_len == 0 is not allowed */
375 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
376 return AVERROR_INVALIDDATA;
377 /* add subframes to the individual channels and find new min_channel_len */
378 min_channel_len += subframe_len;
379 for (c = 0; c < s->num_channels; c++) {
380 WmallChannelCtx *chan = &s->channel[c];
382 if (contains_subframe[c]) {
383 if (chan->num_subframes >= MAX_SUBFRAMES) {
384 av_log(s->avctx, AV_LOG_ERROR,
385 "broken frame: num subframes > 31\n");
386 return AVERROR_INVALIDDATA;
388 chan->subframe_len[chan->num_subframes] = subframe_len;
389 num_samples[c] += subframe_len;
390 ++chan->num_subframes;
391 if (num_samples[c] > s->samples_per_frame) {
392 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
393 "channel len(%"PRIu16") > samples_per_frame(%"PRIu16")\n",
394 num_samples[c], s->samples_per_frame);
395 return AVERROR_INVALIDDATA;
397 } else if (num_samples[c] <= min_channel_len) {
398 if (num_samples[c] < min_channel_len) {
399 channels_for_cur_subframe = 0;
400 min_channel_len = num_samples[c];
402 ++channels_for_cur_subframe;
405 } while (min_channel_len < s->samples_per_frame);
407 for (c = 0; c < s->num_channels; c++) {
409 for (i = 0; i < s->channel[c].num_subframes; i++) {
410 s->channel[c].subframe_offsets[i] = offset;
411 offset += s->channel[c].subframe_len[i];
418 static void decode_ac_filter(WmallDecodeCtx *s)
421 s->acfilter_order = get_bits(&s->gb, 4) + 1;
422 s->acfilter_scaling = get_bits(&s->gb, 4);
424 for (i = 0; i < s->acfilter_order; i++)
425 s->acfilter_coeffs[i] = get_bitsz(&s->gb, s->acfilter_scaling) + 1;
428 static void decode_mclms(WmallDecodeCtx *s)
430 s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
431 s->mclms_scaling = get_bits(&s->gb, 4);
432 if (get_bits1(&s->gb)) {
433 int i, send_coef_bits;
434 int cbits = av_log2(s->mclms_scaling + 1);
435 if (1 << cbits < s->mclms_scaling + 1)
438 send_coef_bits = get_bitsz(&s->gb, cbits) + 2;
440 for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
441 s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
443 for (i = 0; i < s->num_channels; i++) {
445 for (c = 0; c < i; c++)
446 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
451 static int decode_cdlms(WmallDecodeCtx *s)
454 int cdlms_send_coef = get_bits1(&s->gb);
456 for (c = 0; c < s->num_channels; c++) {
457 s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
458 for (i = 0; i < s->cdlms_ttl[c]; i++) {
459 s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
460 if (s->cdlms[c][i].order > MAX_ORDER) {
461 av_log(s->avctx, AV_LOG_ERROR,
462 "Order[%d][%d] %d > max (%d), not supported\n",
463 c, i, s->cdlms[c][i].order, MAX_ORDER);
464 s->cdlms[0][0].order = 0;
465 return AVERROR_INVALIDDATA;
467 if(s->cdlms[c][i].order & 8 && s->bits_per_sample == 16) {
470 avpriv_request_sample(s->avctx, "CDLMS of order %d",
471 s->cdlms[c][i].order);
476 for (i = 0; i < s->cdlms_ttl[c]; i++)
477 s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
479 if (cdlms_send_coef) {
480 for (i = 0; i < s->cdlms_ttl[c]; i++) {
481 int cbits, shift_l, shift_r, j;
482 cbits = av_log2(s->cdlms[c][i].order);
483 if ((1 << cbits) < s->cdlms[c][i].order)
485 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
487 cbits = av_log2(s->cdlms[c][i].scaling + 1);
488 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
491 s->cdlms[c][i].bitsend = get_bitsz(&s->gb, cbits) + 2;
492 shift_l = 32 - s->cdlms[c][i].bitsend;
493 shift_r = 32 - s->cdlms[c][i].scaling - 2;
494 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
495 s->cdlms[c][i].coefs[j] =
496 (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
500 for (i = 0; i < s->cdlms_ttl[c]; i++)
501 memset(s->cdlms[c][i].coefs + s->cdlms[c][i].order,
502 0, WMALL_COEFF_PAD_SIZE);
508 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
511 unsigned int ave_mean;
512 s->transient[ch] = get_bits1(&s->gb);
513 if (s->transient[ch]) {
514 s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
515 if (s->transient_pos[ch])
516 s->transient[ch] = 0;
517 s->channel[ch].transient_counter =
518 FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
519 } else if (s->channel[ch].transient_counter)
520 s->transient[ch] = 1;
522 if (s->seekable_tile) {
523 ave_mean = get_bits(&s->gb, s->bits_per_sample);
524 s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
527 if (s->seekable_tile) {
528 if (s->do_inter_ch_decorr)
529 s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample + 1);
531 s->channel_residues[ch][0] = get_sbits_long(&s->gb, s->bits_per_sample);
534 for (; i < tile_size; i++) {
535 int quo = 0, rem, rem_bits, residue;
536 while(get_bits1(&s->gb)) {
538 if (get_bits_left(&s->gb) <= 0)
542 quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
544 ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
548 rem_bits = av_ceil_log2(ave_mean);
549 rem = get_bits_long(&s->gb, rem_bits);
550 residue = (quo << rem_bits) + rem;
553 s->ave_sum[ch] = residue + s->ave_sum[ch] -
554 (s->ave_sum[ch] >> s->movave_scaling);
556 residue = (residue >> 1) ^ -(residue & 1);
557 s->channel_residues[ch][i] = residue;
564 static void decode_lpc(WmallDecodeCtx *s)
567 s->lpc_order = get_bits(&s->gb, 5) + 1;
568 s->lpc_scaling = get_bits(&s->gb, 4);
569 s->lpc_intbits = get_bits(&s->gb, 3) + 1;
570 cbits = s->lpc_scaling + s->lpc_intbits;
571 for (ch = 0; ch < s->num_channels; ch++)
572 for (i = 0; i < s->lpc_order; i++)
573 s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
576 static void clear_codec_buffers(WmallDecodeCtx *s)
580 memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
581 memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
582 memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
584 memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
585 memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
586 memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
587 memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
589 for (ich = 0; ich < s->num_channels; ich++) {
590 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
591 memset(s->cdlms[ich][ilms].coefs, 0,
592 sizeof(s->cdlms[ich][ilms].coefs));
593 memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
594 sizeof(s->cdlms[ich][ilms].lms_prevvalues));
595 memset(s->cdlms[ich][ilms].lms_updates, 0,
596 sizeof(s->cdlms[ich][ilms].lms_updates));
603 * @brief Reset filter parameters and transient area at new seekable tile.
605 static void reset_codec(WmallDecodeCtx *s)
608 s->mclms_recent = s->mclms_order * s->num_channels;
609 for (ich = 0; ich < s->num_channels; ich++) {
610 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
611 s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
612 /* first sample of a seekable subframe is considered as the starting of
613 a transient area which is samples_per_frame samples long */
614 s->channel[ich].transient_counter = s->samples_per_frame;
615 s->transient[ich] = 1;
616 s->transient_pos[ich] = 0;
620 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
622 int i, j, ich, pred_error;
623 int order = s->mclms_order;
624 int num_channels = s->num_channels;
625 int range = 1 << (s->bits_per_sample - 1);
627 for (ich = 0; ich < num_channels; ich++) {
628 pred_error = s->channel_residues[ich][icoef] - (unsigned)pred[ich];
629 if (pred_error > 0) {
630 for (i = 0; i < order * num_channels; i++)
631 s->mclms_coeffs[i + ich * order * num_channels] +=
632 s->mclms_updates[s->mclms_recent + i];
633 for (j = 0; j < ich; j++)
634 s->mclms_coeffs_cur[ich * num_channels + j] += WMASIGN(s->channel_residues[j][icoef]);
635 } else if (pred_error < 0) {
636 for (i = 0; i < order * num_channels; i++)
637 s->mclms_coeffs[i + ich * order * num_channels] -=
638 s->mclms_updates[s->mclms_recent + i];
639 for (j = 0; j < ich; j++)
640 s->mclms_coeffs_cur[ich * num_channels + j] -= WMASIGN(s->channel_residues[j][icoef]);
644 for (ich = num_channels - 1; ich >= 0; ich--) {
646 s->mclms_prevvalues[s->mclms_recent] = av_clip(s->channel_residues[ich][icoef],
648 s->mclms_updates[s->mclms_recent] = WMASIGN(s->channel_residues[ich][icoef]);
651 if (s->mclms_recent == 0) {
652 memcpy(&s->mclms_prevvalues[order * num_channels],
654 sizeof(int32_t) * order * num_channels);
655 memcpy(&s->mclms_updates[order * num_channels],
657 sizeof(int32_t) * order * num_channels);
658 s->mclms_recent = num_channels * order;
662 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
665 int order = s->mclms_order;
666 int num_channels = s->num_channels;
668 for (ich = 0; ich < num_channels; ich++) {
670 if (!s->is_channel_coded[ich])
672 for (i = 0; i < order * num_channels; i++)
673 pred[ich] += (uint32_t)s->mclms_prevvalues[i + s->mclms_recent] *
674 s->mclms_coeffs[i + order * num_channels * ich];
675 for (i = 0; i < ich; i++)
676 pred[ich] += (uint32_t)s->channel_residues[i][icoef] *
677 s->mclms_coeffs_cur[i + num_channels * ich];
678 pred[ich] += (1 << s->mclms_scaling) >> 1;
679 pred[ich] >>= s->mclms_scaling;
680 s->channel_residues[ich][icoef] += (unsigned)pred[ich];
684 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
686 int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
687 for (icoef = 0; icoef < tile_size; icoef++) {
688 mclms_predict(s, icoef, pred);
689 mclms_update(s, icoef, pred);
693 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
695 int ilms, recent, icoef;
696 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
697 recent = s->cdlms[ich][ilms].recent;
698 if (s->update_speed[ich] == 16)
701 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
702 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
704 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
705 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
708 s->update_speed[ich] = 16;
711 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
713 int ilms, recent, icoef;
714 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
715 recent = s->cdlms[ich][ilms].recent;
716 if (s->update_speed[ich] == 8)
719 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
720 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
722 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
723 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
725 s->update_speed[ich] = 8;
728 #define CD_LMS(bits, ROUND) \
729 static void lms_update ## bits (WmallDecodeCtx *s, int ich, int ilms, int input) \
731 int recent = s->cdlms[ich][ilms].recent; \
732 int range = 1 << s->bits_per_sample - 1; \
733 int order = s->cdlms[ich][ilms].order; \
734 int ##bits##_t *prev = (int##bits##_t *)s->cdlms[ich][ilms].lms_prevvalues; \
739 memcpy(prev + order, prev, (bits/8) * order); \
740 memcpy(s->cdlms[ich][ilms].lms_updates + order, \
741 s->cdlms[ich][ilms].lms_updates, \
742 sizeof(*s->cdlms[ich][ilms].lms_updates) * order); \
743 recent = order - 1; \
746 prev[recent] = av_clip(input, -range, range - 1); \
747 s->cdlms[ich][ilms].lms_updates[recent] = WMASIGN(input) * s->update_speed[ich]; \
749 s->cdlms[ich][ilms].lms_updates[recent + (order >> 4)] >>= 2; \
750 s->cdlms[ich][ilms].lms_updates[recent + (order >> 3)] >>= 1; \
751 s->cdlms[ich][ilms].recent = recent; \
752 memset(s->cdlms[ich][ilms].lms_updates + recent + order, 0, \
753 sizeof(s->cdlms[ich][ilms].lms_updates) - \
754 sizeof(*s->cdlms[ich][ilms].lms_updates)*(recent+order)); \
757 static void revert_cdlms ## bits (WmallDecodeCtx *s, int ch, \
758 int coef_begin, int coef_end) \
760 int icoef, pred, ilms, num_lms, residue, input; \
762 num_lms = s->cdlms_ttl[ch]; \
763 for (ilms = num_lms - 1; ilms >= 0; ilms--) { \
764 for (icoef = coef_begin; icoef < coef_end; icoef++) { \
765 int##bits##_t *prevvalues = (int##bits##_t *)s->cdlms[ch][ilms].lms_prevvalues; \
766 pred = (1 << s->cdlms[ch][ilms].scaling) >> 1; \
767 residue = s->channel_residues[ch][icoef]; \
768 pred += s->dsp.scalarproduct_and_madd_int## bits (s->cdlms[ch][ilms].coefs, \
769 prevvalues + s->cdlms[ch][ilms].recent, \
770 s->cdlms[ch][ilms].lms_updates + \
771 s->cdlms[ch][ilms].recent, \
772 FFALIGN(s->cdlms[ch][ilms].order, ROUND), \
774 input = residue + (pred >> s->cdlms[ch][ilms].scaling); \
775 lms_update ## bits(s, ch, ilms, input); \
776 s->channel_residues[ch][icoef] = input; \
779 if (bits <= 16) emms_c(); \
782 CD_LMS(16, WMALL_COEFF_PAD_SIZE)
785 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
787 if (s->num_channels != 2)
789 else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
791 for (icoef = 0; icoef < tile_size; icoef++) {
792 s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
793 s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
798 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
801 int16_t *filter_coeffs = s->acfilter_coeffs;
802 int scaling = s->acfilter_scaling;
803 int order = s->acfilter_order;
805 for (ich = 0; ich < s->num_channels; ich++) {
806 int *prevvalues = s->acfilter_prevvalues[ich];
807 for (i = 0; i < order; i++) {
809 for (j = 0; j < order; j++) {
811 pred += (uint32_t)filter_coeffs[j] * prevvalues[j - i];
813 pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
816 s->channel_residues[ich][i] += (unsigned)pred;
818 for (i = order; i < tile_size; i++) {
820 for (j = 0; j < order; j++)
821 pred += (uint32_t)s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
823 s->channel_residues[ich][i] += (unsigned)pred;
825 for (j = 0; j < order; j++)
826 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
830 static int decode_subframe(WmallDecodeCtx *s)
832 int offset = s->samples_per_frame;
833 int subframe_len = s->samples_per_frame;
834 int total_samples = s->samples_per_frame * s->num_channels;
835 int i, j, rawpcm_tile, padding_zeroes, res;
837 s->subframe_offset = get_bits_count(&s->gb);
839 /* reset channel context and find the next block offset and size
840 == the next block of the channel with the smallest number of
842 for (i = 0; i < s->num_channels; i++) {
843 if (offset > s->channel[i].decoded_samples) {
844 offset = s->channel[i].decoded_samples;
846 s->channel[i].subframe_len[s->channel[i].cur_subframe];
850 /* get a list of all channels that contain the estimated block */
851 s->channels_for_cur_subframe = 0;
852 for (i = 0; i < s->num_channels; i++) {
853 const int cur_subframe = s->channel[i].cur_subframe;
854 /* subtract already processed samples */
855 total_samples -= s->channel[i].decoded_samples;
857 /* and count if there are multiple subframes that match our profile */
858 if (offset == s->channel[i].decoded_samples &&
859 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
860 total_samples -= s->channel[i].subframe_len[cur_subframe];
861 s->channel[i].decoded_samples +=
862 s->channel[i].subframe_len[cur_subframe];
863 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
864 ++s->channels_for_cur_subframe;
868 /* check if the frame will be complete after processing the
871 s->parsed_all_subframes = 1;
874 s->seekable_tile = get_bits1(&s->gb);
875 if (s->seekable_tile) {
876 clear_codec_buffers(s);
878 s->do_arith_coding = get_bits1(&s->gb);
879 if (s->do_arith_coding) {
880 avpriv_request_sample(s->avctx, "Arithmetic coding");
881 return AVERROR_PATCHWELCOME;
883 s->do_ac_filter = get_bits1(&s->gb);
884 s->do_inter_ch_decorr = get_bits1(&s->gb);
885 s->do_mclms = get_bits1(&s->gb);
893 if ((res = decode_cdlms(s)) < 0)
895 s->movave_scaling = get_bits(&s->gb, 3);
896 s->quant_stepsize = get_bits(&s->gb, 8) + 1;
901 rawpcm_tile = get_bits1(&s->gb);
903 if (!rawpcm_tile && !s->cdlms[0][0].order) {
904 av_log(s->avctx, AV_LOG_DEBUG,
905 "Waiting for seekable tile\n");
906 av_frame_unref(s->frame);
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 avpriv_request_sample(s->avctx, "Expect wrong output since "
924 "inverse LPC filter");
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 ff_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_residues[i][j] = get_sbits_long(&s->gb, bits);
950 if (s->bits_per_sample < padding_zeroes)
951 return AVERROR_INVALIDDATA;
952 for (i = 0; i < s->num_channels; i++) {
953 if (s->is_channel_coded[i]) {
954 decode_channel_residues(s, i, subframe_len);
955 if (s->seekable_tile)
956 use_high_update_speed(s, i);
958 use_normal_update_speed(s, i);
959 if (s->bits_per_sample > 16)
960 revert_cdlms32(s, i, 0, subframe_len);
962 revert_cdlms16(s, i, 0, subframe_len);
964 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
969 revert_mclms(s, subframe_len);
970 if (s->do_inter_ch_decorr)
971 revert_inter_ch_decorr(s, subframe_len);
973 revert_acfilter(s, subframe_len);
976 if (s->quant_stepsize != 1)
977 for (i = 0; i < s->num_channels; i++)
978 for (j = 0; j < subframe_len; j++)
979 s->channel_residues[i][j] *= (unsigned)s->quant_stepsize;
982 /* Write to proper output buffer depending on bit-depth */
983 for (i = 0; i < s->channels_for_cur_subframe; i++) {
984 int c = s->channel_indexes_for_cur_subframe[i];
985 int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
987 for (j = 0; j < subframe_len; j++) {
988 if (s->bits_per_sample == 16) {
989 *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] * (1 << padding_zeroes);
991 *s->samples_32[c]++ = s->channel_residues[c][j] * (256 << padding_zeroes);
996 /* handled one subframe */
997 for (i = 0; i < s->channels_for_cur_subframe; i++) {
998 int c = s->channel_indexes_for_cur_subframe[i];
999 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1000 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1001 return AVERROR_INVALIDDATA;
1003 ++s->channel[c].cur_subframe;
1009 * @brief Decode one WMA frame.
1010 * @param s codec context
1011 * @return 0 if the trailer bit indicates that this is the last frame,
1012 * 1 if there are additional frames
1014 static int decode_frame(WmallDecodeCtx *s)
1016 GetBitContext* gb = &s->gb;
1017 int more_frames = 0, len = 0, i, ret;
1019 s->frame->nb_samples = s->samples_per_frame;
1020 if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1021 /* return an error if no frame could be decoded at all */
1023 s->frame->nb_samples = 0;
1026 for (i = 0; i < s->num_channels; i++) {
1027 s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1028 s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1031 /* get frame length */
1033 len = get_bits(gb, s->log2_frame_size);
1035 /* decode tile information */
1036 if ((ret = decode_tilehdr(s))) {
1038 av_frame_unref(s->frame);
1043 if (s->dynamic_range_compression)
1044 s->drc_gain = get_bits(gb, 8);
1046 /* no idea what these are for, might be the number of samples
1047 that need to be skipped at the beginning or end of a stream */
1048 if (get_bits1(gb)) {
1051 /* usually true for the first frame */
1052 if (get_bits1(gb)) {
1053 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1054 ff_dlog(s->avctx, "start skip: %i\n", skip);
1057 /* sometimes true for the last frame */
1058 if (get_bits1(gb)) {
1059 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1060 ff_dlog(s->avctx, "end skip: %i\n", skip);
1061 s->frame->nb_samples -= skip;
1062 if (s->frame->nb_samples <= 0)
1063 return AVERROR_INVALIDDATA;
1068 /* reset subframe states */
1069 s->parsed_all_subframes = 0;
1070 for (i = 0; i < s->num_channels; i++) {
1071 s->channel[i].decoded_samples = 0;
1072 s->channel[i].cur_subframe = 0;
1075 /* decode all subframes */
1076 while (!s->parsed_all_subframes) {
1077 int decoded_samples = s->channel[0].decoded_samples;
1078 if (decode_subframe(s) < 0) {
1080 if (s->frame->nb_samples)
1081 s->frame->nb_samples = decoded_samples;
1086 ff_dlog(s->avctx, "Frame done\n");
1090 if (s->len_prefix) {
1091 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1092 /* FIXME: not sure if this is always an error */
1093 av_log(s->avctx, AV_LOG_ERROR,
1094 "frame[%"PRIu32"] would have to skip %i bits\n",
1096 len - (get_bits_count(gb) - s->frame_offset) - 1);
1101 /* skip the rest of the frame data */
1102 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1105 /* decode trailer bit */
1106 more_frames = get_bits1(gb);
1112 * @brief Calculate remaining input buffer length.
1113 * @param s codec context
1114 * @param gb bitstream reader context
1115 * @return remaining size in bits
1117 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1119 return s->buf_bit_size - get_bits_count(gb);
1123 * @brief Fill the bit reservoir with a (partial) frame.
1124 * @param s codec context
1125 * @param gb bitstream reader context
1126 * @param len length of the partial frame
1127 * @param append decides whether to reset the buffer or not
1129 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1135 /* when the frame data does not need to be concatenated, the input buffer
1136 is reset and additional bits from the previous frame are copied
1137 and skipped later so that a fast byte copy is possible */
1140 s->frame_offset = get_bits_count(gb) & 7;
1141 s->num_saved_bits = s->frame_offset;
1142 init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1145 buflen = (s->num_saved_bits + len + 8) >> 3;
1147 if (len <= 0 || buflen > s->max_frame_size) {
1148 avpriv_request_sample(s->avctx, "Too small input buffer");
1150 s->num_saved_bits = 0;
1154 s->num_saved_bits += len;
1156 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1159 int align = 8 - (get_bits_count(gb) & 7);
1160 align = FFMIN(align, len);
1161 put_bits(&s->pb, align, get_bits(gb, align));
1163 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1165 skip_bits_long(gb, len);
1168 flush_put_bits(&tmp);
1170 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1171 skip_bits(&s->gb, s->frame_offset);
1174 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1177 WmallDecodeCtx *s = avctx->priv_data;
1178 GetBitContext* gb = &s->pgb;
1179 const uint8_t* buf = avpkt->data;
1180 int buf_size = avpkt->size;
1181 int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1183 s->frame->nb_samples = 0;
1185 if (!buf_size && s->num_saved_bits > get_bits_count(&s->gb)) {
1187 if (!decode_frame(s))
1188 s->num_saved_bits = 0;
1189 } else if (s->packet_done || s->packet_loss) {
1195 s->next_packet_start = buf_size - FFMIN(avctx->block_align, buf_size);
1196 buf_size = FFMIN(avctx->block_align, buf_size);
1197 s->buf_bit_size = buf_size << 3;
1199 /* parse packet header */
1200 init_get_bits(gb, buf, s->buf_bit_size);
1201 packet_sequence_number = get_bits(gb, 4);
1202 skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently unused
1203 spliced_packet = get_bits1(gb);
1205 avpriv_request_sample(avctx, "Bitstream splicing");
1207 /* get number of bits that need to be added to the previous frame */
1208 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1210 /* check for packet loss */
1211 if (!s->packet_loss &&
1212 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1214 av_log(avctx, AV_LOG_ERROR,
1215 "Packet loss detected! seq %"PRIx8" vs %x\n",
1216 s->packet_sequence_number, packet_sequence_number);
1218 s->packet_sequence_number = packet_sequence_number;
1220 if (num_bits_prev_frame > 0) {
1221 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1222 if (num_bits_prev_frame >= remaining_packet_bits) {
1223 num_bits_prev_frame = remaining_packet_bits;
1227 /* Append the previous frame data to the remaining data from the
1228 * previous packet to create a full frame. */
1229 save_bits(s, gb, num_bits_prev_frame, 1);
1231 /* decode the cross packet frame if it is valid */
1232 if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1234 } else if (s->num_saved_bits - s->frame_offset) {
1235 ff_dlog(avctx, "ignoring %x previously saved bits\n",
1236 s->num_saved_bits - s->frame_offset);
1239 if (s->packet_loss) {
1240 /* Reset number of saved bits so that the decoder does not start
1241 * to decode incomplete frames in the s->len_prefix == 0 case. */
1242 s->num_saved_bits = 0;
1244 init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1250 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1251 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1252 skip_bits(gb, s->packet_offset);
1254 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1255 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1256 frame_size <= remaining_bits(s, gb)) {
1257 save_bits(s, gb, frame_size, 0);
1259 if (!s->packet_loss)
1260 s->packet_done = !decode_frame(s);
1261 } else if (!s->len_prefix
1262 && s->num_saved_bits > get_bits_count(&s->gb)) {
1263 /* when the frames do not have a length prefix, we don't know the
1264 * compressed length of the individual frames however, we know what
1265 * part of a new packet belongs to the previous frame therefore we
1266 * save the incoming packet first, then we append the "previous
1267 * frame" data from the next packet so that we get a buffer that
1268 * only contains full frames */
1269 s->packet_done = !decode_frame(s);
1275 if (remaining_bits(s, gb) < 0) {
1276 av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb));
1280 if (s->packet_done && !s->packet_loss &&
1281 remaining_bits(s, gb) > 0) {
1282 /* save the rest of the data so that it can be decoded
1283 * with the next packet */
1284 save_bits(s, gb, remaining_bits(s, gb), 0);
1287 *got_frame_ptr = s->frame->nb_samples > 0;
1288 av_frame_move_ref(data, s->frame);
1290 s->packet_offset = get_bits_count(gb) & 7;
1292 return (s->packet_loss) ? AVERROR_INVALIDDATA : buf_size ? get_bits_count(gb) >> 3 : 0;
1295 static void flush(AVCodecContext *avctx)
1297 WmallDecodeCtx *s = avctx->priv_data;
1300 s->num_saved_bits = 0;
1301 s->frame_offset = 0;
1302 s->next_packet_start = 0;
1303 s->cdlms[0][0].order = 0;
1304 s->frame->nb_samples = 0;
1305 init_put_bits(&s->pb, s->frame_data, s->max_frame_size);
1308 static av_cold int decode_close(AVCodecContext *avctx)
1310 WmallDecodeCtx *s = avctx->priv_data;
1312 av_frame_free(&s->frame);
1313 av_freep(&s->frame_data);
1318 AVCodec ff_wmalossless_decoder = {
1319 .name = "wmalossless",
1320 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1321 .type = AVMEDIA_TYPE_AUDIO,
1322 .id = AV_CODEC_ID_WMALOSSLESS,
1323 .priv_data_size = sizeof(WmallDecodeCtx),
1324 .init = decode_init,
1325 .close = decode_close,
1326 .decode = decode_packet,
1328 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1329 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1330 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1332 AV_SAMPLE_FMT_NONE },