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 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
793 memset(s->ch, 0, sizeof(s->ch));
795 s->and = s->or = s->shift = 0;
796 s->got_extra_bits = 0;
799 s->samples = AV_RL32(buf); buf += 4;
805 s->samples = wc->samples;
807 s->frame_flags = AV_RL32(buf); buf += 4;
808 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
809 samples = (uint8_t*)samples + bpp * wc->ch_offset;
810 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
812 s->stereo = !(s->frame_flags & WV_MONO);
813 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
814 s->joint = s->frame_flags & WV_JOINT_STEREO;
815 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
816 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
817 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
818 s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1);
819 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
820 s->CRC = AV_RL32(buf); buf += 4;
822 buf += 4; //skip block size;
824 wc->ch_offset += 1 + s->stereo;
826 // parse metadata blocks
827 while (buf < buf_end) {
830 if (id & WP_IDF_LONG) {
831 size |= (*buf++) << 8;
832 size |= (*buf++) << 16;
834 size <<= 1; // size is specified in words
839 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
842 if (buf + ssize > buf_end) {
843 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
846 if (id & WP_IDF_IGNORE) {
850 switch (id & WP_IDF_MASK) {
852 if (size > MAX_TERMS) {
853 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
859 for (i = 0; i < s->terms; i++) {
860 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
861 s->decorr[s->terms - i - 1].delta = *buf >> 5;
866 case WP_ID_DECWEIGHTS:
868 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
871 weights = size >> s->stereo_in;
872 if (weights > MAX_TERMS || weights > s->terms) {
873 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
877 for (i = 0; i < weights; i++) {
878 t = (int8_t)(*buf++);
879 s->decorr[s->terms - i - 1].weightA = t << 3;
880 if (s->decorr[s->terms - i - 1].weightA > 0)
881 s->decorr[s->terms - i - 1].weightA +=
882 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
884 t = (int8_t)(*buf++);
885 s->decorr[s->terms - i - 1].weightB = t << 3;
886 if (s->decorr[s->terms - i - 1].weightB > 0)
887 s->decorr[s->terms - i - 1].weightB +=
888 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
893 case WP_ID_DECSAMPLES:
895 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
899 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
900 if (s->decorr[i].value > 8) {
901 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
902 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
904 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
905 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
909 } else if (s->decorr[i].value < 0) {
910 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
911 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
914 for (j = 0; j < s->decorr[i].value; j++) {
915 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
917 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
920 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
926 if (size != 6 * (s->stereo_in + 1)) {
927 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
928 "got %i", 6 * (s->stereo_in + 1), size);
932 for (j = 0; j <= s->stereo_in; j++) {
933 for (i = 0; i < 3; i++) {
934 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
941 if (s->hybrid_bitrate) {
942 for (i = 0; i <= s->stereo_in; i++) {
943 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
948 for (i = 0; i < (s->stereo_in + 1); i++) {
949 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
954 for (i = 0; i < (s->stereo_in + 1); i++) {
955 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
959 for (i = 0; i < (s->stereo_in + 1); i++)
960 s->ch[i].bitrate_delta = 0;
964 case WP_ID_INT32INFO:
966 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
971 s->extra_bits = buf[0];
981 /* original WavPack decoder forces 32-bit lossy sound to be treated
982 * as 24-bit one in order to have proper clipping
984 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
987 s->hybrid_maxclip >>= 8;
988 s->hybrid_minclip >>= 8;
992 case WP_ID_FLOATINFO:
994 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
998 s->float_flag = buf[0];
999 s->float_shift = buf[1];
1000 s->float_max_exp = buf[2];
1005 s->sc.offset = buf - orig_buf;
1006 s->sc.size = size * 8;
1007 init_get_bits(&s->gb, buf, size * 8);
1008 s->data_size = size * 8;
1012 case WP_ID_EXTRABITS:
1014 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1019 s->extra_sc.offset = buf - orig_buf;
1020 s->extra_sc.size = size * 8;
1021 init_get_bits(&s->gb_extra_bits, buf, size * 8);
1022 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1024 s->got_extra_bits = 1;
1026 case WP_ID_CHANINFO:
1028 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1033 case 0: chmask = *buf; break;
1034 case 1: chmask = AV_RL16(buf); break;
1035 case 2: chmask = AV_RL24(buf); break;
1036 case 3: chmask = AV_RL32(buf); break;
1038 chan |= (buf[1] & 0xF) << 8;
1039 chmask = AV_RL24(buf + 2);
1042 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1044 chan = avctx->channels;
1045 chmask = avctx->channel_layout;
1047 if (chan != avctx->channels) {
1048 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1049 "decoder believes it's %d channels\n", chan,
1053 if (!avctx->channel_layout)
1054 avctx->channel_layout = chmask;
1060 if (id & WP_IDF_ODD)
1065 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1069 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1073 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1077 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1080 if (s->hybrid && !got_hybrid) {
1081 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1085 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1088 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1089 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1092 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1093 const int size = get_bits_left(&s->gb_extra_bits);
1094 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1095 if (size < wanted) {
1096 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1097 s->got_extra_bits = 0;
1102 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1103 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1104 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1105 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1107 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1109 if (samplecount < 0)
1114 const int channel_stride = avctx->channels;
1116 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1117 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1118 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1119 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1121 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1123 if (samplecount < 0)
1126 if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1127 int16_t *dst = (int16_t*)samples + 1;
1128 int16_t *src = (int16_t*)samples;
1129 int cnt = samplecount;
1132 src += channel_stride;
1133 dst += channel_stride;
1135 } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1136 int32_t *dst = (int32_t*)samples + 1;
1137 int32_t *src = (int32_t*)samples;
1138 int cnt = samplecount;
1141 src += channel_stride;
1142 dst += channel_stride;
1144 } else if (s->stereo) {
1145 float *dst = (float*)samples + 1;
1146 float *src = (float*)samples;
1147 int cnt = samplecount;
1150 src += channel_stride;
1151 dst += channel_stride;
1158 return samplecount * bpp;
1161 static void wavpack_decode_flush(AVCodecContext *avctx)
1163 WavpackContext *s = avctx->priv_data;
1166 for (i = 0; i < s->fdec_num; i++)
1167 wv_reset_saved_context(s->fdec[i]);
1170 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1171 int *got_frame_ptr, AVPacket *avpkt)
1173 WavpackContext *s = avctx->priv_data;
1174 const uint8_t *buf = avpkt->data;
1175 int buf_size = avpkt->size;
1176 int frame_size, ret, frame_flags;
1177 int samplecount = 0;
1182 /* determine number of samples */
1184 s->samples = AV_RL32(buf); buf += 4;
1185 frame_flags = AV_RL32(buf);
1187 if (s->multichannel) {
1188 s->samples = AV_RL32(buf + 4);
1189 frame_flags = AV_RL32(buf + 8);
1191 s->samples = AV_RL32(buf);
1192 frame_flags = AV_RL32(buf + 4);
1195 if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1196 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1198 return AVERROR(EINVAL);
1201 if (frame_flags & 0x80) {
1202 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1203 } else if ((frame_flags & 0x03) <= 1) {
1204 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1206 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1207 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1210 /* get output buffer */
1211 s->frame.nb_samples = s->samples + 1;
1212 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1213 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1216 s->frame.nb_samples = s->samples;
1218 while (buf_size > 0) {
1219 if (!s->multichannel) {
1220 frame_size = buf_size;
1223 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1225 if (buf_size < 12) //MKV files can have zero flags after last block
1227 frame_size = AV_RL32(buf + 8) + 12;
1230 if (frame_size < 0 || frame_size > buf_size) {
1231 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1232 "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1233 wavpack_decode_flush(avctx);
1234 return AVERROR_INVALIDDATA;
1236 if ((samplecount = wavpack_decode_block(avctx, s->block,
1237 s->frame.data[0], got_frame_ptr,
1238 buf, frame_size)) < 0) {
1239 wavpack_decode_flush(avctx);
1240 return AVERROR_INVALIDDATA;
1243 buf += frame_size; buf_size -= frame_size;
1247 *(AVFrame *)data = s->frame;
1252 AVCodec ff_wavpack_decoder = {
1254 .type = AVMEDIA_TYPE_AUDIO,
1255 .id = AV_CODEC_ID_WAVPACK,
1256 .priv_data_size = sizeof(WavpackContext),
1257 .init = wavpack_decode_init,
1258 .close = wavpack_decode_end,
1259 .decode = wavpack_decode_frame,
1260 .flush = wavpack_decode_flush,
1261 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1262 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),