2 * WavPack lossless audio decoder
3 * Copyright (c) 2006,2011 Konstantin Shishkov
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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
74 typedef struct SavedContext {
83 typedef struct Decorr {
92 typedef struct WvChannel {
94 int slow_level, error_limit;
95 int bitrate_acc, bitrate_delta;
98 typedef struct WavpackFrameContext {
99 AVCodecContext *avctx;
101 int stereo, stereo_in;
106 uint32_t crc_extra_bits;
107 GetBitContext gb_extra_bits;
108 int data_size; // in bits
111 Decorr decorr[MAX_TERMS];
112 int zero, one, zeroes;
116 int hybrid, hybrid_bitrate;
117 int hybrid_maxclip, hybrid_minclip;
123 SavedContext sc, extra_sc;
124 } WavpackFrameContext;
126 #define WV_MAX_FRAME_DECODERS 14
128 typedef struct WavpackContext {
129 AVCodecContext *avctx;
132 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
142 // exponent table copied from WavPack source
143 static const uint8_t wp_exp2_table [256] = {
144 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
145 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
146 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
147 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
148 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
149 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
150 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
151 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
152 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
153 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
154 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
155 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
156 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
157 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
158 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
159 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
162 static const uint8_t wp_log2_table [] = {
163 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
164 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
165 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
166 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
167 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
168 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
169 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
170 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
171 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
172 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
173 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
174 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
175 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
176 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
177 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
178 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
181 static av_always_inline int wp_exp2(int16_t val)
190 res = wp_exp2_table[val & 0xFF] | 0x100;
192 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
193 return neg ? -res : res;
196 static av_always_inline int wp_log2(int32_t val)
205 bits = av_log2(val) + 1;
207 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
209 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
212 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
214 // macros for manipulating median values
215 #define GET_MED(n) ((c->median[n] >> 4) + 1)
216 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
217 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
219 // macros for applying weight
220 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
221 if (samples && in) { \
222 if ((samples ^ in) < 0) { \
224 if (weight < -1024) \
234 static av_always_inline int get_tail(GetBitContext *gb, int k)
241 e = (1 << (p + 1)) - k - 1;
242 res = p ? get_bits(gb, p) : 0;
244 res = (res << 1) - e + get_bits1(gb);
248 static void update_error_limit(WavpackFrameContext *ctx)
252 for (i = 0; i <= ctx->stereo_in; i++) {
253 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
254 br[i] = ctx->ch[i].bitrate_acc >> 16;
255 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
257 if (ctx->stereo_in && ctx->hybrid_bitrate) {
258 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
259 if (balance > br[0]) {
262 } else if (-balance > br[0]) {
266 br[1] = br[0] + balance;
267 br[0] = br[0] - balance;
270 for (i = 0; i <= ctx->stereo_in; i++) {
271 if (ctx->hybrid_bitrate) {
272 if (sl[i] - br[i] > -0x100)
273 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
275 ctx->ch[i].error_limit = 0;
277 ctx->ch[i].error_limit = wp_exp2(br[i]);
282 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
283 int channel, int *last)
286 int sign, base, add, ret;
287 WvChannel *c = &ctx->ch[channel];
291 if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
292 !ctx->zero && !ctx->one) {
296 c->slow_level -= LEVEL_DECAY(c->slow_level);
300 t = get_unary_0_33(gb);
302 if (get_bits_left(gb) < t - 1)
304 t = get_bits(gb, t - 1) | (1 << (t-1));
306 if (get_bits_left(gb) < 0)
311 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
312 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
313 c->slow_level -= LEVEL_DECAY(c->slow_level);
323 t = get_unary_0_33(gb);
324 if (get_bits_left(gb) < 0)
327 t2 = get_unary_0_33(gb);
329 if (get_bits_left(gb) < 0)
333 if (get_bits_left(gb) < t2 - 1)
335 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
346 ctx->zero = !ctx->one;
349 if (ctx->hybrid && !channel)
350 update_error_limit(ctx);
354 add = GET_MED(0) - 1;
358 add = GET_MED(1) - 1;
362 base = GET_MED(0) + GET_MED(1);
363 add = GET_MED(2) - 1;
368 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
369 add = GET_MED(2) - 1;
374 if (!c->error_limit) {
375 ret = base + get_tail(gb, add);
376 if (get_bits_left(gb) <= 0)
379 int mid = (base * 2 + add + 1) >> 1;
380 while (add > c->error_limit) {
381 if (get_bits_left(gb) <= 0)
387 add = mid - base - 1;
388 mid = (base * 2 + add + 1) >> 1;
392 sign = get_bits1(gb);
393 if (ctx->hybrid_bitrate)
394 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
395 return sign ? ~ret : ret;
402 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
410 if (s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
411 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
412 *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
416 bit = (S & s->and) | s->or;
417 bit = ((S + bit) << s->shift) - bit;
420 bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
422 return bit << s->post_shift;
425 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
433 int exp = s->float_max_exp;
435 if (s->got_extra_bits) {
436 const int max_bits = 1 + 23 + 8 + 1;
437 const int left_bits = get_bits_left(&s->gb_extra_bits);
439 if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
444 S <<= s->float_shift;
448 if (S >= 0x1000000) {
449 if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
450 S = get_bits(&s->gb_extra_bits, 23);
455 int shift = 23 - av_log2(S);
456 exp = s->float_max_exp;
463 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
464 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) &&
465 get_bits1(&s->gb_extra_bits))) {
466 S |= (1 << shift) - 1;
467 } else if (s->got_extra_bits &&
468 (s->float_flag & WV_FLT_SHIFT_SENT)) {
469 S |= get_bits(&s->gb_extra_bits, shift);
473 exp = s->float_max_exp;
479 if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
480 if (get_bits1(&s->gb_extra_bits)) {
481 S = get_bits(&s->gb_extra_bits, 23);
482 if (s->float_max_exp >= 25)
483 exp = get_bits(&s->gb_extra_bits, 8);
484 sign = get_bits1(&s->gb_extra_bits);
486 if (s->float_flag & WV_FLT_ZERO_SIGN)
487 sign = get_bits1(&s->gb_extra_bits);
492 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
494 value.u = (sign << 31) | (exp << 23) | S;
498 static void wv_reset_saved_context(WavpackFrameContext *s)
501 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
504 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
505 uint32_t crc_extra_bits)
508 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
509 return AVERROR_INVALIDDATA;
511 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
512 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
513 return AVERROR_INVALIDDATA;
519 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
520 void *dst, const int type)
524 int A, B, L, L2, R, R2;
526 uint32_t crc = s->sc.crc;
527 uint32_t crc_extra_bits = s->extra_sc.crc;
528 int16_t *dst16 = dst;
529 int32_t *dst32 = dst;
531 const int channel_pad = s->avctx->channels - 2;
533 s->one = s->zero = s->zeroes = 0;
535 L = wv_get_value(s, gb, 0, &last);
538 R = wv_get_value(s, gb, 1, &last);
541 for (i = 0; i < s->terms; i++) {
542 t = s->decorr[i].value;
546 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
547 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
549 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
550 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
552 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
553 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
556 A = s->decorr[i].samplesA[pos];
557 B = s->decorr[i].samplesB[pos];
560 if (type != AV_SAMPLE_FMT_S16) {
561 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
562 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
564 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
565 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
567 if (A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
568 if (B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
569 s->decorr[i].samplesA[j] = L = L2;
570 s->decorr[i].samplesB[j] = R = R2;
571 } else if (t == -1) {
572 if (type != AV_SAMPLE_FMT_S16)
573 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
575 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
576 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
578 if (type != AV_SAMPLE_FMT_S16)
579 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
581 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
582 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
584 s->decorr[i].samplesA[0] = R;
586 if (type != AV_SAMPLE_FMT_S16)
587 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
589 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
590 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
594 R2 = s->decorr[i].samplesA[0];
595 s->decorr[i].samplesA[0] = R;
598 if (type != AV_SAMPLE_FMT_S16)
599 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
601 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
602 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
604 s->decorr[i].samplesB[0] = L;
609 L += (R -= (L >> 1));
610 crc = (crc * 3 + L) * 3 + R;
612 if (type == AV_SAMPLE_FMT_FLT) {
613 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
614 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
615 dstfl += channel_pad;
616 } else if (type == AV_SAMPLE_FMT_S32) {
617 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
618 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
619 dst32 += channel_pad;
621 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
622 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
623 dst16 += channel_pad;
626 } while (!last && count < s->samples);
628 wv_reset_saved_context(s);
629 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
630 wv_check_crc(s, crc, crc_extra_bits))
631 return AVERROR_INVALIDDATA;
636 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
637 void *dst, const int type)
643 uint32_t crc = s->sc.crc;
644 uint32_t crc_extra_bits = s->extra_sc.crc;
645 int16_t *dst16 = dst;
646 int32_t *dst32 = dst;
648 const int channel_stride = s->avctx->channels;
650 s->one = s->zero = s->zeroes = 0;
652 T = wv_get_value(s, gb, 0, &last);
656 for (i = 0; i < s->terms; i++) {
657 t = s->decorr[i].value;
660 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
662 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
663 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
666 A = s->decorr[i].samplesA[pos];
669 if (type != AV_SAMPLE_FMT_S16)
670 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
672 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
674 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
675 s->decorr[i].samplesA[j] = T = S;
680 if (type == AV_SAMPLE_FMT_FLT) {
681 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
682 dstfl += channel_stride;
683 } else if (type == AV_SAMPLE_FMT_S32) {
684 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
685 dst32 += channel_stride;
687 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
688 dst16 += channel_stride;
691 } while (!last && count < s->samples);
693 wv_reset_saved_context(s);
694 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
695 wv_check_crc(s, crc, crc_extra_bits))
696 return AVERROR_INVALIDDATA;
701 static av_cold int wv_alloc_frame_context(WavpackContext *c)
704 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
707 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
708 if (!c->fdec[c->fdec_num])
711 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
712 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
717 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
719 WavpackContext *s = avctx->priv_data;
722 if (avctx->bits_per_coded_sample <= 16)
723 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
725 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
726 if (avctx->channels <= 2 && !avctx->channel_layout)
727 avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO :
730 s->multichannel = avctx->channels > 2;
731 /* lavf demuxer does not provide extradata, Matroska stores 0x403
732 there, use this to detect decoding mode for multichannel */
734 if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
735 int ver = AV_RL16(avctx->extradata);
736 if (ver >= 0x402 && ver <= 0x410)
742 avcodec_get_frame_defaults(&s->frame);
743 avctx->coded_frame = &s->frame;
748 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
750 WavpackContext *s = avctx->priv_data;
753 for (i = 0; i < s->fdec_num; i++)
754 av_freep(&s->fdec[i]);
760 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
761 void *data, int *got_frame_ptr,
762 const uint8_t *buf, int buf_size)
764 WavpackContext *wc = avctx->priv_data;
765 WavpackFrameContext *s;
766 void *samples = data;
768 int got_terms = 0, got_weights = 0, got_samples = 0,
769 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
770 const uint8_t *orig_buf = buf;
771 const uint8_t *buf_end = buf + buf_size;
772 int i, j, id, size, ssize, weights, t;
773 int bpp, chan, chmask, orig_bpp;
780 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
781 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
785 s = wc->fdec[block_no];
787 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
791 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
792 memset(s->ch, 0, sizeof(s->ch));
794 s->and = s->or = s->shift = 0;
795 s->got_extra_bits = 0;
798 s->samples = AV_RL32(buf); buf += 4;
804 s->samples = wc->samples;
806 s->frame_flags = AV_RL32(buf); buf += 4;
807 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
808 samples = (uint8_t*)samples + bpp * wc->ch_offset;
809 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
811 s->stereo = !(s->frame_flags & WV_MONO);
812 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
813 s->joint = s->frame_flags & WV_JOINT_STEREO;
814 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
815 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
816 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
817 s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1);
818 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
819 s->CRC = AV_RL32(buf); buf += 4;
821 buf += 4; //skip block size;
823 wc->ch_offset += 1 + s->stereo;
825 // parse metadata blocks
826 while (buf < buf_end) {
829 if (id & WP_IDF_LONG) {
830 size |= (*buf++) << 8;
831 size |= (*buf++) << 16;
833 size <<= 1; // size is specified in words
838 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
841 if (buf + ssize > buf_end) {
842 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
845 if (id & WP_IDF_IGNORE) {
849 switch (id & WP_IDF_MASK) {
851 if (size > MAX_TERMS) {
852 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
858 for (i = 0; i < s->terms; i++) {
859 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
860 s->decorr[s->terms - i - 1].delta = *buf >> 5;
865 case WP_ID_DECWEIGHTS:
867 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
870 weights = size >> s->stereo_in;
871 if (weights > MAX_TERMS || weights > s->terms) {
872 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
876 for (i = 0; i < weights; i++) {
877 t = (int8_t)(*buf++);
878 s->decorr[s->terms - i - 1].weightA = t << 3;
879 if (s->decorr[s->terms - i - 1].weightA > 0)
880 s->decorr[s->terms - i - 1].weightA +=
881 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
883 t = (int8_t)(*buf++);
884 s->decorr[s->terms - i - 1].weightB = t << 3;
885 if (s->decorr[s->terms - i - 1].weightB > 0)
886 s->decorr[s->terms - i - 1].weightB +=
887 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
892 case WP_ID_DECSAMPLES:
894 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
898 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
899 if (s->decorr[i].value > 8) {
900 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
901 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
903 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
904 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
908 } else if (s->decorr[i].value < 0) {
909 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
910 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
913 for (j = 0; j < s->decorr[i].value; j++) {
914 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
916 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
919 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
925 if (size != 6 * (s->stereo_in + 1)) {
926 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
927 "got %i", 6 * (s->stereo_in + 1), size);
931 for (j = 0; j <= s->stereo_in; j++) {
932 for (i = 0; i < 3; i++) {
933 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
940 if (s->hybrid_bitrate) {
941 for (i = 0; i <= s->stereo_in; i++) {
942 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
947 for (i = 0; i < (s->stereo_in + 1); i++) {
948 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
953 for (i = 0; i < (s->stereo_in + 1); i++) {
954 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
958 for (i = 0; i < (s->stereo_in + 1); i++)
959 s->ch[i].bitrate_delta = 0;
963 case WP_ID_INT32INFO:
965 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
970 s->extra_bits = buf[0];
980 /* original WavPack decoder forces 32-bit lossy sound to be treated
981 * as 24-bit one in order to have proper clipping
983 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
986 s->hybrid_maxclip >>= 8;
987 s->hybrid_minclip >>= 8;
991 case WP_ID_FLOATINFO:
993 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
997 s->float_flag = buf[0];
998 s->float_shift = buf[1];
999 s->float_max_exp = buf[2];
1004 s->sc.offset = buf - orig_buf;
1005 s->sc.size = size * 8;
1006 init_get_bits(&s->gb, buf, size * 8);
1007 s->data_size = size * 8;
1011 case WP_ID_EXTRABITS:
1013 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1018 s->extra_sc.offset = buf - orig_buf;
1019 s->extra_sc.size = size * 8;
1020 init_get_bits(&s->gb_extra_bits, buf, size * 8);
1021 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1023 s->got_extra_bits = 1;
1025 case WP_ID_CHANINFO:
1027 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1032 case 0: chmask = *buf; break;
1033 case 1: chmask = AV_RL16(buf); break;
1034 case 2: chmask = AV_RL24(buf); break;
1035 case 3: chmask = AV_RL32(buf); break;
1037 chan |= (buf[1] & 0xF) << 8;
1038 chmask = AV_RL24(buf + 2);
1041 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1043 chan = avctx->channels;
1044 chmask = avctx->channel_layout;
1046 if (chan != avctx->channels) {
1047 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1048 "decoder believes it's %d channels\n", chan,
1052 if (!avctx->channel_layout)
1053 avctx->channel_layout = chmask;
1059 if (id & WP_IDF_ODD)
1064 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1068 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1072 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1076 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1079 if (s->hybrid && !got_hybrid) {
1080 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1084 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1087 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1088 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1091 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1092 const int size = get_bits_left(&s->gb_extra_bits);
1093 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1094 if (size < wanted) {
1095 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1096 s->got_extra_bits = 0;
1101 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1102 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1103 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1104 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1106 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1108 if (samplecount < 0)
1113 const int channel_stride = avctx->channels;
1115 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1116 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1117 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1118 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1120 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1122 if (samplecount < 0)
1125 if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1126 int16_t *dst = (int16_t*)samples + 1;
1127 int16_t *src = (int16_t*)samples;
1128 int cnt = samplecount;
1131 src += channel_stride;
1132 dst += channel_stride;
1134 } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1135 int32_t *dst = (int32_t*)samples + 1;
1136 int32_t *src = (int32_t*)samples;
1137 int cnt = samplecount;
1140 src += channel_stride;
1141 dst += channel_stride;
1143 } else if (s->stereo) {
1144 float *dst = (float*)samples + 1;
1145 float *src = (float*)samples;
1146 int cnt = samplecount;
1149 src += channel_stride;
1150 dst += channel_stride;
1157 return samplecount * bpp;
1160 static void wavpack_decode_flush(AVCodecContext *avctx)
1162 WavpackContext *s = avctx->priv_data;
1165 for (i = 0; i < s->fdec_num; i++)
1166 wv_reset_saved_context(s->fdec[i]);
1169 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1170 int *got_frame_ptr, AVPacket *avpkt)
1172 WavpackContext *s = avctx->priv_data;
1173 const uint8_t *buf = avpkt->data;
1174 int buf_size = avpkt->size;
1175 int frame_size, ret, frame_flags;
1176 int samplecount = 0;
1181 /* determine number of samples */
1183 s->samples = AV_RL32(buf); buf += 4;
1184 frame_flags = AV_RL32(buf);
1186 if (s->multichannel) {
1187 s->samples = AV_RL32(buf + 4);
1188 frame_flags = AV_RL32(buf + 8);
1190 s->samples = AV_RL32(buf);
1191 frame_flags = AV_RL32(buf + 4);
1194 if (s->samples <= 0) {
1195 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1197 return AVERROR(EINVAL);
1200 if (frame_flags & 0x80) {
1201 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1202 } else if ((frame_flags & 0x03) <= 1) {
1203 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1205 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1206 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1209 /* get output buffer */
1210 s->frame.nb_samples = s->samples;
1211 if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
1212 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1216 while (buf_size > 0) {
1217 if (!s->multichannel) {
1218 frame_size = buf_size;
1221 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1223 if (buf_size < 12) //MKV files can have zero flags after last block
1225 frame_size = AV_RL32(buf + 8) + 12;
1228 if (frame_size < 0 || frame_size > buf_size) {
1229 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1230 "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1231 wavpack_decode_flush(avctx);
1234 if ((samplecount = wavpack_decode_block(avctx, s->block,
1235 s->frame.data[0], got_frame_ptr,
1236 buf, frame_size)) < 0) {
1237 wavpack_decode_flush(avctx);
1241 buf += frame_size; buf_size -= frame_size;
1245 *(AVFrame *)data = s->frame;
1250 AVCodec ff_wavpack_decoder = {
1252 .type = AVMEDIA_TYPE_AUDIO,
1253 .id = AV_CODEC_ID_WAVPACK,
1254 .priv_data_size = sizeof(WavpackContext),
1255 .init = wavpack_decode_init,
1256 .close = wavpack_decode_end,
1257 .decode = wavpack_decode_frame,
1258 .flush = wavpack_decode_flush,
1259 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1260 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),