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"
31 * WavPack lossless audio decoder
34 #define WV_MONO 0x00000004
35 #define WV_JOINT_STEREO 0x00000010
36 #define WV_FALSE_STEREO 0x40000000
38 #define WV_HYBRID_MODE 0x00000008
39 #define WV_HYBRID_SHAPE 0x00000008
40 #define WV_HYBRID_BITRATE 0x00000200
41 #define WV_HYBRID_BALANCE 0x00000400
43 #define WV_FLT_SHIFT_ONES 0x01
44 #define WV_FLT_SHIFT_SAME 0x02
45 #define WV_FLT_SHIFT_SENT 0x04
46 #define WV_FLT_ZERO_SENT 0x08
47 #define WV_FLT_ZERO_SIGN 0x10
49 #define WV_MAX_SAMPLES 131072
75 typedef struct SavedContext {
84 typedef struct Decorr {
93 typedef struct WvChannel {
95 int slow_level, error_limit;
96 int bitrate_acc, bitrate_delta;
99 typedef struct WavpackFrameContext {
100 AVCodecContext *avctx;
102 int stereo, stereo_in;
107 uint32_t crc_extra_bits;
108 GetBitContext gb_extra_bits;
109 int data_size; // in bits
112 Decorr decorr[MAX_TERMS];
113 int zero, one, zeroes;
117 int hybrid, hybrid_bitrate;
118 int hybrid_maxclip, hybrid_minclip;
124 SavedContext sc, extra_sc;
125 } WavpackFrameContext;
127 #define WV_MAX_FRAME_DECODERS 14
129 typedef struct WavpackContext {
130 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)
743 avcodec_get_frame_defaults(&s->frame);
744 avctx->coded_frame = &s->frame;
749 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
751 WavpackContext *s = avctx->priv_data;
754 for (i = 0; i < s->fdec_num; i++)
755 av_freep(&s->fdec[i]);
761 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
762 void *data, int *got_frame_ptr,
763 const uint8_t *buf, int buf_size)
765 WavpackContext *wc = avctx->priv_data;
766 WavpackFrameContext *s;
767 void *samples = data;
769 int got_terms = 0, got_weights = 0, got_samples = 0,
770 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
771 const uint8_t *orig_buf = buf;
772 const uint8_t *buf_end = buf + buf_size;
773 int i, j, id, size, ssize, weights, t;
774 int bpp, chan, chmask, orig_bpp;
781 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
782 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
786 s = wc->fdec[block_no];
788 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
792 if (wc->ch_offset >= avctx->channels) {
793 av_log(avctx, AV_LOG_ERROR, "too many channels\n");
797 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
798 memset(s->ch, 0, sizeof(s->ch));
800 s->and = s->or = s->shift = 0;
801 s->got_extra_bits = 0;
804 s->samples = AV_RL32(buf); buf += 4;
809 if (s->samples > wc->samples) {
810 av_log(avctx, AV_LOG_ERROR, "too many samples in block");
814 s->samples = wc->samples;
816 s->frame_flags = AV_RL32(buf); buf += 4;
817 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
818 samples = (uint8_t*)samples + bpp * wc->ch_offset;
819 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
821 s->stereo = !(s->frame_flags & WV_MONO);
822 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
823 s->joint = s->frame_flags & WV_JOINT_STEREO;
824 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
825 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
826 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
827 s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1);
828 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
829 s->CRC = AV_RL32(buf); buf += 4;
831 buf += 4; //skip block size;
833 wc->ch_offset += 1 + s->stereo;
835 // parse metadata blocks
836 while (buf < buf_end) {
839 if (id & WP_IDF_LONG) {
840 size |= (*buf++) << 8;
841 size |= (*buf++) << 16;
843 size <<= 1; // size is specified in words
848 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
851 if (buf + ssize > buf_end) {
852 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
855 if (id & WP_IDF_IGNORE) {
859 switch (id & WP_IDF_MASK) {
861 if (size > MAX_TERMS) {
862 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
868 for (i = 0; i < s->terms; i++) {
869 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
870 s->decorr[s->terms - i - 1].delta = *buf >> 5;
875 case WP_ID_DECWEIGHTS:
877 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
880 weights = size >> s->stereo_in;
881 if (weights > MAX_TERMS || weights > s->terms) {
882 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
886 for (i = 0; i < weights; i++) {
887 t = (int8_t)(*buf++);
888 s->decorr[s->terms - i - 1].weightA = t << 3;
889 if (s->decorr[s->terms - i - 1].weightA > 0)
890 s->decorr[s->terms - i - 1].weightA +=
891 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
893 t = (int8_t)(*buf++);
894 s->decorr[s->terms - i - 1].weightB = t << 3;
895 if (s->decorr[s->terms - i - 1].weightB > 0)
896 s->decorr[s->terms - i - 1].weightB +=
897 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
902 case WP_ID_DECSAMPLES:
904 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
908 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
909 if (s->decorr[i].value > 8) {
910 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
911 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
913 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
914 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
918 } else if (s->decorr[i].value < 0) {
919 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
920 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
923 for (j = 0; j < s->decorr[i].value; j++) {
924 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
926 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
929 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
935 if (size != 6 * (s->stereo_in + 1)) {
936 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
937 "got %i", 6 * (s->stereo_in + 1), size);
941 for (j = 0; j <= s->stereo_in; j++) {
942 for (i = 0; i < 3; i++) {
943 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
950 if (s->hybrid_bitrate) {
951 for (i = 0; i <= s->stereo_in; i++) {
952 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
957 for (i = 0; i < (s->stereo_in + 1); i++) {
958 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
963 for (i = 0; i < (s->stereo_in + 1); i++) {
964 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
968 for (i = 0; i < (s->stereo_in + 1); i++)
969 s->ch[i].bitrate_delta = 0;
973 case WP_ID_INT32INFO:
975 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
980 s->extra_bits = buf[0];
990 /* original WavPack decoder forces 32-bit lossy sound to be treated
991 * as 24-bit one in order to have proper clipping
993 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
996 s->hybrid_maxclip >>= 8;
997 s->hybrid_minclip >>= 8;
1001 case WP_ID_FLOATINFO:
1003 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
1007 s->float_flag = buf[0];
1008 s->float_shift = buf[1];
1009 s->float_max_exp = buf[2];
1014 s->sc.offset = buf - orig_buf;
1015 s->sc.size = size * 8;
1016 init_get_bits(&s->gb, buf, size * 8);
1017 s->data_size = size * 8;
1021 case WP_ID_EXTRABITS:
1023 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1028 s->extra_sc.offset = buf - orig_buf;
1029 s->extra_sc.size = size * 8;
1030 init_get_bits(&s->gb_extra_bits, buf, size * 8);
1031 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1033 s->got_extra_bits = 1;
1035 case WP_ID_CHANINFO:
1037 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1042 case 0: chmask = *buf; break;
1043 case 1: chmask = AV_RL16(buf); break;
1044 case 2: chmask = AV_RL24(buf); break;
1045 case 3: chmask = AV_RL32(buf); break;
1047 chan |= (buf[1] & 0xF) << 8;
1048 chmask = AV_RL24(buf + 2);
1051 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1053 chan = avctx->channels;
1054 chmask = avctx->channel_layout;
1056 if (chan != avctx->channels) {
1057 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1058 "decoder believes it's %d channels\n", chan,
1062 if (!avctx->channel_layout)
1063 avctx->channel_layout = chmask;
1069 if (id & WP_IDF_ODD)
1074 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1078 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1082 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1086 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1089 if (s->hybrid && !got_hybrid) {
1090 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1094 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1097 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1098 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1101 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1102 const int size = get_bits_left(&s->gb_extra_bits);
1103 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1104 if (size < wanted) {
1105 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1106 s->got_extra_bits = 0;
1111 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1112 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1113 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1114 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1116 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1118 if (samplecount < 0)
1123 const int channel_stride = avctx->channels;
1125 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1126 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1127 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1128 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1130 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1132 if (samplecount < 0)
1135 if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1136 int16_t *dst = (int16_t*)samples + 1;
1137 int16_t *src = (int16_t*)samples;
1138 int cnt = samplecount;
1141 src += channel_stride;
1142 dst += channel_stride;
1144 } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1145 int32_t *dst = (int32_t*)samples + 1;
1146 int32_t *src = (int32_t*)samples;
1147 int cnt = samplecount;
1150 src += channel_stride;
1151 dst += channel_stride;
1153 } else if (s->stereo) {
1154 float *dst = (float*)samples + 1;
1155 float *src = (float*)samples;
1156 int cnt = samplecount;
1159 src += channel_stride;
1160 dst += channel_stride;
1167 return samplecount * bpp;
1170 static void wavpack_decode_flush(AVCodecContext *avctx)
1172 WavpackContext *s = avctx->priv_data;
1175 for (i = 0; i < s->fdec_num; i++)
1176 wv_reset_saved_context(s->fdec[i]);
1179 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1180 int *got_frame_ptr, AVPacket *avpkt)
1182 WavpackContext *s = avctx->priv_data;
1183 const uint8_t *buf = avpkt->data;
1184 int buf_size = avpkt->size;
1185 int frame_size, ret, frame_flags;
1186 int samplecount = 0;
1191 /* determine number of samples */
1193 s->samples = AV_RL32(buf); buf += 4;
1194 frame_flags = AV_RL32(buf);
1196 if (s->multichannel) {
1197 s->samples = AV_RL32(buf + 4);
1198 frame_flags = AV_RL32(buf + 8);
1200 s->samples = AV_RL32(buf);
1201 frame_flags = AV_RL32(buf + 4);
1204 if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1205 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1207 return AVERROR(EINVAL);
1210 if (frame_flags & 0x80) {
1211 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1212 } else if ((frame_flags & 0x03) <= 1) {
1213 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1215 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1216 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1219 /* get output buffer */
1220 s->frame.nb_samples = s->samples + 1;
1221 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1222 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1225 s->frame.nb_samples = s->samples;
1227 while (buf_size > 0) {
1228 if (!s->multichannel) {
1229 frame_size = buf_size;
1232 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1234 if (buf_size < 12) //MKV files can have zero flags after last block
1236 frame_size = AV_RL32(buf + 8) + 12;
1239 if (frame_size < 0 || frame_size > buf_size) {
1240 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1241 "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1242 wavpack_decode_flush(avctx);
1243 return AVERROR_INVALIDDATA;
1245 if ((samplecount = wavpack_decode_block(avctx, s->block,
1246 s->frame.data[0], got_frame_ptr,
1247 buf, frame_size)) < 0) {
1248 wavpack_decode_flush(avctx);
1249 return AVERROR_INVALIDDATA;
1252 buf += frame_size; buf_size -= frame_size;
1256 *(AVFrame *)data = s->frame;
1261 AVCodec ff_wavpack_decoder = {
1263 .type = AVMEDIA_TYPE_AUDIO,
1264 .id = AV_CODEC_ID_WAVPACK,
1265 .priv_data_size = sizeof(WavpackContext),
1266 .init = wavpack_decode_init,
1267 .close = wavpack_decode_end,
1268 .decode = wavpack_decode_frame,
1269 .flush = wavpack_decode_flush,
1270 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1271 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),