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_check_crc(WavpackFrameContext *s, uint32_t crc,
504 uint32_t crc_extra_bits)
507 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
508 return AVERROR_INVALIDDATA;
510 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
511 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
512 return AVERROR_INVALIDDATA;
518 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
519 void *dst, const int type)
523 int A, B, L, L2, R, R2;
525 uint32_t crc = s->sc.crc;
526 uint32_t crc_extra_bits = s->extra_sc.crc;
527 int16_t *dst16 = dst;
528 int32_t *dst32 = dst;
530 const int channel_pad = s->avctx->channels - 2;
532 s->one = s->zero = s->zeroes = 0;
534 L = wv_get_value(s, gb, 0, &last);
537 R = wv_get_value(s, gb, 1, &last);
540 for (i = 0; i < s->terms; i++) {
541 t = s->decorr[i].value;
545 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
546 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
548 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
549 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
551 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
552 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
555 A = s->decorr[i].samplesA[pos];
556 B = s->decorr[i].samplesB[pos];
559 if (type != AV_SAMPLE_FMT_S16) {
560 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
561 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
563 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
564 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
566 if (A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
567 if (B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
568 s->decorr[i].samplesA[j] = L = L2;
569 s->decorr[i].samplesB[j] = R = R2;
570 } else if (t == -1) {
571 if (type != AV_SAMPLE_FMT_S16)
572 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
574 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
575 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
577 if (type != AV_SAMPLE_FMT_S16)
578 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
580 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
581 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
583 s->decorr[i].samplesA[0] = R;
585 if (type != AV_SAMPLE_FMT_S16)
586 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
588 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
589 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
593 R2 = s->decorr[i].samplesA[0];
594 s->decorr[i].samplesA[0] = R;
597 if (type != AV_SAMPLE_FMT_S16)
598 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
600 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
601 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
603 s->decorr[i].samplesB[0] = L;
608 L += (R -= (L >> 1));
609 crc = (crc * 3 + L) * 3 + R;
611 if (type == AV_SAMPLE_FMT_FLT) {
612 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
613 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
614 dstfl += channel_pad;
615 } else if (type == AV_SAMPLE_FMT_S32) {
616 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
617 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
618 dst32 += channel_pad;
620 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
621 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
622 dst16 += channel_pad;
625 } while (!last && count < s->samples);
627 wv_reset_saved_context(s);
628 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
629 wv_check_crc(s, crc, crc_extra_bits))
630 return AVERROR_INVALIDDATA;
635 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
636 void *dst, const int type)
642 uint32_t crc = s->sc.crc;
643 uint32_t crc_extra_bits = s->extra_sc.crc;
644 int16_t *dst16 = dst;
645 int32_t *dst32 = dst;
647 const int channel_stride = s->avctx->channels;
649 s->one = s->zero = s->zeroes = 0;
651 T = wv_get_value(s, gb, 0, &last);
655 for (i = 0; i < s->terms; i++) {
656 t = s->decorr[i].value;
659 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
661 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
662 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
665 A = s->decorr[i].samplesA[pos];
668 if (type != AV_SAMPLE_FMT_S16)
669 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
671 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
673 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
674 s->decorr[i].samplesA[j] = T = S;
679 if (type == AV_SAMPLE_FMT_FLT) {
680 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
681 dstfl += channel_stride;
682 } else if (type == AV_SAMPLE_FMT_S32) {
683 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
684 dst32 += channel_stride;
686 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
687 dst16 += channel_stride;
690 } while (!last && count < s->samples);
692 wv_reset_saved_context(s);
693 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
694 wv_check_crc(s, crc, crc_extra_bits))
695 return AVERROR_INVALIDDATA;
700 static av_cold int wv_alloc_frame_context(WavpackContext *c)
703 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
706 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
707 if (!c->fdec[c->fdec_num])
710 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
711 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
716 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
718 WavpackContext *s = avctx->priv_data;
721 if (avctx->bits_per_coded_sample <= 16)
722 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
724 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
725 if (avctx->channels <= 2 && !avctx->channel_layout)
726 avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO :
729 s->multichannel = avctx->channels > 2;
730 /* lavf demuxer does not provide extradata, Matroska stores 0x403
731 there, use this to detect decoding mode for multichannel */
733 if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
734 int ver = AV_RL16(avctx->extradata);
735 if (ver >= 0x402 && ver <= 0x410)
741 avcodec_get_frame_defaults(&s->frame);
742 avctx->coded_frame = &s->frame;
747 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
749 WavpackContext *s = avctx->priv_data;
752 for (i = 0; i < s->fdec_num; i++)
753 av_freep(&s->fdec[i]);
759 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
760 void *data, int *got_frame_ptr,
761 const uint8_t *buf, int buf_size)
763 WavpackContext *wc = avctx->priv_data;
764 WavpackFrameContext *s;
765 void *samples = data;
767 int got_terms = 0, got_weights = 0, got_samples = 0,
768 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
769 const uint8_t *orig_buf = buf;
770 const uint8_t *buf_end = buf + buf_size;
771 int i, j, id, size, ssize, weights, t;
772 int bpp, chan, chmask, orig_bpp;
779 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
780 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
784 s = wc->fdec[block_no];
786 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
790 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
791 memset(s->ch, 0, sizeof(s->ch));
793 s->and = s->or = s->shift = 0;
794 s->got_extra_bits = 0;
797 s->samples = AV_RL32(buf); buf += 4;
803 s->samples = wc->samples;
805 s->frame_flags = AV_RL32(buf); buf += 4;
806 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
807 samples = (uint8_t*)samples + bpp * wc->ch_offset;
808 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
810 s->stereo = !(s->frame_flags & WV_MONO);
811 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
812 s->joint = s->frame_flags & WV_JOINT_STEREO;
813 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
814 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
815 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
816 s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1);
817 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
818 s->CRC = AV_RL32(buf); buf += 4;
820 buf += 4; //skip block size;
822 wc->ch_offset += 1 + s->stereo;
824 // parse metadata blocks
825 while (buf < buf_end) {
828 if (id & WP_IDF_LONG) {
829 size |= (*buf++) << 8;
830 size |= (*buf++) << 16;
832 size <<= 1; // size is specified in words
837 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
840 if (buf + ssize > buf_end) {
841 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
844 if (id & WP_IDF_IGNORE) {
848 switch (id & WP_IDF_MASK) {
850 if (size > MAX_TERMS) {
851 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
857 for (i = 0; i < s->terms; i++) {
858 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
859 s->decorr[s->terms - i - 1].delta = *buf >> 5;
864 case WP_ID_DECWEIGHTS:
866 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
869 weights = size >> s->stereo_in;
870 if (weights > MAX_TERMS || weights > s->terms) {
871 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
875 for (i = 0; i < weights; i++) {
876 t = (int8_t)(*buf++);
877 s->decorr[s->terms - i - 1].weightA = t << 3;
878 if (s->decorr[s->terms - i - 1].weightA > 0)
879 s->decorr[s->terms - i - 1].weightA +=
880 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
882 t = (int8_t)(*buf++);
883 s->decorr[s->terms - i - 1].weightB = t << 3;
884 if (s->decorr[s->terms - i - 1].weightB > 0)
885 s->decorr[s->terms - i - 1].weightB +=
886 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
891 case WP_ID_DECSAMPLES:
893 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
897 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
898 if (s->decorr[i].value > 8) {
899 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
900 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
902 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
903 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
907 } else if (s->decorr[i].value < 0) {
908 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
909 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
912 for (j = 0; j < s->decorr[i].value; j++) {
913 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
915 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
918 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
924 if (size != 6 * (s->stereo_in + 1)) {
925 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
926 "got %i", 6 * (s->stereo_in + 1), size);
930 for (j = 0; j <= s->stereo_in; j++) {
931 for (i = 0; i < 3; i++) {
932 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
939 if (s->hybrid_bitrate) {
940 for (i = 0; i <= s->stereo_in; i++) {
941 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
946 for (i = 0; i < (s->stereo_in + 1); i++) {
947 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
952 for (i = 0; i < (s->stereo_in + 1); i++) {
953 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
957 for (i = 0; i < (s->stereo_in + 1); i++)
958 s->ch[i].bitrate_delta = 0;
962 case WP_ID_INT32INFO:
964 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
969 s->extra_bits = buf[0];
979 /* original WavPack decoder forces 32-bit lossy sound to be treated
980 * as 24-bit one in order to have proper clipping
982 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
985 s->hybrid_maxclip >>= 8;
986 s->hybrid_minclip >>= 8;
990 case WP_ID_FLOATINFO:
992 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
996 s->float_flag = buf[0];
997 s->float_shift = buf[1];
998 s->float_max_exp = buf[2];
1003 s->sc.offset = buf - orig_buf;
1004 s->sc.size = size * 8;
1005 init_get_bits(&s->gb, buf, size * 8);
1006 s->data_size = size * 8;
1010 case WP_ID_EXTRABITS:
1012 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1017 s->extra_sc.offset = buf - orig_buf;
1018 s->extra_sc.size = size * 8;
1019 init_get_bits(&s->gb_extra_bits, buf, size * 8);
1020 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1022 s->got_extra_bits = 1;
1024 case WP_ID_CHANINFO:
1026 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1031 case 0: chmask = *buf; break;
1032 case 1: chmask = AV_RL16(buf); break;
1033 case 2: chmask = AV_RL24(buf); break;
1034 case 3: chmask = AV_RL32(buf); break;
1036 chan |= (buf[1] & 0xF) << 8;
1037 chmask = AV_RL24(buf + 2);
1040 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1042 chan = avctx->channels;
1043 chmask = avctx->channel_layout;
1045 if (chan != avctx->channels) {
1046 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1047 "decoder believes it's %d channels\n", chan,
1051 if (!avctx->channel_layout)
1052 avctx->channel_layout = chmask;
1058 if (id & WP_IDF_ODD)
1063 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1067 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1071 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1075 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1078 if (s->hybrid && !got_hybrid) {
1079 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1083 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1086 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1087 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1090 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1091 const int size = get_bits_left(&s->gb_extra_bits);
1092 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1093 if (size < wanted) {
1094 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1095 s->got_extra_bits = 0;
1100 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1101 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1102 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1103 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1105 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1107 if (samplecount < 0)
1112 const int channel_stride = avctx->channels;
1114 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1115 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1116 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1117 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1119 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1121 if (samplecount < 0)
1124 if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1125 int16_t *dst = (int16_t*)samples + 1;
1126 int16_t *src = (int16_t*)samples;
1127 int cnt = samplecount;
1130 src += channel_stride;
1131 dst += channel_stride;
1133 } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1134 int32_t *dst = (int32_t*)samples + 1;
1135 int32_t *src = (int32_t*)samples;
1136 int cnt = samplecount;
1139 src += channel_stride;
1140 dst += channel_stride;
1142 } else if (s->stereo) {
1143 float *dst = (float*)samples + 1;
1144 float *src = (float*)samples;
1145 int cnt = samplecount;
1148 src += channel_stride;
1149 dst += channel_stride;
1156 return samplecount * bpp;
1159 static void wavpack_decode_flush(AVCodecContext *avctx)
1161 WavpackContext *s = avctx->priv_data;
1164 for (i = 0; i < s->fdec_num; i++)
1165 wv_reset_saved_context(s->fdec[i]);
1168 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1169 int *got_frame_ptr, AVPacket *avpkt)
1171 WavpackContext *s = avctx->priv_data;
1172 const uint8_t *buf = avpkt->data;
1173 int buf_size = avpkt->size;
1174 int frame_size, ret, frame_flags;
1175 int samplecount = 0;
1180 /* determine number of samples */
1182 s->samples = AV_RL32(buf); buf += 4;
1183 frame_flags = AV_RL32(buf);
1185 if (s->multichannel) {
1186 s->samples = AV_RL32(buf + 4);
1187 frame_flags = AV_RL32(buf + 8);
1189 s->samples = AV_RL32(buf);
1190 frame_flags = AV_RL32(buf + 4);
1193 if (s->samples <= 0) {
1194 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1196 return AVERROR(EINVAL);
1199 if (frame_flags & 0x80) {
1200 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1201 } else if ((frame_flags & 0x03) <= 1) {
1202 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1204 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1205 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1208 /* get output buffer */
1209 s->frame.nb_samples = s->samples;
1210 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1211 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1215 while (buf_size > 0) {
1216 if (!s->multichannel) {
1217 frame_size = buf_size;
1220 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1222 if (buf_size < 12) //MKV files can have zero flags after last block
1224 frame_size = AV_RL32(buf + 8) + 12;
1227 if (frame_size < 0 || frame_size > buf_size) {
1228 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1229 "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1230 wavpack_decode_flush(avctx);
1233 if ((samplecount = wavpack_decode_block(avctx, s->block,
1234 s->frame.data[0], got_frame_ptr,
1235 buf, frame_size)) < 0) {
1236 wavpack_decode_flush(avctx);
1240 buf += frame_size; buf_size -= frame_size;
1244 *(AVFrame *)data = s->frame;
1249 AVCodec ff_wavpack_decoder = {
1251 .type = AVMEDIA_TYPE_AUDIO,
1252 .id = CODEC_ID_WAVPACK,
1253 .priv_data_size = sizeof(WavpackContext),
1254 .init = wavpack_decode_init,
1255 .close = wavpack_decode_end,
1256 .decode = wavpack_decode_frame,
1257 .flush = wavpack_decode_flush,
1258 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1259 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),