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