2 * WavPack lossless audio decoder
3 * Copyright (c) 2006 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
27 * @file libavcodec/wavpack.c
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 WavpackContext {
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;
123 // exponent table copied from WavPack source
124 static const uint8_t wp_exp2_table [256] = {
125 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
126 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
127 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
128 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
129 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
130 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
131 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
132 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
133 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
134 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
135 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
136 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
137 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
138 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
139 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
140 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
143 static const uint8_t wp_log2_table [] = {
144 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
145 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
146 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
147 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
148 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
149 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
150 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
151 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
152 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
153 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
154 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
155 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
156 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
157 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
158 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
159 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
162 static av_always_inline int wp_exp2(int16_t val)
171 res = wp_exp2_table[val & 0xFF] | 0x100;
173 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
174 return neg ? -res : res;
177 static av_always_inline int wp_log2(int32_t val)
186 bits = av_log2(val) + 1;
188 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
190 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
193 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
195 // macros for manipulating median values
196 #define GET_MED(n) ((c->median[n] >> 4) + 1)
197 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
198 #define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
200 // macros for applying weight
201 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
203 if((samples ^ in) < 0){ \
205 if(weight < -1024) weight = -1024; \
208 if(weight > 1024) weight = 1024; \
213 static av_always_inline int get_tail(GetBitContext *gb, int k)
219 e = (1 << (p + 1)) - k - 1;
220 res = p ? get_bits(gb, p) : 0;
222 res = (res<<1) - e + get_bits1(gb);
227 static void update_error_limit(WavpackContext *ctx)
231 for(i = 0; i <= ctx->stereo_in; i++){
232 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
233 br[i] = ctx->ch[i].bitrate_acc >> 16;
234 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
236 if(ctx->stereo_in && ctx->hybrid_bitrate){
237 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
241 }else if(-balance > br[0]){
245 br[1] = br[0] + balance;
246 br[0] = br[0] - balance;
249 for(i = 0; i <= ctx->stereo_in; i++){
250 if(ctx->hybrid_bitrate){
251 if(sl[i] - br[i] > -0x100)
252 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
254 ctx->ch[i].error_limit = 0;
256 ctx->ch[i].error_limit = wp_exp2(br[i]);
261 static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last)
264 int sign, base, add, ret;
265 WvChannel *c = &ctx->ch[channel];
269 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
273 c->slow_level -= LEVEL_DECAY(c->slow_level);
277 t = get_unary_0_33(gb);
278 if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1));
281 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
282 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
283 c->slow_level -= LEVEL_DECAY(c->slow_level);
289 if(get_bits_count(gb) >= ctx->data_size){
298 t = get_unary_0_33(gb);
299 if(get_bits_count(gb) >= ctx->data_size){
304 t2 = get_unary_0_33(gb);
306 else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
316 ctx->zero = !ctx->one;
319 if(ctx->hybrid && !channel)
320 update_error_limit(ctx);
324 add = GET_MED(0) - 1;
328 add = GET_MED(1) - 1;
332 base = GET_MED(0) + GET_MED(1);
333 add = GET_MED(2) - 1;
338 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
339 add = GET_MED(2) - 1;
345 ret = base + get_tail(gb, add);
347 int mid = (base*2 + add + 1) >> 1;
348 while(add > c->error_limit){
353 add = mid - base - 1;
354 mid = (base*2 + add + 1) >> 1;
358 sign = get_bits1(gb);
359 if(ctx->hybrid_bitrate)
360 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
361 return sign ? ~ret : ret;
364 static inline int wv_get_value_integer(WavpackContext *s, uint32_t *crc, int S)
371 if(s->got_extra_bits){
372 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
373 *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
376 bit = (S & s->and) | s->or;
377 return (((S + bit) << s->shift) - bit) << s->post_shift;
380 static float wv_get_value_float(WavpackContext *s, uint32_t *crc, int S)
388 int exp = s->float_max_exp;
390 if(s->got_extra_bits){
391 const int max_bits = 1 + 23 + 8 + 1;
392 const int left_bits = get_bits_left(&s->gb_extra_bits);
394 if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
399 S <<= s->float_shift;
404 if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
405 S = get_bits(&s->gb_extra_bits, 23);
411 int shift = 23 - av_log2(S);
412 exp = s->float_max_exp;
420 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
421 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
422 S |= (1 << shift) - 1;
423 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
424 S |= get_bits(&s->gb_extra_bits, shift);
428 exp = s->float_max_exp;
434 if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
435 if(get_bits1(&s->gb_extra_bits)){
436 S = get_bits(&s->gb_extra_bits, 23);
437 if(s->float_max_exp >= 25)
438 exp = get_bits(&s->gb_extra_bits, 8);
439 sign = get_bits1(&s->gb_extra_bits);
441 if(s->float_flag & WV_FLT_ZERO_SIGN)
442 sign = get_bits1(&s->gb_extra_bits);
447 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
449 value.u = (sign << 31) | (exp << 23) | S;
453 static void wv_reset_saved_context(WavpackContext *s)
456 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
459 static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
463 int A, B, L, L2, R, R2;
465 uint32_t crc = s->sc.crc;
466 uint32_t crc_extra_bits = s->extra_sc.crc;
467 int16_t *dst16 = dst;
468 int32_t *dst32 = dst;
471 if(s->samples_left == s->samples)
472 s->one = s->zero = s->zeroes = 0;
474 L = wv_get_value(s, gb, 0, &last);
476 R = wv_get_value(s, gb, 1, &last);
478 for(i = 0; i < s->terms; i++){
479 t = s->decorr[i].value;
483 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
484 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
486 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
487 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
489 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
490 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
493 A = s->decorr[i].samplesA[pos];
494 B = s->decorr[i].samplesB[pos];
497 if(type != SAMPLE_FMT_S16){
498 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
499 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
501 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
502 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
504 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
505 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
506 s->decorr[i].samplesA[j] = L = L2;
507 s->decorr[i].samplesB[j] = R = R2;
509 if(type != SAMPLE_FMT_S16)
510 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
512 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
513 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
515 if(type != SAMPLE_FMT_S16)
516 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
518 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
519 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
521 s->decorr[i].samplesA[0] = R;
523 if(type != SAMPLE_FMT_S16)
524 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
526 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
527 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
531 R2 = s->decorr[i].samplesA[0];
532 s->decorr[i].samplesA[0] = R;
535 if(type != SAMPLE_FMT_S16)
536 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
538 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
539 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
541 s->decorr[i].samplesB[0] = L;
546 L += (R -= (L >> 1));
547 crc = (crc * 3 + L) * 3 + R;
549 if(type == SAMPLE_FMT_FLT){
550 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
551 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
552 } else if(type == SAMPLE_FMT_S32){
553 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
554 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
556 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
557 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
560 }while(!last && count < s->max_samples);
562 s->samples_left -= count;
563 if(!s->samples_left){
565 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
568 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
569 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
572 wv_reset_saved_context(s);
576 s->sc.bits_used = get_bits_count(&s->gb);
577 if(s->got_extra_bits){
578 s->extra_sc.crc = crc_extra_bits;
579 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
585 static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
591 uint32_t crc = s->sc.crc;
592 uint32_t crc_extra_bits = s->extra_sc.crc;
593 int16_t *dst16 = dst;
594 int32_t *dst32 = dst;
597 if(s->samples_left == s->samples)
598 s->one = s->zero = s->zeroes = 0;
600 T = wv_get_value(s, gb, 0, &last);
603 for(i = 0; i < s->terms; i++){
604 t = s->decorr[i].value;
607 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
609 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
610 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
613 A = s->decorr[i].samplesA[pos];
616 if(type != SAMPLE_FMT_S16)
617 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
619 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
620 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
621 s->decorr[i].samplesA[j] = T = S;
626 if(type == SAMPLE_FMT_FLT)
627 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
628 else if(type == SAMPLE_FMT_S32)
629 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
631 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
633 }while(!last && count < s->samples);
635 s->samples_left -= count;
636 if(!s->samples_left){
638 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
641 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
642 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
645 wv_reset_saved_context(s);
649 s->sc.bits_used = get_bits_count(&s->gb);
650 if(s->got_extra_bits){
651 s->extra_sc.crc = crc_extra_bits;
652 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
658 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
660 WavpackContext *s = avctx->priv_data;
663 s->stereo = (avctx->channels == 2);
664 if(avctx->bits_per_coded_sample <= 16)
665 avctx->sample_fmt = SAMPLE_FMT_S16;
667 avctx->sample_fmt = SAMPLE_FMT_S32;
668 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
670 wv_reset_saved_context(s);
675 static int wavpack_decode_frame(AVCodecContext *avctx,
676 void *data, int *data_size,
679 const uint8_t *buf = avpkt->data;
680 int buf_size = avpkt->size;
681 WavpackContext *s = avctx->priv_data;
682 void *samples = data;
684 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
686 const uint8_t* buf_end = buf + buf_size;
687 int i, j, id, size, ssize, weights, t;
695 if(!s->samples_left){
696 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
697 memset(s->ch, 0, sizeof(s->ch));
699 s->and = s->or = s->shift = 0;
700 s->got_extra_bits = 0;
703 s->samples = AV_RL32(buf); buf += 4;
708 s->frame_flags = AV_RL32(buf); buf += 4;
709 if(s->frame_flags&0x80){
711 avctx->sample_fmt = SAMPLE_FMT_FLT;
712 } else if((s->frame_flags&0x03) <= 1){
714 avctx->sample_fmt = SAMPLE_FMT_S16;
717 avctx->sample_fmt = SAMPLE_FMT_S32;
719 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
720 s->joint = s->frame_flags & WV_JOINT_STEREO;
721 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
722 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
723 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
724 s->CRC = AV_RL32(buf); buf += 4;
726 s->max_samples = *data_size / (bpp * avctx->channels);
727 s->max_samples = FFMIN(s->max_samples, s->samples);
728 if(s->samples_left > 0){
729 s->max_samples = FFMIN(s->max_samples, s->samples_left);
733 // parse metadata blocks
734 while(buf < buf_end){
737 if(id & WP_IDF_LONG) {
738 size |= (*buf++) << 8;
739 size |= (*buf++) << 16;
741 size <<= 1; // size is specified in words
743 if(id & WP_IDF_ODD) size--;
745 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
748 if(buf + ssize > buf_end){
749 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
752 if(id & WP_IDF_IGNORE){
756 switch(id & WP_IDF_MASK){
759 if(s->terms > MAX_TERMS){
760 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
764 for(i = 0; i < s->terms; i++) {
765 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
766 s->decorr[s->terms - i - 1].delta = *buf >> 5;
771 case WP_ID_DECWEIGHTS:
773 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
776 weights = size >> s->stereo_in;
777 if(weights > MAX_TERMS || weights > s->terms){
778 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
782 for(i = 0; i < weights; i++) {
783 t = (int8_t)(*buf++);
784 s->decorr[s->terms - i - 1].weightA = t << 3;
785 if(s->decorr[s->terms - i - 1].weightA > 0)
786 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
788 t = (int8_t)(*buf++);
789 s->decorr[s->terms - i - 1].weightB = t << 3;
790 if(s->decorr[s->terms - i - 1].weightB > 0)
791 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
796 case WP_ID_DECSAMPLES:
798 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
802 for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
803 if(s->decorr[i].value > 8){
804 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
805 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
807 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
808 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
812 }else if(s->decorr[i].value < 0){
813 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
814 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
817 for(j = 0; j < s->decorr[i].value; j++){
818 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
820 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
823 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
829 if(size != 6 * (s->stereo_in + 1)){
830 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
834 for(j = 0; j <= s->stereo_in; j++){
835 for(i = 0; i < 3; i++){
836 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
843 if(s->hybrid_bitrate){
844 for(i = 0; i <= s->stereo_in; i++){
845 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
850 for(i = 0; i < (s->stereo_in + 1); i++){
851 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
856 for(i = 0; i < (s->stereo_in + 1); i++){
857 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
861 for(i = 0; i < (s->stereo_in + 1); i++)
862 s->ch[i].bitrate_delta = 0;
866 case WP_ID_INT32INFO:
868 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
873 s->extra_bits = buf[0];
885 case WP_ID_FLOATINFO:
887 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
891 s->float_flag = buf[0];
892 s->float_shift = buf[1];
893 s->float_max_exp = buf[2];
898 s->sc.offset = buf - avpkt->data;
899 s->sc.size = size * 8;
900 init_get_bits(&s->gb, buf, size * 8);
901 s->data_size = size * 8;
905 case WP_ID_EXTRABITS:
907 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
911 s->extra_sc.offset = buf - avpkt->data;
912 s->extra_sc.size = size * 8;
913 init_get_bits(&s->gb_extra_bits, buf, size * 8);
914 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
916 s->got_extra_bits = 1;
921 if(id & WP_IDF_ODD) buf++;
923 if(!s->samples_left){
925 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
929 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
933 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
937 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
940 if(s->hybrid && !got_hybrid){
941 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
945 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
948 if(!got_float && avctx->sample_fmt == SAMPLE_FMT_FLT){
949 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
952 if(s->got_extra_bits && avctx->sample_fmt != SAMPLE_FMT_FLT){
953 const int size = get_bits_left(&s->gb_extra_bits);
954 const int wanted = s->samples * s->extra_bits << s->stereo_in;
956 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
957 s->got_extra_bits = 0;
960 s->samples_left = s->samples;
962 init_get_bits(&s->gb, avpkt->data + s->sc.offset, s->sc.size);
963 skip_bits_long(&s->gb, s->sc.bits_used);
964 if(s->got_extra_bits){
965 init_get_bits(&s->gb_extra_bits, avpkt->data + s->extra_sc.offset,
967 skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
972 if(avctx->sample_fmt == SAMPLE_FMT_S16)
973 samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S16);
974 else if(avctx->sample_fmt == SAMPLE_FMT_S32)
975 samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S32);
977 samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_FLT);
980 if(avctx->sample_fmt == SAMPLE_FMT_S16)
981 samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S16);
982 else if(avctx->sample_fmt == SAMPLE_FMT_S32)
983 samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S32);
985 samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_FLT);
987 if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S16){
988 int16_t *dst = (int16_t*)samples + samplecount * 2;
989 int16_t *src = (int16_t*)samples + samplecount;
990 int cnt = samplecount;
996 }else if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S32){
997 int32_t *dst = (int32_t*)samples + samplecount * 2;
998 int32_t *src = (int32_t*)samples + samplecount;
999 int cnt = samplecount;
1005 }else if(s->stereo){
1006 float *dst = (float*)samples + samplecount * 2;
1007 float *src = (float*)samples + samplecount;
1008 int cnt = samplecount;
1016 *data_size = samplecount * bpp;
1018 return s->samples_left > 0 ? 0 : buf_size;
1021 AVCodec wavpack_decoder = {
1025 sizeof(WavpackContext),
1026 wavpack_decode_init,
1029 wavpack_decode_frame,
1030 .capabilities = CODEC_CAP_SUBFRAMES,
1031 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),