2 * WavPack lossless audio decoder
3 * Copyright (c) 2006,2011 Konstantin Shishkov
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #define BITSTREAM_READER_LE
24 #include "libavutil/channel_layout.h"
29 #include "bytestream.h"
33 * WavPack lossless audio decoder
36 #define WV_HEADER_SIZE 32
38 #define WV_MONO 0x00000004
39 #define WV_JOINT_STEREO 0x00000010
40 #define WV_FALSE_STEREO 0x40000000
42 #define WV_HYBRID_MODE 0x00000008
43 #define WV_HYBRID_SHAPE 0x00000008
44 #define WV_HYBRID_BITRATE 0x00000200
45 #define WV_HYBRID_BALANCE 0x00000400
46 #define WV_INITIAL_BLOCK 0x00000800
47 #define WV_FINAL_BLOCK 0x00001000
49 #define WV_SINGLE_BLOCK (WV_INITIAL_BLOCK | WV_FINAL_BLOCK)
51 #define WV_FLT_SHIFT_ONES 0x01
52 #define WV_FLT_SHIFT_SAME 0x02
53 #define WV_FLT_SHIFT_SENT 0x04
54 #define WV_FLT_ZERO_SENT 0x08
55 #define WV_FLT_ZERO_SIGN 0x10
79 WP_ID_SAMPLE_RATE = 0x27,
82 typedef struct SavedContext {
91 typedef struct Decorr {
100 typedef struct WvChannel {
102 int slow_level, error_limit;
103 int bitrate_acc, bitrate_delta;
106 typedef struct WavpackFrameContext {
107 AVCodecContext *avctx;
109 int stereo, stereo_in;
114 uint32_t crc_extra_bits;
115 GetBitContext gb_extra_bits;
116 int data_size; // in bits
119 Decorr decorr[MAX_TERMS];
120 int zero, one, zeroes;
124 int hybrid, hybrid_bitrate;
125 int hybrid_maxclip, hybrid_minclip;
131 SavedContext sc, extra_sc;
132 } WavpackFrameContext;
134 #define WV_MAX_FRAME_DECODERS 14
136 typedef struct WavpackContext {
137 AVCodecContext *avctx;
139 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
147 static const int wv_rates[16] = {
148 6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000,
149 32000, 44100, 48000, 64000, 88200, 96000, 192000, 0
152 // exponent table copied from WavPack source
153 static const uint8_t wp_exp2_table[256] = {
154 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
155 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
156 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
157 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
158 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
159 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
160 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
161 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
162 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
163 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
164 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
165 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
166 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
167 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
168 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
169 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
172 static const uint8_t wp_log2_table [] = {
173 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
174 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
175 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
176 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
177 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
178 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
179 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
180 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
181 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
182 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
183 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
184 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
185 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
186 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
187 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
188 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
191 static av_always_inline int wp_exp2(int16_t val)
200 res = wp_exp2_table[val & 0xFF] | 0x100;
202 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
203 return neg ? -res : res;
206 static av_always_inline int wp_log2(int32_t val)
215 bits = av_log2(val) + 1;
217 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
219 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
222 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
224 // macros for manipulating median values
225 #define GET_MED(n) ((c->median[n] >> 4) + 1)
226 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
227 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
229 // macros for applying weight
230 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
231 if (samples && in) { \
232 if ((samples ^ in) < 0) { \
234 if (weight < -1024) \
243 static av_always_inline int get_tail(GetBitContext *gb, int k)
250 e = (1 << (p + 1)) - k - 1;
251 res = p ? get_bits(gb, p) : 0;
253 res = (res << 1) - e + get_bits1(gb);
257 static void update_error_limit(WavpackFrameContext *ctx)
261 for (i = 0; i <= ctx->stereo_in; i++) {
262 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
263 br[i] = ctx->ch[i].bitrate_acc >> 16;
264 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
266 if (ctx->stereo_in && ctx->hybrid_bitrate) {
267 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
268 if (balance > br[0]) {
271 } else if (-balance > br[0]) {
275 br[1] = br[0] + balance;
276 br[0] = br[0] - balance;
279 for (i = 0; i <= ctx->stereo_in; i++) {
280 if (ctx->hybrid_bitrate) {
281 if (sl[i] - br[i] > -0x100)
282 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
284 ctx->ch[i].error_limit = 0;
286 ctx->ch[i].error_limit = wp_exp2(br[i]);
291 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
292 int channel, int *last)
295 int sign, base, add, ret;
296 WvChannel *c = &ctx->ch[channel];
300 if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
301 !ctx->zero && !ctx->one) {
305 c->slow_level -= LEVEL_DECAY(c->slow_level);
309 t = get_unary_0_33(gb);
311 if (get_bits_left(gb) < t - 1)
313 t = get_bits(gb, t - 1) | (1 << (t - 1));
315 if (get_bits_left(gb) < 0)
320 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
321 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
322 c->slow_level -= LEVEL_DECAY(c->slow_level);
332 t = get_unary_0_33(gb);
333 if (get_bits_left(gb) < 0)
336 t2 = get_unary_0_33(gb);
338 if (get_bits_left(gb) < 0)
342 if (get_bits_left(gb) < t2 - 1)
344 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
355 ctx->zero = !ctx->one;
358 if (ctx->hybrid && !channel)
359 update_error_limit(ctx);
363 add = GET_MED(0) - 1;
367 add = GET_MED(1) - 1;
371 base = GET_MED(0) + GET_MED(1);
372 add = GET_MED(2) - 1;
377 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
378 add = GET_MED(2) - 1;
383 if (!c->error_limit) {
384 ret = base + get_tail(gb, add);
385 if (get_bits_left(gb) <= 0)
388 int mid = (base * 2 + add + 1) >> 1;
389 while (add > c->error_limit) {
390 if (get_bits_left(gb) <= 0)
396 add = mid - base - 1;
397 mid = (base * 2 + add + 1) >> 1;
401 sign = get_bits1(gb);
402 if (ctx->hybrid_bitrate)
403 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
404 return sign ? ~ret : ret;
411 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
419 if (s->got_extra_bits &&
420 get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
421 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
422 *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
426 bit = (S & s->and) | s->or;
427 bit = ((S + bit) << s->shift) - bit;
430 bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
432 return bit << s->post_shift;
435 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
443 int exp = s->float_max_exp;
445 if (s->got_extra_bits) {
446 const int max_bits = 1 + 23 + 8 + 1;
447 const int left_bits = get_bits_left(&s->gb_extra_bits);
449 if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
454 S <<= s->float_shift;
458 if (S >= 0x1000000) {
459 if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
460 S = get_bits(&s->gb_extra_bits, 23);
465 int shift = 23 - av_log2(S);
466 exp = s->float_max_exp;
473 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
474 (s->got_extra_bits &&
475 (s->float_flag & WV_FLT_SHIFT_SAME) &&
476 get_bits1(&s->gb_extra_bits))) {
477 S |= (1 << shift) - 1;
478 } else if (s->got_extra_bits &&
479 (s->float_flag & WV_FLT_SHIFT_SENT)) {
480 S |= get_bits(&s->gb_extra_bits, shift);
484 exp = s->float_max_exp;
490 if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
491 if (get_bits1(&s->gb_extra_bits)) {
492 S = get_bits(&s->gb_extra_bits, 23);
493 if (s->float_max_exp >= 25)
494 exp = get_bits(&s->gb_extra_bits, 8);
495 sign = get_bits1(&s->gb_extra_bits);
497 if (s->float_flag & WV_FLT_ZERO_SIGN)
498 sign = get_bits1(&s->gb_extra_bits);
503 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
505 value.u = (sign << 31) | (exp << 23) | S;
509 static void wv_reset_saved_context(WavpackFrameContext *s)
512 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
515 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
516 uint32_t crc_extra_bits)
519 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
520 return AVERROR_INVALIDDATA;
522 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
523 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
524 return AVERROR_INVALIDDATA;
530 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
531 void *dst_l, void *dst_r, const int type)
535 int A, B, L, L2, R, R2;
537 uint32_t crc = s->sc.crc;
538 uint32_t crc_extra_bits = s->extra_sc.crc;
539 int16_t *dst16_l = dst_l;
540 int16_t *dst16_r = dst_r;
541 int32_t *dst32_l = dst_l;
542 int32_t *dst32_r = dst_r;
543 float *dstfl_l = dst_l;
544 float *dstfl_r = dst_r;
546 s->one = s->zero = s->zeroes = 0;
548 L = wv_get_value(s, gb, 0, &last);
551 R = wv_get_value(s, gb, 1, &last);
554 for (i = 0; i < s->terms; i++) {
555 t = s->decorr[i].value;
559 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
560 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
562 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
563 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
565 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
566 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
569 A = s->decorr[i].samplesA[pos];
570 B = s->decorr[i].samplesB[pos];
573 if (type != AV_SAMPLE_FMT_S16P) {
574 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
575 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
577 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
578 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
581 s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
583 s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
584 s->decorr[i].samplesA[j] = L = L2;
585 s->decorr[i].samplesB[j] = R = R2;
586 } else if (t == -1) {
587 if (type != AV_SAMPLE_FMT_S16P)
588 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
590 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
591 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
593 if (type != AV_SAMPLE_FMT_S16P)
594 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
596 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
597 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
599 s->decorr[i].samplesA[0] = R;
601 if (type != AV_SAMPLE_FMT_S16P)
602 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
604 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
605 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
609 R2 = s->decorr[i].samplesA[0];
610 s->decorr[i].samplesA[0] = R;
613 if (type != AV_SAMPLE_FMT_S16P)
614 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
616 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
617 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
619 s->decorr[i].samplesB[0] = L;
624 L += (R -= (L >> 1));
625 crc = (crc * 3 + L) * 3 + R;
627 if (type == AV_SAMPLE_FMT_FLTP) {
628 *dstfl_l++ = wv_get_value_float(s, &crc_extra_bits, L);
629 *dstfl_r++ = wv_get_value_float(s, &crc_extra_bits, R);
630 } else if (type == AV_SAMPLE_FMT_S32P) {
631 *dst32_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
632 *dst32_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
634 *dst16_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
635 *dst16_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
638 } while (!last && count < s->samples);
640 wv_reset_saved_context(s);
641 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
642 wv_check_crc(s, crc, crc_extra_bits))
643 return AVERROR_INVALIDDATA;
648 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
649 void *dst, const int type)
655 uint32_t crc = s->sc.crc;
656 uint32_t crc_extra_bits = s->extra_sc.crc;
657 int16_t *dst16 = dst;
658 int32_t *dst32 = dst;
661 s->one = s->zero = s->zeroes = 0;
663 T = wv_get_value(s, gb, 0, &last);
667 for (i = 0; i < s->terms; i++) {
668 t = s->decorr[i].value;
671 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
673 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
674 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
677 A = s->decorr[i].samplesA[pos];
680 if (type != AV_SAMPLE_FMT_S16P)
681 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
683 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
685 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
686 s->decorr[i].samplesA[j] = T = S;
691 if (type == AV_SAMPLE_FMT_FLTP) {
692 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
693 } else if (type == AV_SAMPLE_FMT_S32P) {
694 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
696 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
699 } while (!last && count < s->samples);
701 wv_reset_saved_context(s);
702 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
703 wv_check_crc(s, crc, crc_extra_bits))
704 return AVERROR_INVALIDDATA;
709 static av_cold int wv_alloc_frame_context(WavpackContext *c)
711 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
714 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
715 if (!c->fdec[c->fdec_num])
718 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
719 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
724 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
726 WavpackContext *s = avctx->priv_data;
735 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
737 WavpackContext *s = avctx->priv_data;
740 for (i = 0; i < s->fdec_num; i++)
741 av_freep(&s->fdec[i]);
747 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
748 AVFrame *frame, const uint8_t *buf, int buf_size)
750 WavpackContext *wc = avctx->priv_data;
751 WavpackFrameContext *s;
753 void *samples_l, *samples_r;
755 int got_terms = 0, got_weights = 0, got_samples = 0,
756 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
757 int i, j, id, size, ssize, weights, t;
758 int bpp, chan = 0, chmask = 0, orig_bpp, sample_rate = 0;
761 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
762 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
763 return AVERROR_INVALIDDATA;
766 s = wc->fdec[block_no];
768 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n",
770 return AVERROR_INVALIDDATA;
773 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
774 memset(s->ch, 0, sizeof(s->ch));
776 s->and = s->or = s->shift = 0;
777 s->got_extra_bits = 0;
779 bytestream2_init(&gb, buf, buf_size);
781 s->samples = bytestream2_get_le32(&gb);
782 if (s->samples != wc->samples) {
783 av_log(avctx, AV_LOG_ERROR, "Mismatching number of samples in "
784 "a sequence: %d and %d\n", wc->samples, s->samples);
785 return AVERROR_INVALIDDATA;
787 s->frame_flags = bytestream2_get_le32(&gb);
788 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
789 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
790 multiblock = (s->frame_flags & WV_SINGLE_BLOCK) != WV_SINGLE_BLOCK;
792 s->stereo = !(s->frame_flags & WV_MONO);
793 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
794 s->joint = s->frame_flags & WV_JOINT_STEREO;
795 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
796 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
797 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
798 s->hybrid_maxclip = ((1LL << (orig_bpp - 1)) - 1);
799 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
800 s->CRC = bytestream2_get_le32(&gb);
802 // parse metadata blocks
803 while (bytestream2_get_bytes_left(&gb)) {
804 id = bytestream2_get_byte(&gb);
805 size = bytestream2_get_byte(&gb);
806 if (id & WP_IDF_LONG) {
807 size |= (bytestream2_get_byte(&gb)) << 8;
808 size |= (bytestream2_get_byte(&gb)) << 16;
810 size <<= 1; // size is specified in words
815 av_log(avctx, AV_LOG_ERROR,
816 "Got incorrect block %02X with size %i\n", id, size);
819 if (bytestream2_get_bytes_left(&gb) < ssize) {
820 av_log(avctx, AV_LOG_ERROR,
821 "Block size %i is out of bounds\n", size);
824 switch (id & WP_IDF_MASK) {
826 if (size > MAX_TERMS) {
827 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
829 bytestream2_skip(&gb, ssize);
833 for (i = 0; i < s->terms; i++) {
834 uint8_t val = bytestream2_get_byte(&gb);
835 s->decorr[s->terms - i - 1].value = (val & 0x1F) - 5;
836 s->decorr[s->terms - i - 1].delta = val >> 5;
840 case WP_ID_DECWEIGHTS:
842 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
845 weights = size >> s->stereo_in;
846 if (weights > MAX_TERMS || weights > s->terms) {
847 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
848 bytestream2_skip(&gb, ssize);
851 for (i = 0; i < weights; i++) {
852 t = (int8_t)bytestream2_get_byte(&gb);
853 s->decorr[s->terms - i - 1].weightA = t << 3;
854 if (s->decorr[s->terms - i - 1].weightA > 0)
855 s->decorr[s->terms - i - 1].weightA +=
856 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
858 t = (int8_t)bytestream2_get_byte(&gb);
859 s->decorr[s->terms - i - 1].weightB = t << 3;
860 if (s->decorr[s->terms - i - 1].weightB > 0)
861 s->decorr[s->terms - i - 1].weightB +=
862 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
867 case WP_ID_DECSAMPLES:
869 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
873 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
874 if (s->decorr[i].value > 8) {
875 s->decorr[i].samplesA[0] =
876 wp_exp2(bytestream2_get_le16(&gb));
877 s->decorr[i].samplesA[1] =
878 wp_exp2(bytestream2_get_le16(&gb));
881 s->decorr[i].samplesB[0] =
882 wp_exp2(bytestream2_get_le16(&gb));
883 s->decorr[i].samplesB[1] =
884 wp_exp2(bytestream2_get_le16(&gb));
888 } else if (s->decorr[i].value < 0) {
889 s->decorr[i].samplesA[0] =
890 wp_exp2(bytestream2_get_le16(&gb));
891 s->decorr[i].samplesB[0] =
892 wp_exp2(bytestream2_get_le16(&gb));
895 for (j = 0; j < s->decorr[i].value; j++) {
896 s->decorr[i].samplesA[j] =
897 wp_exp2(bytestream2_get_le16(&gb));
899 s->decorr[i].samplesB[j] =
900 wp_exp2(bytestream2_get_le16(&gb));
903 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
909 if (size != 6 * (s->stereo_in + 1)) {
910 av_log(avctx, AV_LOG_ERROR,
911 "Entropy vars size should be %i, got %i",
912 6 * (s->stereo_in + 1), size);
913 bytestream2_skip(&gb, ssize);
916 for (j = 0; j <= s->stereo_in; j++)
917 for (i = 0; i < 3; i++) {
918 s->ch[j].median[i] = wp_exp2(bytestream2_get_le16(&gb));
923 if (s->hybrid_bitrate) {
924 for (i = 0; i <= s->stereo_in; i++) {
925 s->ch[i].slow_level = wp_exp2(bytestream2_get_le16(&gb));
929 for (i = 0; i < (s->stereo_in + 1); i++) {
930 s->ch[i].bitrate_acc = bytestream2_get_le16(&gb) << 16;
934 for (i = 0; i < (s->stereo_in + 1); i++) {
935 s->ch[i].bitrate_delta =
936 wp_exp2((int16_t)bytestream2_get_le16(&gb));
939 for (i = 0; i < (s->stereo_in + 1); i++)
940 s->ch[i].bitrate_delta = 0;
944 case WP_ID_INT32INFO: {
947 av_log(avctx, AV_LOG_ERROR,
948 "Invalid INT32INFO, size = %i\n",
950 bytestream2_skip(&gb, ssize - 4);
953 bytestream2_get_buffer(&gb, val, 4);
955 s->extra_bits = val[0];
965 /* original WavPack decoder forces 32-bit lossy sound to be treated
966 * as 24-bit one in order to have proper clipping */
967 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
970 s->hybrid_maxclip >>= 8;
971 s->hybrid_minclip >>= 8;
975 case WP_ID_FLOATINFO:
977 av_log(avctx, AV_LOG_ERROR,
978 "Invalid FLOATINFO, size = %i\n", size);
979 bytestream2_skip(&gb, ssize);
982 s->float_flag = bytestream2_get_byte(&gb);
983 s->float_shift = bytestream2_get_byte(&gb);
984 s->float_max_exp = bytestream2_get_byte(&gb);
986 bytestream2_skip(&gb, 1);
989 s->sc.offset = bytestream2_tell(&gb);
990 s->sc.size = size * 8;
991 init_get_bits(&s->gb, gb.buffer, size * 8);
992 s->data_size = size * 8;
993 bytestream2_skip(&gb, size);
996 case WP_ID_EXTRABITS:
998 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1000 bytestream2_skip(&gb, size);
1003 s->extra_sc.offset = bytestream2_tell(&gb);
1004 s->extra_sc.size = size * 8;
1005 init_get_bits(&s->gb_extra_bits, gb.buffer, size * 8);
1006 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1007 bytestream2_skip(&gb, size);
1008 s->got_extra_bits = 1;
1010 case WP_ID_CHANINFO:
1012 av_log(avctx, AV_LOG_ERROR,
1013 "Insufficient channel information\n");
1014 return AVERROR_INVALIDDATA;
1016 chan = bytestream2_get_byte(&gb);
1019 chmask = bytestream2_get_byte(&gb);
1022 chmask = bytestream2_get_le16(&gb);
1025 chmask = bytestream2_get_le24(&gb);
1028 chmask = bytestream2_get_le32(&gb);;
1031 bytestream2_skip(&gb, 1);
1032 chan |= (bytestream2_get_byte(&gb) & 0xF) << 8;
1033 chmask = bytestream2_get_le16(&gb);
1036 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1038 chan = avctx->channels;
1039 chmask = avctx->channel_layout;
1042 case WP_ID_SAMPLE_RATE:
1044 av_log(avctx, AV_LOG_ERROR, "Invalid custom sample rate.\n");
1045 return AVERROR_INVALIDDATA;
1047 sample_rate = bytestream2_get_le24(&gb);
1050 bytestream2_skip(&gb, size);
1052 if (id & WP_IDF_ODD)
1053 bytestream2_skip(&gb, 1);
1057 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1058 return AVERROR_INVALIDDATA;
1061 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1062 return AVERROR_INVALIDDATA;
1065 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1066 return AVERROR_INVALIDDATA;
1069 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1070 return AVERROR_INVALIDDATA;
1072 if (s->hybrid && !got_hybrid) {
1073 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1074 return AVERROR_INVALIDDATA;
1077 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1078 return AVERROR_INVALIDDATA;
1080 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) {
1081 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1082 return AVERROR_INVALIDDATA;
1084 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) {
1085 const int size = get_bits_left(&s->gb_extra_bits);
1086 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1087 if (size < wanted) {
1088 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1089 s->got_extra_bits = 0;
1093 if (!wc->ch_offset) {
1094 int sr = (s->frame_flags >> 23) & 0xf;
1097 av_log(avctx, AV_LOG_ERROR, "Custom sample rate missing.\n");
1098 return AVERROR_INVALIDDATA;
1100 avctx->sample_rate = sample_rate;
1102 avctx->sample_rate = wv_rates[sr];
1106 avctx->channels = chan;
1108 avctx->channel_layout = chmask;
1110 avctx->channels = s->stereo ? 2 : 1;
1111 avctx->channel_layout = s->stereo ? AV_CH_LAYOUT_STEREO :
1115 /* get output buffer */
1116 frame->nb_samples = s->samples;
1117 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1118 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1123 if (wc->ch_offset + s->stereo >= avctx->channels) {
1124 av_log(avctx, AV_LOG_WARNING, "Too many channels coded in a packet.\n");
1125 return (avctx->err_recognition & AV_EF_EXPLODE) ? AVERROR_INVALIDDATA : 0;
1128 samples_l = frame->extended_data[wc->ch_offset];
1130 samples_r = frame->extended_data[wc->ch_offset + 1];
1132 wc->ch_offset += 1 + s->stereo;
1135 ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt);
1139 ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt);
1144 memcpy(samples_r, samples_l, bpp * s->samples);
1150 static void wavpack_decode_flush(AVCodecContext *avctx)
1152 WavpackContext *s = avctx->priv_data;
1155 for (i = 0; i < s->fdec_num; i++)
1156 wv_reset_saved_context(s->fdec[i]);
1159 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1160 int *got_frame_ptr, AVPacket *avpkt)
1162 WavpackContext *s = avctx->priv_data;
1163 const uint8_t *buf = avpkt->data;
1164 int buf_size = avpkt->size;
1165 AVFrame *frame = data;
1166 int frame_size, ret, frame_flags;
1168 if (avpkt->size <= WV_HEADER_SIZE)
1169 return AVERROR_INVALIDDATA;
1174 /* determine number of samples */
1175 s->samples = AV_RL32(buf + 20);
1176 frame_flags = AV_RL32(buf + 24);
1177 if (s->samples <= 0) {
1178 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1180 return AVERROR_INVALIDDATA;
1183 if (frame_flags & 0x80) {
1184 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1185 } else if ((frame_flags & 0x03) <= 1) {
1186 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
1188 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
1189 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1192 while (buf_size > 0) {
1193 if (buf_size <= WV_HEADER_SIZE)
1195 frame_size = AV_RL32(buf + 4) - 12;
1198 if (frame_size <= 0 || frame_size > buf_size) {
1199 av_log(avctx, AV_LOG_ERROR,
1200 "Block %d has invalid size (size %d vs. %d bytes left)\n",
1201 s->block, frame_size, buf_size);
1202 wavpack_decode_flush(avctx);
1203 return AVERROR_INVALIDDATA;
1205 if ((ret = wavpack_decode_block(avctx, s->block,
1206 frame, buf, frame_size)) < 0) {
1207 wavpack_decode_flush(avctx);
1212 buf_size -= frame_size;
1215 if (s->ch_offset != avctx->channels) {
1216 av_log(avctx, AV_LOG_ERROR, "Not enough channels coded in a packet.\n");
1217 return AVERROR_INVALIDDATA;
1225 AVCodec ff_wavpack_decoder = {
1227 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1228 .type = AVMEDIA_TYPE_AUDIO,
1229 .id = AV_CODEC_ID_WAVPACK,
1230 .priv_data_size = sizeof(WavpackContext),
1231 .init = wavpack_decode_init,
1232 .close = wavpack_decode_end,
1233 .decode = wavpack_decode_frame,
1234 .flush = wavpack_decode_flush,
1235 .capabilities = CODEC_CAP_DR1,