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
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;
121 SavedContext sc, extra_sc;
122 } WavpackFrameContext;
124 #define WV_MAX_FRAME_DECODERS 14
126 typedef struct WavpackContext {
127 AVCodecContext *avctx;
129 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
140 // exponent table copied from WavPack source
141 static const uint8_t wp_exp2_table [256] = {
142 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
143 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
144 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
145 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
146 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
147 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
148 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
149 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
150 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
151 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
152 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
153 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
154 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
155 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
156 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
157 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
160 static const uint8_t wp_log2_table [] = {
161 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
162 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
163 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
164 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
165 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
166 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
167 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
168 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
169 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
170 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
171 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
172 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
173 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
174 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
175 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
176 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
179 static av_always_inline int wp_exp2(int16_t val)
188 res = wp_exp2_table[val & 0xFF] | 0x100;
190 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
191 return neg ? -res : res;
194 static av_always_inline int wp_log2(int32_t val)
203 bits = av_log2(val) + 1;
205 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
207 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
210 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
212 // macros for manipulating median values
213 #define GET_MED(n) ((c->median[n] >> 4) + 1)
214 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
215 #define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
217 // macros for applying weight
218 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
220 if((samples ^ in) < 0){ \
222 if(weight < -1024) weight = -1024; \
225 if(weight > 1024) weight = 1024; \
230 static av_always_inline int get_tail(GetBitContext *gb, int k)
236 e = (1 << (p + 1)) - k - 1;
237 res = p ? get_bits(gb, p) : 0;
239 res = (res<<1) - e + get_bits1(gb);
244 static void update_error_limit(WavpackFrameContext *ctx)
248 for(i = 0; i <= ctx->stereo_in; i++){
249 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
250 br[i] = ctx->ch[i].bitrate_acc >> 16;
251 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
253 if(ctx->stereo_in && ctx->hybrid_bitrate){
254 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
258 }else if(-balance > br[0]){
262 br[1] = br[0] + balance;
263 br[0] = br[0] - balance;
266 for(i = 0; i <= ctx->stereo_in; i++){
267 if(ctx->hybrid_bitrate){
268 if(sl[i] - br[i] > -0x100)
269 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
271 ctx->ch[i].error_limit = 0;
273 ctx->ch[i].error_limit = wp_exp2(br[i]);
278 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, int channel, int *last)
281 int sign, base, add, ret;
282 WvChannel *c = &ctx->ch[channel];
286 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
290 c->slow_level -= LEVEL_DECAY(c->slow_level);
294 t = get_unary_0_33(gb);
296 if(get_bits_left(gb) < t-1)
298 t = get_bits(gb, t - 1) | (1 << (t-1));
300 if(get_bits_left(gb) < 0)
305 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
306 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
307 c->slow_level -= LEVEL_DECAY(c->slow_level);
317 t = get_unary_0_33(gb);
318 if(get_bits_left(gb) < 0)
321 t2 = get_unary_0_33(gb);
323 if(get_bits_left(gb) < 0)
327 if(get_bits_left(gb) < t2 - 1)
329 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
340 ctx->zero = !ctx->one;
343 if(ctx->hybrid && !channel)
344 update_error_limit(ctx);
348 add = GET_MED(0) - 1;
352 add = GET_MED(1) - 1;
356 base = GET_MED(0) + GET_MED(1);
357 add = GET_MED(2) - 1;
362 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
363 add = GET_MED(2) - 1;
369 ret = base + get_tail(gb, add);
370 if (get_bits_left(gb) <= 0)
373 int mid = (base*2 + add + 1) >> 1;
374 while(add > c->error_limit){
375 if(get_bits_left(gb) <= 0)
381 add = mid - base - 1;
382 mid = (base*2 + add + 1) >> 1;
386 sign = get_bits1(gb);
387 if(ctx->hybrid_bitrate)
388 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
389 return sign ? ~ret : ret;
396 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
403 if(s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits){
404 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
405 *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
408 bit = (S & s->and) | s->or;
409 return (((S + bit) << s->shift) - bit) << s->post_shift;
412 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
420 int exp = s->float_max_exp;
422 if(s->got_extra_bits){
423 const int max_bits = 1 + 23 + 8 + 1;
424 const int left_bits = get_bits_left(&s->gb_extra_bits);
426 if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
431 S <<= s->float_shift;
436 if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
437 S = get_bits(&s->gb_extra_bits, 23);
443 int shift = 23 - av_log2(S);
444 exp = s->float_max_exp;
452 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
453 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
454 S |= (1 << shift) - 1;
455 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
456 S |= get_bits(&s->gb_extra_bits, shift);
460 exp = s->float_max_exp;
466 if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
467 if(get_bits1(&s->gb_extra_bits)){
468 S = get_bits(&s->gb_extra_bits, 23);
469 if(s->float_max_exp >= 25)
470 exp = get_bits(&s->gb_extra_bits, 8);
471 sign = get_bits1(&s->gb_extra_bits);
473 if(s->float_flag & WV_FLT_ZERO_SIGN)
474 sign = get_bits1(&s->gb_extra_bits);
479 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
481 value.u = (sign << 31) | (exp << 23) | S;
485 static void wv_reset_saved_context(WavpackFrameContext *s)
489 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
492 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
496 int A, B, L, L2, R, R2;
498 uint32_t crc = s->sc.crc;
499 uint32_t crc_extra_bits = s->extra_sc.crc;
500 int16_t *dst16 = dst;
501 int32_t *dst32 = dst;
503 const int channel_pad = s->avctx->channels - 2;
505 if(s->samples_left == s->samples)
506 s->one = s->zero = s->zeroes = 0;
508 L = wv_get_value(s, gb, 0, &last);
510 R = wv_get_value(s, gb, 1, &last);
512 for(i = 0; i < s->terms; i++){
513 t = s->decorr[i].value;
517 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
518 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
520 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
521 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
523 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
524 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
527 A = s->decorr[i].samplesA[pos];
528 B = s->decorr[i].samplesB[pos];
531 if(type != AV_SAMPLE_FMT_S16){
532 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
533 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
535 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
536 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
538 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
539 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
540 s->decorr[i].samplesA[j] = L = L2;
541 s->decorr[i].samplesB[j] = R = R2;
543 if(type != AV_SAMPLE_FMT_S16)
544 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
546 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
547 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
549 if(type != AV_SAMPLE_FMT_S16)
550 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
552 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
553 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
555 s->decorr[i].samplesA[0] = R;
557 if(type != AV_SAMPLE_FMT_S16)
558 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
560 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
561 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
565 R2 = s->decorr[i].samplesA[0];
566 s->decorr[i].samplesA[0] = R;
569 if(type != AV_SAMPLE_FMT_S16)
570 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
572 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
573 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
575 s->decorr[i].samplesB[0] = L;
580 L += (R -= (L >> 1));
581 crc = (crc * 3 + L) * 3 + R;
583 if(type == AV_SAMPLE_FMT_FLT){
584 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
585 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
586 dstfl += channel_pad;
587 } else if(type == AV_SAMPLE_FMT_S32){
588 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
589 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
590 dst32 += channel_pad;
592 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
593 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
594 dst16 += channel_pad;
597 }while(!last && count < s->max_samples);
602 s->samples_left -= count;
603 if(!s->samples_left){
604 wv_reset_saved_context(s);
606 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
609 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
610 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
616 s->sc.bits_used = get_bits_count(&s->gb);
617 if(s->got_extra_bits){
618 s->extra_sc.crc = crc_extra_bits;
619 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
625 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
631 uint32_t crc = s->sc.crc;
632 uint32_t crc_extra_bits = s->extra_sc.crc;
633 int16_t *dst16 = dst;
634 int32_t *dst32 = dst;
636 const int channel_stride = s->avctx->channels;
638 if(s->samples_left == s->samples)
639 s->one = s->zero = s->zeroes = 0;
641 T = wv_get_value(s, gb, 0, &last);
644 for(i = 0; i < s->terms; i++){
645 t = s->decorr[i].value;
648 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
650 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
651 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
654 A = s->decorr[i].samplesA[pos];
657 if(type != AV_SAMPLE_FMT_S16)
658 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
660 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
661 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
662 s->decorr[i].samplesA[j] = T = S;
667 if(type == AV_SAMPLE_FMT_FLT){
668 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
669 dstfl += channel_stride;
670 }else if(type == AV_SAMPLE_FMT_S32){
671 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
672 dst32 += channel_stride;
674 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
675 dst16 += channel_stride;
678 }while(!last && count < s->max_samples);
683 s->samples_left -= count;
684 if(!s->samples_left){
685 wv_reset_saved_context(s);
687 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
690 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
691 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
697 s->sc.bits_used = get_bits_count(&s->gb);
698 if(s->got_extra_bits){
699 s->extra_sc.crc = crc_extra_bits;
700 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
706 static av_cold int wv_alloc_frame_context(WavpackContext *c)
709 if(c->fdec_num == WV_MAX_FRAME_DECODERS)
712 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
713 if(!c->fdec[c->fdec_num])
716 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
717 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
722 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
724 WavpackContext *s = avctx->priv_data;
727 if(avctx->bits_per_coded_sample <= 16)
728 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
730 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
731 if(avctx->channels <= 2 && !avctx->channel_layout)
732 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
734 s->multichannel = avctx->channels > 2;
735 /* lavf demuxer does not provide extradata, Matroska stores 0x403
736 there, use this to detect decoding mode for multichannel */
738 if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
739 int ver = AV_RL16(avctx->extradata);
740 if(ver >= 0x402 && ver <= 0x410)
749 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
751 WavpackContext *s = avctx->priv_data;
754 for(i = 0; i < s->fdec_num; i++)
755 av_freep(&s->fdec[i]);
761 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
762 void *data, int *data_size,
763 const uint8_t *buf, int buf_size)
765 WavpackContext *wc = avctx->priv_data;
766 WavpackFrameContext *s;
767 void *samples = data;
769 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
771 const uint8_t* orig_buf = buf;
772 const uint8_t* buf_end = buf + buf_size;
773 int i, j, id, size, ssize, weights, t;
774 int bpp, chan, chmask;
781 if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
782 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
786 s = wc->fdec[block_no];
788 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
792 if(!s->samples_left){
793 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
794 memset(s->ch, 0, sizeof(s->ch));
796 s->and = s->or = s->shift = 0;
797 s->got_extra_bits = 0;
801 s->samples = AV_RL32(buf); buf += 4;
807 s->samples = wc->samples;
809 s->frame_flags = AV_RL32(buf); buf += 4;
810 if(s->frame_flags&0x80){
811 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
812 } else if((s->frame_flags&0x03) <= 1){
813 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
815 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
817 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
818 samples = (uint8_t*)samples + bpp * wc->ch_offset;
820 s->stereo = !(s->frame_flags & WV_MONO);
821 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
822 s->joint = s->frame_flags & WV_JOINT_STEREO;
823 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
824 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
825 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
826 s->CRC = AV_RL32(buf); buf += 4;
828 buf += 4; //skip block size;
830 wc->ch_offset += 1 + s->stereo;
832 s->max_samples = *data_size / (bpp * avctx->channels);
833 s->max_samples = FFMIN(s->max_samples, s->samples);
834 if(s->samples_left > 0){
835 s->max_samples = FFMIN(s->max_samples, s->samples_left);
839 // parse metadata blocks
840 while(buf < buf_end){
843 if(id & WP_IDF_LONG) {
844 size |= (*buf++) << 8;
845 size |= (*buf++) << 16;
847 size <<= 1; // size is specified in words
849 if(id & WP_IDF_ODD) size--;
851 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
854 if(buf + ssize > buf_end){
855 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
858 if(id & WP_IDF_IGNORE){
862 switch(id & WP_IDF_MASK){
864 if(size > MAX_TERMS){
865 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
871 for(i = 0; i < s->terms; i++) {
872 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
873 s->decorr[s->terms - i - 1].delta = *buf >> 5;
878 case WP_ID_DECWEIGHTS:
880 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
883 weights = size >> s->stereo_in;
884 if(weights > MAX_TERMS || weights > s->terms){
885 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
889 for(i = 0; i < weights; i++) {
890 t = (int8_t)(*buf++);
891 s->decorr[s->terms - i - 1].weightA = t << 3;
892 if(s->decorr[s->terms - i - 1].weightA > 0)
893 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
895 t = (int8_t)(*buf++);
896 s->decorr[s->terms - i - 1].weightB = t << 3;
897 if(s->decorr[s->terms - i - 1].weightB > 0)
898 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
903 case WP_ID_DECSAMPLES:
905 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
909 for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
910 if(s->decorr[i].value > 8){
911 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
912 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
914 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
915 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
919 }else if(s->decorr[i].value < 0){
920 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
921 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
924 for(j = 0; j < s->decorr[i].value; j++){
925 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
927 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
930 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
936 if(size != 6 * (s->stereo_in + 1)){
937 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
941 for(j = 0; j <= s->stereo_in; j++){
942 for(i = 0; i < 3; i++){
943 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
950 if(s->hybrid_bitrate){
951 for(i = 0; i <= s->stereo_in; i++){
952 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
957 for(i = 0; i < (s->stereo_in + 1); i++){
958 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
963 for(i = 0; i < (s->stereo_in + 1); i++){
964 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
968 for(i = 0; i < (s->stereo_in + 1); i++)
969 s->ch[i].bitrate_delta = 0;
973 case WP_ID_INT32INFO:
975 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
980 s->extra_bits = buf[0];
992 case WP_ID_FLOATINFO:
994 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
998 s->float_flag = buf[0];
999 s->float_shift = buf[1];
1000 s->float_max_exp = buf[2];
1005 s->sc.offset = buf - orig_buf;
1006 s->sc.size = size * 8;
1007 init_get_bits(&s->gb, buf, size * 8);
1008 s->data_size = size * 8;
1012 case WP_ID_EXTRABITS:
1014 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
1018 s->extra_sc.offset = buf - orig_buf;
1019 s->extra_sc.size = size * 8;
1020 init_get_bits(&s->gb_extra_bits, buf, size * 8);
1021 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1023 s->got_extra_bits = 1;
1025 case WP_ID_CHANINFO:
1027 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1036 chmask = AV_RL16(buf);
1039 chmask = AV_RL24(buf);
1042 chmask = AV_RL32(buf);
1045 chan |= (buf[1] & 0xF) << 8;
1046 chmask = AV_RL24(buf + 2);
1049 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
1050 chan = avctx->channels;
1051 chmask = avctx->channel_layout;
1053 if(chan != avctx->channels){
1054 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
1055 chan, avctx->channels);
1058 if(!avctx->channel_layout)
1059 avctx->channel_layout = chmask;
1065 if(id & WP_IDF_ODD) buf++;
1067 if(!s->samples_left){
1069 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1073 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1077 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1081 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1084 if(s->hybrid && !got_hybrid){
1085 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1089 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1092 if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
1093 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1096 if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
1097 const int size = get_bits_left(&s->gb_extra_bits);
1098 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1100 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1101 s->got_extra_bits = 0;
1104 s->samples_left = s->samples;
1106 init_get_bits(&s->gb, orig_buf + s->sc.offset, s->sc.size);
1107 skip_bits_long(&s->gb, s->sc.bits_used);
1108 if(s->got_extra_bits){
1109 init_get_bits(&s->gb_extra_bits, orig_buf + s->extra_sc.offset,
1111 skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
1116 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1117 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1118 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1119 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1121 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1123 if (samplecount < 0)
1128 const int channel_stride = avctx->channels;
1130 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1131 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1132 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1133 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1135 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1137 if (samplecount < 0)
1140 if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
1141 int16_t *dst = (int16_t*)samples + 1;
1142 int16_t *src = (int16_t*)samples;
1143 int cnt = samplecount;
1146 src += channel_stride;
1147 dst += channel_stride;
1149 }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
1150 int32_t *dst = (int32_t*)samples + 1;
1151 int32_t *src = (int32_t*)samples;
1152 int cnt = samplecount;
1155 src += channel_stride;
1156 dst += channel_stride;
1158 }else if(s->stereo){
1159 float *dst = (float*)samples + 1;
1160 float *src = (float*)samples;
1161 int cnt = samplecount;
1164 src += channel_stride;
1165 dst += channel_stride;
1170 wc->samples_left = s->samples_left;
1172 return samplecount * bpp;
1175 static void wavpack_decode_flush(AVCodecContext *avctx)
1177 WavpackContext *s = avctx->priv_data;
1180 for (i = 0; i < s->fdec_num; i++)
1181 wv_reset_saved_context(s->fdec[i]);
1184 static int wavpack_decode_frame(AVCodecContext *avctx,
1185 void *data, int *data_size,
1188 WavpackContext *s = avctx->priv_data;
1189 const uint8_t *buf = avpkt->data;
1190 int buf_size = avpkt->size;
1192 int samplecount = 0;
1195 s->samples_left = 0;
1199 s->samples = AV_RL32(buf); buf += 4;
1201 while(buf_size > 0){
1202 if(!s->multichannel){
1203 frame_size = buf_size;
1206 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1208 if(buf_size < 12) //MKV files can have zero flags after last block
1210 frame_size = AV_RL32(buf + 8) + 12;
1213 if(frame_size < 0 || frame_size > buf_size){
1214 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1215 s->block, frame_size, buf_size);
1216 wavpack_decode_flush(avctx);
1219 if((samplecount = wavpack_decode_block(avctx, s->block, data,
1220 data_size, buf, frame_size)) < 0) {
1221 wavpack_decode_flush(avctx);
1225 buf += frame_size; buf_size -= frame_size;
1227 *data_size = samplecount * avctx->channels;
1229 return s->samples_left > 0 ? 0 : avpkt->size;
1232 AVCodec ff_wavpack_decoder = {
1234 .type = AVMEDIA_TYPE_AUDIO,
1235 .id = CODEC_ID_WAVPACK,
1236 .priv_data_size = sizeof(WavpackContext),
1237 .init = wavpack_decode_init,
1238 .close = wavpack_decode_end,
1239 .decode = wavpack_decode_frame,
1240 .flush = wavpack_decode_flush,
1241 .capabilities = CODEC_CAP_SUBFRAMES,
1242 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),