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
22 #define BITSTREAM_READER_LE
24 #include "libavutil/channel_layout.h"
30 #include "bytestream.h"
34 * WavPack lossless audio decoder
37 #define WV_HEADER_SIZE 32
39 #define WV_MONO 0x00000004
40 #define WV_JOINT_STEREO 0x00000010
41 #define WV_FALSE_STEREO 0x40000000
43 #define WV_HYBRID_MODE 0x00000008
44 #define WV_HYBRID_SHAPE 0x00000008
45 #define WV_HYBRID_BITRATE 0x00000200
46 #define WV_HYBRID_BALANCE 0x00000400
47 #define WV_INITIAL_BLOCK 0x00000800
48 #define WV_FINAL_BLOCK 0x00001000
50 #define WV_SINGLE_BLOCK (WV_INITIAL_BLOCK | WV_FINAL_BLOCK)
52 #define WV_FLT_SHIFT_ONES 0x01
53 #define WV_FLT_SHIFT_SAME 0x02
54 #define WV_FLT_SHIFT_SENT 0x04
55 #define WV_FLT_ZERO_SENT 0x08
56 #define WV_FLT_ZERO_SIGN 0x10
58 #define WV_MAX_SAMPLES 131072
82 WP_ID_SAMPLE_RATE = 0x27,
85 typedef struct SavedContext {
94 typedef struct Decorr {
103 typedef struct WvChannel {
105 int slow_level, error_limit;
106 int bitrate_acc, bitrate_delta;
109 typedef struct WavpackFrameContext {
110 AVCodecContext *avctx;
112 int stereo, stereo_in;
117 uint32_t crc_extra_bits;
118 GetBitContext gb_extra_bits;
119 int data_size; // in bits
122 Decorr decorr[MAX_TERMS];
123 int zero, one, zeroes;
127 int hybrid, hybrid_bitrate;
128 int hybrid_maxclip, hybrid_minclip;
134 SavedContext sc, extra_sc;
135 } WavpackFrameContext;
137 #define WV_MAX_FRAME_DECODERS 14
139 typedef struct WavpackContext {
140 AVCodecContext *avctx;
142 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
150 static const int wv_rates[16] = {
151 6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000,
152 32000, 44100, 48000, 64000, 88200, 96000, 192000, 0
155 // exponent table copied from WavPack source
156 static const uint8_t wp_exp2_table[256] = {
157 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
158 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
159 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
160 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
161 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
162 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
163 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
164 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
165 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
166 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
167 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
168 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
169 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
170 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
171 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
172 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
175 static const uint8_t wp_log2_table [] = {
176 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
177 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
178 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
179 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
180 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
181 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
182 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
183 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
184 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
185 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
186 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
187 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
188 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
189 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
190 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
191 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
194 static av_always_inline int wp_exp2(int16_t val)
203 res = wp_exp2_table[val & 0xFF] | 0x100;
205 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
206 return neg ? -res : res;
209 static av_always_inline int wp_log2(int32_t val)
218 bits = av_log2(val) + 1;
220 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
222 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
225 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
227 // macros for manipulating median values
228 #define GET_MED(n) ((c->median[n] >> 4) + 1)
229 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
230 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
232 // macros for applying weight
233 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
234 if (samples && in) { \
235 if ((samples ^ in) < 0) { \
237 if (weight < -1024) \
246 static av_always_inline int get_tail(GetBitContext *gb, int k)
253 e = (1 << (p + 1)) - k - 1;
254 res = p ? get_bits(gb, p) : 0;
256 res = (res << 1) - e + get_bits1(gb);
260 static void update_error_limit(WavpackFrameContext *ctx)
264 for (i = 0; i <= ctx->stereo_in; i++) {
265 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
266 br[i] = ctx->ch[i].bitrate_acc >> 16;
267 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
269 if (ctx->stereo_in && ctx->hybrid_bitrate) {
270 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
271 if (balance > br[0]) {
274 } else if (-balance > br[0]) {
278 br[1] = br[0] + balance;
279 br[0] = br[0] - balance;
282 for (i = 0; i <= ctx->stereo_in; i++) {
283 if (ctx->hybrid_bitrate) {
284 if (sl[i] - br[i] > -0x100)
285 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
287 ctx->ch[i].error_limit = 0;
289 ctx->ch[i].error_limit = wp_exp2(br[i]);
294 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
295 int channel, int *last)
298 int sign, base, add, ret;
299 WvChannel *c = &ctx->ch[channel];
303 if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
304 !ctx->zero && !ctx->one) {
308 c->slow_level -= LEVEL_DECAY(c->slow_level);
312 t = get_unary_0_33(gb);
314 if (get_bits_left(gb) < t - 1)
316 t = get_bits(gb, t - 1) | (1 << (t - 1));
318 if (get_bits_left(gb) < 0)
323 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
324 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
325 c->slow_level -= LEVEL_DECAY(c->slow_level);
335 t = get_unary_0_33(gb);
336 if (get_bits_left(gb) < 0)
339 t2 = get_unary_0_33(gb);
341 if (get_bits_left(gb) < 0)
345 if (get_bits_left(gb) < t2 - 1)
347 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
358 ctx->zero = !ctx->one;
361 if (ctx->hybrid && !channel)
362 update_error_limit(ctx);
366 add = GET_MED(0) - 1;
370 add = GET_MED(1) - 1;
374 base = GET_MED(0) + GET_MED(1);
375 add = GET_MED(2) - 1;
380 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
381 add = GET_MED(2) - 1;
386 if (!c->error_limit) {
387 if (add >= 0x2000000U) {
388 av_log(ctx->avctx, AV_LOG_ERROR, "k %d is too large\n", add);
391 ret = base + get_tail(gb, add);
392 if (get_bits_left(gb) <= 0)
395 int mid = (base * 2 + add + 1) >> 1;
396 while (add > c->error_limit) {
397 if (get_bits_left(gb) <= 0)
403 add = mid - base - 1;
404 mid = (base * 2 + add + 1) >> 1;
408 sign = get_bits1(gb);
409 if (ctx->hybrid_bitrate)
410 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
411 return sign ? ~ret : ret;
418 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
426 if (s->got_extra_bits &&
427 get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
428 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
429 *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
433 bit = (S & s->and) | s->or;
434 bit = ((S + bit) << s->shift) - bit;
437 bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
439 return bit << s->post_shift;
442 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
450 int exp = s->float_max_exp;
452 if (s->got_extra_bits) {
453 const int max_bits = 1 + 23 + 8 + 1;
454 const int left_bits = get_bits_left(&s->gb_extra_bits);
456 if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
461 S <<= s->float_shift;
465 if (S >= 0x1000000) {
466 if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
467 S = get_bits(&s->gb_extra_bits, 23);
472 int shift = 23 - av_log2(S);
473 exp = s->float_max_exp;
480 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
481 (s->got_extra_bits &&
482 (s->float_flag & WV_FLT_SHIFT_SAME) &&
483 get_bits1(&s->gb_extra_bits))) {
484 S |= (1 << shift) - 1;
485 } else if (s->got_extra_bits &&
486 (s->float_flag & WV_FLT_SHIFT_SENT)) {
487 S |= get_bits(&s->gb_extra_bits, shift);
491 exp = s->float_max_exp;
497 if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
498 if (get_bits1(&s->gb_extra_bits)) {
499 S = get_bits(&s->gb_extra_bits, 23);
500 if (s->float_max_exp >= 25)
501 exp = get_bits(&s->gb_extra_bits, 8);
502 sign = get_bits1(&s->gb_extra_bits);
504 if (s->float_flag & WV_FLT_ZERO_SIGN)
505 sign = get_bits1(&s->gb_extra_bits);
510 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
512 value.u = (sign << 31) | (exp << 23) | S;
516 static void wv_reset_saved_context(WavpackFrameContext *s)
519 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
522 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
523 uint32_t crc_extra_bits)
526 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
527 return AVERROR_INVALIDDATA;
529 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
530 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
531 return AVERROR_INVALIDDATA;
537 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
538 void *dst_l, void *dst_r, const int type)
542 int A, B, L, L2, R, R2;
544 uint32_t crc = s->sc.crc;
545 uint32_t crc_extra_bits = s->extra_sc.crc;
546 int16_t *dst16_l = dst_l;
547 int16_t *dst16_r = dst_r;
548 int32_t *dst32_l = dst_l;
549 int32_t *dst32_r = dst_r;
550 float *dstfl_l = dst_l;
551 float *dstfl_r = dst_r;
553 s->one = s->zero = s->zeroes = 0;
555 L = wv_get_value(s, gb, 0, &last);
558 R = wv_get_value(s, gb, 1, &last);
561 for (i = 0; i < s->terms; i++) {
562 t = s->decorr[i].value;
566 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
567 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
569 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
570 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
572 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
573 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
576 A = s->decorr[i].samplesA[pos];
577 B = s->decorr[i].samplesB[pos];
580 if (type != AV_SAMPLE_FMT_S16P) {
581 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
582 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
584 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
585 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
588 s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
590 s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
591 s->decorr[i].samplesA[j] = L = L2;
592 s->decorr[i].samplesB[j] = R = R2;
593 } else if (t == -1) {
594 if (type != AV_SAMPLE_FMT_S16P)
595 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
597 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
598 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
600 if (type != AV_SAMPLE_FMT_S16P)
601 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
603 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
604 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
606 s->decorr[i].samplesA[0] = R;
608 if (type != AV_SAMPLE_FMT_S16P)
609 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
611 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
612 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
616 R2 = s->decorr[i].samplesA[0];
617 s->decorr[i].samplesA[0] = R;
620 if (type != AV_SAMPLE_FMT_S16P)
621 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
623 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
624 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
626 s->decorr[i].samplesB[0] = L;
631 L += (R -= (L >> 1));
632 crc = (crc * 3 + L) * 3 + R;
634 if (type == AV_SAMPLE_FMT_FLTP) {
635 *dstfl_l++ = wv_get_value_float(s, &crc_extra_bits, L);
636 *dstfl_r++ = wv_get_value_float(s, &crc_extra_bits, R);
637 } else if (type == AV_SAMPLE_FMT_S32P) {
638 *dst32_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
639 *dst32_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
641 *dst16_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
642 *dst16_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
645 } while (!last && count < s->samples);
647 wv_reset_saved_context(s);
648 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
649 wv_check_crc(s, crc, crc_extra_bits))
650 return AVERROR_INVALIDDATA;
655 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
656 void *dst, const int type)
662 uint32_t crc = s->sc.crc;
663 uint32_t crc_extra_bits = s->extra_sc.crc;
664 int16_t *dst16 = dst;
665 int32_t *dst32 = dst;
668 s->one = s->zero = s->zeroes = 0;
670 T = wv_get_value(s, gb, 0, &last);
674 for (i = 0; i < s->terms; i++) {
675 t = s->decorr[i].value;
678 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
680 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
681 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
684 A = s->decorr[i].samplesA[pos];
687 if (type != AV_SAMPLE_FMT_S16P)
688 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
690 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
692 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
693 s->decorr[i].samplesA[j] = T = S;
698 if (type == AV_SAMPLE_FMT_FLTP) {
699 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
700 } else if (type == AV_SAMPLE_FMT_S32P) {
701 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
703 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
706 } while (!last && count < s->samples);
708 wv_reset_saved_context(s);
709 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
710 wv_check_crc(s, crc, crc_extra_bits))
711 return AVERROR_INVALIDDATA;
716 static av_cold int wv_alloc_frame_context(WavpackContext *c)
718 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
721 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
722 if (!c->fdec[c->fdec_num])
725 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
726 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
731 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
733 WavpackContext *s = avctx->priv_data;
742 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
744 WavpackContext *s = avctx->priv_data;
747 for (i = 0; i < s->fdec_num; i++)
748 av_freep(&s->fdec[i]);
754 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
755 AVFrame *frame, const uint8_t *buf, int buf_size)
757 WavpackContext *wc = avctx->priv_data;
758 ThreadFrame tframe = { .f = frame };
759 WavpackFrameContext *s;
761 void *samples_l, *samples_r;
763 int got_terms = 0, got_weights = 0, got_samples = 0,
764 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
765 int i, j, id, size, ssize, weights, t;
766 int bpp, chan = 0, chmask = 0, orig_bpp, sample_rate = 0;
769 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
770 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
771 return AVERROR_INVALIDDATA;
774 s = wc->fdec[block_no];
776 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n",
778 return AVERROR_INVALIDDATA;
781 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
782 memset(s->ch, 0, sizeof(s->ch));
784 s->and = s->or = s->shift = 0;
785 s->got_extra_bits = 0;
787 bytestream2_init(&gb, buf, buf_size);
789 s->samples = bytestream2_get_le32(&gb);
790 if (s->samples != wc->samples) {
791 av_log(avctx, AV_LOG_ERROR, "Mismatching number of samples in "
792 "a sequence: %d and %d\n", wc->samples, s->samples);
793 return AVERROR_INVALIDDATA;
795 s->frame_flags = bytestream2_get_le32(&gb);
796 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
797 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
798 multiblock = (s->frame_flags & WV_SINGLE_BLOCK) != WV_SINGLE_BLOCK;
800 s->stereo = !(s->frame_flags & WV_MONO);
801 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
802 s->joint = s->frame_flags & WV_JOINT_STEREO;
803 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
804 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
805 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
806 s->hybrid_maxclip = ((1LL << (orig_bpp - 1)) - 1);
807 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
808 s->CRC = bytestream2_get_le32(&gb);
810 // parse metadata blocks
811 while (bytestream2_get_bytes_left(&gb)) {
812 id = bytestream2_get_byte(&gb);
813 size = bytestream2_get_byte(&gb);
814 if (id & WP_IDF_LONG) {
815 size |= (bytestream2_get_byte(&gb)) << 8;
816 size |= (bytestream2_get_byte(&gb)) << 16;
818 size <<= 1; // size is specified in words
823 av_log(avctx, AV_LOG_ERROR,
824 "Got incorrect block %02X with size %i\n", id, size);
827 if (bytestream2_get_bytes_left(&gb) < ssize) {
828 av_log(avctx, AV_LOG_ERROR,
829 "Block size %i is out of bounds\n", size);
832 switch (id & WP_IDF_MASK) {
834 if (size > MAX_TERMS) {
835 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
837 bytestream2_skip(&gb, ssize);
841 for (i = 0; i < s->terms; i++) {
842 uint8_t val = bytestream2_get_byte(&gb);
843 s->decorr[s->terms - i - 1].value = (val & 0x1F) - 5;
844 s->decorr[s->terms - i - 1].delta = val >> 5;
848 case WP_ID_DECWEIGHTS:
850 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
853 weights = size >> s->stereo_in;
854 if (weights > MAX_TERMS || weights > s->terms) {
855 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
856 bytestream2_skip(&gb, ssize);
859 for (i = 0; i < weights; i++) {
860 t = (int8_t)bytestream2_get_byte(&gb);
861 s->decorr[s->terms - i - 1].weightA = t << 3;
862 if (s->decorr[s->terms - i - 1].weightA > 0)
863 s->decorr[s->terms - i - 1].weightA +=
864 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
866 t = (int8_t)bytestream2_get_byte(&gb);
867 s->decorr[s->terms - i - 1].weightB = t << 3;
868 if (s->decorr[s->terms - i - 1].weightB > 0)
869 s->decorr[s->terms - i - 1].weightB +=
870 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
875 case WP_ID_DECSAMPLES:
877 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
881 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
882 if (s->decorr[i].value > 8) {
883 s->decorr[i].samplesA[0] =
884 wp_exp2(bytestream2_get_le16(&gb));
885 s->decorr[i].samplesA[1] =
886 wp_exp2(bytestream2_get_le16(&gb));
889 s->decorr[i].samplesB[0] =
890 wp_exp2(bytestream2_get_le16(&gb));
891 s->decorr[i].samplesB[1] =
892 wp_exp2(bytestream2_get_le16(&gb));
896 } else if (s->decorr[i].value < 0) {
897 s->decorr[i].samplesA[0] =
898 wp_exp2(bytestream2_get_le16(&gb));
899 s->decorr[i].samplesB[0] =
900 wp_exp2(bytestream2_get_le16(&gb));
903 for (j = 0; j < s->decorr[i].value; j++) {
904 s->decorr[i].samplesA[j] =
905 wp_exp2(bytestream2_get_le16(&gb));
907 s->decorr[i].samplesB[j] =
908 wp_exp2(bytestream2_get_le16(&gb));
911 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
917 if (size != 6 * (s->stereo_in + 1)) {
918 av_log(avctx, AV_LOG_ERROR,
919 "Entropy vars size should be %i, got %i.\n",
920 6 * (s->stereo_in + 1), size);
921 bytestream2_skip(&gb, ssize);
924 for (j = 0; j <= s->stereo_in; j++)
925 for (i = 0; i < 3; i++) {
926 s->ch[j].median[i] = wp_exp2(bytestream2_get_le16(&gb));
931 if (s->hybrid_bitrate) {
932 for (i = 0; i <= s->stereo_in; i++) {
933 s->ch[i].slow_level = wp_exp2(bytestream2_get_le16(&gb));
937 for (i = 0; i < (s->stereo_in + 1); i++) {
938 s->ch[i].bitrate_acc = bytestream2_get_le16(&gb) << 16;
942 for (i = 0; i < (s->stereo_in + 1); i++) {
943 s->ch[i].bitrate_delta =
944 wp_exp2((int16_t)bytestream2_get_le16(&gb));
947 for (i = 0; i < (s->stereo_in + 1); i++)
948 s->ch[i].bitrate_delta = 0;
952 case WP_ID_INT32INFO: {
955 av_log(avctx, AV_LOG_ERROR,
956 "Invalid INT32INFO, size = %i\n",
958 bytestream2_skip(&gb, ssize - 4);
961 bytestream2_get_buffer(&gb, val, 4);
963 s->extra_bits = val[0];
973 /* original WavPack decoder forces 32-bit lossy sound to be treated
974 * as 24-bit one in order to have proper clipping */
975 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
978 s->hybrid_maxclip >>= 8;
979 s->hybrid_minclip >>= 8;
983 case WP_ID_FLOATINFO:
985 av_log(avctx, AV_LOG_ERROR,
986 "Invalid FLOATINFO, size = %i\n", size);
987 bytestream2_skip(&gb, ssize);
990 s->float_flag = bytestream2_get_byte(&gb);
991 s->float_shift = bytestream2_get_byte(&gb);
992 s->float_max_exp = bytestream2_get_byte(&gb);
994 bytestream2_skip(&gb, 1);
997 s->sc.offset = bytestream2_tell(&gb);
998 s->sc.size = size * 8;
999 init_get_bits(&s->gb, gb.buffer, size * 8);
1000 s->data_size = size * 8;
1001 bytestream2_skip(&gb, size);
1004 case WP_ID_EXTRABITS:
1006 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1008 bytestream2_skip(&gb, size);
1011 s->extra_sc.offset = bytestream2_tell(&gb);
1012 s->extra_sc.size = size * 8;
1013 init_get_bits(&s->gb_extra_bits, gb.buffer, size * 8);
1014 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1015 bytestream2_skip(&gb, size);
1016 s->got_extra_bits = 1;
1018 case WP_ID_CHANINFO:
1020 av_log(avctx, AV_LOG_ERROR,
1021 "Insufficient channel information\n");
1022 return AVERROR_INVALIDDATA;
1024 chan = bytestream2_get_byte(&gb);
1027 chmask = bytestream2_get_byte(&gb);
1030 chmask = bytestream2_get_le16(&gb);
1033 chmask = bytestream2_get_le24(&gb);
1036 chmask = bytestream2_get_le32(&gb);
1039 bytestream2_skip(&gb, 1);
1040 chan |= (bytestream2_get_byte(&gb) & 0xF) << 8;
1041 chmask = bytestream2_get_le16(&gb);
1044 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1046 chan = avctx->channels;
1047 chmask = avctx->channel_layout;
1050 case WP_ID_SAMPLE_RATE:
1052 av_log(avctx, AV_LOG_ERROR, "Invalid custom sample rate.\n");
1053 return AVERROR_INVALIDDATA;
1055 sample_rate = bytestream2_get_le24(&gb);
1058 bytestream2_skip(&gb, size);
1060 if (id & WP_IDF_ODD)
1061 bytestream2_skip(&gb, 1);
1065 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1066 return AVERROR_INVALIDDATA;
1069 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1070 return AVERROR_INVALIDDATA;
1073 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1074 return AVERROR_INVALIDDATA;
1077 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1078 return AVERROR_INVALIDDATA;
1080 if (s->hybrid && !got_hybrid) {
1081 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1082 return AVERROR_INVALIDDATA;
1085 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1086 return AVERROR_INVALIDDATA;
1088 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) {
1089 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1090 return AVERROR_INVALIDDATA;
1092 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) {
1093 const int size = get_bits_left(&s->gb_extra_bits);
1094 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1095 if (size < wanted) {
1096 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1097 s->got_extra_bits = 0;
1101 if (!wc->ch_offset) {
1102 int sr = (s->frame_flags >> 23) & 0xf;
1105 av_log(avctx, AV_LOG_ERROR, "Custom sample rate missing.\n");
1106 return AVERROR_INVALIDDATA;
1108 avctx->sample_rate = sample_rate;
1110 avctx->sample_rate = wv_rates[sr];
1114 avctx->channels = chan;
1116 avctx->channel_layout = chmask;
1118 avctx->channels = s->stereo ? 2 : 1;
1119 avctx->channel_layout = s->stereo ? AV_CH_LAYOUT_STEREO :
1123 /* get output buffer */
1124 frame->nb_samples = s->samples + 1;
1125 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
1127 frame->nb_samples = s->samples;
1130 if (wc->ch_offset + s->stereo >= avctx->channels) {
1131 av_log(avctx, AV_LOG_WARNING, "Too many channels coded in a packet.\n");
1132 return (avctx->err_recognition & AV_EF_EXPLODE) ? AVERROR_INVALIDDATA : 0;
1135 samples_l = frame->extended_data[wc->ch_offset];
1137 samples_r = frame->extended_data[wc->ch_offset + 1];
1139 wc->ch_offset += 1 + s->stereo;
1142 ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt);
1146 ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt);
1151 memcpy(samples_r, samples_l, bpp * s->samples);
1157 static void wavpack_decode_flush(AVCodecContext *avctx)
1159 WavpackContext *s = avctx->priv_data;
1162 for (i = 0; i < s->fdec_num; i++)
1163 wv_reset_saved_context(s->fdec[i]);
1166 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1167 int *got_frame_ptr, AVPacket *avpkt)
1169 WavpackContext *s = avctx->priv_data;
1170 const uint8_t *buf = avpkt->data;
1171 int buf_size = avpkt->size;
1172 AVFrame *frame = data;
1173 int frame_size, ret, frame_flags;
1175 if (avpkt->size <= WV_HEADER_SIZE)
1176 return AVERROR_INVALIDDATA;
1181 /* determine number of samples */
1182 s->samples = AV_RL32(buf + 20);
1183 frame_flags = AV_RL32(buf + 24);
1184 if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1185 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1187 return AVERROR_INVALIDDATA;
1190 if (frame_flags & 0x80) {
1191 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1192 } else if ((frame_flags & 0x03) <= 1) {
1193 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
1195 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
1196 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1199 while (buf_size > 0) {
1200 if (buf_size <= WV_HEADER_SIZE)
1202 frame_size = AV_RL32(buf + 4) - 12;
1205 if (frame_size <= 0 || frame_size > buf_size) {
1206 av_log(avctx, AV_LOG_ERROR,
1207 "Block %d has invalid size (size %d vs. %d bytes left)\n",
1208 s->block, frame_size, buf_size);
1209 wavpack_decode_flush(avctx);
1210 return AVERROR_INVALIDDATA;
1212 if ((ret = wavpack_decode_block(avctx, s->block,
1213 frame, buf, frame_size)) < 0) {
1214 wavpack_decode_flush(avctx);
1219 buf_size -= frame_size;
1222 if (s->ch_offset != avctx->channels) {
1223 av_log(avctx, AV_LOG_ERROR, "Not enough channels coded in a packet.\n");
1224 return AVERROR_INVALIDDATA;
1232 AVCodec ff_wavpack_decoder = {
1234 .type = AVMEDIA_TYPE_AUDIO,
1235 .id = AV_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_DR1 | CODEC_CAP_FRAME_THREADS,
1242 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),