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"
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
57 #define WV_MAX_SAMPLES 131072
81 WP_ID_SAMPLE_RATE = 0x27,
84 typedef struct SavedContext {
93 typedef struct Decorr {
102 typedef struct WvChannel {
104 int slow_level, error_limit;
105 int bitrate_acc, bitrate_delta;
108 typedef struct WavpackFrameContext {
109 AVCodecContext *avctx;
111 int stereo, stereo_in;
116 uint32_t crc_extra_bits;
117 GetBitContext gb_extra_bits;
118 int data_size; // in bits
121 Decorr decorr[MAX_TERMS];
122 int zero, one, zeroes;
126 int hybrid, hybrid_bitrate;
127 int hybrid_maxclip, hybrid_minclip;
133 SavedContext sc, extra_sc;
134 } WavpackFrameContext;
136 #define WV_MAX_FRAME_DECODERS 14
138 typedef struct WavpackContext {
139 AVCodecContext *avctx;
141 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
149 static const int wv_rates[16] = {
150 6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000,
151 32000, 44100, 48000, 64000, 88200, 96000, 192000, 0
154 // exponent table copied from WavPack source
155 static const uint8_t wp_exp2_table[256] = {
156 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
157 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
158 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
159 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
160 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
161 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
162 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
163 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
164 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
165 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
166 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
167 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
168 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
169 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
170 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
171 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
174 static const uint8_t wp_log2_table [] = {
175 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
176 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
177 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
178 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
179 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
180 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
181 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
182 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
183 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
184 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
185 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
186 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
187 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
188 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
189 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
190 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
193 static av_always_inline int wp_exp2(int16_t val)
202 res = wp_exp2_table[val & 0xFF] | 0x100;
204 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
205 return neg ? -res : res;
208 static av_always_inline int wp_log2(int32_t val)
217 bits = av_log2(val) + 1;
219 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
221 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
224 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
226 // macros for manipulating median values
227 #define GET_MED(n) ((c->median[n] >> 4) + 1)
228 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
229 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
231 // macros for applying weight
232 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
233 if (samples && in) { \
234 if ((samples ^ in) < 0) { \
236 if (weight < -1024) \
245 static av_always_inline int get_tail(GetBitContext *gb, int k)
252 e = (1 << (p + 1)) - k - 1;
253 res = p ? get_bits(gb, p) : 0;
255 res = (res << 1) - e + get_bits1(gb);
259 static void update_error_limit(WavpackFrameContext *ctx)
263 for (i = 0; i <= ctx->stereo_in; i++) {
264 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
265 br[i] = ctx->ch[i].bitrate_acc >> 16;
266 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
268 if (ctx->stereo_in && ctx->hybrid_bitrate) {
269 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
270 if (balance > br[0]) {
273 } else if (-balance > br[0]) {
277 br[1] = br[0] + balance;
278 br[0] = br[0] - balance;
281 for (i = 0; i <= ctx->stereo_in; i++) {
282 if (ctx->hybrid_bitrate) {
283 if (sl[i] - br[i] > -0x100)
284 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
286 ctx->ch[i].error_limit = 0;
288 ctx->ch[i].error_limit = wp_exp2(br[i]);
293 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
294 int channel, int *last)
297 int sign, base, add, ret;
298 WvChannel *c = &ctx->ch[channel];
302 if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
303 !ctx->zero && !ctx->one) {
307 c->slow_level -= LEVEL_DECAY(c->slow_level);
311 t = get_unary_0_33(gb);
313 if (get_bits_left(gb) < t - 1)
315 t = get_bits(gb, t - 1) | (1 << (t - 1));
317 if (get_bits_left(gb) < 0)
322 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
323 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
324 c->slow_level -= LEVEL_DECAY(c->slow_level);
334 t = get_unary_0_33(gb);
335 if (get_bits_left(gb) < 0)
338 t2 = get_unary_0_33(gb);
340 if (get_bits_left(gb) < 0)
344 if (get_bits_left(gb) < t2 - 1)
346 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
357 ctx->zero = !ctx->one;
360 if (ctx->hybrid && !channel)
361 update_error_limit(ctx);
365 add = GET_MED(0) - 1;
369 add = GET_MED(1) - 1;
373 base = GET_MED(0) + GET_MED(1);
374 add = GET_MED(2) - 1;
379 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
380 add = GET_MED(2) - 1;
385 if (!c->error_limit) {
386 if (add >= 0x2000000U) {
387 av_log(ctx->avctx, AV_LOG_ERROR, "k %d is too large\n", add);
390 ret = base + get_tail(gb, add);
391 if (get_bits_left(gb) <= 0)
394 int mid = (base * 2 + add + 1) >> 1;
395 while (add > c->error_limit) {
396 if (get_bits_left(gb) <= 0)
402 add = mid - base - 1;
403 mid = (base * 2 + add + 1) >> 1;
407 sign = get_bits1(gb);
408 if (ctx->hybrid_bitrate)
409 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
410 return sign ? ~ret : ret;
417 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
425 if (s->got_extra_bits &&
426 get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
427 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
428 *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
432 bit = (S & s->and) | s->or;
433 bit = ((S + bit) << s->shift) - bit;
436 bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
438 return bit << s->post_shift;
441 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
449 int exp = s->float_max_exp;
451 if (s->got_extra_bits) {
452 const int max_bits = 1 + 23 + 8 + 1;
453 const int left_bits = get_bits_left(&s->gb_extra_bits);
455 if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
460 S <<= s->float_shift;
464 if (S >= 0x1000000) {
465 if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
466 S = get_bits(&s->gb_extra_bits, 23);
471 int shift = 23 - av_log2(S);
472 exp = s->float_max_exp;
479 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
480 (s->got_extra_bits &&
481 (s->float_flag & WV_FLT_SHIFT_SAME) &&
482 get_bits1(&s->gb_extra_bits))) {
483 S |= (1 << shift) - 1;
484 } else if (s->got_extra_bits &&
485 (s->float_flag & WV_FLT_SHIFT_SENT)) {
486 S |= get_bits(&s->gb_extra_bits, shift);
490 exp = s->float_max_exp;
496 if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
497 if (get_bits1(&s->gb_extra_bits)) {
498 S = get_bits(&s->gb_extra_bits, 23);
499 if (s->float_max_exp >= 25)
500 exp = get_bits(&s->gb_extra_bits, 8);
501 sign = get_bits1(&s->gb_extra_bits);
503 if (s->float_flag & WV_FLT_ZERO_SIGN)
504 sign = get_bits1(&s->gb_extra_bits);
509 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
511 value.u = (sign << 31) | (exp << 23) | S;
515 static void wv_reset_saved_context(WavpackFrameContext *s)
518 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
521 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
522 uint32_t crc_extra_bits)
525 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
526 return AVERROR_INVALIDDATA;
528 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
529 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
530 return AVERROR_INVALIDDATA;
536 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
537 void *dst_l, void *dst_r, const int type)
541 int A, B, L, L2, R, R2;
543 uint32_t crc = s->sc.crc;
544 uint32_t crc_extra_bits = s->extra_sc.crc;
545 int16_t *dst16_l = dst_l;
546 int16_t *dst16_r = dst_r;
547 int32_t *dst32_l = dst_l;
548 int32_t *dst32_r = dst_r;
549 float *dstfl_l = dst_l;
550 float *dstfl_r = dst_r;
552 s->one = s->zero = s->zeroes = 0;
554 L = wv_get_value(s, gb, 0, &last);
557 R = wv_get_value(s, gb, 1, &last);
560 for (i = 0; i < s->terms; i++) {
561 t = s->decorr[i].value;
565 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
566 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
568 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
569 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
571 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
572 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
575 A = s->decorr[i].samplesA[pos];
576 B = s->decorr[i].samplesB[pos];
579 if (type != AV_SAMPLE_FMT_S16P) {
580 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
581 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
583 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
584 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
587 s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
589 s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
590 s->decorr[i].samplesA[j] = L = L2;
591 s->decorr[i].samplesB[j] = R = R2;
592 } else if (t == -1) {
593 if (type != AV_SAMPLE_FMT_S16P)
594 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
596 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
597 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
599 if (type != AV_SAMPLE_FMT_S16P)
600 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
602 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
603 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
605 s->decorr[i].samplesA[0] = R;
607 if (type != AV_SAMPLE_FMT_S16P)
608 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
610 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
611 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
615 R2 = s->decorr[i].samplesA[0];
616 s->decorr[i].samplesA[0] = R;
619 if (type != AV_SAMPLE_FMT_S16P)
620 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
622 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
623 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
625 s->decorr[i].samplesB[0] = L;
630 L += (R -= (L >> 1));
631 crc = (crc * 3 + L) * 3 + R;
633 if (type == AV_SAMPLE_FMT_FLTP) {
634 *dstfl_l++ = wv_get_value_float(s, &crc_extra_bits, L);
635 *dstfl_r++ = wv_get_value_float(s, &crc_extra_bits, R);
636 } else if (type == AV_SAMPLE_FMT_S32P) {
637 *dst32_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
638 *dst32_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
640 *dst16_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
641 *dst16_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
644 } while (!last && count < s->samples);
646 wv_reset_saved_context(s);
647 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
648 wv_check_crc(s, crc, crc_extra_bits))
649 return AVERROR_INVALIDDATA;
654 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
655 void *dst, const int type)
661 uint32_t crc = s->sc.crc;
662 uint32_t crc_extra_bits = s->extra_sc.crc;
663 int16_t *dst16 = dst;
664 int32_t *dst32 = dst;
667 s->one = s->zero = s->zeroes = 0;
669 T = wv_get_value(s, gb, 0, &last);
673 for (i = 0; i < s->terms; i++) {
674 t = s->decorr[i].value;
677 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
679 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
680 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
683 A = s->decorr[i].samplesA[pos];
686 if (type != AV_SAMPLE_FMT_S16P)
687 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
689 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
691 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
692 s->decorr[i].samplesA[j] = T = S;
697 if (type == AV_SAMPLE_FMT_FLTP) {
698 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
699 } else if (type == AV_SAMPLE_FMT_S32P) {
700 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
702 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
705 } while (!last && count < s->samples);
707 wv_reset_saved_context(s);
708 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
709 wv_check_crc(s, crc, crc_extra_bits))
710 return AVERROR_INVALIDDATA;
715 static av_cold int wv_alloc_frame_context(WavpackContext *c)
717 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
720 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
721 if (!c->fdec[c->fdec_num])
724 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
725 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
730 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
732 WavpackContext *s = avctx->priv_data;
741 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
743 WavpackContext *s = avctx->priv_data;
746 for (i = 0; i < s->fdec_num; i++)
747 av_freep(&s->fdec[i]);
753 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
754 AVFrame *frame, const uint8_t *buf, int buf_size)
756 WavpackContext *wc = avctx->priv_data;
757 WavpackFrameContext *s;
759 void *samples_l, *samples_r;
761 int got_terms = 0, got_weights = 0, got_samples = 0,
762 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
763 int i, j, id, size, ssize, weights, t;
764 int bpp, chan = 0, chmask = 0, orig_bpp, sample_rate = 0;
767 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
768 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
769 return AVERROR_INVALIDDATA;
772 s = wc->fdec[block_no];
774 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n",
776 return AVERROR_INVALIDDATA;
779 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
780 memset(s->ch, 0, sizeof(s->ch));
782 s->and = s->or = s->shift = 0;
783 s->got_extra_bits = 0;
785 bytestream2_init(&gb, buf, buf_size);
787 s->samples = bytestream2_get_le32(&gb);
788 if (s->samples != wc->samples) {
789 av_log(avctx, AV_LOG_ERROR, "Mismatching number of samples in "
790 "a sequence: %d and %d\n", wc->samples, s->samples);
791 return AVERROR_INVALIDDATA;
793 s->frame_flags = bytestream2_get_le32(&gb);
794 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
795 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
796 multiblock = (s->frame_flags & WV_SINGLE_BLOCK) != WV_SINGLE_BLOCK;
798 s->stereo = !(s->frame_flags & WV_MONO);
799 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
800 s->joint = s->frame_flags & WV_JOINT_STEREO;
801 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
802 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
803 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
804 s->hybrid_maxclip = ((1LL << (orig_bpp - 1)) - 1);
805 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
806 s->CRC = bytestream2_get_le32(&gb);
808 // parse metadata blocks
809 while (bytestream2_get_bytes_left(&gb)) {
810 id = bytestream2_get_byte(&gb);
811 size = bytestream2_get_byte(&gb);
812 if (id & WP_IDF_LONG) {
813 size |= (bytestream2_get_byte(&gb)) << 8;
814 size |= (bytestream2_get_byte(&gb)) << 16;
816 size <<= 1; // size is specified in words
821 av_log(avctx, AV_LOG_ERROR,
822 "Got incorrect block %02X with size %i\n", id, size);
825 if (bytestream2_get_bytes_left(&gb) < ssize) {
826 av_log(avctx, AV_LOG_ERROR,
827 "Block size %i is out of bounds\n", size);
830 switch (id & WP_IDF_MASK) {
832 if (size > MAX_TERMS) {
833 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
835 bytestream2_skip(&gb, ssize);
839 for (i = 0; i < s->terms; i++) {
840 uint8_t val = bytestream2_get_byte(&gb);
841 s->decorr[s->terms - i - 1].value = (val & 0x1F) - 5;
842 s->decorr[s->terms - i - 1].delta = val >> 5;
846 case WP_ID_DECWEIGHTS:
848 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
851 weights = size >> s->stereo_in;
852 if (weights > MAX_TERMS || weights > s->terms) {
853 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
854 bytestream2_skip(&gb, ssize);
857 for (i = 0; i < weights; i++) {
858 t = (int8_t)bytestream2_get_byte(&gb);
859 s->decorr[s->terms - i - 1].weightA = t << 3;
860 if (s->decorr[s->terms - i - 1].weightA > 0)
861 s->decorr[s->terms - i - 1].weightA +=
862 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
864 t = (int8_t)bytestream2_get_byte(&gb);
865 s->decorr[s->terms - i - 1].weightB = t << 3;
866 if (s->decorr[s->terms - i - 1].weightB > 0)
867 s->decorr[s->terms - i - 1].weightB +=
868 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
873 case WP_ID_DECSAMPLES:
875 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
879 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
880 if (s->decorr[i].value > 8) {
881 s->decorr[i].samplesA[0] =
882 wp_exp2(bytestream2_get_le16(&gb));
883 s->decorr[i].samplesA[1] =
884 wp_exp2(bytestream2_get_le16(&gb));
887 s->decorr[i].samplesB[0] =
888 wp_exp2(bytestream2_get_le16(&gb));
889 s->decorr[i].samplesB[1] =
890 wp_exp2(bytestream2_get_le16(&gb));
894 } else if (s->decorr[i].value < 0) {
895 s->decorr[i].samplesA[0] =
896 wp_exp2(bytestream2_get_le16(&gb));
897 s->decorr[i].samplesB[0] =
898 wp_exp2(bytestream2_get_le16(&gb));
901 for (j = 0; j < s->decorr[i].value; j++) {
902 s->decorr[i].samplesA[j] =
903 wp_exp2(bytestream2_get_le16(&gb));
905 s->decorr[i].samplesB[j] =
906 wp_exp2(bytestream2_get_le16(&gb));
909 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
915 if (size != 6 * (s->stereo_in + 1)) {
916 av_log(avctx, AV_LOG_ERROR,
917 "Entropy vars size should be %i, got %i",
918 6 * (s->stereo_in + 1), size);
919 bytestream2_skip(&gb, ssize);
922 for (j = 0; j <= s->stereo_in; j++)
923 for (i = 0; i < 3; i++) {
924 s->ch[j].median[i] = wp_exp2(bytestream2_get_le16(&gb));
929 if (s->hybrid_bitrate) {
930 for (i = 0; i <= s->stereo_in; i++) {
931 s->ch[i].slow_level = wp_exp2(bytestream2_get_le16(&gb));
935 for (i = 0; i < (s->stereo_in + 1); i++) {
936 s->ch[i].bitrate_acc = bytestream2_get_le16(&gb) << 16;
940 for (i = 0; i < (s->stereo_in + 1); i++) {
941 s->ch[i].bitrate_delta =
942 wp_exp2((int16_t)bytestream2_get_le16(&gb));
945 for (i = 0; i < (s->stereo_in + 1); i++)
946 s->ch[i].bitrate_delta = 0;
950 case WP_ID_INT32INFO: {
953 av_log(avctx, AV_LOG_ERROR,
954 "Invalid INT32INFO, size = %i\n",
956 bytestream2_skip(&gb, ssize - 4);
959 bytestream2_get_buffer(&gb, val, 4);
961 s->extra_bits = val[0];
971 /* original WavPack decoder forces 32-bit lossy sound to be treated
972 * as 24-bit one in order to have proper clipping */
973 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
976 s->hybrid_maxclip >>= 8;
977 s->hybrid_minclip >>= 8;
981 case WP_ID_FLOATINFO:
983 av_log(avctx, AV_LOG_ERROR,
984 "Invalid FLOATINFO, size = %i\n", size);
985 bytestream2_skip(&gb, ssize);
988 s->float_flag = bytestream2_get_byte(&gb);
989 s->float_shift = bytestream2_get_byte(&gb);
990 s->float_max_exp = bytestream2_get_byte(&gb);
992 bytestream2_skip(&gb, 1);
995 s->sc.offset = bytestream2_tell(&gb);
996 s->sc.size = size * 8;
997 init_get_bits(&s->gb, gb.buffer, size * 8);
998 s->data_size = size * 8;
999 bytestream2_skip(&gb, size);
1002 case WP_ID_EXTRABITS:
1004 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1006 bytestream2_skip(&gb, size);
1009 s->extra_sc.offset = bytestream2_tell(&gb);
1010 s->extra_sc.size = size * 8;
1011 init_get_bits(&s->gb_extra_bits, gb.buffer, size * 8);
1012 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1013 bytestream2_skip(&gb, size);
1014 s->got_extra_bits = 1;
1016 case WP_ID_CHANINFO:
1018 av_log(avctx, AV_LOG_ERROR,
1019 "Insufficient channel information\n");
1020 return AVERROR_INVALIDDATA;
1022 chan = bytestream2_get_byte(&gb);
1025 chmask = bytestream2_get_byte(&gb);
1028 chmask = bytestream2_get_le16(&gb);
1031 chmask = bytestream2_get_le24(&gb);
1034 chmask = bytestream2_get_le32(&gb);
1037 bytestream2_skip(&gb, 1);
1038 chan |= (bytestream2_get_byte(&gb) & 0xF) << 8;
1039 chmask = bytestream2_get_le16(&gb);
1042 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1044 chan = avctx->channels;
1045 chmask = avctx->channel_layout;
1048 case WP_ID_SAMPLE_RATE:
1050 av_log(avctx, AV_LOG_ERROR, "Invalid custom sample rate.\n");
1051 return AVERROR_INVALIDDATA;
1053 sample_rate = bytestream2_get_le24(&gb);
1056 bytestream2_skip(&gb, size);
1058 if (id & WP_IDF_ODD)
1059 bytestream2_skip(&gb, 1);
1063 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1064 return AVERROR_INVALIDDATA;
1067 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1068 return AVERROR_INVALIDDATA;
1071 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1072 return AVERROR_INVALIDDATA;
1075 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1076 return AVERROR_INVALIDDATA;
1078 if (s->hybrid && !got_hybrid) {
1079 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1080 return AVERROR_INVALIDDATA;
1083 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1084 return AVERROR_INVALIDDATA;
1086 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) {
1087 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1088 return AVERROR_INVALIDDATA;
1090 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) {
1091 const int size = get_bits_left(&s->gb_extra_bits);
1092 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1093 if (size < wanted) {
1094 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1095 s->got_extra_bits = 0;
1099 if (!wc->ch_offset) {
1100 int sr = (s->frame_flags >> 23) & 0xf;
1103 av_log(avctx, AV_LOG_ERROR, "Custom sample rate missing.\n");
1104 return AVERROR_INVALIDDATA;
1106 avctx->sample_rate = sample_rate;
1108 avctx->sample_rate = wv_rates[sr];
1112 avctx->channels = chan;
1114 avctx->channel_layout = chmask;
1116 avctx->channels = s->stereo ? 2 : 1;
1117 avctx->channel_layout = s->stereo ? AV_CH_LAYOUT_STEREO :
1121 /* get output buffer */
1122 frame->nb_samples = s->samples + 1;
1123 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1125 frame->nb_samples = s->samples;
1128 if (wc->ch_offset + s->stereo >= avctx->channels) {
1129 av_log(avctx, AV_LOG_WARNING, "Too many channels coded in a packet.\n");
1130 return (avctx->err_recognition & AV_EF_EXPLODE) ? AVERROR_INVALIDDATA : 0;
1133 samples_l = frame->extended_data[wc->ch_offset];
1135 samples_r = frame->extended_data[wc->ch_offset + 1];
1137 wc->ch_offset += 1 + s->stereo;
1140 ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt);
1144 ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt);
1149 memcpy(samples_r, samples_l, bpp * s->samples);
1155 static void wavpack_decode_flush(AVCodecContext *avctx)
1157 WavpackContext *s = avctx->priv_data;
1160 for (i = 0; i < s->fdec_num; i++)
1161 wv_reset_saved_context(s->fdec[i]);
1164 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1165 int *got_frame_ptr, AVPacket *avpkt)
1167 WavpackContext *s = avctx->priv_data;
1168 const uint8_t *buf = avpkt->data;
1169 int buf_size = avpkt->size;
1170 AVFrame *frame = data;
1171 int frame_size, ret, frame_flags;
1173 if (avpkt->size <= WV_HEADER_SIZE)
1174 return AVERROR_INVALIDDATA;
1179 /* determine number of samples */
1180 s->samples = AV_RL32(buf + 20);
1181 frame_flags = AV_RL32(buf + 24);
1182 if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1183 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1185 return AVERROR_INVALIDDATA;
1188 if (frame_flags & 0x80) {
1189 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1190 } else if ((frame_flags & 0x03) <= 1) {
1191 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
1193 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
1194 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1197 while (buf_size > 0) {
1198 if (buf_size <= WV_HEADER_SIZE)
1200 frame_size = AV_RL32(buf + 4) - 12;
1203 if (frame_size <= 0 || frame_size > buf_size) {
1204 av_log(avctx, AV_LOG_ERROR,
1205 "Block %d has invalid size (size %d vs. %d bytes left)\n",
1206 s->block, frame_size, buf_size);
1207 wavpack_decode_flush(avctx);
1208 return AVERROR_INVALIDDATA;
1210 if ((ret = wavpack_decode_block(avctx, s->block,
1211 frame, buf, frame_size)) < 0) {
1212 wavpack_decode_flush(avctx);
1217 buf_size -= frame_size;
1220 if (s->ch_offset != avctx->channels) {
1221 av_log(avctx, AV_LOG_ERROR, "Not enough channels coded in a packet.\n");
1222 return AVERROR_INVALIDDATA;
1230 AVCodec ff_wavpack_decoder = {
1232 .type = AVMEDIA_TYPE_AUDIO,
1233 .id = AV_CODEC_ID_WAVPACK,
1234 .priv_data_size = sizeof(WavpackContext),
1235 .init = wavpack_decode_init,
1236 .close = wavpack_decode_end,
1237 .decode = wavpack_decode_frame,
1238 .flush = wavpack_decode_flush,
1239 .capabilities = CODEC_CAP_DR1,
1240 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),