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
66 typedef struct Decorr {
75 typedef struct WvChannel {
77 int slow_level, error_limit;
78 int bitrate_acc, bitrate_delta;
81 typedef struct WavpackContext {
82 AVCodecContext *avctx;
84 int stereo, stereo_in;
88 int data_size; // in bits
91 Decorr decorr[MAX_TERMS];
92 int zero, one, zeroes;
95 int hybrid, hybrid_bitrate;
99 // exponent table copied from WavPack source
100 static const uint8_t wp_exp2_table [256] = {
101 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
102 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
103 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
104 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
105 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
106 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
107 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
108 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
109 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
110 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
111 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
112 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
113 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
114 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
115 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
116 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
119 static const uint8_t wp_log2_table [] = {
120 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
121 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
122 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
123 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
124 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
125 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
126 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
127 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
128 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
129 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
130 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
131 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
132 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
133 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
134 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
135 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
138 static av_always_inline int wp_exp2(int16_t val)
147 res = wp_exp2_table[val & 0xFF] | 0x100;
149 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
150 return neg ? -res : res;
153 static av_always_inline int wp_log2(int32_t val)
162 bits = av_log2(val) + 1;
164 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
166 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
169 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
171 // macros for manipulating median values
172 #define GET_MED(n) ((c->median[n] >> 4) + 1)
173 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
174 #define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
176 // macros for applying weight
177 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
179 if((samples ^ in) < 0){ \
181 if(weight < -1024) weight = -1024; \
184 if(weight > 1024) weight = 1024; \
189 static av_always_inline int get_tail(GetBitContext *gb, int k)
195 e = (1 << (p + 1)) - k - 1;
196 res = p ? get_bits(gb, p) : 0;
198 res = (res<<1) - e + get_bits1(gb);
203 static void update_error_limit(WavpackContext *ctx)
207 for(i = 0; i <= ctx->stereo_in; i++){
208 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
209 br[i] = ctx->ch[i].bitrate_acc >> 16;
210 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
212 if(ctx->stereo_in && ctx->hybrid_bitrate){
213 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
217 }else if(-balance > br[0]){
221 br[1] = br[0] + balance;
222 br[0] = br[0] - balance;
225 for(i = 0; i <= ctx->stereo_in; i++){
226 if(ctx->hybrid_bitrate){
227 if(sl[i] - br[i] > -0x100)
228 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
230 ctx->ch[i].error_limit = 0;
232 ctx->ch[i].error_limit = wp_exp2(br[i]);
237 static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last)
240 int sign, base, add, ret;
241 WvChannel *c = &ctx->ch[channel];
245 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
249 c->slow_level -= LEVEL_DECAY(c->slow_level);
253 t = get_unary_0_33(gb);
254 if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1));
257 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
258 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
259 c->slow_level -= LEVEL_DECAY(c->slow_level);
265 if(get_bits_count(gb) >= ctx->data_size){
274 t = get_unary_0_33(gb);
275 if(get_bits_count(gb) >= ctx->data_size){
280 t2 = get_unary_0_33(gb);
282 else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
292 ctx->zero = !ctx->one;
295 if(ctx->hybrid && !channel)
296 update_error_limit(ctx);
300 add = GET_MED(0) - 1;
304 add = GET_MED(1) - 1;
308 base = GET_MED(0) + GET_MED(1);
309 add = GET_MED(2) - 1;
314 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
315 add = GET_MED(2) - 1;
321 ret = base + get_tail(gb, add);
323 int mid = (base*2 + add + 1) >> 1;
324 while(add > c->error_limit){
329 add = mid - base - 1;
330 mid = (base*2 + add + 1) >> 1;
334 sign = get_bits1(gb);
335 if(ctx->hybrid_bitrate)
336 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
337 return sign ? ~ret : ret;
340 static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int hires)
344 int A, B, L, L2, R, R2, bit;
346 uint32_t crc = 0xFFFFFFFF;
347 int16_t *dst16 = dst;
348 int32_t *dst32 = dst;
350 s->one = s->zero = s->zeroes = 0;
352 L = wv_get_value(s, gb, 0, &last);
354 R = wv_get_value(s, gb, 1, &last);
356 for(i = 0; i < s->terms; i++){
357 t = s->decorr[i].value;
362 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
363 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
365 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
366 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
368 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
369 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
372 A = s->decorr[i].samplesA[pos];
373 B = s->decorr[i].samplesB[pos];
377 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
378 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
380 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
381 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
383 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
384 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
385 s->decorr[i].samplesA[j] = L = L2;
386 s->decorr[i].samplesB[j] = R = R2;
389 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
391 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
392 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
395 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
397 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
398 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
400 s->decorr[i].samplesA[0] = R;
403 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
405 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
406 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
410 R2 = s->decorr[i].samplesA[0];
411 s->decorr[i].samplesA[0] = R;
415 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
417 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
418 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
420 s->decorr[i].samplesB[0] = L;
425 L += (R -= (L >> 1));
426 crc = (crc * 3 + L) * 3 + R;
427 bit = (L & s->and) | s->or;
429 *dst32++ = (((L + bit) << s->shift) - bit) << s->post_shift;
431 *dst16++ = (((L + bit) << s->shift) - bit) << s->post_shift;
432 bit = (R & s->and) | s->or;
434 *dst32++ = (((R + bit) << s->shift) - bit) << s->post_shift;
436 *dst16++ = (((R + bit) << s->shift) - bit) << s->post_shift;
438 }while(!last && count < s->samples);
441 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
447 static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int hires)
453 uint32_t crc = 0xFFFFFFFF;
454 int16_t *dst16 = dst;
455 int32_t *dst32 = dst;
457 s->one = s->zero = s->zeroes = 0;
459 T = wv_get_value(s, gb, 0, &last);
462 for(i = 0; i < s->terms; i++){
463 t = s->decorr[i].value;
466 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
468 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
469 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
472 A = s->decorr[i].samplesA[pos];
476 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
478 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
479 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
480 s->decorr[i].samplesA[j] = T = S;
484 bit = (S & s->and) | s->or;
486 *dst32++ = (((S + bit) << s->shift) - bit) << s->post_shift;
488 *dst16++ = (((S + bit) << s->shift) - bit) << s->post_shift;
490 }while(!last && count < s->samples);
493 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
499 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
501 WavpackContext *s = avctx->priv_data;
504 s->stereo = (avctx->channels == 2);
505 if(avctx->bits_per_coded_sample <= 16)
506 avctx->sample_fmt = SAMPLE_FMT_S16;
508 avctx->sample_fmt = SAMPLE_FMT_S32;
509 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
514 static int wavpack_decode_frame(AVCodecContext *avctx,
515 void *data, int *data_size,
518 const uint8_t *buf = avpkt->data;
519 int buf_size = avpkt->size;
520 WavpackContext *s = avctx->priv_data;
521 void *samples = data;
523 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0;
525 const uint8_t* buf_end = buf + buf_size;
526 int i, j, id, size, ssize, weights, t;
527 int bpp = avctx->bits_per_coded_sample <= 16 ? 2 : 4;
534 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
535 memset(s->ch, 0, sizeof(s->ch));
536 s->and = s->or = s->shift = 0;
538 s->samples = AV_RL32(buf); buf += 4;
543 /* should not happen but who knows */
544 if(s->samples * bpp * avctx->channels > *data_size){
545 av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n");
548 s->frame_flags = AV_RL32(buf); buf += 4;
549 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
550 s->joint = s->frame_flags & WV_JOINT_STEREO;
551 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
552 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
553 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
554 s->CRC = AV_RL32(buf); buf += 4;
555 // parse metadata blocks
556 while(buf < buf_end){
559 if(id & WP_IDF_LONG) {
560 size |= (*buf++) << 8;
561 size |= (*buf++) << 16;
563 size <<= 1; // size is specified in words
565 if(id & WP_IDF_ODD) size--;
567 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
570 if(buf + ssize > buf_end){
571 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
574 if(id & WP_IDF_IGNORE){
578 switch(id & WP_IDF_MASK){
581 if(s->terms > MAX_TERMS){
582 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
586 for(i = 0; i < s->terms; i++) {
587 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
588 s->decorr[s->terms - i - 1].delta = *buf >> 5;
593 case WP_ID_DECWEIGHTS:
595 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
598 weights = size >> s->stereo_in;
599 if(weights > MAX_TERMS || weights > s->terms){
600 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
604 for(i = 0; i < weights; i++) {
605 t = (int8_t)(*buf++);
606 s->decorr[s->terms - i - 1].weightA = t << 3;
607 if(s->decorr[s->terms - i - 1].weightA > 0)
608 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
610 t = (int8_t)(*buf++);
611 s->decorr[s->terms - i - 1].weightB = t << 3;
612 if(s->decorr[s->terms - i - 1].weightB > 0)
613 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
618 case WP_ID_DECSAMPLES:
620 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
624 for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
625 if(s->decorr[i].value > 8){
626 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
627 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
629 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
630 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
634 }else if(s->decorr[i].value < 0){
635 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
636 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
639 for(j = 0; j < s->decorr[i].value; j++){
640 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
642 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
645 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
651 if(size != 6 * (s->stereo_in + 1)){
652 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
656 for(j = 0; j <= s->stereo_in; j++){
657 for(i = 0; i < 3; i++){
658 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
665 if(s->hybrid_bitrate){
666 for(i = 0; i <= s->stereo_in; i++){
667 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
672 for(i = 0; i < (s->stereo_in + 1); i++){
673 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
678 for(i = 0; i < (s->stereo_in + 1); i++){
679 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
683 for(i = 0; i < (s->stereo_in + 1); i++)
684 s->ch[i].bitrate_delta = 0;
688 case WP_ID_INT32INFO:
690 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
695 s->post_shift = buf[0];
708 init_get_bits(&s->gb, buf, size * 8);
709 s->data_size = size * 8;
716 if(id & WP_IDF_ODD) buf++;
719 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
723 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
727 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
731 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
734 if(s->hybrid && !got_hybrid){
735 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
739 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
745 samplecount = wv_unpack_stereo(s, &s->gb, samples, 0);
747 samplecount = wv_unpack_stereo(s, &s->gb, samples, 1);
750 samplecount = wv_unpack_mono(s, &s->gb, samples, 0);
752 samplecount = wv_unpack_mono(s, &s->gb, samples, 1);
753 if(s->stereo && bpp == 2){
754 int16_t *dst = (int16_t*)samples + samplecount * 2;
755 int16_t *src = (int16_t*)samples + samplecount;
756 int cnt = samplecount;
762 }else if(s->stereo){ //32-bit output
763 int32_t *dst = (int32_t*)samples + samplecount * 2;
764 int32_t *src = (int32_t*)samples + samplecount;
765 int cnt = samplecount;
773 *data_size = samplecount * bpp;
778 AVCodec wavpack_decoder = {
782 sizeof(WavpackContext),
786 wavpack_decode_frame,
787 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),