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
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 if(s->frame_flags&0x80){
787 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
788 } else if((s->frame_flags&0x03) <= 1){
789 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
791 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
793 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
794 samples = (uint8_t*)samples + bpp * wc->ch_offset;
796 s->stereo = !(s->frame_flags & WV_MONO);
797 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
798 s->joint = s->frame_flags & WV_JOINT_STEREO;
799 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
800 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
801 s->hybrid_maxclip = (1LL << ((((s->frame_flags & 0x03) + 1) << 3) - 1)) - 1;
802 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
803 s->CRC = AV_RL32(buf); buf += 4;
805 buf += 4; //skip block size;
807 wc->ch_offset += 1 + s->stereo;
809 // parse metadata blocks
810 while(buf < buf_end){
813 if(id & WP_IDF_LONG) {
814 size |= (*buf++) << 8;
815 size |= (*buf++) << 16;
817 size <<= 1; // size is specified in words
819 if(id & WP_IDF_ODD) size--;
821 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
824 if(buf + ssize > buf_end){
825 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
828 if(id & WP_IDF_IGNORE){
832 switch(id & WP_IDF_MASK){
834 if(size > MAX_TERMS){
835 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
841 for(i = 0; i < s->terms; i++) {
842 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
843 s->decorr[s->terms - i - 1].delta = *buf >> 5;
848 case WP_ID_DECWEIGHTS:
850 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
853 weights = size >> s->stereo_in;
854 if(weights > MAX_TERMS || weights > s->terms){
855 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
859 for(i = 0; i < weights; i++) {
860 t = (int8_t)(*buf++);
861 s->decorr[s->terms - i - 1].weightA = t << 3;
862 if(s->decorr[s->terms - i - 1].weightA > 0)
863 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
865 t = (int8_t)(*buf++);
866 s->decorr[s->terms - i - 1].weightB = t << 3;
867 if(s->decorr[s->terms - i - 1].weightB > 0)
868 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
873 case WP_ID_DECSAMPLES:
875 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
879 for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
880 if(s->decorr[i].value > 8){
881 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
882 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
884 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
885 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
889 }else if(s->decorr[i].value < 0){
890 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
891 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
894 for(j = 0; j < s->decorr[i].value; j++){
895 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
897 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
900 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
906 if(size != 6 * (s->stereo_in + 1)){
907 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
911 for(j = 0; j <= s->stereo_in; j++){
912 for(i = 0; i < 3; i++){
913 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
920 if(s->hybrid_bitrate){
921 for(i = 0; i <= s->stereo_in; i++){
922 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
927 for(i = 0; i < (s->stereo_in + 1); i++){
928 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
933 for(i = 0; i < (s->stereo_in + 1); i++){
934 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
938 for(i = 0; i < (s->stereo_in + 1); i++)
939 s->ch[i].bitrate_delta = 0;
943 case WP_ID_INT32INFO:
945 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
950 s->extra_bits = buf[0];
962 case WP_ID_FLOATINFO:
964 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
968 s->float_flag = buf[0];
969 s->float_shift = buf[1];
970 s->float_max_exp = buf[2];
975 s->sc.offset = buf - orig_buf;
976 s->sc.size = size * 8;
977 init_get_bits(&s->gb, buf, size * 8);
978 s->data_size = size * 8;
982 case WP_ID_EXTRABITS:
984 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
988 s->extra_sc.offset = buf - orig_buf;
989 s->extra_sc.size = size * 8;
990 init_get_bits(&s->gb_extra_bits, buf, size * 8);
991 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
993 s->got_extra_bits = 1;
997 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1006 chmask = AV_RL16(buf);
1009 chmask = AV_RL24(buf);
1012 chmask = AV_RL32(buf);
1015 chan |= (buf[1] & 0xF) << 8;
1016 chmask = AV_RL24(buf + 2);
1019 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
1020 chan = avctx->channels;
1021 chmask = avctx->channel_layout;
1023 if(chan != avctx->channels){
1024 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
1025 chan, avctx->channels);
1028 if(!avctx->channel_layout)
1029 avctx->channel_layout = chmask;
1035 if(id & WP_IDF_ODD) buf++;
1039 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1043 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1047 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1051 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1054 if(s->hybrid && !got_hybrid){
1055 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1059 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1062 if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
1063 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1066 if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
1067 const int size = get_bits_left(&s->gb_extra_bits);
1068 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1070 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1071 s->got_extra_bits = 0;
1076 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1077 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1078 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1079 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1081 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1083 if (samplecount < 0)
1088 const int channel_stride = avctx->channels;
1090 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1091 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1092 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1093 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1095 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1097 if (samplecount < 0)
1100 if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
1101 int16_t *dst = (int16_t*)samples + 1;
1102 int16_t *src = (int16_t*)samples;
1103 int cnt = samplecount;
1106 src += channel_stride;
1107 dst += channel_stride;
1109 }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
1110 int32_t *dst = (int32_t*)samples + 1;
1111 int32_t *src = (int32_t*)samples;
1112 int cnt = samplecount;
1115 src += channel_stride;
1116 dst += channel_stride;
1118 }else if(s->stereo){
1119 float *dst = (float*)samples + 1;
1120 float *src = (float*)samples;
1121 int cnt = samplecount;
1124 src += channel_stride;
1125 dst += channel_stride;
1132 return samplecount * bpp;
1135 static void wavpack_decode_flush(AVCodecContext *avctx)
1137 WavpackContext *s = avctx->priv_data;
1140 for (i = 0; i < s->fdec_num; i++)
1141 wv_reset_saved_context(s->fdec[i]);
1144 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1145 int *got_frame_ptr, AVPacket *avpkt)
1147 WavpackContext *s = avctx->priv_data;
1148 const uint8_t *buf = avpkt->data;
1149 int buf_size = avpkt->size;
1150 int frame_size, ret;
1151 int samplecount = 0;
1156 /* determine number of samples */
1158 s->samples = AV_RL32(buf); buf += 4;
1160 if (s->multichannel)
1161 s->samples = AV_RL32(buf + 4);
1163 s->samples = AV_RL32(buf);
1165 if (s->samples <= 0) {
1166 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1168 return AVERROR(EINVAL);
1171 /* get output buffer */
1172 s->frame.nb_samples = s->samples;
1173 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1174 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1178 while(buf_size > 0){
1179 if(!s->multichannel){
1180 frame_size = buf_size;
1183 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1185 if(buf_size < 12) //MKV files can have zero flags after last block
1187 frame_size = AV_RL32(buf + 8) + 12;
1190 if(frame_size < 0 || frame_size > buf_size){
1191 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1192 s->block, frame_size, buf_size);
1193 wavpack_decode_flush(avctx);
1196 if((samplecount = wavpack_decode_block(avctx, s->block, s->frame.data[0],
1197 got_frame_ptr, buf, frame_size)) < 0) {
1198 wavpack_decode_flush(avctx);
1202 buf += frame_size; buf_size -= frame_size;
1206 *(AVFrame *)data = s->frame;
1211 AVCodec ff_wavpack_decoder = {
1213 .type = AVMEDIA_TYPE_AUDIO,
1214 .id = CODEC_ID_WAVPACK,
1215 .priv_data_size = sizeof(WavpackContext),
1216 .init = wavpack_decode_init,
1217 .close = wavpack_decode_end,
1218 .decode = wavpack_decode_frame,
1219 .flush = wavpack_decode_flush,
1220 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1221 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),