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 ALT_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;
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);
406 bit = (S & s->and) | s->or;
407 return (((S + bit) << s->shift) - bit) << s->post_shift;
410 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
418 int exp = s->float_max_exp;
420 if(s->got_extra_bits){
421 const int max_bits = 1 + 23 + 8 + 1;
422 const int left_bits = get_bits_left(&s->gb_extra_bits);
424 if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
429 S <<= s->float_shift;
434 if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
435 S = get_bits(&s->gb_extra_bits, 23);
441 int shift = 23 - av_log2(S);
442 exp = s->float_max_exp;
450 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
451 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
452 S |= (1 << shift) - 1;
453 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
454 S |= get_bits(&s->gb_extra_bits, shift);
458 exp = s->float_max_exp;
464 if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
465 if(get_bits1(&s->gb_extra_bits)){
466 S = get_bits(&s->gb_extra_bits, 23);
467 if(s->float_max_exp >= 25)
468 exp = get_bits(&s->gb_extra_bits, 8);
469 sign = get_bits1(&s->gb_extra_bits);
471 if(s->float_flag & WV_FLT_ZERO_SIGN)
472 sign = get_bits1(&s->gb_extra_bits);
477 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
479 value.u = (sign << 31) | (exp << 23) | S;
483 static void wv_reset_saved_context(WavpackFrameContext *s)
486 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
489 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
493 int A, B, L, L2, R, R2;
495 uint32_t crc = s->sc.crc;
496 uint32_t crc_extra_bits = s->extra_sc.crc;
497 int16_t *dst16 = dst;
498 int32_t *dst32 = dst;
500 const int channel_pad = s->avctx->channels - 2;
502 s->one = s->zero = s->zeroes = 0;
504 L = wv_get_value(s, gb, 0, &last);
506 R = wv_get_value(s, gb, 1, &last);
508 for(i = 0; i < s->terms; i++){
509 t = s->decorr[i].value;
513 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
514 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
516 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
517 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
519 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
520 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
523 A = s->decorr[i].samplesA[pos];
524 B = s->decorr[i].samplesB[pos];
527 if(type != AV_SAMPLE_FMT_S16){
528 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
529 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
531 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
532 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
534 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
535 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
536 s->decorr[i].samplesA[j] = L = L2;
537 s->decorr[i].samplesB[j] = R = R2;
539 if(type != AV_SAMPLE_FMT_S16)
540 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
542 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
543 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
545 if(type != AV_SAMPLE_FMT_S16)
546 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
548 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
549 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
551 s->decorr[i].samplesA[0] = R;
553 if(type != AV_SAMPLE_FMT_S16)
554 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
556 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
557 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
561 R2 = s->decorr[i].samplesA[0];
562 s->decorr[i].samplesA[0] = R;
565 if(type != AV_SAMPLE_FMT_S16)
566 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
568 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
569 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
571 s->decorr[i].samplesB[0] = L;
576 L += (R -= (L >> 1));
577 crc = (crc * 3 + L) * 3 + R;
579 if(type == AV_SAMPLE_FMT_FLT){
580 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
581 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
582 dstfl += channel_pad;
583 } else if(type == AV_SAMPLE_FMT_S32){
584 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
585 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
586 dst32 += channel_pad;
588 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
589 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
590 dst16 += channel_pad;
593 } while (!last && count < s->samples);
595 wv_reset_saved_context(s);
597 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
600 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
601 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
608 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
614 uint32_t crc = s->sc.crc;
615 uint32_t crc_extra_bits = s->extra_sc.crc;
616 int16_t *dst16 = dst;
617 int32_t *dst32 = dst;
619 const int channel_stride = s->avctx->channels;
621 s->one = s->zero = s->zeroes = 0;
623 T = wv_get_value(s, gb, 0, &last);
626 for(i = 0; i < s->terms; i++){
627 t = s->decorr[i].value;
630 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
632 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
633 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
636 A = s->decorr[i].samplesA[pos];
639 if(type != AV_SAMPLE_FMT_S16)
640 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
642 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
643 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
644 s->decorr[i].samplesA[j] = T = S;
649 if(type == AV_SAMPLE_FMT_FLT){
650 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
651 dstfl += channel_stride;
652 }else if(type == AV_SAMPLE_FMT_S32){
653 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
654 dst32 += channel_stride;
656 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
657 dst16 += channel_stride;
660 } while (!last && count < s->samples);
662 wv_reset_saved_context(s);
664 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
667 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
668 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
675 static av_cold int wv_alloc_frame_context(WavpackContext *c)
678 if(c->fdec_num == WV_MAX_FRAME_DECODERS)
681 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
682 if(!c->fdec[c->fdec_num])
685 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
686 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
691 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
693 WavpackContext *s = avctx->priv_data;
696 if(avctx->bits_per_coded_sample <= 16)
697 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
699 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
700 if(avctx->channels <= 2 && !avctx->channel_layout)
701 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
703 s->multichannel = avctx->channels > 2;
704 /* lavf demuxer does not provide extradata, Matroska stores 0x403
705 there, use this to detect decoding mode for multichannel */
707 if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
708 int ver = AV_RL16(avctx->extradata);
709 if(ver >= 0x402 && ver <= 0x410)
715 avcodec_get_frame_defaults(&s->frame);
716 avctx->coded_frame = &s->frame;
721 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
723 WavpackContext *s = avctx->priv_data;
726 for(i = 0; i < s->fdec_num; i++)
727 av_freep(&s->fdec[i]);
733 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
734 void *data, int *got_frame_ptr,
735 const uint8_t *buf, int buf_size)
737 WavpackContext *wc = avctx->priv_data;
738 WavpackFrameContext *s;
739 void *samples = data;
741 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
743 const uint8_t* orig_buf = buf;
744 const uint8_t* buf_end = buf + buf_size;
745 int i, j, id, size, ssize, weights, t;
746 int bpp, chan, chmask;
753 if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
754 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
758 s = wc->fdec[block_no];
760 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
764 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
765 memset(s->ch, 0, sizeof(s->ch));
767 s->and = s->or = s->shift = 0;
768 s->got_extra_bits = 0;
771 s->samples = AV_RL32(buf); buf += 4;
777 s->samples = wc->samples;
779 s->frame_flags = AV_RL32(buf); buf += 4;
780 if(s->frame_flags&0x80){
781 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
782 } else if((s->frame_flags&0x03) <= 1){
783 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
785 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
787 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
788 samples = (uint8_t*)samples + bpp * wc->ch_offset;
790 s->stereo = !(s->frame_flags & WV_MONO);
791 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
792 s->joint = s->frame_flags & WV_JOINT_STEREO;
793 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
794 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
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;
1144 int samplecount = 0;
1149 /* determine number of samples */
1151 s->samples = AV_RL32(buf); buf += 4;
1153 if (s->multichannel)
1154 s->samples = AV_RL32(buf + 4);
1156 s->samples = AV_RL32(buf);
1158 if (s->samples <= 0) {
1159 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1161 return AVERROR(EINVAL);
1164 /* get output buffer */
1165 s->frame.nb_samples = s->samples;
1166 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1167 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1171 while(buf_size > 0){
1172 if(!s->multichannel){
1173 frame_size = buf_size;
1176 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1178 if(buf_size < 12) //MKV files can have zero flags after last block
1180 frame_size = AV_RL32(buf + 8) + 12;
1183 if(frame_size < 0 || frame_size > buf_size){
1184 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1185 s->block, frame_size, buf_size);
1186 wavpack_decode_flush(avctx);
1189 if((samplecount = wavpack_decode_block(avctx, s->block, s->frame.data[0],
1190 got_frame_ptr, buf, frame_size)) < 0) {
1191 wavpack_decode_flush(avctx);
1195 buf += frame_size; buf_size -= frame_size;
1199 *(AVFrame *)data = s->frame;
1204 AVCodec ff_wavpack_decoder = {
1206 .type = AVMEDIA_TYPE_AUDIO,
1207 .id = CODEC_ID_WAVPACK,
1208 .priv_data_size = sizeof(WavpackContext),
1209 .init = wavpack_decode_init,
1210 .close = wavpack_decode_end,
1211 .decode = wavpack_decode_frame,
1212 .flush = wavpack_decode_flush,
1213 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1214 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),