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"
29 #include "bytestream.h"
33 * WavPack lossless audio decoder
36 #define WV_MONO 0x00000004
37 #define WV_JOINT_STEREO 0x00000010
38 #define WV_FALSE_STEREO 0x40000000
40 #define WV_HYBRID_MODE 0x00000008
41 #define WV_HYBRID_SHAPE 0x00000008
42 #define WV_HYBRID_BITRATE 0x00000200
43 #define WV_HYBRID_BALANCE 0x00000400
45 #define WV_FLT_SHIFT_ONES 0x01
46 #define WV_FLT_SHIFT_SAME 0x02
47 #define WV_FLT_SHIFT_SENT 0x04
48 #define WV_FLT_ZERO_SENT 0x08
49 #define WV_FLT_ZERO_SIGN 0x10
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;
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) \
233 static av_always_inline int get_tail(GetBitContext *gb, int k)
240 e = (1 << (p + 1)) - k - 1;
241 res = p ? get_bits(gb, p) : 0;
243 res = (res << 1) - e + get_bits1(gb);
247 static void update_error_limit(WavpackFrameContext *ctx)
251 for (i = 0; i <= ctx->stereo_in; i++) {
252 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
253 br[i] = ctx->ch[i].bitrate_acc >> 16;
254 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
256 if (ctx->stereo_in && ctx->hybrid_bitrate) {
257 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
258 if (balance > br[0]) {
261 } else if (-balance > br[0]) {
265 br[1] = br[0] + balance;
266 br[0] = br[0] - balance;
269 for (i = 0; i <= ctx->stereo_in; i++) {
270 if (ctx->hybrid_bitrate) {
271 if (sl[i] - br[i] > -0x100)
272 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
274 ctx->ch[i].error_limit = 0;
276 ctx->ch[i].error_limit = wp_exp2(br[i]);
281 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
282 int channel, int *last)
285 int sign, base, add, ret;
286 WvChannel *c = &ctx->ch[channel];
290 if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
291 !ctx->zero && !ctx->one) {
295 c->slow_level -= LEVEL_DECAY(c->slow_level);
299 t = get_unary_0_33(gb);
301 if (get_bits_left(gb) < t - 1)
303 t = get_bits(gb, t - 1) | (1 << (t - 1));
305 if (get_bits_left(gb) < 0)
310 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
311 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
312 c->slow_level -= LEVEL_DECAY(c->slow_level);
322 t = get_unary_0_33(gb);
323 if (get_bits_left(gb) < 0)
326 t2 = get_unary_0_33(gb);
328 if (get_bits_left(gb) < 0)
332 if (get_bits_left(gb) < t2 - 1)
334 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
345 ctx->zero = !ctx->one;
348 if (ctx->hybrid && !channel)
349 update_error_limit(ctx);
353 add = GET_MED(0) - 1;
357 add = GET_MED(1) - 1;
361 base = GET_MED(0) + GET_MED(1);
362 add = GET_MED(2) - 1;
367 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
368 add = GET_MED(2) - 1;
373 if (!c->error_limit) {
374 ret = base + get_tail(gb, add);
375 if (get_bits_left(gb) <= 0)
378 int mid = (base * 2 + add + 1) >> 1;
379 while (add > c->error_limit) {
380 if (get_bits_left(gb) <= 0)
386 add = mid - base - 1;
387 mid = (base * 2 + add + 1) >> 1;
391 sign = get_bits1(gb);
392 if (ctx->hybrid_bitrate)
393 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
394 return sign ? ~ret : ret;
401 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
409 if (s->got_extra_bits &&
410 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 &&
465 (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_l, void *dst_r, 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_l = dst_l;
530 int16_t *dst16_r = dst_r;
531 int32_t *dst32_l = dst_l;
532 int32_t *dst32_r = dst_r;
533 float *dstfl_l = dst_l;
534 float *dstfl_r = dst_r;
536 s->one = s->zero = s->zeroes = 0;
538 L = wv_get_value(s, gb, 0, &last);
541 R = wv_get_value(s, gb, 1, &last);
544 for (i = 0; i < s->terms; i++) {
545 t = s->decorr[i].value;
549 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
550 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
552 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
553 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
555 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
556 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
559 A = s->decorr[i].samplesA[pos];
560 B = s->decorr[i].samplesB[pos];
563 if (type != AV_SAMPLE_FMT_S16P) {
564 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
565 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
567 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
568 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
571 s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
573 s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
574 s->decorr[i].samplesA[j] = L = L2;
575 s->decorr[i].samplesB[j] = R = R2;
576 } else if (t == -1) {
577 if (type != AV_SAMPLE_FMT_S16P)
578 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
580 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
581 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
583 if (type != AV_SAMPLE_FMT_S16P)
584 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
586 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
587 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
589 s->decorr[i].samplesA[0] = R;
591 if (type != AV_SAMPLE_FMT_S16P)
592 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
594 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
595 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
599 R2 = s->decorr[i].samplesA[0];
600 s->decorr[i].samplesA[0] = R;
603 if (type != AV_SAMPLE_FMT_S16P)
604 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
606 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
607 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
609 s->decorr[i].samplesB[0] = L;
614 L += (R -= (L >> 1));
615 crc = (crc * 3 + L) * 3 + R;
617 if (type == AV_SAMPLE_FMT_FLTP) {
618 *dstfl_l++ = wv_get_value_float(s, &crc_extra_bits, L);
619 *dstfl_r++ = wv_get_value_float(s, &crc_extra_bits, R);
620 } else if (type == AV_SAMPLE_FMT_S32P) {
621 *dst32_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
622 *dst32_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
624 *dst16_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
625 *dst16_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
628 } while (!last && count < s->samples);
630 wv_reset_saved_context(s);
631 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
632 wv_check_crc(s, crc, crc_extra_bits))
633 return AVERROR_INVALIDDATA;
638 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
639 void *dst, const int type)
645 uint32_t crc = s->sc.crc;
646 uint32_t crc_extra_bits = s->extra_sc.crc;
647 int16_t *dst16 = dst;
648 int32_t *dst32 = dst;
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_S16P)
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_FLTP) {
682 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
683 } else if (type == AV_SAMPLE_FMT_S32P) {
684 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
686 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
689 } while (!last && count < s->samples);
691 wv_reset_saved_context(s);
692 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
693 wv_check_crc(s, crc, crc_extra_bits))
694 return AVERROR_INVALIDDATA;
699 static av_cold int wv_alloc_frame_context(WavpackContext *c)
701 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
704 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
705 if (!c->fdec[c->fdec_num])
708 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
709 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
714 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
716 WavpackContext *s = avctx->priv_data;
719 if (avctx->bits_per_coded_sample <= 16)
720 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
722 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
723 if (avctx->channels <= 2 && !avctx->channel_layout)
724 avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO
727 s->multichannel = avctx->channels > 2;
728 /* lavf demuxer does not provide extradata, Matroska stores 0x403
729 * there, use this to detect decoding mode for multichannel */
731 if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
732 int ver = AV_RL16(avctx->extradata);
733 if (ver >= 0x402 && ver <= 0x410)
742 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
744 WavpackContext *s = avctx->priv_data;
747 for (i = 0; i < s->fdec_num; i++)
748 av_freep(&s->fdec[i]);
754 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
755 uint8_t **data, int *got_frame_ptr,
756 const uint8_t *buf, int buf_size)
758 WavpackContext *wc = avctx->priv_data;
759 WavpackFrameContext *s;
761 void *samples_l, *samples_r;
763 int got_terms = 0, got_weights = 0, got_samples = 0,
764 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
765 int i, j, id, size, ssize, weights, t;
766 int bpp, chan, chmask, orig_bpp;
773 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
774 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
775 return AVERROR_INVALIDDATA;
778 s = wc->fdec[block_no];
780 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n",
782 return AVERROR_INVALIDDATA;
785 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
786 memset(s->ch, 0, sizeof(s->ch));
788 s->and = s->or = s->shift = 0;
789 s->got_extra_bits = 0;
791 bytestream2_init(&gb, buf, buf_size);
794 s->samples = bytestream2_get_le32(&gb);
795 if (s->samples != wc->samples) {
796 av_log(avctx, AV_LOG_ERROR, "Mismatching number of samples in "
797 "a sequence: %d and %d\n", wc->samples, s->samples);
798 return AVERROR_INVALIDDATA;
806 s->samples = wc->samples;
808 s->frame_flags = bytestream2_get_le32(&gb);
809 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
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 = bytestream2_get_le32(&gb);
822 samples_l = data[wc->ch_offset];
824 samples_r = data[wc->ch_offset + 1];
827 bytestream2_skip(&gb, 4); // skip block size;
829 wc->ch_offset += 1 + s->stereo;
831 // parse metadata blocks
832 while (bytestream2_get_bytes_left(&gb)) {
833 id = bytestream2_get_byte(&gb);
834 size = bytestream2_get_byte(&gb);
835 if (id & WP_IDF_LONG) {
836 size |= (bytestream2_get_byte(&gb)) << 8;
837 size |= (bytestream2_get_byte(&gb)) << 16;
839 size <<= 1; // size is specified in words
844 av_log(avctx, AV_LOG_ERROR,
845 "Got incorrect block %02X with size %i\n", id, size);
848 if (bytestream2_get_bytes_left(&gb) < ssize) {
849 av_log(avctx, AV_LOG_ERROR,
850 "Block size %i is out of bounds\n", size);
853 if (id & WP_IDF_IGNORE) {
854 bytestream2_skip(&gb, ssize);
857 switch (id & WP_IDF_MASK) {
859 if (size > MAX_TERMS) {
860 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
862 bytestream2_skip(&gb, ssize);
866 for (i = 0; i < s->terms; i++) {
867 uint8_t val = bytestream2_get_byte(&gb);
868 s->decorr[s->terms - i - 1].value = (val & 0x1F) - 5;
869 s->decorr[s->terms - i - 1].delta = val >> 5;
873 case WP_ID_DECWEIGHTS:
875 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
878 weights = size >> s->stereo_in;
879 if (weights > MAX_TERMS || weights > s->terms) {
880 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
881 bytestream2_skip(&gb, ssize);
884 for (i = 0; i < weights; i++) {
885 t = (int8_t)bytestream2_get_byte(&gb);
886 s->decorr[s->terms - i - 1].weightA = t << 3;
887 if (s->decorr[s->terms - i - 1].weightA > 0)
888 s->decorr[s->terms - i - 1].weightA +=
889 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
891 t = (int8_t)bytestream2_get_byte(&gb);
892 s->decorr[s->terms - i - 1].weightB = t << 3;
893 if (s->decorr[s->terms - i - 1].weightB > 0)
894 s->decorr[s->terms - i - 1].weightB +=
895 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
900 case WP_ID_DECSAMPLES:
902 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
906 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
907 if (s->decorr[i].value > 8) {
908 s->decorr[i].samplesA[0] =
909 wp_exp2(bytestream2_get_le16(&gb));
910 s->decorr[i].samplesA[1] =
911 wp_exp2(bytestream2_get_le16(&gb));
914 s->decorr[i].samplesB[0] =
915 wp_exp2(bytestream2_get_le16(&gb));
916 s->decorr[i].samplesB[1] =
917 wp_exp2(bytestream2_get_le16(&gb));
921 } else if (s->decorr[i].value < 0) {
922 s->decorr[i].samplesA[0] =
923 wp_exp2(bytestream2_get_le16(&gb));
924 s->decorr[i].samplesB[0] =
925 wp_exp2(bytestream2_get_le16(&gb));
928 for (j = 0; j < s->decorr[i].value; j++) {
929 s->decorr[i].samplesA[j] =
930 wp_exp2(bytestream2_get_le16(&gb));
932 s->decorr[i].samplesB[j] =
933 wp_exp2(bytestream2_get_le16(&gb));
936 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
942 if (size != 6 * (s->stereo_in + 1)) {
943 av_log(avctx, AV_LOG_ERROR,
944 "Entropy vars size should be %i, got %i",
945 6 * (s->stereo_in + 1), size);
946 bytestream2_skip(&gb, ssize);
949 for (j = 0; j <= s->stereo_in; j++)
950 for (i = 0; i < 3; i++) {
951 s->ch[j].median[i] = wp_exp2(bytestream2_get_le16(&gb));
956 if (s->hybrid_bitrate) {
957 for (i = 0; i <= s->stereo_in; i++) {
958 s->ch[i].slow_level = wp_exp2(bytestream2_get_le16(&gb));
962 for (i = 0; i < (s->stereo_in + 1); i++) {
963 s->ch[i].bitrate_acc = bytestream2_get_le16(&gb) << 16;
967 for (i = 0; i < (s->stereo_in + 1); i++) {
968 s->ch[i].bitrate_delta =
969 wp_exp2((int16_t)bytestream2_get_le16(&gb));
972 for (i = 0; i < (s->stereo_in + 1); i++)
973 s->ch[i].bitrate_delta = 0;
977 case WP_ID_INT32INFO: {
980 av_log(avctx, AV_LOG_ERROR,
981 "Invalid INT32INFO, size = %i\n",
983 bytestream2_skip(&gb, ssize - 4);
986 bytestream2_get_buffer(&gb, val, 4);
988 s->extra_bits = val[0];
998 /* original WavPack decoder forces 32-bit lossy sound to be treated
999 * as 24-bit one in order to have proper clipping */
1000 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
1003 s->hybrid_maxclip >>= 8;
1004 s->hybrid_minclip >>= 8;
1008 case WP_ID_FLOATINFO:
1010 av_log(avctx, AV_LOG_ERROR,
1011 "Invalid FLOATINFO, size = %i\n", size);
1012 bytestream2_skip(&gb, ssize);
1015 s->float_flag = bytestream2_get_byte(&gb);
1016 s->float_shift = bytestream2_get_byte(&gb);
1017 s->float_max_exp = bytestream2_get_byte(&gb);
1019 bytestream2_skip(&gb, 1);
1022 s->sc.offset = bytestream2_tell(&gb);
1023 s->sc.size = size * 8;
1024 init_get_bits(&s->gb, gb.buffer, size * 8);
1025 s->data_size = size * 8;
1026 bytestream2_skip(&gb, size);
1029 case WP_ID_EXTRABITS:
1031 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1033 bytestream2_skip(&gb, size);
1036 s->extra_sc.offset = bytestream2_tell(&gb);
1037 s->extra_sc.size = size * 8;
1038 init_get_bits(&s->gb_extra_bits, gb.buffer, size * 8);
1039 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1040 bytestream2_skip(&gb, size);
1041 s->got_extra_bits = 1;
1043 case WP_ID_CHANINFO:
1045 av_log(avctx, AV_LOG_ERROR,
1046 "Insufficient channel information\n");
1047 return AVERROR_INVALIDDATA;
1049 chan = bytestream2_get_byte(&gb);
1052 chmask = bytestream2_get_byte(&gb);
1055 chmask = bytestream2_get_le16(&gb);
1058 chmask = bytestream2_get_le24(&gb);
1061 chmask = bytestream2_get_le32(&gb);;
1064 bytestream2_skip(&gb, 1);
1065 chan |= (bytestream2_get_byte(&gb) & 0xF) << 8;
1066 chmask = bytestream2_get_le16(&gb);
1069 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1071 chan = avctx->channels;
1072 chmask = avctx->channel_layout;
1074 if (chan != avctx->channels) {
1075 av_log(avctx, AV_LOG_ERROR,
1076 "Block reports total %d channels, "
1077 "decoder believes it's %d channels\n",
1078 chan, avctx->channels);
1079 return AVERROR_INVALIDDATA;
1081 if (!avctx->channel_layout)
1082 avctx->channel_layout = chmask;
1085 bytestream2_skip(&gb, size);
1087 if (id & WP_IDF_ODD)
1088 bytestream2_skip(&gb, 1);
1092 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1093 return AVERROR_INVALIDDATA;
1096 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1097 return AVERROR_INVALIDDATA;
1100 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1101 return AVERROR_INVALIDDATA;
1104 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1105 return AVERROR_INVALIDDATA;
1107 if (s->hybrid && !got_hybrid) {
1108 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1109 return AVERROR_INVALIDDATA;
1112 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1113 return AVERROR_INVALIDDATA;
1115 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) {
1116 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1117 return AVERROR_INVALIDDATA;
1119 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) {
1120 const int size = get_bits_left(&s->gb_extra_bits);
1121 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1122 if (size < wanted) {
1123 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1124 s->got_extra_bits = 0;
1129 ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt);
1133 ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt);
1138 memcpy(samples_r, samples_l, bpp * s->samples);
1146 static void wavpack_decode_flush(AVCodecContext *avctx)
1148 WavpackContext *s = avctx->priv_data;
1151 for (i = 0; i < s->fdec_num; i++)
1152 wv_reset_saved_context(s->fdec[i]);
1155 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1156 int *got_frame_ptr, AVPacket *avpkt)
1158 WavpackContext *s = avctx->priv_data;
1159 const uint8_t *buf = avpkt->data;
1160 int buf_size = avpkt->size;
1161 AVFrame *frame = data;
1162 int frame_size, ret, frame_flags;
1164 if (avpkt->size < 12 + s->multichannel * 4)
1165 return AVERROR_INVALIDDATA;
1170 /* determine number of samples */
1172 s->samples = AV_RL32(buf);
1174 frame_flags = AV_RL32(buf);
1176 if (s->multichannel) {
1177 s->samples = AV_RL32(buf + 4);
1178 frame_flags = AV_RL32(buf + 8);
1180 s->samples = AV_RL32(buf);
1181 frame_flags = AV_RL32(buf + 4);
1184 if (s->samples <= 0) {
1185 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1187 return AVERROR_INVALIDDATA;
1190 if (frame_flags & 0x80) {
1191 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1192 } else if ((frame_flags & 0x03) <= 1) {
1193 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
1195 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
1196 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1199 /* get output buffer */
1200 frame->nb_samples = s->samples;
1201 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1202 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1206 while (buf_size > 0) {
1207 if (!s->multichannel) {
1208 frame_size = buf_size;
1211 frame_size = AV_RL32(buf) - 12;
1215 if (buf_size < 12) // MKV files can have zero flags after last block
1217 frame_size = AV_RL32(buf + 8) + 12;
1220 if (frame_size < 0 || frame_size > buf_size) {
1221 av_log(avctx, AV_LOG_ERROR,
1222 "Block %d has invalid size (size %d vs. %d bytes left)\n",
1223 s->block, frame_size, buf_size);
1224 wavpack_decode_flush(avctx);
1225 return AVERROR_INVALIDDATA;
1227 if ((ret = wavpack_decode_block(avctx, s->block,
1228 frame->extended_data, got_frame_ptr,
1229 buf, frame_size)) < 0) {
1230 wavpack_decode_flush(avctx);
1235 buf_size -= frame_size;
1241 AVCodec ff_wavpack_decoder = {
1243 .type = AVMEDIA_TYPE_AUDIO,
1244 .id = AV_CODEC_ID_WAVPACK,
1245 .priv_data_size = sizeof(WavpackContext),
1246 .init = wavpack_decode_init,
1247 .close = wavpack_decode_end,
1248 .decode = wavpack_decode_frame,
1249 .flush = wavpack_decode_flush,
1250 .capabilities = CODEC_CAP_DR1,
1251 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),