2 * WavPack lossless audio decoder
3 * Copyright (c) 2006,2011 Konstantin Shishkov
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #define BITSTREAM_READER_LE
24 #include "libavutil/channel_layout.h"
32 * WavPack lossless audio decoder
35 #define WV_MONO 0x00000004
36 #define WV_JOINT_STEREO 0x00000010
37 #define WV_FALSE_STEREO 0x40000000
39 #define WV_HYBRID_MODE 0x00000008
40 #define WV_HYBRID_SHAPE 0x00000008
41 #define WV_HYBRID_BITRATE 0x00000200
42 #define WV_HYBRID_BALANCE 0x00000400
44 #define WV_FLT_SHIFT_ONES 0x01
45 #define WV_FLT_SHIFT_SAME 0x02
46 #define WV_FLT_SHIFT_SENT 0x04
47 #define WV_FLT_ZERO_SENT 0x08
48 #define WV_FLT_ZERO_SIGN 0x10
50 #define WV_MAX_SAMPLES 131072
76 typedef struct SavedContext {
85 typedef struct Decorr {
94 typedef struct WvChannel {
96 int slow_level, error_limit;
97 int bitrate_acc, bitrate_delta;
100 typedef struct WavpackFrameContext {
101 AVCodecContext *avctx;
103 int stereo, stereo_in;
108 uint32_t crc_extra_bits;
109 GetBitContext gb_extra_bits;
110 int data_size; // in bits
113 Decorr decorr[MAX_TERMS];
114 int zero, one, zeroes;
118 int hybrid, hybrid_bitrate;
119 int hybrid_maxclip, hybrid_minclip;
125 SavedContext sc, extra_sc;
126 } WavpackFrameContext;
128 #define WV_MAX_FRAME_DECODERS 14
130 typedef struct WavpackContext {
131 AVCodecContext *avctx;
133 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
143 // exponent table copied from WavPack source
144 static const uint8_t wp_exp2_table [256] = {
145 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
146 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
147 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
148 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
149 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
150 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
151 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
152 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
153 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
154 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
155 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
156 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
157 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
158 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
159 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
160 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
163 static const uint8_t wp_log2_table [] = {
164 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
165 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
166 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
167 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
168 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
169 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
170 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
171 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
172 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
173 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
174 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
175 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
176 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
177 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
178 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
179 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
182 static av_always_inline int wp_exp2(int16_t val)
191 res = wp_exp2_table[val & 0xFF] | 0x100;
193 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
194 return neg ? -res : res;
197 static av_always_inline int wp_log2(int32_t val)
206 bits = av_log2(val) + 1;
208 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
210 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
213 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
215 // macros for manipulating median values
216 #define GET_MED(n) ((c->median[n] >> 4) + 1)
217 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
218 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
220 // macros for applying weight
221 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
222 if (samples && in) { \
223 if ((samples ^ in) < 0) { \
225 if (weight < -1024) \
235 static av_always_inline int get_tail(GetBitContext *gb, int k)
242 e = (1 << (p + 1)) - k - 1;
243 res = p ? get_bits(gb, p) : 0;
245 res = (res << 1) - e + get_bits1(gb);
249 static void update_error_limit(WavpackFrameContext *ctx)
253 for (i = 0; i <= ctx->stereo_in; i++) {
254 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
255 br[i] = ctx->ch[i].bitrate_acc >> 16;
256 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
258 if (ctx->stereo_in && ctx->hybrid_bitrate) {
259 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
260 if (balance > br[0]) {
263 } else if (-balance > br[0]) {
267 br[1] = br[0] + balance;
268 br[0] = br[0] - balance;
271 for (i = 0; i <= ctx->stereo_in; i++) {
272 if (ctx->hybrid_bitrate) {
273 if (sl[i] - br[i] > -0x100)
274 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
276 ctx->ch[i].error_limit = 0;
278 ctx->ch[i].error_limit = wp_exp2(br[i]);
283 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
284 int channel, int *last)
287 int sign, base, add, ret;
288 WvChannel *c = &ctx->ch[channel];
292 if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
293 !ctx->zero && !ctx->one) {
297 c->slow_level -= LEVEL_DECAY(c->slow_level);
301 t = get_unary_0_33(gb);
303 if (get_bits_left(gb) < t - 1)
305 t = get_bits(gb, t - 1) | (1 << (t-1));
307 if (get_bits_left(gb) < 0)
312 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
313 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
314 c->slow_level -= LEVEL_DECAY(c->slow_level);
324 t = get_unary_0_33(gb);
325 if (get_bits_left(gb) < 0)
328 t2 = get_unary_0_33(gb);
330 if (get_bits_left(gb) < 0)
334 if (get_bits_left(gb) < t2 - 1)
336 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
347 ctx->zero = !ctx->one;
350 if (ctx->hybrid && !channel)
351 update_error_limit(ctx);
355 add = GET_MED(0) - 1;
359 add = GET_MED(1) - 1;
363 base = GET_MED(0) + GET_MED(1);
364 add = GET_MED(2) - 1;
369 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
370 add = GET_MED(2) - 1;
375 if (!c->error_limit) {
376 ret = base + get_tail(gb, add);
377 if (get_bits_left(gb) <= 0)
380 int mid = (base * 2 + add + 1) >> 1;
381 while (add > c->error_limit) {
382 if (get_bits_left(gb) <= 0)
388 add = mid - base - 1;
389 mid = (base * 2 + add + 1) >> 1;
393 sign = get_bits1(gb);
394 if (ctx->hybrid_bitrate)
395 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
396 return sign ? ~ret : ret;
403 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
411 if (s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
412 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
413 *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
417 bit = (S & s->and) | s->or;
418 bit = ((S + bit) << s->shift) - bit;
421 bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
423 return bit << s->post_shift;
426 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
434 int exp = s->float_max_exp;
436 if (s->got_extra_bits) {
437 const int max_bits = 1 + 23 + 8 + 1;
438 const int left_bits = get_bits_left(&s->gb_extra_bits);
440 if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
445 S <<= s->float_shift;
449 if (S >= 0x1000000) {
450 if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
451 S = get_bits(&s->gb_extra_bits, 23);
456 int shift = 23 - av_log2(S);
457 exp = s->float_max_exp;
464 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
465 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) &&
466 get_bits1(&s->gb_extra_bits))) {
467 S |= (1 << shift) - 1;
468 } else if (s->got_extra_bits &&
469 (s->float_flag & WV_FLT_SHIFT_SENT)) {
470 S |= get_bits(&s->gb_extra_bits, shift);
474 exp = s->float_max_exp;
480 if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
481 if (get_bits1(&s->gb_extra_bits)) {
482 S = get_bits(&s->gb_extra_bits, 23);
483 if (s->float_max_exp >= 25)
484 exp = get_bits(&s->gb_extra_bits, 8);
485 sign = get_bits1(&s->gb_extra_bits);
487 if (s->float_flag & WV_FLT_ZERO_SIGN)
488 sign = get_bits1(&s->gb_extra_bits);
493 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
495 value.u = (sign << 31) | (exp << 23) | S;
499 static void wv_reset_saved_context(WavpackFrameContext *s)
502 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
505 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
506 uint32_t crc_extra_bits)
509 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
510 return AVERROR_INVALIDDATA;
512 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
513 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
514 return AVERROR_INVALIDDATA;
520 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
521 void *dst, const int type)
525 int A, B, L, L2, R, R2;
527 uint32_t crc = s->sc.crc;
528 uint32_t crc_extra_bits = s->extra_sc.crc;
529 int16_t *dst16 = dst;
530 int32_t *dst32 = dst;
532 const int channel_pad = s->avctx->channels - 2;
534 s->one = s->zero = s->zeroes = 0;
536 L = wv_get_value(s, gb, 0, &last);
539 R = wv_get_value(s, gb, 1, &last);
542 for (i = 0; i < s->terms; i++) {
543 t = s->decorr[i].value;
547 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
548 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
550 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
551 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
553 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
554 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
557 A = s->decorr[i].samplesA[pos];
558 B = s->decorr[i].samplesB[pos];
561 if (type != AV_SAMPLE_FMT_S16) {
562 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
563 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
565 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
566 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
568 if (A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
569 if (B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
570 s->decorr[i].samplesA[j] = L = L2;
571 s->decorr[i].samplesB[j] = R = R2;
572 } else if (t == -1) {
573 if (type != AV_SAMPLE_FMT_S16)
574 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
576 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
577 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
579 if (type != AV_SAMPLE_FMT_S16)
580 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
582 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
583 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
585 s->decorr[i].samplesA[0] = R;
587 if (type != AV_SAMPLE_FMT_S16)
588 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
590 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
591 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
595 R2 = s->decorr[i].samplesA[0];
596 s->decorr[i].samplesA[0] = R;
599 if (type != AV_SAMPLE_FMT_S16)
600 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
602 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
603 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
605 s->decorr[i].samplesB[0] = L;
610 L += (R -= (L >> 1));
611 crc = (crc * 3 + L) * 3 + R;
613 if (type == AV_SAMPLE_FMT_FLT) {
614 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
615 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
616 dstfl += channel_pad;
617 } else if (type == AV_SAMPLE_FMT_S32) {
618 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
619 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
620 dst32 += channel_pad;
622 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
623 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
624 dst16 += channel_pad;
627 } while (!last && count < s->samples);
629 wv_reset_saved_context(s);
630 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
631 wv_check_crc(s, crc, crc_extra_bits))
632 return AVERROR_INVALIDDATA;
637 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
638 void *dst, const int type)
644 uint32_t crc = s->sc.crc;
645 uint32_t crc_extra_bits = s->extra_sc.crc;
646 int16_t *dst16 = dst;
647 int32_t *dst32 = dst;
649 const int channel_stride = s->avctx->channels;
651 s->one = s->zero = s->zeroes = 0;
653 T = wv_get_value(s, gb, 0, &last);
657 for (i = 0; i < s->terms; i++) {
658 t = s->decorr[i].value;
661 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
663 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
664 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
667 A = s->decorr[i].samplesA[pos];
670 if (type != AV_SAMPLE_FMT_S16)
671 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
673 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
675 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
676 s->decorr[i].samplesA[j] = T = S;
681 if (type == AV_SAMPLE_FMT_FLT) {
682 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
683 dstfl += channel_stride;
684 } else if (type == AV_SAMPLE_FMT_S32) {
685 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
686 dst32 += channel_stride;
688 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
689 dst16 += channel_stride;
692 } while (!last && count < s->samples);
694 wv_reset_saved_context(s);
695 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
696 wv_check_crc(s, crc, crc_extra_bits))
697 return AVERROR_INVALIDDATA;
702 static av_cold int wv_alloc_frame_context(WavpackContext *c)
705 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
708 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
709 if (!c->fdec[c->fdec_num])
712 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
713 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
718 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
720 WavpackContext *s = avctx->priv_data;
723 if (avctx->bits_per_coded_sample <= 16)
724 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
726 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
727 if (avctx->channels <= 2 && !avctx->channel_layout)
728 avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO :
731 s->multichannel = avctx->channels > 2;
732 /* lavf demuxer does not provide extradata, Matroska stores 0x403
733 there, use this to detect decoding mode for multichannel */
735 if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
736 int ver = AV_RL16(avctx->extradata);
737 if (ver >= 0x402 && ver <= 0x410)
746 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
748 WavpackContext *s = avctx->priv_data;
751 for (i = 0; i < s->fdec_num; i++)
752 av_freep(&s->fdec[i]);
758 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
759 void *data, int *got_frame_ptr,
760 const uint8_t *buf, int buf_size)
762 WavpackContext *wc = avctx->priv_data;
763 WavpackFrameContext *s;
764 void *samples = data;
766 int got_terms = 0, got_weights = 0, got_samples = 0,
767 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
768 const uint8_t *orig_buf = buf;
769 const uint8_t *buf_end = buf + buf_size;
770 int i, j, id, size, ssize, weights, t;
771 int bpp, chan, chmask, orig_bpp;
778 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
779 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
783 s = wc->fdec[block_no];
785 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
789 if (wc->ch_offset >= avctx->channels) {
790 av_log(avctx, AV_LOG_ERROR, "too many channels\n");
794 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
795 memset(s->ch, 0, sizeof(s->ch));
797 s->and = s->or = s->shift = 0;
798 s->got_extra_bits = 0;
801 s->samples = AV_RL32(buf); buf += 4;
806 if (s->samples > wc->samples) {
807 av_log(avctx, AV_LOG_ERROR, "too many samples in block");
811 s->samples = wc->samples;
813 s->frame_flags = AV_RL32(buf); buf += 4;
814 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
815 samples = (uint8_t*)samples + bpp * wc->ch_offset;
816 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
818 s->stereo = !(s->frame_flags & WV_MONO);
819 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
820 s->joint = s->frame_flags & WV_JOINT_STEREO;
821 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
822 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
823 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
824 s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1);
825 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
826 s->CRC = AV_RL32(buf); buf += 4;
828 buf += 4; //skip block size;
830 wc->ch_offset += 1 + s->stereo;
832 // parse metadata blocks
833 while (buf < buf_end) {
836 if (id & WP_IDF_LONG) {
837 size |= (*buf++) << 8;
838 size |= (*buf++) << 16;
840 size <<= 1; // size is specified in words
845 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
848 if (buf + ssize > buf_end) {
849 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
852 if (id & WP_IDF_IGNORE) {
856 switch (id & WP_IDF_MASK) {
858 if (size > MAX_TERMS) {
859 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
865 for (i = 0; i < s->terms; i++) {
866 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
867 s->decorr[s->terms - i - 1].delta = *buf >> 5;
872 case WP_ID_DECWEIGHTS:
874 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
877 weights = size >> s->stereo_in;
878 if (weights > MAX_TERMS || weights > s->terms) {
879 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
883 for (i = 0; i < weights; i++) {
884 t = (int8_t)(*buf++);
885 s->decorr[s->terms - i - 1].weightA = t << 3;
886 if (s->decorr[s->terms - i - 1].weightA > 0)
887 s->decorr[s->terms - i - 1].weightA +=
888 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
890 t = (int8_t)(*buf++);
891 s->decorr[s->terms - i - 1].weightB = t << 3;
892 if (s->decorr[s->terms - i - 1].weightB > 0)
893 s->decorr[s->terms - i - 1].weightB +=
894 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
899 case WP_ID_DECSAMPLES:
901 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
905 for (i = s->terms - 1; (i >= 0) && (t < size) && buf <= buf_end; i--) {
906 if (s->decorr[i].value > 8) {
907 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
908 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
910 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
911 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
915 } else if (s->decorr[i].value < 0) {
916 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
917 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
920 for (j = 0; j < s->decorr[i].value && buf+1<buf_end; j++) {
921 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
923 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
926 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
932 if (size != 6 * (s->stereo_in + 1)) {
933 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
934 "got %i", 6 * (s->stereo_in + 1), size);
938 for (j = 0; j <= s->stereo_in; j++) {
939 for (i = 0; i < 3; i++) {
940 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
947 if (s->hybrid_bitrate) {
948 for (i = 0; i <= s->stereo_in; i++) {
949 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
954 for (i = 0; i < (s->stereo_in + 1); i++) {
955 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
960 for (i = 0; i < (s->stereo_in + 1); i++) {
961 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
965 for (i = 0; i < (s->stereo_in + 1); i++)
966 s->ch[i].bitrate_delta = 0;
970 case WP_ID_INT32INFO:
972 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
977 s->extra_bits = buf[0];
987 /* original WavPack decoder forces 32-bit lossy sound to be treated
988 * as 24-bit one in order to have proper clipping
990 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
993 s->hybrid_maxclip >>= 8;
994 s->hybrid_minclip >>= 8;
998 case WP_ID_FLOATINFO:
1000 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
1004 s->float_flag = buf[0];
1005 s->float_shift = buf[1];
1006 s->float_max_exp = buf[2];
1011 s->sc.offset = buf - orig_buf;
1012 s->sc.size = size * 8;
1013 init_get_bits(&s->gb, buf, size * 8);
1014 s->data_size = size * 8;
1018 case WP_ID_EXTRABITS:
1020 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1025 s->extra_sc.offset = buf - orig_buf;
1026 s->extra_sc.size = size * 8;
1027 init_get_bits(&s->gb_extra_bits, buf, size * 8);
1028 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1030 s->got_extra_bits = 1;
1032 case WP_ID_CHANINFO:
1034 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1039 case 0: chmask = *buf; break;
1040 case 1: chmask = AV_RL16(buf); break;
1041 case 2: chmask = AV_RL24(buf); break;
1042 case 3: chmask = AV_RL32(buf); break;
1044 chan |= (buf[1] & 0xF) << 8;
1045 chmask = AV_RL24(buf + 2);
1048 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1050 chan = avctx->channels;
1051 chmask = avctx->channel_layout;
1053 if (chan != avctx->channels) {
1054 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1055 "decoder believes it's %d channels\n", chan,
1059 if (!avctx->channel_layout)
1060 avctx->channel_layout = chmask;
1066 if (id & WP_IDF_ODD)
1071 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1075 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1079 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1083 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1086 if (s->hybrid && !got_hybrid) {
1087 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1091 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1094 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1095 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1098 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1099 const int size = get_bits_left(&s->gb_extra_bits);
1100 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1101 if (size < wanted) {
1102 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1103 s->got_extra_bits = 0;
1108 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1109 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1110 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1111 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1113 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1115 if (samplecount < 0)
1120 const int channel_stride = avctx->channels;
1122 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1123 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1124 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1125 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1127 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1129 if (samplecount < 0)
1132 if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1133 int16_t *dst = (int16_t*)samples + 1;
1134 int16_t *src = (int16_t*)samples;
1135 int cnt = samplecount;
1138 src += channel_stride;
1139 dst += channel_stride;
1141 } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1142 int32_t *dst = (int32_t*)samples + 1;
1143 int32_t *src = (int32_t*)samples;
1144 int cnt = samplecount;
1147 src += channel_stride;
1148 dst += channel_stride;
1150 } else if (s->stereo) {
1151 float *dst = (float*)samples + 1;
1152 float *src = (float*)samples;
1153 int cnt = samplecount;
1156 src += channel_stride;
1157 dst += channel_stride;
1164 return samplecount * bpp;
1167 static void wavpack_decode_flush(AVCodecContext *avctx)
1169 WavpackContext *s = avctx->priv_data;
1172 for (i = 0; i < s->fdec_num; i++)
1173 wv_reset_saved_context(s->fdec[i]);
1176 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1177 int *got_frame_ptr, AVPacket *avpkt)
1179 WavpackContext *s = avctx->priv_data;
1180 const uint8_t *buf = avpkt->data;
1181 int buf_size = avpkt->size;
1182 AVFrame *frame = data;
1183 int frame_size, ret, frame_flags;
1184 int samplecount = 0;
1189 /* determine number of samples */
1191 s->samples = AV_RL32(buf); buf += 4;
1192 frame_flags = AV_RL32(buf);
1194 if (s->multichannel) {
1195 s->samples = AV_RL32(buf + 4);
1196 frame_flags = AV_RL32(buf + 8);
1198 s->samples = AV_RL32(buf);
1199 frame_flags = AV_RL32(buf + 4);
1202 if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1203 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1205 return AVERROR(EINVAL);
1208 if (frame_flags & 0x80) {
1209 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1210 } else if ((frame_flags & 0x03) <= 1) {
1211 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1213 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1214 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1217 /* get output buffer */
1218 frame->nb_samples = s->samples + 1;
1219 if ((ret = ff_get_buffer(avctx, frame)) < 0) {
1220 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1223 frame->nb_samples = s->samples;
1225 while (buf_size > 0) {
1226 if (!s->multichannel) {
1227 frame_size = buf_size;
1230 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1232 if (buf_size < 12) //MKV files can have zero flags after last block
1234 frame_size = AV_RL32(buf + 8) + 12;
1237 if (frame_size < 0 || frame_size > buf_size) {
1238 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1239 "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1240 wavpack_decode_flush(avctx);
1241 return AVERROR_INVALIDDATA;
1243 if ((samplecount = wavpack_decode_block(avctx, s->block,
1244 frame->data[0], got_frame_ptr,
1245 buf, frame_size)) < 0) {
1246 wavpack_decode_flush(avctx);
1247 return AVERROR_INVALIDDATA;
1250 buf += frame_size; buf_size -= frame_size;
1256 AVCodec ff_wavpack_decoder = {
1258 .type = AVMEDIA_TYPE_AUDIO,
1259 .id = AV_CODEC_ID_WAVPACK,
1260 .priv_data_size = sizeof(WavpackContext),
1261 .init = wavpack_decode_init,
1262 .close = wavpack_decode_end,
1263 .decode = wavpack_decode_frame,
1264 .flush = wavpack_decode_flush,
1265 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1266 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),