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 samples_l = frame->extended_data[wc->ch_offset];
1125 samples_r = frame->extended_data[wc->ch_offset + 1];
1127 wc->ch_offset += 1 + s->stereo;
1130 ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt);
1134 ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt);
1139 memcpy(samples_r, samples_l, bpp * s->samples);
1145 static void wavpack_decode_flush(AVCodecContext *avctx)
1147 WavpackContext *s = avctx->priv_data;
1150 for (i = 0; i < s->fdec_num; i++)
1151 wv_reset_saved_context(s->fdec[i]);
1154 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1155 int *got_frame_ptr, AVPacket *avpkt)
1157 WavpackContext *s = avctx->priv_data;
1158 const uint8_t *buf = avpkt->data;
1159 int buf_size = avpkt->size;
1160 AVFrame *frame = data;
1161 int frame_size, ret, frame_flags;
1163 if (avpkt->size <= WV_HEADER_SIZE)
1164 return AVERROR_INVALIDDATA;
1169 /* determine number of samples */
1170 s->samples = AV_RL32(buf + 20);
1171 frame_flags = AV_RL32(buf + 24);
1172 if (s->samples <= 0) {
1173 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1175 return AVERROR_INVALIDDATA;
1178 if (frame_flags & 0x80) {
1179 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1180 } else if ((frame_flags & 0x03) <= 1) {
1181 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
1183 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
1184 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1187 while (buf_size > 0) {
1188 if (buf_size <= WV_HEADER_SIZE)
1190 frame_size = AV_RL32(buf + 4) - 12;
1193 if (frame_size <= 0 || frame_size > buf_size) {
1194 av_log(avctx, AV_LOG_ERROR,
1195 "Block %d has invalid size (size %d vs. %d bytes left)\n",
1196 s->block, frame_size, buf_size);
1197 wavpack_decode_flush(avctx);
1198 return AVERROR_INVALIDDATA;
1200 if ((ret = wavpack_decode_block(avctx, s->block,
1201 frame, buf, frame_size)) < 0) {
1202 wavpack_decode_flush(avctx);
1207 buf_size -= frame_size;
1215 AVCodec ff_wavpack_decoder = {
1217 .type = AVMEDIA_TYPE_AUDIO,
1218 .id = AV_CODEC_ID_WAVPACK,
1219 .priv_data_size = sizeof(WavpackContext),
1220 .init = wavpack_decode_init,
1221 .close = wavpack_decode_end,
1222 .decode = wavpack_decode_frame,
1223 .flush = wavpack_decode_flush,
1224 .capabilities = CODEC_CAP_DR1,
1225 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),