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 int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, int16_t *dst)
344 int A, B, L, L2, R, R2, bit;
346 uint32_t crc = 0xFFFFFFFF;
348 s->one = s->zero = s->zeroes = 0;
350 L = wv_get_value(s, gb, 0, &last);
352 R = wv_get_value(s, gb, 1, &last);
354 for(i = 0; i < s->terms; i++){
355 t = s->decorr[i].value;
360 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
361 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
363 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
364 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
366 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
367 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
370 A = s->decorr[i].samplesA[pos];
371 B = s->decorr[i].samplesB[pos];
374 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
375 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
376 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
377 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
378 s->decorr[i].samplesA[j] = L = L2;
379 s->decorr[i].samplesB[j] = R = R2;
381 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
382 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
384 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
385 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
387 s->decorr[i].samplesA[0] = R;
389 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
390 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
394 R2 = s->decorr[i].samplesA[0];
395 s->decorr[i].samplesA[0] = R;
398 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
399 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
401 s->decorr[i].samplesB[0] = L;
406 L += (R -= (L >> 1));
407 crc = (crc * 3 + L) * 3 + R;
408 bit = (L & s->and) | s->or;
409 *dst++ = (((L + bit) << s->shift) - bit) << s->post_shift;
410 bit = (R & s->and) | s->or;
411 *dst++ = (((R + bit) << s->shift) - bit) << s->post_shift;
413 }while(!last && count < s->samples);
416 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
422 static int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, int16_t *dst)
428 uint32_t crc = 0xFFFFFFFF;
430 s->one = s->zero = s->zeroes = 0;
432 T = wv_get_value(s, gb, 0, &last);
435 for(i = 0; i < s->terms; i++){
436 t = s->decorr[i].value;
439 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
441 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
442 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
445 A = s->decorr[i].samplesA[pos];
448 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
449 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
450 s->decorr[i].samplesA[j] = T = S;
454 bit = (S & s->and) | s->or;
455 *dst++ = (((S + bit) << s->shift) - bit) << s->post_shift;
457 }while(!last && count < s->samples);
460 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
466 static int wv_unpack_stereo_hires(WavpackContext *s, GetBitContext *gb, int32_t *dst)
470 int A, B, L, L2, R, R2, bit;
472 uint32_t crc = 0xFFFFFFFF;
474 s->one = s->zero = s->zeroes = 0;
476 L = wv_get_value(s, gb, 0, &last);
478 R = wv_get_value(s, gb, 1, &last);
480 for(i = 0; i < s->terms; i++){
481 t = s->decorr[i].value;
486 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
487 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
489 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
490 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
492 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
493 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
496 A = s->decorr[i].samplesA[pos];
497 B = s->decorr[i].samplesB[pos];
500 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
501 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
502 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
503 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
504 s->decorr[i].samplesA[j] = L = L2;
505 s->decorr[i].samplesB[j] = R = R2;
507 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
508 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
510 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
511 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
513 s->decorr[i].samplesA[0] = R;
515 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
516 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
520 R2 = s->decorr[i].samplesA[0];
521 s->decorr[i].samplesA[0] = R;
524 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
525 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
527 s->decorr[i].samplesB[0] = L;
532 L += (R -= (L >> 1));
533 crc = (crc * 3 + L) * 3 + R;
534 bit = (L & s->and) | s->or;
535 *dst++ = (((L + bit) << s->shift) - bit) << s->post_shift;
536 bit = (R & s->and) | s->or;
537 *dst++ = (((R + bit) << s->shift) - bit) << s->post_shift;
539 }while(!last && count < s->samples);
542 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
548 static int wv_unpack_mono_hires(WavpackContext *s, GetBitContext *gb, int32_t *dst)
554 uint32_t crc = 0xFFFFFFFF;
556 s->one = s->zero = s->zeroes = 0;
558 T = wv_get_value(s, gb, 0, &last);
561 for(i = 0; i < s->terms; i++){
562 t = s->decorr[i].value;
565 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
567 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
568 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
571 A = s->decorr[i].samplesA[pos];
574 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
575 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
576 s->decorr[i].samplesA[j] = T = S;
580 bit = (S & s->and) | s->or;
581 *dst++ = (((S + bit) << s->shift) - bit) << s->post_shift;
583 }while(!last && count < s->samples);
586 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
592 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
594 WavpackContext *s = avctx->priv_data;
597 s->stereo = (avctx->channels == 2);
598 if(avctx->bits_per_coded_sample <= 16)
599 avctx->sample_fmt = SAMPLE_FMT_S16;
601 avctx->sample_fmt = SAMPLE_FMT_S32;
602 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
607 static int wavpack_decode_frame(AVCodecContext *avctx,
608 void *data, int *data_size,
611 const uint8_t *buf = avpkt->data;
612 int buf_size = avpkt->size;
613 WavpackContext *s = avctx->priv_data;
614 int16_t *samples = data;
615 int32_t *samples32 = data;
617 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0;
619 const uint8_t* buf_end = buf + buf_size;
620 int i, j, id, size, ssize, weights, t;
621 int bpp = avctx->bits_per_coded_sample <= 16 ? 2 : 4;
628 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
629 memset(s->ch, 0, sizeof(s->ch));
630 s->and = s->or = s->shift = 0;
632 s->samples = AV_RL32(buf); buf += 4;
637 /* should not happen but who knows */
638 if(s->samples * bpp * avctx->channels > *data_size){
639 av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n");
642 s->frame_flags = AV_RL32(buf); buf += 4;
643 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
644 s->joint = s->frame_flags & WV_JOINT_STEREO;
645 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
646 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
647 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
648 s->CRC = AV_RL32(buf); buf += 4;
649 // parse metadata blocks
650 while(buf < buf_end){
653 if(id & WP_IDF_LONG) {
654 size |= (*buf++) << 8;
655 size |= (*buf++) << 16;
657 size <<= 1; // size is specified in words
659 if(id & WP_IDF_ODD) size--;
661 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
664 if(buf + ssize > buf_end){
665 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
668 if(id & WP_IDF_IGNORE){
672 switch(id & WP_IDF_MASK){
675 if(s->terms > MAX_TERMS){
676 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
680 for(i = 0; i < s->terms; i++) {
681 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
682 s->decorr[s->terms - i - 1].delta = *buf >> 5;
687 case WP_ID_DECWEIGHTS:
689 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
692 weights = size >> s->stereo_in;
693 if(weights > MAX_TERMS || weights > s->terms){
694 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
698 for(i = 0; i < weights; i++) {
699 t = (int8_t)(*buf++);
700 s->decorr[s->terms - i - 1].weightA = t << 3;
701 if(s->decorr[s->terms - i - 1].weightA > 0)
702 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
704 t = (int8_t)(*buf++);
705 s->decorr[s->terms - i - 1].weightB = t << 3;
706 if(s->decorr[s->terms - i - 1].weightB > 0)
707 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
712 case WP_ID_DECSAMPLES:
714 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
718 for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
719 if(s->decorr[i].value > 8){
720 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
721 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
723 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
724 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
728 }else if(s->decorr[i].value < 0){
729 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
730 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
733 for(j = 0; j < s->decorr[i].value; j++){
734 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
736 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
739 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
745 if(size != 6 * (s->stereo_in + 1)){
746 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
750 for(j = 0; j <= s->stereo_in; j++){
751 for(i = 0; i < 3; i++){
752 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
759 if(s->hybrid_bitrate){
760 for(i = 0; i <= s->stereo_in; i++){
761 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
766 for(i = 0; i < (s->stereo_in + 1); i++){
767 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
772 for(i = 0; i < (s->stereo_in + 1); i++){
773 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
777 for(i = 0; i < (s->stereo_in + 1); i++)
778 s->ch[i].bitrate_delta = 0;
782 case WP_ID_INT32INFO:
783 if(size != 4 || *buf){
784 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
800 init_get_bits(&s->gb, buf, size * 8);
801 s->data_size = size * 8;
808 if(id & WP_IDF_ODD) buf++;
811 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
815 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
819 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
823 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
826 if(s->hybrid && !got_hybrid){
827 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
831 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
837 samplecount = wv_unpack_stereo(s, &s->gb, samples);
839 samplecount = wv_unpack_stereo_hires(s, &s->gb, samples32);
842 samplecount = wv_unpack_mono(s, &s->gb, samples);
844 samplecount = wv_unpack_mono_hires(s, &s->gb, samples32);
845 if(s->stereo && bpp == 2){
846 int16_t *dst = samples + samplecount * 2;
847 int16_t *src = samples + samplecount;
848 int cnt = samplecount;
854 }else if(s->stereo){ //32-bit output
855 int32_t *dst = samples32 + samplecount * 2;
856 int32_t *src = samples32 + samplecount;
857 int cnt = samplecount;
865 *data_size = samplecount * bpp;
870 AVCodec wavpack_decoder = {
874 sizeof(WavpackContext),
878 wavpack_decode_frame,
879 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),