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/audioconvert.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
73 typedef struct SavedContext {
82 typedef struct Decorr {
91 typedef struct WvChannel {
93 int slow_level, error_limit;
94 int bitrate_acc, bitrate_delta;
97 typedef struct WavpackFrameContext {
98 AVCodecContext *avctx;
100 int stereo, stereo_in;
105 uint32_t crc_extra_bits;
106 GetBitContext gb_extra_bits;
107 int data_size; // in bits
110 Decorr decorr[MAX_TERMS];
111 int zero, one, zeroes;
115 int hybrid, hybrid_bitrate;
116 int hybrid_maxclip, hybrid_minclip;
122 SavedContext sc, extra_sc;
123 } WavpackFrameContext;
125 #define WV_MAX_FRAME_DECODERS 14
127 typedef struct WavpackContext {
128 AVCodecContext *avctx;
131 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
141 // exponent table copied from WavPack source
142 static const uint8_t wp_exp2_table [256] = {
143 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
144 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
145 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
146 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
147 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
148 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
149 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
150 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
151 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
152 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
153 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
154 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
155 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
156 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
157 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
158 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
161 static const uint8_t wp_log2_table [] = {
162 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
163 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
164 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
165 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
166 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
167 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
168 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
169 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
170 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
171 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
172 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
173 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
174 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
175 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
176 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
177 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
180 static av_always_inline int wp_exp2(int16_t val)
189 res = wp_exp2_table[val & 0xFF] | 0x100;
191 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
192 return neg ? -res : res;
195 static av_always_inline int wp_log2(int32_t val)
204 bits = av_log2(val) + 1;
206 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
208 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
211 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
213 // macros for manipulating median values
214 #define GET_MED(n) ((c->median[n] >> 4) + 1)
215 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
216 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
218 // macros for applying weight
219 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
220 if (samples && in) { \
221 if ((samples ^ in) < 0) { \
223 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 && get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
410 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
411 *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
415 bit = (S & s->and) | s->or;
416 bit = ((S + bit) << s->shift) - bit;
419 bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
421 return bit << s->post_shift;
424 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
432 int exp = s->float_max_exp;
434 if (s->got_extra_bits) {
435 const int max_bits = 1 + 23 + 8 + 1;
436 const int left_bits = get_bits_left(&s->gb_extra_bits);
438 if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
443 S <<= s->float_shift;
447 if (S >= 0x1000000) {
448 if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
449 S = get_bits(&s->gb_extra_bits, 23);
454 int shift = 23 - av_log2(S);
455 exp = s->float_max_exp;
462 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
463 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) &&
464 get_bits1(&s->gb_extra_bits))) {
465 S |= (1 << shift) - 1;
466 } else if (s->got_extra_bits &&
467 (s->float_flag & WV_FLT_SHIFT_SENT)) {
468 S |= get_bits(&s->gb_extra_bits, shift);
472 exp = s->float_max_exp;
478 if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
479 if (get_bits1(&s->gb_extra_bits)) {
480 S = get_bits(&s->gb_extra_bits, 23);
481 if (s->float_max_exp >= 25)
482 exp = get_bits(&s->gb_extra_bits, 8);
483 sign = get_bits1(&s->gb_extra_bits);
485 if (s->float_flag & WV_FLT_ZERO_SIGN)
486 sign = get_bits1(&s->gb_extra_bits);
491 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
493 value.u = (sign << 31) | (exp << 23) | S;
497 static void wv_reset_saved_context(WavpackFrameContext *s)
500 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
503 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
504 void *dst, const int type)
508 int A, B, L, L2, R, R2;
510 uint32_t crc = s->sc.crc;
511 uint32_t crc_extra_bits = s->extra_sc.crc;
512 int16_t *dst16 = dst;
513 int32_t *dst32 = dst;
515 const int channel_pad = s->avctx->channels - 2;
517 s->one = s->zero = s->zeroes = 0;
519 L = wv_get_value(s, gb, 0, &last);
522 R = wv_get_value(s, gb, 1, &last);
525 for (i = 0; i < s->terms; i++) {
526 t = s->decorr[i].value;
530 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
531 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
533 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
534 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
536 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
537 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
540 A = s->decorr[i].samplesA[pos];
541 B = s->decorr[i].samplesB[pos];
544 if (type != AV_SAMPLE_FMT_S16) {
545 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
546 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
548 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
549 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
551 if (A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
552 if (B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
553 s->decorr[i].samplesA[j] = L = L2;
554 s->decorr[i].samplesB[j] = R = R2;
555 } else if (t == -1) {
556 if (type != AV_SAMPLE_FMT_S16)
557 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
559 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
560 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
562 if (type != AV_SAMPLE_FMT_S16)
563 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
565 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
566 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
568 s->decorr[i].samplesA[0] = R;
570 if (type != AV_SAMPLE_FMT_S16)
571 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
573 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
574 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
578 R2 = s->decorr[i].samplesA[0];
579 s->decorr[i].samplesA[0] = R;
582 if (type != AV_SAMPLE_FMT_S16)
583 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
585 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
586 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
588 s->decorr[i].samplesB[0] = L;
593 L += (R -= (L >> 1));
594 crc = (crc * 3 + L) * 3 + R;
596 if (type == AV_SAMPLE_FMT_FLT) {
597 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
598 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
599 dstfl += channel_pad;
600 } else if (type == AV_SAMPLE_FMT_S32) {
601 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
602 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
603 dst32 += channel_pad;
605 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
606 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
607 dst16 += channel_pad;
610 } while (!last && count < s->samples);
612 wv_reset_saved_context(s);
614 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
617 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
618 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
625 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
626 void *dst, const int type)
632 uint32_t crc = s->sc.crc;
633 uint32_t crc_extra_bits = s->extra_sc.crc;
634 int16_t *dst16 = dst;
635 int32_t *dst32 = dst;
637 const int channel_stride = s->avctx->channels;
639 s->one = s->zero = s->zeroes = 0;
641 T = wv_get_value(s, gb, 0, &last);
645 for (i = 0; i < s->terms; i++) {
646 t = s->decorr[i].value;
649 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
651 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
652 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
655 A = s->decorr[i].samplesA[pos];
658 if (type != AV_SAMPLE_FMT_S16)
659 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
661 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
663 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
664 s->decorr[i].samplesA[j] = T = S;
669 if (type == AV_SAMPLE_FMT_FLT) {
670 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
671 dstfl += channel_stride;
672 } else if (type == AV_SAMPLE_FMT_S32) {
673 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
674 dst32 += channel_stride;
676 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
677 dst16 += channel_stride;
680 } while (!last && count < s->samples);
682 wv_reset_saved_context(s);
684 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
687 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
688 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
695 static av_cold int wv_alloc_frame_context(WavpackContext *c)
698 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
701 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
702 if (!c->fdec[c->fdec_num])
705 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
706 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
711 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
713 WavpackContext *s = avctx->priv_data;
716 if (avctx->bits_per_coded_sample <= 16)
717 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
719 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
720 if (avctx->channels <= 2 && !avctx->channel_layout)
721 avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO :
724 s->multichannel = avctx->channels > 2;
725 /* lavf demuxer does not provide extradata, Matroska stores 0x403
726 there, use this to detect decoding mode for multichannel */
728 if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
729 int ver = AV_RL16(avctx->extradata);
730 if (ver >= 0x402 && ver <= 0x410)
736 avcodec_get_frame_defaults(&s->frame);
737 avctx->coded_frame = &s->frame;
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 void *data, int *got_frame_ptr,
756 const uint8_t *buf, int buf_size)
758 WavpackContext *wc = avctx->priv_data;
759 WavpackFrameContext *s;
760 void *samples = data;
762 int got_terms = 0, got_weights = 0, got_samples = 0,
763 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
764 const uint8_t *orig_buf = buf;
765 const uint8_t *buf_end = buf + buf_size;
766 int i, j, id, size, ssize, weights, t;
767 int bpp, chan, chmask, orig_bpp;
774 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
775 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
779 s = wc->fdec[block_no];
781 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
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;
792 s->samples = AV_RL32(buf); buf += 4;
798 s->samples = wc->samples;
800 s->frame_flags = AV_RL32(buf); buf += 4;
801 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
802 samples = (uint8_t*)samples + bpp * wc->ch_offset;
803 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
805 s->stereo = !(s->frame_flags & WV_MONO);
806 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
807 s->joint = s->frame_flags & WV_JOINT_STEREO;
808 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
809 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
810 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
811 s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1) >> s->post_shift;
812 s->hybrid_minclip = ((-1LL << (orig_bpp - 1))) >> s->post_shift;
813 s->CRC = AV_RL32(buf); buf += 4;
815 buf += 4; //skip block size;
817 wc->ch_offset += 1 + s->stereo;
819 // parse metadata blocks
820 while (buf < buf_end) {
823 if (id & WP_IDF_LONG) {
824 size |= (*buf++) << 8;
825 size |= (*buf++) << 16;
827 size <<= 1; // size is specified in words
832 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
835 if (buf + ssize > buf_end) {
836 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
839 if (id & WP_IDF_IGNORE) {
843 switch (id & WP_IDF_MASK) {
845 if (size > MAX_TERMS) {
846 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
852 for (i = 0; i < s->terms; i++) {
853 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
854 s->decorr[s->terms - i - 1].delta = *buf >> 5;
859 case WP_ID_DECWEIGHTS:
861 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
864 weights = size >> s->stereo_in;
865 if (weights > MAX_TERMS || weights > s->terms) {
866 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
870 for (i = 0; i < weights; i++) {
871 t = (int8_t)(*buf++);
872 s->decorr[s->terms - i - 1].weightA = t << 3;
873 if (s->decorr[s->terms - i - 1].weightA > 0)
874 s->decorr[s->terms - i - 1].weightA +=
875 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
877 t = (int8_t)(*buf++);
878 s->decorr[s->terms - i - 1].weightB = t << 3;
879 if (s->decorr[s->terms - i - 1].weightB > 0)
880 s->decorr[s->terms - i - 1].weightB +=
881 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
886 case WP_ID_DECSAMPLES:
888 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
892 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
893 if (s->decorr[i].value > 8) {
894 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
895 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
897 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
898 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
902 } else if (s->decorr[i].value < 0) {
903 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
904 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
907 for (j = 0; j < s->decorr[i].value; j++) {
908 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
910 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
912 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
918 if (size != 6 * (s->stereo_in + 1)) {
919 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
920 "got %i", 6 * (s->stereo_in + 1), size);
924 for (j = 0; j <= s->stereo_in; j++) {
925 for (i = 0; i < 3; i++) {
926 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
933 if (s->hybrid_bitrate) {
934 for (i = 0; i <= s->stereo_in; i++) {
935 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
940 for (i = 0; i < (s->stereo_in + 1); i++) {
941 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
946 for (i = 0; i < (s->stereo_in + 1); i++) {
947 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
951 for (i = 0; i < (s->stereo_in + 1); i++)
952 s->ch[i].bitrate_delta = 0;
956 case WP_ID_INT32INFO:
958 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
963 s->extra_bits = buf[0];
973 /* original WavPack decoder forces 32-bit lossy sound to be treated
974 * as 24-bit one in order to have proper clipping
976 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
979 s->hybrid_maxclip >>= 8;
980 s->hybrid_minclip >>= 8;
984 case WP_ID_FLOATINFO:
986 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
990 s->float_flag = buf[0];
991 s->float_shift = buf[1];
992 s->float_max_exp = buf[2];
997 s->sc.offset = buf - orig_buf;
998 s->sc.size = size * 8;
999 init_get_bits(&s->gb, buf, size * 8);
1000 s->data_size = size * 8;
1004 case WP_ID_EXTRABITS:
1006 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1011 s->extra_sc.offset = buf - orig_buf;
1012 s->extra_sc.size = size * 8;
1013 init_get_bits(&s->gb_extra_bits, buf, size * 8);
1014 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1016 s->got_extra_bits = 1;
1018 case WP_ID_CHANINFO:
1020 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1025 case 0: chmask = *buf; break;
1026 case 1: chmask = AV_RL16(buf); break;
1027 case 2: chmask = AV_RL24(buf); break;
1028 case 3: chmask = AV_RL32(buf); break;
1030 chan |= (buf[1] & 0xF) << 8;
1031 chmask = AV_RL24(buf + 2);
1034 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1036 chan = avctx->channels;
1037 chmask = avctx->channel_layout;
1039 if (chan != avctx->channels) {
1040 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1041 "decoder believes it's %d channels\n", chan,
1045 if (!avctx->channel_layout)
1046 avctx->channel_layout = chmask;
1052 if (id & WP_IDF_ODD)
1057 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1061 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1065 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1069 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1072 if (s->hybrid && !got_hybrid) {
1073 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1077 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1080 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1081 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1084 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1085 const int size = get_bits_left(&s->gb_extra_bits);
1086 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1087 if (size < wanted) {
1088 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1089 s->got_extra_bits = 0;
1094 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1095 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1096 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1097 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1099 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1101 if (samplecount < 0)
1106 const int channel_stride = avctx->channels;
1108 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1109 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1110 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1111 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1113 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1115 if (samplecount < 0)
1118 if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1119 int16_t *dst = (int16_t*)samples + 1;
1120 int16_t *src = (int16_t*)samples;
1121 int cnt = samplecount;
1124 src += channel_stride;
1125 dst += channel_stride;
1127 } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1128 int32_t *dst = (int32_t*)samples + 1;
1129 int32_t *src = (int32_t*)samples;
1130 int cnt = samplecount;
1133 src += channel_stride;
1134 dst += channel_stride;
1136 } else if (s->stereo) {
1137 float *dst = (float*)samples + 1;
1138 float *src = (float*)samples;
1139 int cnt = samplecount;
1142 src += channel_stride;
1143 dst += channel_stride;
1150 return samplecount * bpp;
1153 static void wavpack_decode_flush(AVCodecContext *avctx)
1155 WavpackContext *s = avctx->priv_data;
1158 for (i = 0; i < s->fdec_num; i++)
1159 wv_reset_saved_context(s->fdec[i]);
1162 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1163 int *got_frame_ptr, AVPacket *avpkt)
1165 WavpackContext *s = avctx->priv_data;
1166 const uint8_t *buf = avpkt->data;
1167 int buf_size = avpkt->size;
1168 int frame_size, ret, frame_flags;
1169 int samplecount = 0;
1174 /* determine number of samples */
1176 s->samples = AV_RL32(buf); buf += 4;
1177 frame_flags = AV_RL32(buf);
1179 if (s->multichannel) {
1180 s->samples = AV_RL32(buf + 4);
1181 frame_flags = AV_RL32(buf + 8);
1183 s->samples = AV_RL32(buf);
1184 frame_flags = AV_RL32(buf + 4);
1187 if (s->samples <= 0) {
1188 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1190 return AVERROR(EINVAL);
1193 if (frame_flags & 0x80) {
1194 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1195 } else if ((frame_flags & 0x03) <= 1) {
1196 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1198 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1201 /* get output buffer */
1202 s->frame.nb_samples = s->samples;
1203 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1204 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1208 while (buf_size > 0) {
1209 if (!s->multichannel) {
1210 frame_size = buf_size;
1213 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
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, "Block %d has invalid size (size %d "
1222 "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1223 wavpack_decode_flush(avctx);
1226 if ((samplecount = wavpack_decode_block(avctx, s->block,
1227 s->frame.data[0], got_frame_ptr,
1228 buf, frame_size)) < 0) {
1229 wavpack_decode_flush(avctx);
1233 buf += frame_size; buf_size -= frame_size;
1237 *(AVFrame *)data = s->frame;
1242 AVCodec ff_wavpack_decoder = {
1244 .type = AVMEDIA_TYPE_AUDIO,
1245 .id = CODEC_ID_WAVPACK,
1246 .priv_data_size = sizeof(WavpackContext),
1247 .init = wavpack_decode_init,
1248 .close = wavpack_decode_end,
1249 .decode = wavpack_decode_frame,
1250 .flush = wavpack_decode_flush,
1251 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1252 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),