lavc: Use get_bitsz where needed
[libav.git] / libavcodec / wmalosslessdec.c
1 /*
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
7 *
8 * This file is part of Libav.
9 *
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.
14 *
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.
19 *
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
23 */
24
25 #include <inttypes.h>
26
27 #include "libavutil/attributes.h"
28 #include "libavutil/avassert.h"
29
30 #include "avcodec.h"
31 #include "internal.h"
32 #include "get_bits.h"
33 #include "put_bits.h"
34 #include "wma.h"
35 #include "wma_common.h"
36
37 /** current decoder limitations */
38 #define WMALL_MAX_CHANNELS 8 ///< max number of handled channels
39 #define MAX_SUBFRAMES 32 ///< max number of subframes per channel
40 #define MAX_BANDS 29 ///< max number of scale factor bands
41 #define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
42 #define MAX_ORDER 256
43
44 #define WMALL_BLOCK_MIN_BITS 6 ///< log2 of min block size
45 #define WMALL_BLOCK_MAX_BITS 14 ///< log2 of max block size
46 #define WMALL_BLOCK_MAX_SIZE (1 << WMALL_BLOCK_MAX_BITS) ///< maximum block size
47 #define WMALL_BLOCK_SIZES (WMALL_BLOCK_MAX_BITS - WMALL_BLOCK_MIN_BITS + 1) ///< possible block sizes
48
49
50 /**
51 * @brief frame-specific decoder context for a single channel
52 */
53 typedef struct WmallChannelCtx {
54 int16_t prev_block_len; ///< length of the previous block
55 uint8_t transmit_coefs;
56 uint8_t num_subframes;
57 uint16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
58 uint16_t subframe_offsets[MAX_SUBFRAMES]; ///< subframe positions in the current frame
59 uint8_t cur_subframe; ///< current subframe number
60 uint16_t decoded_samples; ///< number of already processed samples
61 int quant_step; ///< quantization step for the current subframe
62 int transient_counter; ///< number of transient samples from the beginning of the transient zone
63 } WmallChannelCtx;
64
65 /**
66 * @brief main decoder context
67 */
68 typedef struct WmallDecodeCtx {
69 /* generic decoder variables */
70 AVCodecContext *avctx;
71 AVFrame *frame;
72 uint8_t frame_data[MAX_FRAMESIZE + AV_INPUT_BUFFER_PADDING_SIZE]; ///< compressed frame data
73 PutBitContext pb; ///< context for filling the frame_data buffer
74
75 /* frame size dependent frame information (set during initialization) */
76 uint32_t decode_flags; ///< used compression features
77 int len_prefix; ///< frame is prefixed with its length
78 int dynamic_range_compression; ///< frame contains DRC data
79 uint8_t bits_per_sample; ///< integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
80 uint16_t samples_per_frame; ///< number of samples to output
81 uint16_t log2_frame_size;
82 int8_t num_channels; ///< number of channels in the stream (same as AVCodecContext.num_channels)
83 int8_t lfe_channel; ///< lfe channel index
84 uint8_t max_num_subframes;
85 uint8_t subframe_len_bits; ///< number of bits used for the subframe length
86 uint8_t max_subframe_len_bit; ///< flag indicating that the subframe is of maximum size when the first subframe length bit is 1
87 uint16_t min_samples_per_subframe;
88
89 /* packet decode state */
90 GetBitContext pgb; ///< bitstream reader context for the packet
91 int next_packet_start; ///< start offset of the next WMA packet in the demuxer packet
92 uint8_t packet_offset; ///< offset to the frame in the packet
93 uint8_t packet_sequence_number; ///< current packet number
94 int num_saved_bits; ///< saved number of bits
95 int frame_offset; ///< frame offset in the bit reservoir
96 int subframe_offset; ///< subframe offset in the bit reservoir
97 uint8_t packet_loss; ///< set in case of bitstream error
98 uint8_t packet_done; ///< set when a packet is fully decoded
99
100 /* frame decode state */
101 uint32_t frame_num; ///< current frame number (not used for decoding)
102 GetBitContext gb; ///< bitstream reader context
103 int buf_bit_size; ///< buffer size in bits
104 int16_t *samples_16[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (16-bit)
105 int32_t *samples_32[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (24-bit)
106 uint8_t drc_gain; ///< gain for the DRC tool
107 int8_t skip_frame; ///< skip output step
108 int8_t parsed_all_subframes; ///< all subframes decoded?
109
110 /* subframe/block decode state */
111 int16_t subframe_len; ///< current subframe length
112 int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe
113 int8_t channel_indexes_for_cur_subframe[WMALL_MAX_CHANNELS];
114
115 WmallChannelCtx channel[WMALL_MAX_CHANNELS]; ///< per channel data
116
117 // WMA Lossless-specific
118
119 uint8_t do_arith_coding;
120 uint8_t do_ac_filter;
121 uint8_t do_inter_ch_decorr;
122 uint8_t do_mclms;
123 uint8_t do_lpc;
124
125 int8_t acfilter_order;
126 int8_t acfilter_scaling;
127 int64_t acfilter_coeffs[16];
128 int acfilter_prevvalues[2][16];
129
130 int8_t mclms_order;
131 int8_t mclms_scaling;
132 int16_t mclms_coeffs[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS * 32];
133 int16_t mclms_coeffs_cur[WMALL_MAX_CHANNELS * WMALL_MAX_CHANNELS];
134 int16_t mclms_prevvalues[WMALL_MAX_CHANNELS * 2 * 32];
135 int16_t mclms_updates[WMALL_MAX_CHANNELS * 2 * 32];
136 int mclms_recent;
137
138 int movave_scaling;
139 int quant_stepsize;
140
141 struct {
142 int order;
143 int scaling;
144 int coefsend;
145 int bitsend;
146 int16_t coefs[MAX_ORDER];
147 int16_t lms_prevvalues[MAX_ORDER * 2];
148 int16_t lms_updates[MAX_ORDER * 2];
149 int recent;
150 } cdlms[2][9];
151
152 int cdlms_ttl[2];
153
154 int bV3RTM;
155
156 int is_channel_coded[2];
157 int update_speed[2];
158
159 int transient[2];
160 int transient_pos[2];
161 int seekable_tile;
162
163 int ave_sum[2];
164
165 int channel_residues[2][WMALL_BLOCK_MAX_SIZE];
166
167 int lpc_coefs[2][40];
168 int lpc_order;
169 int lpc_scaling;
170 int lpc_intbits;
171
172 int channel_coeffs[2][WMALL_BLOCK_MAX_SIZE];
173 } WmallDecodeCtx;
174
175
176 static av_cold int decode_init(AVCodecContext *avctx)
177 {
178 WmallDecodeCtx *s = avctx->priv_data;
179 uint8_t *edata_ptr = avctx->extradata;
180 unsigned int channel_mask;
181 int i, log2_max_num_subframes;
182
183 s->avctx = avctx;
184 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
185
186 if (avctx->extradata_size >= 18) {
187 s->decode_flags = AV_RL16(edata_ptr + 14);
188 channel_mask = AV_RL32(edata_ptr + 2);
189 s->bits_per_sample = AV_RL16(edata_ptr);
190 if (s->bits_per_sample == 16)
191 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
192 else if (s->bits_per_sample == 24) {
193 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
194 avpriv_report_missing_feature(avctx, "Bit-depth higher than 16");
195 return AVERROR_PATCHWELCOME;
196 } else {
197 av_log(avctx, AV_LOG_ERROR, "Unknown bit-depth: %"PRIu8"\n",
198 s->bits_per_sample);
199 return AVERROR_INVALIDDATA;
200 }
201 /* dump the extradata */
202 for (i = 0; i < avctx->extradata_size; i++)
203 ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
204 ff_dlog(avctx, "\n");
205
206 } else {
207 avpriv_request_sample(avctx, "Unsupported extradata size");
208 return AVERROR_PATCHWELCOME;
209 }
210
211 /* generic init */
212 s->log2_frame_size = av_log2(avctx->block_align) + 4;
213
214 /* frame info */
215 s->skip_frame = 1; /* skip first frame */
216 s->packet_loss = 1;
217 s->len_prefix = s->decode_flags & 0x40;
218
219 /* get frame len */
220 s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
221 3, s->decode_flags);
222 av_assert0(s->samples_per_frame <= WMALL_BLOCK_MAX_SIZE);
223
224 /* init previous block len */
225 for (i = 0; i < avctx->channels; i++)
226 s->channel[i].prev_block_len = s->samples_per_frame;
227
228 /* subframe info */
229 log2_max_num_subframes = (s->decode_flags & 0x38) >> 3;
230 s->max_num_subframes = 1 << log2_max_num_subframes;
231 s->max_subframe_len_bit = 0;
232 s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
233
234 s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
235 s->dynamic_range_compression = s->decode_flags & 0x80;
236 s->bV3RTM = s->decode_flags & 0x100;
237
238 if (s->max_num_subframes > MAX_SUBFRAMES) {
239 av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %"PRIu8"\n",
240 s->max_num_subframes);
241 return AVERROR_INVALIDDATA;
242 }
243
244 s->num_channels = avctx->channels;
245
246 /* extract lfe channel position */
247 s->lfe_channel = -1;
248
249 if (channel_mask & 8) {
250 unsigned int mask;
251 for (mask = 1; mask < 16; mask <<= 1)
252 if (channel_mask & mask)
253 ++s->lfe_channel;
254 }
255
256 if (s->num_channels < 0) {
257 av_log(avctx, AV_LOG_ERROR, "invalid number of channels %"PRId8"\n",
258 s->num_channels);
259 return AVERROR_INVALIDDATA;
260 } else if (s->num_channels > WMALL_MAX_CHANNELS) {
261 avpriv_request_sample(avctx,
262 "More than %d channels", WMALL_MAX_CHANNELS);
263 return AVERROR_PATCHWELCOME;
264 }
265
266 s->frame = av_frame_alloc();
267 if (!s->frame)
268 return AVERROR(ENOMEM);
269
270 avctx->channel_layout = channel_mask;
271 return 0;
272 }
273
274 /**
275 * @brief Decode the subframe length.
276 * @param s context
277 * @param offset sample offset in the frame
278 * @return decoded subframe length on success, < 0 in case of an error
279 */
280 static int decode_subframe_length(WmallDecodeCtx *s, int offset)
281 {
282 int frame_len_ratio, subframe_len, len;
283
284 /* no need to read from the bitstream when only one length is possible */
285 if (offset == s->samples_per_frame - s->min_samples_per_subframe)
286 return s->min_samples_per_subframe;
287
288 len = av_log2(s->max_num_subframes - 1) + 1;
289 frame_len_ratio = get_bits(&s->gb, len);
290 subframe_len = s->min_samples_per_subframe * (frame_len_ratio + 1);
291
292 /* sanity check the length */
293 if (subframe_len < s->min_samples_per_subframe ||
294 subframe_len > s->samples_per_frame) {
295 av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
296 subframe_len);
297 return AVERROR_INVALIDDATA;
298 }
299 return subframe_len;
300 }
301
302 /**
303 * @brief Decode how the data in the frame is split into subframes.
304 * Every WMA frame contains the encoded data for a fixed number of
305 * samples per channel. The data for every channel might be split
306 * into several subframes. This function will reconstruct the list of
307 * subframes for every channel.
308 *
309 * If the subframes are not evenly split, the algorithm estimates the
310 * channels with the lowest number of total samples.
311 * Afterwards, for each of these channels a bit is read from the
312 * bitstream that indicates if the channel contains a subframe with the
313 * next subframe size that is going to be read from the bitstream or not.
314 * If a channel contains such a subframe, the subframe size gets added to
315 * the channel's subframe list.
316 * The algorithm repeats these steps until the frame is properly divided
317 * between the individual channels.
318 *
319 * @param s context
320 * @return 0 on success, < 0 in case of an error
321 */
322 static int decode_tilehdr(WmallDecodeCtx *s)
323 {
324 uint16_t num_samples[WMALL_MAX_CHANNELS] = { 0 }; /* sum of samples for all currently known subframes of a channel */
325 uint8_t contains_subframe[WMALL_MAX_CHANNELS]; /* flag indicating if a channel contains the current subframe */
326 int channels_for_cur_subframe = s->num_channels; /* number of channels that contain the current subframe */
327 int fixed_channel_layout = 0; /* flag indicating that all channels use the same subfra2me offsets and sizes */
328 int min_channel_len = 0; /* smallest sum of samples (channels with this length will be processed first) */
329 int c, tile_aligned;
330
331 /* reset tiling information */
332 for (c = 0; c < s->num_channels; c++)
333 s->channel[c].num_subframes = 0;
334
335 tile_aligned = get_bits1(&s->gb);
336 if (s->max_num_subframes == 1 || tile_aligned)
337 fixed_channel_layout = 1;
338
339 /* loop until the frame data is split between the subframes */
340 do {
341 int subframe_len, in_use = 0;
342
343 /* check which channels contain the subframe */
344 for (c = 0; c < s->num_channels; c++) {
345 if (num_samples[c] == min_channel_len) {
346 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
347 (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
348 contains_subframe[c] = in_use = 1;
349 } else {
350 if (get_bits1(&s->gb))
351 contains_subframe[c] = in_use = 1;
352 }
353 } else
354 contains_subframe[c] = 0;
355 }
356
357 if (!in_use) {
358 av_log(s->avctx, AV_LOG_ERROR,
359 "Found empty subframe\n");
360 return AVERROR_INVALIDDATA;
361 }
362
363 /* get subframe length, subframe_len == 0 is not allowed */
364 if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
365 return AVERROR_INVALIDDATA;
366 /* add subframes to the individual channels and find new min_channel_len */
367 min_channel_len += subframe_len;
368 for (c = 0; c < s->num_channels; c++) {
369 WmallChannelCtx *chan = &s->channel[c];
370
371 if (contains_subframe[c]) {
372 if (chan->num_subframes >= MAX_SUBFRAMES) {
373 av_log(s->avctx, AV_LOG_ERROR,
374 "broken frame: num subframes > 31\n");
375 return AVERROR_INVALIDDATA;
376 }
377 chan->subframe_len[chan->num_subframes] = subframe_len;
378 num_samples[c] += subframe_len;
379 ++chan->num_subframes;
380 if (num_samples[c] > s->samples_per_frame) {
381 av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
382 "channel len(%"PRIu16") > samples_per_frame(%"PRIu16")\n",
383 num_samples[c], s->samples_per_frame);
384 return AVERROR_INVALIDDATA;
385 }
386 } else if (num_samples[c] <= min_channel_len) {
387 if (num_samples[c] < min_channel_len) {
388 channels_for_cur_subframe = 0;
389 min_channel_len = num_samples[c];
390 }
391 ++channels_for_cur_subframe;
392 }
393 }
394 } while (min_channel_len < s->samples_per_frame);
395
396 for (c = 0; c < s->num_channels; c++) {
397 int i, offset = 0;
398 for (i = 0; i < s->channel[c].num_subframes; i++) {
399 s->channel[c].subframe_offsets[i] = offset;
400 offset += s->channel[c].subframe_len[i];
401 }
402 }
403
404 return 0;
405 }
406
407 static void decode_ac_filter(WmallDecodeCtx *s)
408 {
409 int i;
410 s->acfilter_order = get_bits(&s->gb, 4) + 1;
411 s->acfilter_scaling = get_bits(&s->gb, 4);
412
413 for (i = 0; i < s->acfilter_order; i++)
414 s->acfilter_coeffs[i] = get_bitsz(&s->gb, s->acfilter_scaling) + 1;
415 }
416
417 static void decode_mclms(WmallDecodeCtx *s)
418 {
419 s->mclms_order = (get_bits(&s->gb, 4) + 1) * 2;
420 s->mclms_scaling = get_bits(&s->gb, 4);
421 if (get_bits1(&s->gb)) {
422 int i, send_coef_bits;
423 int cbits = av_log2(s->mclms_scaling + 1);
424 if (1 << cbits < s->mclms_scaling + 1)
425 cbits++;
426
427 send_coef_bits = get_bitsz(&s->gb, cbits) + 2;
428
429 for (i = 0; i < s->mclms_order * s->num_channels * s->num_channels; i++)
430 s->mclms_coeffs[i] = get_bits(&s->gb, send_coef_bits);
431
432 for (i = 0; i < s->num_channels; i++) {
433 int c;
434 for (c = 0; c < i; c++)
435 s->mclms_coeffs_cur[i * s->num_channels + c] = get_bits(&s->gb, send_coef_bits);
436 }
437 }
438 }
439
440 static int decode_cdlms(WmallDecodeCtx *s)
441 {
442 int c, i;
443 int cdlms_send_coef = get_bits1(&s->gb);
444
445 for (c = 0; c < s->num_channels; c++) {
446 s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
447 for (i = 0; i < s->cdlms_ttl[c]; i++) {
448 s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
449 if (s->cdlms[c][i].order > MAX_ORDER) {
450 av_log(s->avctx, AV_LOG_ERROR,
451 "Order[%d][%d] %d > max (%d), not supported\n",
452 c, i, s->cdlms[c][i].order, MAX_ORDER);
453 s->cdlms[0][0].order = 0;
454 return AVERROR_INVALIDDATA;
455 }
456 }
457
458 for (i = 0; i < s->cdlms_ttl[c]; i++)
459 s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
460
461 if (cdlms_send_coef) {
462 for (i = 0; i < s->cdlms_ttl[c]; i++) {
463 int cbits, shift_l, shift_r, j;
464 cbits = av_log2(s->cdlms[c][i].order);
465 if ((1 << cbits) < s->cdlms[c][i].order)
466 cbits++;
467 s->cdlms[c][i].coefsend = get_bits(&s->gb, cbits) + 1;
468
469 cbits = av_log2(s->cdlms[c][i].scaling + 1);
470 if ((1 << cbits) < s->cdlms[c][i].scaling + 1)
471 cbits++;
472
473 s->cdlms[c][i].bitsend = get_bitsz(&s->gb, cbits) + 2;
474 shift_l = 32 - s->cdlms[c][i].bitsend;
475 shift_r = 32 - s->cdlms[c][i].scaling - 2;
476 for (j = 0; j < s->cdlms[c][i].coefsend; j++)
477 s->cdlms[c][i].coefs[j] =
478 (get_bits(&s->gb, s->cdlms[c][i].bitsend) << shift_l) >> shift_r;
479 }
480 }
481 }
482
483 return 0;
484 }
485
486 static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
487 {
488 int i = 0;
489 unsigned int ave_mean;
490 s->transient[ch] = get_bits1(&s->gb);
491 if (s->transient[ch]) {
492 s->transient_pos[ch] = get_bits(&s->gb, av_log2(tile_size));
493 if (s->transient_pos[ch])
494 s->transient[ch] = 0;
495 s->channel[ch].transient_counter =
496 FFMAX(s->channel[ch].transient_counter, s->samples_per_frame / 2);
497 } else if (s->channel[ch].transient_counter)
498 s->transient[ch] = 1;
499
500 if (s->seekable_tile) {
501 ave_mean = get_bits(&s->gb, s->bits_per_sample);
502 s->ave_sum[ch] = ave_mean << (s->movave_scaling + 1);
503 }
504
505 if (s->seekable_tile) {
506 if (s->do_inter_ch_decorr)
507 s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample + 1);
508 else
509 s->channel_residues[ch][0] = get_sbits(&s->gb, s->bits_per_sample);
510 i++;
511 }
512 for (; i < tile_size; i++) {
513 int quo = 0, rem, rem_bits, residue;
514 while(get_bits1(&s->gb)) {
515 quo++;
516 if (get_bits_left(&s->gb) <= 0)
517 return -1;
518 }
519 if (quo >= 32)
520 quo += get_bits_long(&s->gb, get_bits(&s->gb, 5) + 1);
521
522 ave_mean = (s->ave_sum[ch] + (1 << s->movave_scaling)) >> (s->movave_scaling + 1);
523 if (ave_mean <= 1)
524 residue = quo;
525 else {
526 rem_bits = av_ceil_log2(ave_mean);
527 rem = rem_bits ? get_bits_long(&s->gb, rem_bits) : 0;
528 residue = (quo << rem_bits) + rem;
529 }
530
531 s->ave_sum[ch] = residue + s->ave_sum[ch] -
532 (s->ave_sum[ch] >> s->movave_scaling);
533
534 if (residue & 1)
535 residue = -(residue >> 1) - 1;
536 else
537 residue = residue >> 1;
538 s->channel_residues[ch][i] = residue;
539 }
540
541 return 0;
542
543 }
544
545 static void decode_lpc(WmallDecodeCtx *s)
546 {
547 int ch, i, cbits;
548 s->lpc_order = get_bits(&s->gb, 5) + 1;
549 s->lpc_scaling = get_bits(&s->gb, 4);
550 s->lpc_intbits = get_bits(&s->gb, 3) + 1;
551 cbits = s->lpc_scaling + s->lpc_intbits;
552 for (ch = 0; ch < s->num_channels; ch++)
553 for (i = 0; i < s->lpc_order; i++)
554 s->lpc_coefs[ch][i] = get_sbits(&s->gb, cbits);
555 }
556
557 static void clear_codec_buffers(WmallDecodeCtx *s)
558 {
559 int ich, ilms;
560
561 memset(s->acfilter_coeffs, 0, sizeof(s->acfilter_coeffs));
562 memset(s->acfilter_prevvalues, 0, sizeof(s->acfilter_prevvalues));
563 memset(s->lpc_coefs, 0, sizeof(s->lpc_coefs));
564
565 memset(s->mclms_coeffs, 0, sizeof(s->mclms_coeffs));
566 memset(s->mclms_coeffs_cur, 0, sizeof(s->mclms_coeffs_cur));
567 memset(s->mclms_prevvalues, 0, sizeof(s->mclms_prevvalues));
568 memset(s->mclms_updates, 0, sizeof(s->mclms_updates));
569
570 for (ich = 0; ich < s->num_channels; ich++) {
571 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) {
572 memset(s->cdlms[ich][ilms].coefs, 0,
573 sizeof(s->cdlms[ich][ilms].coefs));
574 memset(s->cdlms[ich][ilms].lms_prevvalues, 0,
575 sizeof(s->cdlms[ich][ilms].lms_prevvalues));
576 memset(s->cdlms[ich][ilms].lms_updates, 0,
577 sizeof(s->cdlms[ich][ilms].lms_updates));
578 }
579 s->ave_sum[ich] = 0;
580 }
581 }
582
583 /**
584 * @brief Reset filter parameters and transient area at new seekable tile.
585 */
586 static void reset_codec(WmallDecodeCtx *s)
587 {
588 int ich, ilms;
589 s->mclms_recent = s->mclms_order * s->num_channels;
590 for (ich = 0; ich < s->num_channels; ich++) {
591 for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++)
592 s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order;
593 /* first sample of a seekable subframe is considered as the starting of
594 a transient area which is samples_per_frame samples long */
595 s->channel[ich].transient_counter = s->samples_per_frame;
596 s->transient[ich] = 1;
597 s->transient_pos[ich] = 0;
598 }
599 }
600
601 static void mclms_update(WmallDecodeCtx *s, int icoef, int *pred)
602 {
603 int i, j, ich, pred_error;
604 int order = s->mclms_order;
605 int num_channels = s->num_channels;
606 int range = 1 << (s->bits_per_sample - 1);
607
608 for (ich = 0; ich < num_channels; ich++) {
609 pred_error = s->channel_residues[ich][icoef] - pred[ich];
610 if (pred_error > 0) {
611 for (i = 0; i < order * num_channels; i++)
612 s->mclms_coeffs[i + ich * order * num_channels] +=
613 s->mclms_updates[s->mclms_recent + i];
614 for (j = 0; j < ich; j++) {
615 if (s->channel_residues[j][icoef] > 0)
616 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
617 else if (s->channel_residues[j][icoef] < 0)
618 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
619 }
620 } else if (pred_error < 0) {
621 for (i = 0; i < order * num_channels; i++)
622 s->mclms_coeffs[i + ich * order * num_channels] -=
623 s->mclms_updates[s->mclms_recent + i];
624 for (j = 0; j < ich; j++) {
625 if (s->channel_residues[j][icoef] > 0)
626 s->mclms_coeffs_cur[ich * num_channels + j] -= 1;
627 else if (s->channel_residues[j][icoef] < 0)
628 s->mclms_coeffs_cur[ich * num_channels + j] += 1;
629 }
630 }
631 }
632
633 for (ich = num_channels - 1; ich >= 0; ich--) {
634 s->mclms_recent--;
635 s->mclms_prevvalues[s->mclms_recent] = s->channel_residues[ich][icoef];
636 if (s->channel_residues[ich][icoef] > range - 1)
637 s->mclms_prevvalues[s->mclms_recent] = range - 1;
638 else if (s->channel_residues[ich][icoef] < -range)
639 s->mclms_prevvalues[s->mclms_recent] = -range;
640
641 s->mclms_updates[s->mclms_recent] = 0;
642 if (s->channel_residues[ich][icoef] > 0)
643 s->mclms_updates[s->mclms_recent] = 1;
644 else if (s->channel_residues[ich][icoef] < 0)
645 s->mclms_updates[s->mclms_recent] = -1;
646 }
647
648 if (s->mclms_recent == 0) {
649 memcpy(&s->mclms_prevvalues[order * num_channels],
650 s->mclms_prevvalues,
651 2 * order * num_channels);
652 memcpy(&s->mclms_updates[order * num_channels],
653 s->mclms_updates,
654 2 * order * num_channels);
655 s->mclms_recent = num_channels * order;
656 }
657 }
658
659 static void mclms_predict(WmallDecodeCtx *s, int icoef, int *pred)
660 {
661 int ich, i;
662 int order = s->mclms_order;
663 int num_channels = s->num_channels;
664
665 for (ich = 0; ich < num_channels; ich++) {
666 pred[ich] = 0;
667 if (!s->is_channel_coded[ich])
668 continue;
669 for (i = 0; i < order * num_channels; i++)
670 pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
671 s->mclms_coeffs[i + order * num_channels * ich];
672 for (i = 0; i < ich; i++)
673 pred[ich] += s->channel_residues[i][icoef] *
674 s->mclms_coeffs_cur[i + num_channels * ich];
675 pred[ich] += 1 << s->mclms_scaling - 1;
676 pred[ich] >>= s->mclms_scaling;
677 s->channel_residues[ich][icoef] += pred[ich];
678 }
679 }
680
681 static void revert_mclms(WmallDecodeCtx *s, int tile_size)
682 {
683 int icoef, pred[WMALL_MAX_CHANNELS] = { 0 };
684 for (icoef = 0; icoef < tile_size; icoef++) {
685 mclms_predict(s, icoef, pred);
686 mclms_update(s, icoef, pred);
687 }
688 }
689
690 static int lms_predict(WmallDecodeCtx *s, int ich, int ilms)
691 {
692 int pred = 0, icoef;
693 int recent = s->cdlms[ich][ilms].recent;
694
695 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
696 pred += s->cdlms[ich][ilms].coefs[icoef] *
697 s->cdlms[ich][ilms].lms_prevvalues[icoef + recent];
698
699 return pred;
700 }
701
702 static void lms_update(WmallDecodeCtx *s, int ich, int ilms,
703 int input, int residue)
704 {
705 int icoef;
706 int recent = s->cdlms[ich][ilms].recent;
707 int range = 1 << s->bits_per_sample - 1;
708
709 if (residue < 0) {
710 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
711 s->cdlms[ich][ilms].coefs[icoef] -=
712 s->cdlms[ich][ilms].lms_updates[icoef + recent];
713 } else if (residue > 0) {
714 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
715 s->cdlms[ich][ilms].coefs[icoef] +=
716 s->cdlms[ich][ilms].lms_updates[icoef + recent];
717 }
718
719 if (recent)
720 recent--;
721 else {
722 memcpy(&s->cdlms[ich][ilms].lms_prevvalues[s->cdlms[ich][ilms].order],
723 s->cdlms[ich][ilms].lms_prevvalues,
724 2 * s->cdlms[ich][ilms].order);
725 memcpy(&s->cdlms[ich][ilms].lms_updates[s->cdlms[ich][ilms].order],
726 s->cdlms[ich][ilms].lms_updates,
727 2 * s->cdlms[ich][ilms].order);
728 recent = s->cdlms[ich][ilms].order - 1;
729 }
730
731 s->cdlms[ich][ilms].lms_prevvalues[recent] = av_clip(input, -range, range - 1);
732 if (!input)
733 s->cdlms[ich][ilms].lms_updates[recent] = 0;
734 else if (input < 0)
735 s->cdlms[ich][ilms].lms_updates[recent] = -s->update_speed[ich];
736 else
737 s->cdlms[ich][ilms].lms_updates[recent] = s->update_speed[ich];
738
739 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 4)] >>= 2;
740 s->cdlms[ich][ilms].lms_updates[recent + (s->cdlms[ich][ilms].order >> 3)] >>= 1;
741 s->cdlms[ich][ilms].recent = recent;
742 }
743
744 static void use_high_update_speed(WmallDecodeCtx *s, int ich)
745 {
746 int ilms, recent, icoef;
747 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
748 recent = s->cdlms[ich][ilms].recent;
749 if (s->update_speed[ich] == 16)
750 continue;
751 if (s->bV3RTM) {
752 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
753 s->cdlms[ich][ilms].lms_updates[icoef + recent] *= 2;
754 } else {
755 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
756 s->cdlms[ich][ilms].lms_updates[icoef] *= 2;
757 }
758 }
759 s->update_speed[ich] = 16;
760 }
761
762 static void use_normal_update_speed(WmallDecodeCtx *s, int ich)
763 {
764 int ilms, recent, icoef;
765 for (ilms = s->cdlms_ttl[ich] - 1; ilms >= 0; ilms--) {
766 recent = s->cdlms[ich][ilms].recent;
767 if (s->update_speed[ich] == 8)
768 continue;
769 if (s->bV3RTM)
770 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
771 s->cdlms[ich][ilms].lms_updates[icoef + recent] /= 2;
772 else
773 for (icoef = 0; icoef < s->cdlms[ich][ilms].order; icoef++)
774 s->cdlms[ich][ilms].lms_updates[icoef] /= 2;
775 }
776 s->update_speed[ich] = 8;
777 }
778
779 static void revert_cdlms(WmallDecodeCtx *s, int ch,
780 int coef_begin, int coef_end)
781 {
782 int icoef, pred, ilms, num_lms, residue, input;
783
784 num_lms = s->cdlms_ttl[ch];
785 for (ilms = num_lms - 1; ilms >= 0; ilms--) {
786 for (icoef = coef_begin; icoef < coef_end; icoef++) {
787 pred = 1 << (s->cdlms[ch][ilms].scaling - 1);
788 residue = s->channel_residues[ch][icoef];
789 pred += lms_predict(s, ch, ilms);
790 input = residue + (pred >> s->cdlms[ch][ilms].scaling);
791 lms_update(s, ch, ilms, input, residue);
792 s->channel_residues[ch][icoef] = input;
793 }
794 }
795 }
796
797 static void revert_inter_ch_decorr(WmallDecodeCtx *s, int tile_size)
798 {
799 if (s->num_channels != 2)
800 return;
801 else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
802 int icoef;
803 for (icoef = 0; icoef < tile_size; icoef++) {
804 s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
805 s->channel_residues[1][icoef] += s->channel_residues[0][icoef];
806 }
807 }
808 }
809
810 static void revert_acfilter(WmallDecodeCtx *s, int tile_size)
811 {
812 int ich, pred, i, j;
813 int64_t *filter_coeffs = s->acfilter_coeffs;
814 int scaling = s->acfilter_scaling;
815 int order = s->acfilter_order;
816
817 for (ich = 0; ich < s->num_channels; ich++) {
818 int *prevvalues = s->acfilter_prevvalues[ich];
819 for (i = 0; i < order; i++) {
820 pred = 0;
821 for (j = 0; j < order; j++) {
822 if (i <= j)
823 pred += filter_coeffs[j] * prevvalues[j - i];
824 else
825 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
826 }
827 pred >>= scaling;
828 s->channel_residues[ich][i] += pred;
829 }
830 for (i = order; i < tile_size; i++) {
831 pred = 0;
832 for (j = 0; j < order; j++)
833 pred += s->channel_residues[ich][i - j - 1] * filter_coeffs[j];
834 pred >>= scaling;
835 s->channel_residues[ich][i] += pred;
836 }
837 for (j = 0; j < order; j++)
838 prevvalues[j] = s->channel_residues[ich][tile_size - j - 1];
839 }
840 }
841
842 static int decode_subframe(WmallDecodeCtx *s)
843 {
844 int offset = s->samples_per_frame;
845 int subframe_len = s->samples_per_frame;
846 int total_samples = s->samples_per_frame * s->num_channels;
847 int i, j, rawpcm_tile, padding_zeroes, res;
848
849 s->subframe_offset = get_bits_count(&s->gb);
850
851 /* reset channel context and find the next block offset and size
852 == the next block of the channel with the smallest number of
853 decoded samples */
854 for (i = 0; i < s->num_channels; i++) {
855 if (offset > s->channel[i].decoded_samples) {
856 offset = s->channel[i].decoded_samples;
857 subframe_len =
858 s->channel[i].subframe_len[s->channel[i].cur_subframe];
859 }
860 }
861
862 /* get a list of all channels that contain the estimated block */
863 s->channels_for_cur_subframe = 0;
864 for (i = 0; i < s->num_channels; i++) {
865 const int cur_subframe = s->channel[i].cur_subframe;
866 /* subtract already processed samples */
867 total_samples -= s->channel[i].decoded_samples;
868
869 /* and count if there are multiple subframes that match our profile */
870 if (offset == s->channel[i].decoded_samples &&
871 subframe_len == s->channel[i].subframe_len[cur_subframe]) {
872 total_samples -= s->channel[i].subframe_len[cur_subframe];
873 s->channel[i].decoded_samples +=
874 s->channel[i].subframe_len[cur_subframe];
875 s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
876 ++s->channels_for_cur_subframe;
877 }
878 }
879
880 /* check if the frame will be complete after processing the
881 estimated block */
882 if (!total_samples)
883 s->parsed_all_subframes = 1;
884
885
886 s->seekable_tile = get_bits1(&s->gb);
887 if (s->seekable_tile) {
888 clear_codec_buffers(s);
889
890 s->do_arith_coding = get_bits1(&s->gb);
891 if (s->do_arith_coding) {
892 avpriv_request_sample(s->avctx, "Arithmetic coding");
893 return AVERROR_PATCHWELCOME;
894 }
895 s->do_ac_filter = get_bits1(&s->gb);
896 s->do_inter_ch_decorr = get_bits1(&s->gb);
897 s->do_mclms = get_bits1(&s->gb);
898
899 if (s->do_ac_filter)
900 decode_ac_filter(s);
901
902 if (s->do_mclms)
903 decode_mclms(s);
904
905 if ((res = decode_cdlms(s)) < 0)
906 return res;
907 s->movave_scaling = get_bits(&s->gb, 3);
908 s->quant_stepsize = get_bits(&s->gb, 8) + 1;
909
910 reset_codec(s);
911 } else if (!s->cdlms[0][0].order) {
912 av_log(s->avctx, AV_LOG_DEBUG,
913 "Waiting for seekable tile\n");
914 av_frame_unref(s->frame);
915 return -1;
916 }
917
918 rawpcm_tile = get_bits1(&s->gb);
919
920 for (i = 0; i < s->num_channels; i++)
921 s->is_channel_coded[i] = 1;
922
923 if (!rawpcm_tile) {
924 for (i = 0; i < s->num_channels; i++)
925 s->is_channel_coded[i] = get_bits1(&s->gb);
926
927 if (s->bV3RTM) {
928 // LPC
929 s->do_lpc = get_bits1(&s->gb);
930 if (s->do_lpc) {
931 decode_lpc(s);
932 avpriv_request_sample(s->avctx, "Expect wrong output since "
933 "inverse LPC filter");
934 }
935 } else
936 s->do_lpc = 0;
937 }
938
939
940 if (get_bits1(&s->gb))
941 padding_zeroes = get_bits(&s->gb, 5);
942 else
943 padding_zeroes = 0;
944
945 if (rawpcm_tile) {
946 int bits = s->bits_per_sample - padding_zeroes;
947 if (bits <= 0) {
948 av_log(s->avctx, AV_LOG_ERROR,
949 "Invalid number of padding bits in raw PCM tile\n");
950 return AVERROR_INVALIDDATA;
951 }
952 ff_dlog(s->avctx, "RAWPCM %d bits per sample. "
953 "total %d bits, remain=%d\n", bits,
954 bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
955 for (i = 0; i < s->num_channels; i++)
956 for (j = 0; j < subframe_len; j++)
957 s->channel_coeffs[i][j] = get_sbits(&s->gb, bits);
958 } else {
959 for (i = 0; i < s->num_channels; i++)
960 if (s->is_channel_coded[i]) {
961 decode_channel_residues(s, i, subframe_len);
962 if (s->seekable_tile)
963 use_high_update_speed(s, i);
964 else
965 use_normal_update_speed(s, i);
966 revert_cdlms(s, i, 0, subframe_len);
967 } else {
968 memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
969 }
970 }
971 if (s->do_mclms)
972 revert_mclms(s, subframe_len);
973 if (s->do_inter_ch_decorr)
974 revert_inter_ch_decorr(s, subframe_len);
975 if (s->do_ac_filter)
976 revert_acfilter(s, subframe_len);
977
978 /* Dequantize */
979 if (s->quant_stepsize != 1)
980 for (i = 0; i < s->num_channels; i++)
981 for (j = 0; j < subframe_len; j++)
982 s->channel_residues[i][j] *= s->quant_stepsize;
983
984 /* Write to proper output buffer depending on bit-depth */
985 for (i = 0; i < s->channels_for_cur_subframe; i++) {
986 int c = s->channel_indexes_for_cur_subframe[i];
987 int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
988
989 for (j = 0; j < subframe_len; j++) {
990 if (s->bits_per_sample == 16) {
991 *s->samples_16[c]++ = (int16_t) s->channel_residues[c][j] << padding_zeroes;
992 } else {
993 *s->samples_32[c]++ = s->channel_residues[c][j] << padding_zeroes;
994 }
995 }
996 }
997
998 /* handled one subframe */
999 for (i = 0; i < s->channels_for_cur_subframe; i++) {
1000 int c = s->channel_indexes_for_cur_subframe[i];
1001 if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
1002 av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
1003 return AVERROR_INVALIDDATA;
1004 }
1005 ++s->channel[c].cur_subframe;
1006 }
1007 return 0;
1008 }
1009
1010 /**
1011 * @brief Decode one WMA frame.
1012 * @param s codec context
1013 * @return 0 if the trailer bit indicates that this is the last frame,
1014 * 1 if there are additional frames
1015 */
1016 static int decode_frame(WmallDecodeCtx *s)
1017 {
1018 GetBitContext* gb = &s->gb;
1019 int more_frames = 0, len = 0, i, ret;
1020
1021 s->frame->nb_samples = s->samples_per_frame;
1022 if ((ret = ff_get_buffer(s->avctx, s->frame, 0)) < 0) {
1023 /* return an error if no frame could be decoded at all */
1024 av_log(s->avctx, AV_LOG_ERROR,
1025 "not enough space for the output samples\n");
1026 s->packet_loss = 1;
1027 return ret;
1028 }
1029 for (i = 0; i < s->num_channels; i++) {
1030 s->samples_16[i] = (int16_t *)s->frame->extended_data[i];
1031 s->samples_32[i] = (int32_t *)s->frame->extended_data[i];
1032 }
1033
1034 /* get frame length */
1035 if (s->len_prefix)
1036 len = get_bits(gb, s->log2_frame_size);
1037
1038 /* decode tile information */
1039 if (decode_tilehdr(s)) {
1040 s->packet_loss = 1;
1041 return 0;
1042 }
1043
1044 /* read drc info */
1045 if (s->dynamic_range_compression)
1046 s->drc_gain = get_bits(gb, 8);
1047
1048 /* no idea what these are for, might be the number of samples
1049 that need to be skipped at the beginning or end of a stream */
1050 if (get_bits1(gb)) {
1051 int av_unused skip;
1052
1053 /* usually true for the first frame */
1054 if (get_bits1(gb)) {
1055 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1056 ff_dlog(s->avctx, "start skip: %i\n", skip);
1057 }
1058
1059 /* sometimes true for the last frame */
1060 if (get_bits1(gb)) {
1061 skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1062 ff_dlog(s->avctx, "end skip: %i\n", skip);
1063 }
1064
1065 }
1066
1067 /* reset subframe states */
1068 s->parsed_all_subframes = 0;
1069 for (i = 0; i < s->num_channels; i++) {
1070 s->channel[i].decoded_samples = 0;
1071 s->channel[i].cur_subframe = 0;
1072 }
1073
1074 /* decode all subframes */
1075 while (!s->parsed_all_subframes) {
1076 if (decode_subframe(s) < 0) {
1077 s->packet_loss = 1;
1078 return 0;
1079 }
1080 }
1081
1082 ff_dlog(s->avctx, "Frame done\n");
1083
1084 if (s->skip_frame)
1085 s->skip_frame = 0;
1086
1087 if (s->len_prefix) {
1088 if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
1089 /* FIXME: not sure if this is always an error */
1090 av_log(s->avctx, AV_LOG_ERROR,
1091 "frame[%"PRIu32"] would have to skip %i bits\n",
1092 s->frame_num,
1093 len - (get_bits_count(gb) - s->frame_offset) - 1);
1094 s->packet_loss = 1;
1095 return 0;
1096 }
1097
1098 /* skip the rest of the frame data */
1099 skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
1100 }
1101
1102 /* decode trailer bit */
1103 more_frames = get_bits1(gb);
1104 ++s->frame_num;
1105 return more_frames;
1106 }
1107
1108 /**
1109 * @brief Calculate remaining input buffer length.
1110 * @param s codec context
1111 * @param gb bitstream reader context
1112 * @return remaining size in bits
1113 */
1114 static int remaining_bits(WmallDecodeCtx *s, GetBitContext *gb)
1115 {
1116 return s->buf_bit_size - get_bits_count(gb);
1117 }
1118
1119 /**
1120 * @brief Fill the bit reservoir with a (partial) frame.
1121 * @param s codec context
1122 * @param gb bitstream reader context
1123 * @param len length of the partial frame
1124 * @param append decides whether to reset the buffer or not
1125 */
1126 static void save_bits(WmallDecodeCtx *s, GetBitContext* gb, int len,
1127 int append)
1128 {
1129 int buflen;
1130 PutBitContext tmp;
1131
1132 /* when the frame data does not need to be concatenated, the input buffer
1133 is reset and additional bits from the previous frame are copied
1134 and skipped later so that a fast byte copy is possible */
1135
1136 if (!append) {
1137 s->frame_offset = get_bits_count(gb) & 7;
1138 s->num_saved_bits = s->frame_offset;
1139 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1140 }
1141
1142 buflen = (s->num_saved_bits + len + 8) >> 3;
1143
1144 if (len <= 0 || buflen > MAX_FRAMESIZE) {
1145 avpriv_request_sample(s->avctx, "Too small input buffer");
1146 s->packet_loss = 1;
1147 return;
1148 }
1149
1150 s->num_saved_bits += len;
1151 if (!append) {
1152 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
1153 s->num_saved_bits);
1154 } else {
1155 int align = 8 - (get_bits_count(gb) & 7);
1156 align = FFMIN(align, len);
1157 put_bits(&s->pb, align, get_bits(gb, align));
1158 len -= align;
1159 avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
1160 }
1161 skip_bits_long(gb, len);
1162
1163 tmp = s->pb;
1164 flush_put_bits(&tmp);
1165
1166 init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
1167 skip_bits(&s->gb, s->frame_offset);
1168 }
1169
1170 static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
1171 AVPacket* avpkt)
1172 {
1173 WmallDecodeCtx *s = avctx->priv_data;
1174 GetBitContext* gb = &s->pgb;
1175 const uint8_t* buf = avpkt->data;
1176 int buf_size = avpkt->size;
1177 int num_bits_prev_frame, packet_sequence_number, spliced_packet;
1178
1179 s->frame->nb_samples = 0;
1180
1181 if (s->packet_done || s->packet_loss) {
1182 s->packet_done = 0;
1183
1184 /* sanity check for the buffer length */
1185 if (buf_size < avctx->block_align)
1186 return 0;
1187
1188 s->next_packet_start = buf_size - avctx->block_align;
1189 buf_size = avctx->block_align;
1190 s->buf_bit_size = buf_size << 3;
1191
1192 /* parse packet header */
1193 init_get_bits(gb, buf, s->buf_bit_size);
1194 packet_sequence_number = get_bits(gb, 4);
1195 skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently ununused
1196 spliced_packet = get_bits1(gb);
1197 if (spliced_packet)
1198 avpriv_request_sample(avctx, "Bitstream splicing");
1199
1200 /* get number of bits that need to be added to the previous frame */
1201 num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1202
1203 /* check for packet loss */
1204 if (!s->packet_loss &&
1205 ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
1206 s->packet_loss = 1;
1207 av_log(avctx, AV_LOG_ERROR,
1208 "Packet loss detected! seq %"PRIx8" vs %x\n",
1209 s->packet_sequence_number, packet_sequence_number);
1210 }
1211 s->packet_sequence_number = packet_sequence_number;
1212
1213 if (num_bits_prev_frame > 0) {
1214 int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
1215 if (num_bits_prev_frame >= remaining_packet_bits) {
1216 num_bits_prev_frame = remaining_packet_bits;
1217 s->packet_done = 1;
1218 }
1219
1220 /* Append the previous frame data to the remaining data from the
1221 * previous packet to create a full frame. */
1222 save_bits(s, gb, num_bits_prev_frame, 1);
1223
1224 /* decode the cross packet frame if it is valid */
1225 if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
1226 decode_frame(s);
1227 } else if (s->num_saved_bits - s->frame_offset) {
1228 ff_dlog(avctx, "ignoring %x previously saved bits\n",
1229 s->num_saved_bits - s->frame_offset);
1230 }
1231
1232 if (s->packet_loss) {
1233 /* Reset number of saved bits so that the decoder does not start
1234 * to decode incomplete frames in the s->len_prefix == 0 case. */
1235 s->num_saved_bits = 0;
1236 s->packet_loss = 0;
1237 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1238 }
1239
1240 } else {
1241 int frame_size;
1242
1243 s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
1244 init_get_bits(gb, avpkt->data, s->buf_bit_size);
1245 skip_bits(gb, s->packet_offset);
1246
1247 if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
1248 (frame_size = show_bits(gb, s->log2_frame_size)) &&
1249 frame_size <= remaining_bits(s, gb)) {
1250 save_bits(s, gb, frame_size, 0);
1251 s->packet_done = !decode_frame(s);
1252 } else if (!s->len_prefix
1253 && s->num_saved_bits > get_bits_count(&s->gb)) {
1254 /* when the frames do not have a length prefix, we don't know the
1255 * compressed length of the individual frames however, we know what
1256 * part of a new packet belongs to the previous frame therefore we
1257 * save the incoming packet first, then we append the "previous
1258 * frame" data from the next packet so that we get a buffer that
1259 * only contains full frames */
1260 s->packet_done = !decode_frame(s);
1261 } else {
1262 s->packet_done = 1;
1263 }
1264 }
1265
1266 if (s->packet_done && !s->packet_loss &&
1267 remaining_bits(s, gb) > 0) {
1268 /* save the rest of the data so that it can be decoded
1269 * with the next packet */
1270 save_bits(s, gb, remaining_bits(s, gb), 0);
1271 }
1272
1273 *got_frame_ptr = s->frame->nb_samples > 0;
1274 av_frame_move_ref(data, s->frame);
1275
1276 s->packet_offset = get_bits_count(gb) & 7;
1277
1278 return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
1279 }
1280
1281 static void flush(AVCodecContext *avctx)
1282 {
1283 WmallDecodeCtx *s = avctx->priv_data;
1284 s->packet_loss = 1;
1285 s->packet_done = 0;
1286 s->num_saved_bits = 0;
1287 s->frame_offset = 0;
1288 s->next_packet_start = 0;
1289 s->cdlms[0][0].order = 0;
1290 s->frame->nb_samples = 0;
1291 init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
1292 }
1293
1294 static av_cold int decode_close(AVCodecContext *avctx)
1295 {
1296 WmallDecodeCtx *s = avctx->priv_data;
1297
1298 av_frame_free(&s->frame);
1299
1300 return 0;
1301 }
1302
1303 AVCodec ff_wmalossless_decoder = {
1304 .name = "wmalossless",
1305 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
1306 .type = AVMEDIA_TYPE_AUDIO,
1307 .id = AV_CODEC_ID_WMALOSSLESS,
1308 .priv_data_size = sizeof(WmallDecodeCtx),
1309 .init = decode_init,
1310 .close = decode_close,
1311 .decode = decode_packet,
1312 .flush = flush,
1313 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1314 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
1315 AV_SAMPLE_FMT_S32P,
1316 AV_SAMPLE_FMT_NONE },
1317 };