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 ALT_BITSTREAM_READER_LE
28 * WavPack lossless audio decoder
31 #define WV_MONO 0x00000004
32 #define WV_JOINT_STEREO 0x00000010
33 #define WV_FALSE_STEREO 0x40000000
35 #define WV_HYBRID_MODE 0x00000008
36 #define WV_HYBRID_SHAPE 0x00000008
37 #define WV_HYBRID_BITRATE 0x00000200
38 #define WV_HYBRID_BALANCE 0x00000400
40 #define WV_FLT_SHIFT_ONES 0x01
41 #define WV_FLT_SHIFT_SAME 0x02
42 #define WV_FLT_SHIFT_SENT 0x04
43 #define WV_FLT_ZERO_SENT 0x08
44 #define WV_FLT_ZERO_SIGN 0x10
70 typedef struct SavedContext {
79 typedef struct Decorr {
88 typedef struct WvChannel {
90 int slow_level, error_limit;
91 int bitrate_acc, bitrate_delta;
94 typedef struct WavpackFrameContext {
95 AVCodecContext *avctx;
97 int stereo, stereo_in;
102 uint32_t crc_extra_bits;
103 GetBitContext gb_extra_bits;
104 int data_size; // in bits
107 Decorr decorr[MAX_TERMS];
108 int zero, one, zeroes;
112 int hybrid, hybrid_bitrate;
120 SavedContext sc, extra_sc;
121 } WavpackFrameContext;
123 #define WV_MAX_FRAME_DECODERS 14
125 typedef struct WavpackContext {
126 AVCodecContext *avctx;
128 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
139 // exponent table copied from WavPack source
140 static const uint8_t wp_exp2_table [256] = {
141 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
142 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
143 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
144 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
145 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
146 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
147 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
148 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
149 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
150 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
151 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
152 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
153 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
154 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
155 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
156 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
159 static const uint8_t wp_log2_table [] = {
160 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
161 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
162 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
163 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
164 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
165 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
166 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
167 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
168 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
169 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
170 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
171 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
172 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
173 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
174 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
175 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
178 static av_always_inline int wp_exp2(int16_t val)
187 res = wp_exp2_table[val & 0xFF] | 0x100;
189 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
190 return neg ? -res : res;
193 static av_always_inline int wp_log2(int32_t val)
202 bits = av_log2(val) + 1;
204 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
206 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
209 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
211 // macros for manipulating median values
212 #define GET_MED(n) ((c->median[n] >> 4) + 1)
213 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
214 #define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
216 // macros for applying weight
217 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
219 if((samples ^ in) < 0){ \
221 if(weight < -1024) weight = -1024; \
224 if(weight > 1024) weight = 1024; \
229 static av_always_inline int get_tail(GetBitContext *gb, int k)
235 e = (1 << (p + 1)) - k - 1;
236 res = p ? get_bits(gb, p) : 0;
238 res = (res<<1) - e + get_bits1(gb);
243 static void update_error_limit(WavpackFrameContext *ctx)
247 for(i = 0; i <= ctx->stereo_in; i++){
248 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
249 br[i] = ctx->ch[i].bitrate_acc >> 16;
250 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
252 if(ctx->stereo_in && ctx->hybrid_bitrate){
253 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
257 }else if(-balance > br[0]){
261 br[1] = br[0] + balance;
262 br[0] = br[0] - balance;
265 for(i = 0; i <= ctx->stereo_in; i++){
266 if(ctx->hybrid_bitrate){
267 if(sl[i] - br[i] > -0x100)
268 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
270 ctx->ch[i].error_limit = 0;
272 ctx->ch[i].error_limit = wp_exp2(br[i]);
277 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, int channel, int *last)
280 int sign, base, add, ret;
281 WvChannel *c = &ctx->ch[channel];
285 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
289 c->slow_level -= LEVEL_DECAY(c->slow_level);
293 t = get_unary_0_33(gb);
294 if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1));
297 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
298 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
299 c->slow_level -= LEVEL_DECAY(c->slow_level);
305 if(get_bits_count(gb) >= ctx->data_size){
314 t = get_unary_0_33(gb);
315 if(get_bits_count(gb) >= ctx->data_size){
320 t2 = get_unary_0_33(gb);
322 else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
332 ctx->zero = !ctx->one;
335 if(ctx->hybrid && !channel)
336 update_error_limit(ctx);
340 add = GET_MED(0) - 1;
344 add = GET_MED(1) - 1;
348 base = GET_MED(0) + GET_MED(1);
349 add = GET_MED(2) - 1;
354 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
355 add = GET_MED(2) - 1;
361 ret = base + get_tail(gb, add);
363 int mid = (base*2 + add + 1) >> 1;
364 while(add > c->error_limit){
369 add = mid - base - 1;
370 mid = (base*2 + add + 1) >> 1;
374 sign = get_bits1(gb);
375 if(ctx->hybrid_bitrate)
376 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
377 return sign ? ~ret : ret;
380 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
387 if(s->got_extra_bits){
388 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
389 *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
392 bit = (S & s->and) | s->or;
393 return (((S + bit) << s->shift) - bit) << s->post_shift;
396 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
404 int exp = s->float_max_exp;
406 if(s->got_extra_bits){
407 const int max_bits = 1 + 23 + 8 + 1;
408 const int left_bits = get_bits_left(&s->gb_extra_bits);
410 if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
415 S <<= s->float_shift;
420 if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
421 S = get_bits(&s->gb_extra_bits, 23);
427 int shift = 23 - av_log2(S);
428 exp = s->float_max_exp;
436 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
437 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
438 S |= (1 << shift) - 1;
439 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
440 S |= get_bits(&s->gb_extra_bits, shift);
444 exp = s->float_max_exp;
450 if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
451 if(get_bits1(&s->gb_extra_bits)){
452 S = get_bits(&s->gb_extra_bits, 23);
453 if(s->float_max_exp >= 25)
454 exp = get_bits(&s->gb_extra_bits, 8);
455 sign = get_bits1(&s->gb_extra_bits);
457 if(s->float_flag & WV_FLT_ZERO_SIGN)
458 sign = get_bits1(&s->gb_extra_bits);
463 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
465 value.u = (sign << 31) | (exp << 23) | S;
469 static void wv_reset_saved_context(WavpackFrameContext *s)
472 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
475 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
479 int A, B, L, L2, R, R2;
481 uint32_t crc = s->sc.crc;
482 uint32_t crc_extra_bits = s->extra_sc.crc;
483 int16_t *dst16 = dst;
484 int32_t *dst32 = dst;
486 const int channel_pad = s->avctx->channels - 2;
488 if(s->samples_left == s->samples)
489 s->one = s->zero = s->zeroes = 0;
491 L = wv_get_value(s, gb, 0, &last);
493 R = wv_get_value(s, gb, 1, &last);
495 for(i = 0; i < s->terms; i++){
496 t = s->decorr[i].value;
500 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
501 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
503 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
504 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
506 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
507 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
510 A = s->decorr[i].samplesA[pos];
511 B = s->decorr[i].samplesB[pos];
514 if(type != AV_SAMPLE_FMT_S16){
515 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
516 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
518 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
519 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
521 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
522 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
523 s->decorr[i].samplesA[j] = L = L2;
524 s->decorr[i].samplesB[j] = R = R2;
526 if(type != AV_SAMPLE_FMT_S16)
527 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
529 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
530 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
532 if(type != AV_SAMPLE_FMT_S16)
533 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
535 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
536 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
538 s->decorr[i].samplesA[0] = R;
540 if(type != AV_SAMPLE_FMT_S16)
541 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
543 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
544 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
548 R2 = s->decorr[i].samplesA[0];
549 s->decorr[i].samplesA[0] = R;
552 if(type != AV_SAMPLE_FMT_S16)
553 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
555 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
556 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
558 s->decorr[i].samplesB[0] = L;
563 L += (R -= (L >> 1));
564 crc = (crc * 3 + L) * 3 + R;
566 if(type == AV_SAMPLE_FMT_FLT){
567 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
568 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
569 dstfl += channel_pad;
570 } else if(type == AV_SAMPLE_FMT_S32){
571 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
572 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
573 dst32 += channel_pad;
575 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
576 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
577 dst16 += channel_pad;
580 }while(!last && count < s->max_samples);
582 s->samples_left -= count;
583 if(!s->samples_left){
585 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
588 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
589 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
592 wv_reset_saved_context(s);
596 s->sc.bits_used = get_bits_count(&s->gb);
597 if(s->got_extra_bits){
598 s->extra_sc.crc = crc_extra_bits;
599 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
605 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
611 uint32_t crc = s->sc.crc;
612 uint32_t crc_extra_bits = s->extra_sc.crc;
613 int16_t *dst16 = dst;
614 int32_t *dst32 = dst;
616 const int channel_stride = s->avctx->channels;
618 if(s->samples_left == s->samples)
619 s->one = s->zero = s->zeroes = 0;
621 T = wv_get_value(s, gb, 0, &last);
624 for(i = 0; i < s->terms; i++){
625 t = s->decorr[i].value;
628 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
630 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
631 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
634 A = s->decorr[i].samplesA[pos];
637 if(type != AV_SAMPLE_FMT_S16)
638 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
640 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
641 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
642 s->decorr[i].samplesA[j] = T = S;
647 if(type == AV_SAMPLE_FMT_FLT){
648 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
649 dstfl += channel_stride;
650 }else if(type == AV_SAMPLE_FMT_S32){
651 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
652 dst32 += channel_stride;
654 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
655 dst16 += channel_stride;
658 }while(!last && count < s->max_samples);
660 s->samples_left -= count;
661 if(!s->samples_left){
663 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
666 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
667 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
670 wv_reset_saved_context(s);
674 s->sc.bits_used = get_bits_count(&s->gb);
675 if(s->got_extra_bits){
676 s->extra_sc.crc = crc_extra_bits;
677 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
683 static av_cold int wv_alloc_frame_context(WavpackContext *c)
686 if(c->fdec_num == WV_MAX_FRAME_DECODERS)
689 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
690 if(!c->fdec[c->fdec_num])
693 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
694 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
699 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
701 WavpackContext *s = avctx->priv_data;
704 if(avctx->bits_per_coded_sample <= 16)
705 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
707 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
708 if(avctx->channels <= 2 && !avctx->channel_layout)
709 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
711 s->multichannel = avctx->channels > 2;
712 /* lavf demuxer does not provide extradata, Matroska stores 0x403
713 there, use this to detect decoding mode for multichannel */
715 if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
716 int ver = AV_RL16(avctx->extradata);
717 if(ver >= 0x402 && ver <= 0x410)
726 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
728 WavpackContext *s = avctx->priv_data;
731 for(i = 0; i < s->fdec_num; i++)
732 av_freep(&s->fdec[i]);
738 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
739 void *data, int *data_size,
740 const uint8_t *buf, int buf_size)
742 WavpackContext *wc = avctx->priv_data;
743 WavpackFrameContext *s;
744 void *samples = data;
746 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
748 const uint8_t* orig_buf = buf;
749 const uint8_t* buf_end = buf + buf_size;
750 int i, j, id, size, ssize, weights, t;
751 int bpp, chan, chmask;
758 if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
759 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
763 s = wc->fdec[block_no];
765 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
769 if(!s->samples_left){
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;
778 s->samples = AV_RL32(buf); buf += 4;
784 s->samples = wc->samples;
786 s->frame_flags = AV_RL32(buf); buf += 4;
787 if(s->frame_flags&0x80){
789 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
790 } else if((s->frame_flags&0x03) <= 1){
792 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
795 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
797 samples = (uint8_t*)samples + bpp * wc->ch_offset;
799 s->stereo = !(s->frame_flags & WV_MONO);
800 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
801 s->joint = s->frame_flags & WV_JOINT_STEREO;
802 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
803 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
804 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
805 s->CRC = AV_RL32(buf); buf += 4;
807 buf += 4; //skip block size;
809 wc->ch_offset += 1 + s->stereo;
811 s->max_samples = *data_size / (bpp * avctx->channels);
812 s->max_samples = FFMIN(s->max_samples, s->samples);
813 if(s->samples_left > 0){
814 s->max_samples = FFMIN(s->max_samples, s->samples_left);
818 // parse metadata blocks
819 while(buf < buf_end){
822 if(id & WP_IDF_LONG) {
823 size |= (*buf++) << 8;
824 size |= (*buf++) << 16;
826 size <<= 1; // size is specified in words
828 if(id & WP_IDF_ODD) size--;
830 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
833 if(buf + ssize > buf_end){
834 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
837 if(id & WP_IDF_IGNORE){
841 switch(id & WP_IDF_MASK){
844 if(s->terms > MAX_TERMS){
845 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
849 for(i = 0; i < s->terms; i++) {
850 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
851 s->decorr[s->terms - i - 1].delta = *buf >> 5;
856 case WP_ID_DECWEIGHTS:
858 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
861 weights = size >> s->stereo_in;
862 if(weights > MAX_TERMS || weights > s->terms){
863 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
867 for(i = 0; i < weights; i++) {
868 t = (int8_t)(*buf++);
869 s->decorr[s->terms - i - 1].weightA = t << 3;
870 if(s->decorr[s->terms - i - 1].weightA > 0)
871 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
873 t = (int8_t)(*buf++);
874 s->decorr[s->terms - i - 1].weightB = t << 3;
875 if(s->decorr[s->terms - i - 1].weightB > 0)
876 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
881 case WP_ID_DECSAMPLES:
883 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
887 for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
888 if(s->decorr[i].value > 8){
889 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
890 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
892 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
893 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
897 }else if(s->decorr[i].value < 0){
898 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
899 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
902 for(j = 0; j < s->decorr[i].value; j++){
903 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
905 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
908 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
914 if(size != 6 * (s->stereo_in + 1)){
915 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
919 for(j = 0; j <= s->stereo_in; j++){
920 for(i = 0; i < 3; i++){
921 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
928 if(s->hybrid_bitrate){
929 for(i = 0; i <= s->stereo_in; i++){
930 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
935 for(i = 0; i < (s->stereo_in + 1); i++){
936 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
941 for(i = 0; i < (s->stereo_in + 1); i++){
942 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
946 for(i = 0; i < (s->stereo_in + 1); i++)
947 s->ch[i].bitrate_delta = 0;
951 case WP_ID_INT32INFO:
953 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
958 s->extra_bits = buf[0];
970 case WP_ID_FLOATINFO:
972 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
976 s->float_flag = buf[0];
977 s->float_shift = buf[1];
978 s->float_max_exp = buf[2];
983 s->sc.offset = buf - orig_buf;
984 s->sc.size = size * 8;
985 init_get_bits(&s->gb, buf, size * 8);
986 s->data_size = size * 8;
990 case WP_ID_EXTRABITS:
992 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
996 s->extra_sc.offset = buf - orig_buf;
997 s->extra_sc.size = size * 8;
998 init_get_bits(&s->gb_extra_bits, buf, size * 8);
999 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1001 s->got_extra_bits = 1;
1003 case WP_ID_CHANINFO:
1005 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1014 chmask = AV_RL16(buf);
1017 chmask = AV_RL24(buf);
1020 chmask = AV_RL32(buf);
1023 chan |= (buf[1] & 0xF) << 8;
1024 chmask = AV_RL24(buf + 2);
1027 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
1028 chan = avctx->channels;
1029 chmask = avctx->channel_layout;
1031 if(chan != avctx->channels){
1032 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
1033 chan, avctx->channels);
1036 if(!avctx->channel_layout)
1037 avctx->channel_layout = chmask;
1043 if(id & WP_IDF_ODD) buf++;
1045 if(!s->samples_left){
1047 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1051 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1055 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1059 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1062 if(s->hybrid && !got_hybrid){
1063 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1067 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1070 if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
1071 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1074 if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
1075 const int size = get_bits_left(&s->gb_extra_bits);
1076 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1078 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1079 s->got_extra_bits = 0;
1082 s->samples_left = s->samples;
1084 init_get_bits(&s->gb, orig_buf + s->sc.offset, s->sc.size);
1085 skip_bits_long(&s->gb, s->sc.bits_used);
1086 if(s->got_extra_bits){
1087 init_get_bits(&s->gb_extra_bits, orig_buf + s->extra_sc.offset,
1089 skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
1094 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1095 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1096 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1097 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1099 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1102 const int channel_stride = avctx->channels;
1104 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1105 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1106 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1107 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1109 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1111 if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
1112 int16_t *dst = (int16_t*)samples + 1;
1113 int16_t *src = (int16_t*)samples;
1114 int cnt = samplecount;
1117 src += channel_stride;
1118 dst += channel_stride;
1120 }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
1121 int32_t *dst = (int32_t*)samples + 1;
1122 int32_t *src = (int32_t*)samples;
1123 int cnt = samplecount;
1126 src += channel_stride;
1127 dst += channel_stride;
1129 }else if(s->stereo){
1130 float *dst = (float*)samples + 1;
1131 float *src = (float*)samples;
1132 int cnt = samplecount;
1135 src += channel_stride;
1136 dst += channel_stride;
1141 wc->samples_left = s->samples_left;
1143 return samplecount * bpp;
1146 static int wavpack_decode_frame(AVCodecContext *avctx,
1147 void *data, int *data_size,
1150 WavpackContext *s = avctx->priv_data;
1151 const uint8_t *buf = avpkt->data;
1152 int buf_size = avpkt->size;
1154 int samplecount = 0;
1157 s->samples_left = 0;
1161 s->samples = AV_RL32(buf); buf += 4;
1163 while(buf_size > 0){
1164 if(!s->multichannel){
1165 frame_size = buf_size;
1168 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1170 if(buf_size < 12) //MKV files can have zero flags after last block
1172 frame_size = AV_RL32(buf + 8) + 12;
1175 if(frame_size < 0 || frame_size > buf_size){
1176 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1177 s->block, frame_size, buf_size);
1180 if((samplecount = wavpack_decode_block(avctx, s->block, data,
1181 data_size, buf, frame_size)) < 0)
1184 buf += frame_size; buf_size -= frame_size;
1186 *data_size = samplecount * avctx->channels;
1188 return s->samples_left > 0 ? 0 : avpkt->size;
1191 AVCodec ff_wavpack_decoder = {
1195 sizeof(WavpackContext),
1196 wavpack_decode_init,
1199 wavpack_decode_frame,
1200 .capabilities = CODEC_CAP_SUBFRAMES,
1201 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),