2 * WavPack lossless audio decoder
3 * Copyright (c) 2006,2011 Konstantin Shishkov
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #define BITSTREAM_READER_LE
24 #include "libavutil/channel_layout.h"
32 * WavPack lossless audio decoder
35 #define WV_MONO 0x00000004
36 #define WV_JOINT_STEREO 0x00000010
37 #define WV_FALSE_STEREO 0x40000000
39 #define WV_HYBRID_MODE 0x00000008
40 #define WV_HYBRID_SHAPE 0x00000008
41 #define WV_HYBRID_BITRATE 0x00000200
42 #define WV_HYBRID_BALANCE 0x00000400
44 #define WV_FLT_SHIFT_ONES 0x01
45 #define WV_FLT_SHIFT_SAME 0x02
46 #define WV_FLT_SHIFT_SENT 0x04
47 #define WV_FLT_ZERO_SENT 0x08
48 #define WV_FLT_ZERO_SIGN 0x10
50 #define WV_MAX_SAMPLES 131072
76 typedef struct SavedContext {
85 typedef struct Decorr {
94 typedef struct WvChannel {
96 int slow_level, error_limit;
97 int bitrate_acc, bitrate_delta;
100 typedef struct WavpackFrameContext {
101 AVCodecContext *avctx;
103 int stereo, stereo_in;
108 uint32_t crc_extra_bits;
109 GetBitContext gb_extra_bits;
110 int data_size; // in bits
113 Decorr decorr[MAX_TERMS];
114 int zero, one, zeroes;
118 int hybrid, hybrid_bitrate;
119 int hybrid_maxclip, hybrid_minclip;
125 SavedContext sc, extra_sc;
126 } WavpackFrameContext;
128 #define WV_MAX_FRAME_DECODERS 14
130 typedef struct WavpackContext {
131 AVCodecContext *avctx;
133 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
143 // exponent table copied from WavPack source
144 static const uint8_t wp_exp2_table [256] = {
145 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
146 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
147 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
148 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
149 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
150 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
151 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
152 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
153 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
154 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
155 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
156 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
157 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
158 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
159 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
160 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
163 static const uint8_t wp_log2_table [] = {
164 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
165 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
166 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
167 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
168 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
169 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
170 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
171 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
172 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
173 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
174 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
175 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
176 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
177 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
178 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
179 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
182 static av_always_inline int wp_exp2(int16_t val)
191 res = wp_exp2_table[val & 0xFF] | 0x100;
193 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
194 return neg ? -res : res;
197 static av_always_inline int wp_log2(int32_t val)
206 bits = av_log2(val) + 1;
208 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
210 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
213 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
215 // macros for manipulating median values
216 #define GET_MED(n) ((c->median[n] >> 4) + 1)
217 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
218 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
220 // macros for applying weight
221 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
222 if (samples && in) { \
223 if ((samples ^ in) < 0) { \
225 if (weight < -1024) \
235 static av_always_inline int get_tail(GetBitContext *gb, int k)
242 e = (1 << (p + 1)) - k - 1;
243 res = p ? get_bits(gb, p) : 0;
245 res = (res << 1) - e + get_bits1(gb);
249 static void update_error_limit(WavpackFrameContext *ctx)
253 for (i = 0; i <= ctx->stereo_in; i++) {
254 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
255 br[i] = ctx->ch[i].bitrate_acc >> 16;
256 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
258 if (ctx->stereo_in && ctx->hybrid_bitrate) {
259 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
260 if (balance > br[0]) {
263 } else if (-balance > br[0]) {
267 br[1] = br[0] + balance;
268 br[0] = br[0] - balance;
271 for (i = 0; i <= ctx->stereo_in; i++) {
272 if (ctx->hybrid_bitrate) {
273 if (sl[i] - br[i] > -0x100)
274 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
276 ctx->ch[i].error_limit = 0;
278 ctx->ch[i].error_limit = wp_exp2(br[i]);
283 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
284 int channel, int *last)
287 int sign, base, add, ret;
288 WvChannel *c = &ctx->ch[channel];
292 if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
293 !ctx->zero && !ctx->one) {
297 c->slow_level -= LEVEL_DECAY(c->slow_level);
301 t = get_unary_0_33(gb);
303 if (get_bits_left(gb) < t - 1)
305 t = get_bits(gb, t - 1) | (1 << (t-1));
307 if (get_bits_left(gb) < 0)
312 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
313 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
314 c->slow_level -= LEVEL_DECAY(c->slow_level);
324 t = get_unary_0_33(gb);
325 if (get_bits_left(gb) < 0)
328 t2 = get_unary_0_33(gb);
330 if (get_bits_left(gb) < 0)
334 if (get_bits_left(gb) < t2 - 1)
336 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
347 ctx->zero = !ctx->one;
350 if (ctx->hybrid && !channel)
351 update_error_limit(ctx);
355 add = GET_MED(0) - 1;
359 add = GET_MED(1) - 1;
363 base = GET_MED(0) + GET_MED(1);
364 add = GET_MED(2) - 1;
369 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
370 add = GET_MED(2) - 1;
375 if (!c->error_limit) {
376 if (add >= 0x2000000U) {
377 av_log(ctx->avctx, AV_LOG_ERROR, "k %d is too large\n", add);
380 ret = base + get_tail(gb, add);
381 if (get_bits_left(gb) <= 0)
384 int mid = (base * 2 + add + 1) >> 1;
385 while (add > c->error_limit) {
386 if (get_bits_left(gb) <= 0)
392 add = mid - base - 1;
393 mid = (base * 2 + add + 1) >> 1;
397 sign = get_bits1(gb);
398 if (ctx->hybrid_bitrate)
399 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
400 return sign ? ~ret : ret;
407 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
415 if (s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
416 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
417 *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
421 bit = (S & s->and) | s->or;
422 bit = ((S + bit) << s->shift) - bit;
425 bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
427 return bit << s->post_shift;
430 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
438 int exp = s->float_max_exp;
440 if (s->got_extra_bits) {
441 const int max_bits = 1 + 23 + 8 + 1;
442 const int left_bits = get_bits_left(&s->gb_extra_bits);
444 if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
449 S <<= s->float_shift;
453 if (S >= 0x1000000) {
454 if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
455 S = get_bits(&s->gb_extra_bits, 23);
460 int shift = 23 - av_log2(S);
461 exp = s->float_max_exp;
468 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
469 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) &&
470 get_bits1(&s->gb_extra_bits))) {
471 S |= (1 << shift) - 1;
472 } else if (s->got_extra_bits &&
473 (s->float_flag & WV_FLT_SHIFT_SENT)) {
474 S |= get_bits(&s->gb_extra_bits, shift);
478 exp = s->float_max_exp;
484 if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
485 if (get_bits1(&s->gb_extra_bits)) {
486 S = get_bits(&s->gb_extra_bits, 23);
487 if (s->float_max_exp >= 25)
488 exp = get_bits(&s->gb_extra_bits, 8);
489 sign = get_bits1(&s->gb_extra_bits);
491 if (s->float_flag & WV_FLT_ZERO_SIGN)
492 sign = get_bits1(&s->gb_extra_bits);
497 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
499 value.u = (sign << 31) | (exp << 23) | S;
503 static void wv_reset_saved_context(WavpackFrameContext *s)
506 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
509 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
510 uint32_t crc_extra_bits)
513 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
514 return AVERROR_INVALIDDATA;
516 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
517 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
518 return AVERROR_INVALIDDATA;
524 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
525 void *dst, const int type)
529 int A, B, L, L2, R, R2;
531 uint32_t crc = s->sc.crc;
532 uint32_t crc_extra_bits = s->extra_sc.crc;
533 int16_t *dst16 = dst;
534 int32_t *dst32 = dst;
536 const int channel_pad = s->avctx->channels - 2;
538 s->one = s->zero = s->zeroes = 0;
540 L = wv_get_value(s, gb, 0, &last);
543 R = wv_get_value(s, gb, 1, &last);
546 for (i = 0; i < s->terms; i++) {
547 t = s->decorr[i].value;
551 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
552 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
554 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
555 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
557 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
558 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
561 A = s->decorr[i].samplesA[pos];
562 B = s->decorr[i].samplesB[pos];
565 if (type != AV_SAMPLE_FMT_S16) {
566 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
567 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
569 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
570 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
572 if (A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
573 if (B && R) 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_S16)
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_S16)
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_S16)
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_S16)
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_FLT) {
618 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
619 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
620 dstfl += channel_pad;
621 } else if (type == AV_SAMPLE_FMT_S32) {
622 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
623 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
624 dst32 += channel_pad;
626 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
627 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
628 dst16 += channel_pad;
631 } while (!last && count < s->samples);
633 wv_reset_saved_context(s);
634 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
635 wv_check_crc(s, crc, crc_extra_bits))
636 return AVERROR_INVALIDDATA;
641 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
642 void *dst, const int type)
648 uint32_t crc = s->sc.crc;
649 uint32_t crc_extra_bits = s->extra_sc.crc;
650 int16_t *dst16 = dst;
651 int32_t *dst32 = dst;
653 const int channel_stride = s->avctx->channels;
655 s->one = s->zero = s->zeroes = 0;
657 T = wv_get_value(s, gb, 0, &last);
661 for (i = 0; i < s->terms; i++) {
662 t = s->decorr[i].value;
665 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
667 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
668 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
671 A = s->decorr[i].samplesA[pos];
674 if (type != AV_SAMPLE_FMT_S16)
675 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
677 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
679 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
680 s->decorr[i].samplesA[j] = T = S;
685 if (type == AV_SAMPLE_FMT_FLT) {
686 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
687 dstfl += channel_stride;
688 } else if (type == AV_SAMPLE_FMT_S32) {
689 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
690 dst32 += channel_stride;
692 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
693 dst16 += channel_stride;
696 } while (!last && count < s->samples);
698 wv_reset_saved_context(s);
699 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
700 wv_check_crc(s, crc, crc_extra_bits))
701 return AVERROR_INVALIDDATA;
706 static av_cold int wv_alloc_frame_context(WavpackContext *c)
709 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
712 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
713 if (!c->fdec[c->fdec_num])
716 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
717 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
722 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
724 WavpackContext *s = avctx->priv_data;
727 if (avctx->bits_per_coded_sample <= 16)
728 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
730 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
731 if (avctx->channels <= 2 && !avctx->channel_layout)
732 avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO :
735 s->multichannel = avctx->channels > 2;
736 /* lavf demuxer does not provide extradata, Matroska stores 0x403
737 there, use this to detect decoding mode for multichannel */
739 if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
740 int ver = AV_RL16(avctx->extradata);
741 if (ver >= 0x402 && ver <= 0x410)
750 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
752 WavpackContext *s = avctx->priv_data;
755 for (i = 0; i < s->fdec_num; i++)
756 av_freep(&s->fdec[i]);
762 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
763 void *data, int *got_frame_ptr,
764 const uint8_t *buf, int buf_size)
766 WavpackContext *wc = avctx->priv_data;
767 WavpackFrameContext *s;
768 void *samples = data;
770 int got_terms = 0, got_weights = 0, got_samples = 0,
771 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
772 const uint8_t *orig_buf = buf;
773 const uint8_t *buf_end = buf + buf_size;
774 int i, j, id, size, ssize, weights, t;
775 int bpp, chan, chmask, orig_bpp;
782 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
783 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
787 s = wc->fdec[block_no];
789 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
793 if (wc->ch_offset >= avctx->channels) {
794 av_log(avctx, AV_LOG_ERROR, "too many channels\n");
798 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
799 memset(s->ch, 0, sizeof(s->ch));
801 s->and = s->or = s->shift = 0;
802 s->got_extra_bits = 0;
805 s->samples = AV_RL32(buf); buf += 4;
810 if (s->samples > wc->samples) {
811 av_log(avctx, AV_LOG_ERROR, "too many samples in block");
815 s->samples = wc->samples;
817 s->frame_flags = AV_RL32(buf); buf += 4;
818 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
819 samples = (uint8_t*)samples + bpp * wc->ch_offset;
820 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
822 s->stereo = !(s->frame_flags & WV_MONO);
823 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
824 s->joint = s->frame_flags & WV_JOINT_STEREO;
825 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
826 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
827 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
828 s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1);
829 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
830 s->CRC = AV_RL32(buf); buf += 4;
832 buf += 4; //skip block size;
834 wc->ch_offset += 1 + s->stereo;
836 // parse metadata blocks
837 while (buf < buf_end) {
840 if (id & WP_IDF_LONG) {
841 size |= (*buf++) << 8;
842 size |= (*buf++) << 16;
844 size <<= 1; // size is specified in words
849 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
852 if (buf + ssize > buf_end) {
853 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
856 if (id & WP_IDF_IGNORE) {
860 switch (id & WP_IDF_MASK) {
862 if (size > MAX_TERMS) {
863 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
869 for (i = 0; i < s->terms; i++) {
870 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
871 s->decorr[s->terms - i - 1].delta = *buf >> 5;
876 case WP_ID_DECWEIGHTS:
878 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
881 weights = size >> s->stereo_in;
882 if (weights > MAX_TERMS || weights > s->terms) {
883 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
887 for (i = 0; i < weights; i++) {
888 t = (int8_t)(*buf++);
889 s->decorr[s->terms - i - 1].weightA = t << 3;
890 if (s->decorr[s->terms - i - 1].weightA > 0)
891 s->decorr[s->terms - i - 1].weightA +=
892 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
894 t = (int8_t)(*buf++);
895 s->decorr[s->terms - i - 1].weightB = t << 3;
896 if (s->decorr[s->terms - i - 1].weightB > 0)
897 s->decorr[s->terms - i - 1].weightB +=
898 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
903 case WP_ID_DECSAMPLES:
905 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
909 for (i = s->terms - 1; (i >= 0) && (t < size) && buf <= buf_end; i--) {
910 if (s->decorr[i].value > 8) {
911 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
912 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
914 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
915 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
919 } else if (s->decorr[i].value < 0) {
920 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
921 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
924 for (j = 0; j < s->decorr[i].value && buf+1<buf_end; j++) {
925 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
927 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
930 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
936 if (size != 6 * (s->stereo_in + 1)) {
937 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
938 "got %i", 6 * (s->stereo_in + 1), size);
942 for (j = 0; j <= s->stereo_in; j++) {
943 for (i = 0; i < 3; i++) {
944 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
951 if (s->hybrid_bitrate) {
952 for (i = 0; i <= s->stereo_in; i++) {
953 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
958 for (i = 0; i < (s->stereo_in + 1); i++) {
959 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
964 for (i = 0; i < (s->stereo_in + 1); i++) {
965 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
969 for (i = 0; i < (s->stereo_in + 1); i++)
970 s->ch[i].bitrate_delta = 0;
974 case WP_ID_INT32INFO:
976 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
981 s->extra_bits = buf[0];
991 /* original WavPack decoder forces 32-bit lossy sound to be treated
992 * as 24-bit one in order to have proper clipping
994 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
997 s->hybrid_maxclip >>= 8;
998 s->hybrid_minclip >>= 8;
1002 case WP_ID_FLOATINFO:
1004 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
1008 s->float_flag = buf[0];
1009 s->float_shift = buf[1];
1010 s->float_max_exp = buf[2];
1015 s->sc.offset = buf - orig_buf;
1016 s->sc.size = size * 8;
1017 init_get_bits(&s->gb, buf, size * 8);
1018 s->data_size = size * 8;
1022 case WP_ID_EXTRABITS:
1024 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1029 s->extra_sc.offset = buf - orig_buf;
1030 s->extra_sc.size = size * 8;
1031 init_get_bits(&s->gb_extra_bits, buf, size * 8);
1032 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1034 s->got_extra_bits = 1;
1036 case WP_ID_CHANINFO:
1038 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1043 case 0: chmask = *buf; break;
1044 case 1: chmask = AV_RL16(buf); break;
1045 case 2: chmask = AV_RL24(buf); break;
1046 case 3: chmask = AV_RL32(buf); break;
1048 chan |= (buf[1] & 0xF) << 8;
1049 chmask = AV_RL24(buf + 2);
1052 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1054 chan = avctx->channels;
1055 chmask = avctx->channel_layout;
1057 if (chan != avctx->channels) {
1058 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1059 "decoder believes it's %d channels\n", chan,
1063 if (!avctx->channel_layout)
1064 avctx->channel_layout = chmask;
1070 if (id & WP_IDF_ODD)
1075 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1079 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1083 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1087 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1090 if (s->hybrid && !got_hybrid) {
1091 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1095 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1098 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1099 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1102 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1103 const int size = get_bits_left(&s->gb_extra_bits);
1104 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1105 if (size < wanted) {
1106 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1107 s->got_extra_bits = 0;
1112 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1113 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1114 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1115 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1117 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1119 if (samplecount < 0)
1124 const int channel_stride = avctx->channels;
1126 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1127 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1128 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1129 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1131 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1133 if (samplecount < 0)
1136 if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1137 int16_t *dst = (int16_t*)samples + 1;
1138 int16_t *src = (int16_t*)samples;
1139 int cnt = samplecount;
1142 src += channel_stride;
1143 dst += channel_stride;
1145 } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1146 int32_t *dst = (int32_t*)samples + 1;
1147 int32_t *src = (int32_t*)samples;
1148 int cnt = samplecount;
1151 src += channel_stride;
1152 dst += channel_stride;
1154 } else if (s->stereo) {
1155 float *dst = (float*)samples + 1;
1156 float *src = (float*)samples;
1157 int cnt = samplecount;
1160 src += channel_stride;
1161 dst += channel_stride;
1168 return samplecount * bpp;
1171 static void wavpack_decode_flush(AVCodecContext *avctx)
1173 WavpackContext *s = avctx->priv_data;
1176 for (i = 0; i < s->fdec_num; i++)
1177 wv_reset_saved_context(s->fdec[i]);
1180 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1181 int *got_frame_ptr, AVPacket *avpkt)
1183 WavpackContext *s = avctx->priv_data;
1184 const uint8_t *buf = avpkt->data;
1185 int buf_size = avpkt->size;
1186 AVFrame *frame = data;
1187 int frame_size, ret, frame_flags;
1188 int samplecount = 0;
1193 /* determine number of samples */
1195 s->samples = AV_RL32(buf); buf += 4;
1196 frame_flags = AV_RL32(buf);
1198 if (s->multichannel) {
1199 s->samples = AV_RL32(buf + 4);
1200 frame_flags = AV_RL32(buf + 8);
1202 s->samples = AV_RL32(buf);
1203 frame_flags = AV_RL32(buf + 4);
1206 if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1207 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1209 return AVERROR(EINVAL);
1212 if (frame_flags & 0x80) {
1213 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1214 } else if ((frame_flags & 0x03) <= 1) {
1215 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1217 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1218 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1221 /* get output buffer */
1222 frame->nb_samples = s->samples + 1;
1223 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1225 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 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;
1258 AVCodec ff_wavpack_decoder = {
1260 .type = AVMEDIA_TYPE_AUDIO,
1261 .id = AV_CODEC_ID_WAVPACK,
1262 .priv_data_size = sizeof(WavpackContext),
1263 .init = wavpack_decode_init,
1264 .close = wavpack_decode_end,
1265 .decode = wavpack_decode_frame,
1266 .flush = wavpack_decode_flush,
1267 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1268 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),