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
21 #define BITSTREAM_READER_LE
25 #include "libavutil/audioconvert.h"
29 * WavPack lossless audio decoder
32 #define WV_MONO 0x00000004
33 #define WV_JOINT_STEREO 0x00000010
34 #define WV_FALSE_STEREO 0x40000000
36 #define WV_HYBRID_MODE 0x00000008
37 #define WV_HYBRID_SHAPE 0x00000008
38 #define WV_HYBRID_BITRATE 0x00000200
39 #define WV_HYBRID_BALANCE 0x00000400
41 #define WV_FLT_SHIFT_ONES 0x01
42 #define WV_FLT_SHIFT_SAME 0x02
43 #define WV_FLT_SHIFT_SENT 0x04
44 #define WV_FLT_ZERO_SENT 0x08
45 #define WV_FLT_ZERO_SIGN 0x10
71 typedef struct SavedContext {
80 typedef struct Decorr {
89 typedef struct WvChannel {
91 int slow_level, error_limit;
92 int bitrate_acc, bitrate_delta;
95 typedef struct WavpackFrameContext {
96 AVCodecContext *avctx;
98 int stereo, stereo_in;
103 uint32_t crc_extra_bits;
104 GetBitContext gb_extra_bits;
105 int data_size; // in bits
108 Decorr decorr[MAX_TERMS];
109 int zero, one, zeroes;
113 int hybrid, hybrid_bitrate, hybrid_maxclip;
119 SavedContext sc, extra_sc;
120 } WavpackFrameContext;
122 #define WV_MAX_FRAME_DECODERS 14
124 typedef struct WavpackContext {
125 AVCodecContext *avctx;
128 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
138 // exponent table copied from WavPack source
139 static const uint8_t wp_exp2_table [256] = {
140 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
141 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
142 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
143 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
144 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
145 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
146 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
147 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
148 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
149 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
150 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
151 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
152 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
153 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
154 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
155 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
158 static const uint8_t wp_log2_table [] = {
159 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
160 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
161 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
162 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
163 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
164 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
165 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
166 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
167 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
168 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
169 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
170 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
171 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
172 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
173 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
174 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
177 static av_always_inline int wp_exp2(int16_t val)
186 res = wp_exp2_table[val & 0xFF] | 0x100;
188 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
189 return neg ? -res : res;
192 static av_always_inline int wp_log2(int32_t val)
201 bits = av_log2(val) + 1;
203 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
205 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
208 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
210 // macros for manipulating median values
211 #define GET_MED(n) ((c->median[n] >> 4) + 1)
212 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
213 #define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
215 // macros for applying weight
216 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
218 if((samples ^ in) < 0){ \
220 if(weight < -1024) weight = -1024; \
223 if(weight > 1024) weight = 1024; \
228 static av_always_inline int get_tail(GetBitContext *gb, int k)
234 e = (1 << (p + 1)) - k - 1;
235 res = p ? get_bits(gb, p) : 0;
237 res = (res<<1) - e + get_bits1(gb);
242 static void update_error_limit(WavpackFrameContext *ctx)
246 for(i = 0; i <= ctx->stereo_in; i++){
247 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
248 br[i] = ctx->ch[i].bitrate_acc >> 16;
249 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
251 if(ctx->stereo_in && ctx->hybrid_bitrate){
252 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
256 }else if(-balance > br[0]){
260 br[1] = br[0] + balance;
261 br[0] = br[0] - balance;
264 for(i = 0; i <= ctx->stereo_in; i++){
265 if(ctx->hybrid_bitrate){
266 if(sl[i] - br[i] > -0x100)
267 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
269 ctx->ch[i].error_limit = 0;
271 ctx->ch[i].error_limit = wp_exp2(br[i]);
276 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, int channel, int *last)
279 int sign, base, add, ret;
280 WvChannel *c = &ctx->ch[channel];
284 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
288 c->slow_level -= LEVEL_DECAY(c->slow_level);
292 t = get_unary_0_33(gb);
294 if(get_bits_left(gb) < t-1)
296 t = get_bits(gb, t - 1) | (1 << (t-1));
298 if(get_bits_left(gb) < 0)
303 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
304 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
305 c->slow_level -= LEVEL_DECAY(c->slow_level);
315 t = get_unary_0_33(gb);
316 if(get_bits_left(gb) < 0)
319 t2 = get_unary_0_33(gb);
321 if(get_bits_left(gb) < 0)
325 if(get_bits_left(gb) < t2 - 1)
327 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
338 ctx->zero = !ctx->one;
341 if(ctx->hybrid && !channel)
342 update_error_limit(ctx);
346 add = GET_MED(0) - 1;
350 add = GET_MED(1) - 1;
354 base = GET_MED(0) + GET_MED(1);
355 add = GET_MED(2) - 1;
360 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
361 add = GET_MED(2) - 1;
367 ret = base + get_tail(gb, add);
368 if (get_bits_left(gb) <= 0)
371 int mid = (base*2 + add + 1) >> 1;
372 while(add > c->error_limit){
373 if(get_bits_left(gb) <= 0)
379 add = mid - base - 1;
380 mid = (base*2 + add + 1) >> 1;
384 sign = get_bits1(gb);
385 if(ctx->hybrid_bitrate)
386 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
387 return sign ? ~ret : ret;
394 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
401 if(s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits){
402 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
403 *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
407 bit = (S & s->and) | s->or;
408 bit = (((S + bit) << s->shift) - bit) << s->post_shift;
411 bit = av_clip(bit, -s->hybrid_maxclip - 1, s->hybrid_maxclip);
416 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
424 int exp = s->float_max_exp;
426 if(s->got_extra_bits){
427 const int max_bits = 1 + 23 + 8 + 1;
428 const int left_bits = get_bits_left(&s->gb_extra_bits);
430 if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
435 S <<= s->float_shift;
440 if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
441 S = get_bits(&s->gb_extra_bits, 23);
447 int shift = 23 - av_log2(S);
448 exp = s->float_max_exp;
456 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
457 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
458 S |= (1 << shift) - 1;
459 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
460 S |= get_bits(&s->gb_extra_bits, shift);
464 exp = s->float_max_exp;
470 if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
471 if(get_bits1(&s->gb_extra_bits)){
472 S = get_bits(&s->gb_extra_bits, 23);
473 if(s->float_max_exp >= 25)
474 exp = get_bits(&s->gb_extra_bits, 8);
475 sign = get_bits1(&s->gb_extra_bits);
477 if(s->float_flag & WV_FLT_ZERO_SIGN)
478 sign = get_bits1(&s->gb_extra_bits);
483 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
485 value.u = (sign << 31) | (exp << 23) | S;
489 static void wv_reset_saved_context(WavpackFrameContext *s)
492 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
495 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
499 int A, B, L, L2, R, R2;
501 uint32_t crc = s->sc.crc;
502 uint32_t crc_extra_bits = s->extra_sc.crc;
503 int16_t *dst16 = dst;
504 int32_t *dst32 = dst;
506 const int channel_pad = s->avctx->channels - 2;
508 s->one = s->zero = s->zeroes = 0;
510 L = wv_get_value(s, gb, 0, &last);
512 R = wv_get_value(s, gb, 1, &last);
514 for(i = 0; i < s->terms; i++){
515 t = s->decorr[i].value;
519 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
520 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
522 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
523 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
525 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
526 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
529 A = s->decorr[i].samplesA[pos];
530 B = s->decorr[i].samplesB[pos];
533 if(type != AV_SAMPLE_FMT_S16){
534 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
535 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
537 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
538 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
540 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
541 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
542 s->decorr[i].samplesA[j] = L = L2;
543 s->decorr[i].samplesB[j] = R = R2;
545 if(type != AV_SAMPLE_FMT_S16)
546 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
548 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
549 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
551 if(type != AV_SAMPLE_FMT_S16)
552 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
554 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
555 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
557 s->decorr[i].samplesA[0] = R;
559 if(type != AV_SAMPLE_FMT_S16)
560 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
562 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
563 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
567 R2 = s->decorr[i].samplesA[0];
568 s->decorr[i].samplesA[0] = R;
571 if(type != AV_SAMPLE_FMT_S16)
572 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
574 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
575 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
577 s->decorr[i].samplesB[0] = L;
582 L += (R -= (L >> 1));
583 crc = (crc * 3 + L) * 3 + R;
585 if(type == AV_SAMPLE_FMT_FLT){
586 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
587 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
588 dstfl += channel_pad;
589 } else if(type == AV_SAMPLE_FMT_S32){
590 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
591 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
592 dst32 += channel_pad;
594 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
595 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
596 dst16 += channel_pad;
599 } while (!last && count < s->samples);
601 wv_reset_saved_context(s);
603 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
606 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
607 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
614 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
620 uint32_t crc = s->sc.crc;
621 uint32_t crc_extra_bits = s->extra_sc.crc;
622 int16_t *dst16 = dst;
623 int32_t *dst32 = dst;
625 const int channel_stride = s->avctx->channels;
627 s->one = s->zero = s->zeroes = 0;
629 T = wv_get_value(s, gb, 0, &last);
632 for(i = 0; i < s->terms; i++){
633 t = s->decorr[i].value;
636 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
638 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
639 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
642 A = s->decorr[i].samplesA[pos];
645 if(type != AV_SAMPLE_FMT_S16)
646 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
648 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
649 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
650 s->decorr[i].samplesA[j] = T = S;
655 if(type == AV_SAMPLE_FMT_FLT){
656 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
657 dstfl += channel_stride;
658 }else if(type == AV_SAMPLE_FMT_S32){
659 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
660 dst32 += channel_stride;
662 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
663 dst16 += channel_stride;
666 } while (!last && count < s->samples);
668 wv_reset_saved_context(s);
670 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
673 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
674 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
681 static av_cold int wv_alloc_frame_context(WavpackContext *c)
684 if(c->fdec_num == WV_MAX_FRAME_DECODERS)
687 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
688 if(!c->fdec[c->fdec_num])
691 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
692 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
697 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
699 WavpackContext *s = avctx->priv_data;
702 if(avctx->bits_per_coded_sample <= 16)
703 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
705 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
706 if(avctx->channels <= 2 && !avctx->channel_layout)
707 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
709 s->multichannel = avctx->channels > 2;
710 /* lavf demuxer does not provide extradata, Matroska stores 0x403
711 there, use this to detect decoding mode for multichannel */
713 if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
714 int ver = AV_RL16(avctx->extradata);
715 if(ver >= 0x402 && ver <= 0x410)
721 avcodec_get_frame_defaults(&s->frame);
722 avctx->coded_frame = &s->frame;
727 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
729 WavpackContext *s = avctx->priv_data;
732 for(i = 0; i < s->fdec_num; i++)
733 av_freep(&s->fdec[i]);
739 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
740 void *data, int *got_frame_ptr,
741 const uint8_t *buf, int buf_size)
743 WavpackContext *wc = avctx->priv_data;
744 WavpackFrameContext *s;
745 void *samples = data;
747 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
749 const uint8_t* orig_buf = buf;
750 const uint8_t* buf_end = buf + buf_size;
751 int i, j, id, size, ssize, weights, t;
752 int bpp, chan, chmask;
759 if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
760 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
764 s = wc->fdec[block_no];
766 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
770 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
771 memset(s->ch, 0, sizeof(s->ch));
773 s->and = s->or = s->shift = 0;
774 s->got_extra_bits = 0;
777 s->samples = AV_RL32(buf); buf += 4;
783 s->samples = wc->samples;
785 s->frame_flags = AV_RL32(buf); buf += 4;
786 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
787 samples = (uint8_t*)samples + bpp * wc->ch_offset;
789 s->stereo = !(s->frame_flags & WV_MONO);
790 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
791 s->joint = s->frame_flags & WV_JOINT_STEREO;
792 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
793 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
794 s->hybrid_maxclip = (1LL << ((((s->frame_flags & 0x03) + 1) << 3) - 1)) - 1;
795 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
796 s->CRC = AV_RL32(buf); buf += 4;
798 buf += 4; //skip block size;
800 wc->ch_offset += 1 + s->stereo;
802 // parse metadata blocks
803 while(buf < buf_end){
806 if(id & WP_IDF_LONG) {
807 size |= (*buf++) << 8;
808 size |= (*buf++) << 16;
810 size <<= 1; // size is specified in words
812 if(id & WP_IDF_ODD) size--;
814 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
817 if(buf + ssize > buf_end){
818 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
821 if(id & WP_IDF_IGNORE){
825 switch(id & WP_IDF_MASK){
827 if(size > MAX_TERMS){
828 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
834 for(i = 0; i < s->terms; i++) {
835 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
836 s->decorr[s->terms - i - 1].delta = *buf >> 5;
841 case WP_ID_DECWEIGHTS:
843 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
846 weights = size >> s->stereo_in;
847 if(weights > MAX_TERMS || weights > s->terms){
848 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
852 for(i = 0; i < weights; i++) {
853 t = (int8_t)(*buf++);
854 s->decorr[s->terms - i - 1].weightA = t << 3;
855 if(s->decorr[s->terms - i - 1].weightA > 0)
856 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
858 t = (int8_t)(*buf++);
859 s->decorr[s->terms - i - 1].weightB = t << 3;
860 if(s->decorr[s->terms - i - 1].weightB > 0)
861 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
866 case WP_ID_DECSAMPLES:
868 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
872 for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
873 if(s->decorr[i].value > 8){
874 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
875 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
877 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
878 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
882 }else if(s->decorr[i].value < 0){
883 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
884 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
887 for(j = 0; j < s->decorr[i].value; j++){
888 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
890 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
893 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
899 if(size != 6 * (s->stereo_in + 1)){
900 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
904 for(j = 0; j <= s->stereo_in; j++){
905 for(i = 0; i < 3; i++){
906 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
913 if(s->hybrid_bitrate){
914 for(i = 0; i <= s->stereo_in; i++){
915 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
920 for(i = 0; i < (s->stereo_in + 1); i++){
921 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
926 for(i = 0; i < (s->stereo_in + 1); i++){
927 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
931 for(i = 0; i < (s->stereo_in + 1); i++)
932 s->ch[i].bitrate_delta = 0;
936 case WP_ID_INT32INFO:
938 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
943 s->extra_bits = buf[0];
955 case WP_ID_FLOATINFO:
957 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
961 s->float_flag = buf[0];
962 s->float_shift = buf[1];
963 s->float_max_exp = buf[2];
968 s->sc.offset = buf - orig_buf;
969 s->sc.size = size * 8;
970 init_get_bits(&s->gb, buf, size * 8);
971 s->data_size = size * 8;
975 case WP_ID_EXTRABITS:
977 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
981 s->extra_sc.offset = buf - orig_buf;
982 s->extra_sc.size = size * 8;
983 init_get_bits(&s->gb_extra_bits, buf, size * 8);
984 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
986 s->got_extra_bits = 1;
990 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
999 chmask = AV_RL16(buf);
1002 chmask = AV_RL24(buf);
1005 chmask = AV_RL32(buf);
1008 chan |= (buf[1] & 0xF) << 8;
1009 chmask = AV_RL24(buf + 2);
1012 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
1013 chan = avctx->channels;
1014 chmask = avctx->channel_layout;
1016 if(chan != avctx->channels){
1017 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
1018 chan, avctx->channels);
1021 if(!avctx->channel_layout)
1022 avctx->channel_layout = chmask;
1028 if(id & WP_IDF_ODD) buf++;
1032 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1036 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1040 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1044 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1047 if(s->hybrid && !got_hybrid){
1048 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1052 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1055 if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
1056 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1059 if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
1060 const int size = get_bits_left(&s->gb_extra_bits);
1061 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1063 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1064 s->got_extra_bits = 0;
1069 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1070 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1071 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1072 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1074 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1076 if (samplecount < 0)
1081 const int channel_stride = avctx->channels;
1083 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1084 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1085 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1086 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1088 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1090 if (samplecount < 0)
1093 if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
1094 int16_t *dst = (int16_t*)samples + 1;
1095 int16_t *src = (int16_t*)samples;
1096 int cnt = samplecount;
1099 src += channel_stride;
1100 dst += channel_stride;
1102 }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
1103 int32_t *dst = (int32_t*)samples + 1;
1104 int32_t *src = (int32_t*)samples;
1105 int cnt = samplecount;
1108 src += channel_stride;
1109 dst += channel_stride;
1111 }else if(s->stereo){
1112 float *dst = (float*)samples + 1;
1113 float *src = (float*)samples;
1114 int cnt = samplecount;
1117 src += channel_stride;
1118 dst += channel_stride;
1125 return samplecount * bpp;
1128 static void wavpack_decode_flush(AVCodecContext *avctx)
1130 WavpackContext *s = avctx->priv_data;
1133 for (i = 0; i < s->fdec_num; i++)
1134 wv_reset_saved_context(s->fdec[i]);
1137 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1138 int *got_frame_ptr, AVPacket *avpkt)
1140 WavpackContext *s = avctx->priv_data;
1141 const uint8_t *buf = avpkt->data;
1142 int buf_size = avpkt->size;
1143 int frame_size, ret, frame_flags;
1144 int samplecount = 0;
1149 /* determine number of samples */
1151 s->samples = AV_RL32(buf); buf += 4;
1152 frame_flags = AV_RL32(buf);
1154 if (s->multichannel) {
1155 s->samples = AV_RL32(buf + 4);
1156 frame_flags = AV_RL32(buf + 8);
1158 s->samples = AV_RL32(buf);
1159 frame_flags = AV_RL32(buf + 4);
1162 if (s->samples <= 0) {
1163 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1165 return AVERROR(EINVAL);
1168 if (frame_flags & 0x80) {
1169 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1170 } else if ((frame_flags & 0x03) <= 1) {
1171 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1173 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1176 /* get output buffer */
1177 s->frame.nb_samples = s->samples;
1178 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1179 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1183 while(buf_size > 0){
1184 if(!s->multichannel){
1185 frame_size = buf_size;
1188 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1190 if(buf_size < 12) //MKV files can have zero flags after last block
1192 frame_size = AV_RL32(buf + 8) + 12;
1195 if(frame_size < 0 || frame_size > buf_size){
1196 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1197 s->block, frame_size, buf_size);
1198 wavpack_decode_flush(avctx);
1201 if((samplecount = wavpack_decode_block(avctx, s->block, s->frame.data[0],
1202 got_frame_ptr, buf, frame_size)) < 0) {
1203 wavpack_decode_flush(avctx);
1207 buf += frame_size; buf_size -= frame_size;
1211 *(AVFrame *)data = s->frame;
1216 AVCodec ff_wavpack_decoder = {
1218 .type = AVMEDIA_TYPE_AUDIO,
1219 .id = CODEC_ID_WAVPACK,
1220 .priv_data_size = sizeof(WavpackContext),
1221 .init = wavpack_decode_init,
1222 .close = wavpack_decode_end,
1223 .decode = wavpack_decode_frame,
1224 .flush = wavpack_decode_flush,
1225 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1226 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),