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"
32 * WavPack lossless audio decoder
35 #define WV_MONO 0x00000004
36 #define WV_JOINT_STEREO 0x00000010
37 #define WV_FALSE_STEREO 0x40000000
39 #define WV_HYBRID_MODE 0x00000008
40 #define WV_HYBRID_SHAPE 0x00000008
41 #define WV_HYBRID_BITRATE 0x00000200
42 #define WV_HYBRID_BALANCE 0x00000400
44 #define WV_FLT_SHIFT_ONES 0x01
45 #define WV_FLT_SHIFT_SAME 0x02
46 #define WV_FLT_SHIFT_SENT 0x04
47 #define WV_FLT_ZERO_SENT 0x08
48 #define WV_FLT_ZERO_SIGN 0x10
50 #define WV_MAX_SAMPLES 131072
76 typedef struct SavedContext {
85 typedef struct Decorr {
94 typedef struct WvChannel {
96 int slow_level, error_limit;
97 int bitrate_acc, bitrate_delta;
100 typedef struct WavpackFrameContext {
101 AVCodecContext *avctx;
103 int stereo, stereo_in;
108 uint32_t crc_extra_bits;
109 GetBitContext gb_extra_bits;
110 int data_size; // in bits
113 Decorr decorr[MAX_TERMS];
114 int zero, one, zeroes;
118 int hybrid, hybrid_bitrate;
119 int hybrid_maxclip, hybrid_minclip;
125 SavedContext sc, extra_sc;
126 } WavpackFrameContext;
128 #define WV_MAX_FRAME_DECODERS 14
130 typedef struct WavpackContext {
131 AVCodecContext *avctx;
134 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
144 // exponent table copied from WavPack source
145 static const uint8_t wp_exp2_table [256] = {
146 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
147 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
148 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
149 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
150 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
151 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
152 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
153 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
154 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
155 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
156 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
157 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
158 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
159 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
160 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
161 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
164 static const uint8_t wp_log2_table [] = {
165 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
166 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
167 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
168 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
169 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
170 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
171 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
172 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
173 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
174 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
175 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
176 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
177 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
178 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
179 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
180 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
183 static av_always_inline int wp_exp2(int16_t val)
192 res = wp_exp2_table[val & 0xFF] | 0x100;
194 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
195 return neg ? -res : res;
198 static av_always_inline int wp_log2(int32_t val)
207 bits = av_log2(val) + 1;
209 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
211 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
214 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
216 // macros for manipulating median values
217 #define GET_MED(n) ((c->median[n] >> 4) + 1)
218 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
219 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
221 // macros for applying weight
222 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
223 if (samples && in) { \
224 if ((samples ^ in) < 0) { \
226 if (weight < -1024) \
236 static av_always_inline int get_tail(GetBitContext *gb, int k)
243 e = (1 << (p + 1)) - k - 1;
244 res = p ? get_bits(gb, p) : 0;
246 res = (res << 1) - e + get_bits1(gb);
250 static void update_error_limit(WavpackFrameContext *ctx)
254 for (i = 0; i <= ctx->stereo_in; i++) {
255 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
256 br[i] = ctx->ch[i].bitrate_acc >> 16;
257 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
259 if (ctx->stereo_in && ctx->hybrid_bitrate) {
260 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
261 if (balance > br[0]) {
264 } else if (-balance > br[0]) {
268 br[1] = br[0] + balance;
269 br[0] = br[0] - balance;
272 for (i = 0; i <= ctx->stereo_in; i++) {
273 if (ctx->hybrid_bitrate) {
274 if (sl[i] - br[i] > -0x100)
275 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
277 ctx->ch[i].error_limit = 0;
279 ctx->ch[i].error_limit = wp_exp2(br[i]);
284 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
285 int channel, int *last)
288 int sign, base, add, ret;
289 WvChannel *c = &ctx->ch[channel];
293 if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
294 !ctx->zero && !ctx->one) {
298 c->slow_level -= LEVEL_DECAY(c->slow_level);
302 t = get_unary_0_33(gb);
304 if (get_bits_left(gb) < t - 1)
306 t = get_bits(gb, t - 1) | (1 << (t-1));
308 if (get_bits_left(gb) < 0)
313 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
314 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
315 c->slow_level -= LEVEL_DECAY(c->slow_level);
325 t = get_unary_0_33(gb);
326 if (get_bits_left(gb) < 0)
329 t2 = get_unary_0_33(gb);
331 if (get_bits_left(gb) < 0)
335 if (get_bits_left(gb) < t2 - 1)
337 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
348 ctx->zero = !ctx->one;
351 if (ctx->hybrid && !channel)
352 update_error_limit(ctx);
356 add = GET_MED(0) - 1;
360 add = GET_MED(1) - 1;
364 base = GET_MED(0) + GET_MED(1);
365 add = GET_MED(2) - 1;
370 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
371 add = GET_MED(2) - 1;
376 if (!c->error_limit) {
377 ret = base + get_tail(gb, add);
378 if (get_bits_left(gb) <= 0)
381 int mid = (base * 2 + add + 1) >> 1;
382 while (add > c->error_limit) {
383 if (get_bits_left(gb) <= 0)
389 add = mid - base - 1;
390 mid = (base * 2 + add + 1) >> 1;
394 sign = get_bits1(gb);
395 if (ctx->hybrid_bitrate)
396 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
397 return sign ? ~ret : ret;
404 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
412 if (s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
413 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
414 *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
418 bit = (S & s->and) | s->or;
419 bit = ((S + bit) << s->shift) - bit;
422 bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
424 return bit << s->post_shift;
427 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
435 int exp = s->float_max_exp;
437 if (s->got_extra_bits) {
438 const int max_bits = 1 + 23 + 8 + 1;
439 const int left_bits = get_bits_left(&s->gb_extra_bits);
441 if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
446 S <<= s->float_shift;
450 if (S >= 0x1000000) {
451 if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
452 S = get_bits(&s->gb_extra_bits, 23);
457 int shift = 23 - av_log2(S);
458 exp = s->float_max_exp;
465 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
466 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) &&
467 get_bits1(&s->gb_extra_bits))) {
468 S |= (1 << shift) - 1;
469 } else if (s->got_extra_bits &&
470 (s->float_flag & WV_FLT_SHIFT_SENT)) {
471 S |= get_bits(&s->gb_extra_bits, shift);
475 exp = s->float_max_exp;
481 if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
482 if (get_bits1(&s->gb_extra_bits)) {
483 S = get_bits(&s->gb_extra_bits, 23);
484 if (s->float_max_exp >= 25)
485 exp = get_bits(&s->gb_extra_bits, 8);
486 sign = get_bits1(&s->gb_extra_bits);
488 if (s->float_flag & WV_FLT_ZERO_SIGN)
489 sign = get_bits1(&s->gb_extra_bits);
494 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
496 value.u = (sign << 31) | (exp << 23) | S;
500 static void wv_reset_saved_context(WavpackFrameContext *s)
503 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
506 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
507 uint32_t crc_extra_bits)
510 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
511 return AVERROR_INVALIDDATA;
513 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
514 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
515 return AVERROR_INVALIDDATA;
521 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
522 void *dst, const int type)
526 int A, B, L, L2, R, R2;
528 uint32_t crc = s->sc.crc;
529 uint32_t crc_extra_bits = s->extra_sc.crc;
530 int16_t *dst16 = dst;
531 int32_t *dst32 = dst;
533 const int channel_pad = s->avctx->channels - 2;
535 s->one = s->zero = s->zeroes = 0;
537 L = wv_get_value(s, gb, 0, &last);
540 R = wv_get_value(s, gb, 1, &last);
543 for (i = 0; i < s->terms; i++) {
544 t = s->decorr[i].value;
548 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
549 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
551 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
552 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
554 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
555 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
558 A = s->decorr[i].samplesA[pos];
559 B = s->decorr[i].samplesB[pos];
562 if (type != AV_SAMPLE_FMT_S16) {
563 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
564 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
566 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
567 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
569 if (A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
570 if (B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
571 s->decorr[i].samplesA[j] = L = L2;
572 s->decorr[i].samplesB[j] = R = R2;
573 } else if (t == -1) {
574 if (type != AV_SAMPLE_FMT_S16)
575 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
577 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
578 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
580 if (type != AV_SAMPLE_FMT_S16)
581 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
583 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
584 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
586 s->decorr[i].samplesA[0] = R;
588 if (type != AV_SAMPLE_FMT_S16)
589 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
591 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
592 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
596 R2 = s->decorr[i].samplesA[0];
597 s->decorr[i].samplesA[0] = R;
600 if (type != AV_SAMPLE_FMT_S16)
601 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
603 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
604 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
606 s->decorr[i].samplesB[0] = L;
611 L += (R -= (L >> 1));
612 crc = (crc * 3 + L) * 3 + R;
614 if (type == AV_SAMPLE_FMT_FLT) {
615 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
616 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
617 dstfl += channel_pad;
618 } else if (type == AV_SAMPLE_FMT_S32) {
619 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
620 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
621 dst32 += channel_pad;
623 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
624 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
625 dst16 += channel_pad;
628 } while (!last && count < s->samples);
630 wv_reset_saved_context(s);
631 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
632 wv_check_crc(s, crc, crc_extra_bits))
633 return AVERROR_INVALIDDATA;
638 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
639 void *dst, const int type)
645 uint32_t crc = s->sc.crc;
646 uint32_t crc_extra_bits = s->extra_sc.crc;
647 int16_t *dst16 = dst;
648 int32_t *dst32 = dst;
650 const int channel_stride = s->avctx->channels;
652 s->one = s->zero = s->zeroes = 0;
654 T = wv_get_value(s, gb, 0, &last);
658 for (i = 0; i < s->terms; i++) {
659 t = s->decorr[i].value;
662 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
664 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
665 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
668 A = s->decorr[i].samplesA[pos];
671 if (type != AV_SAMPLE_FMT_S16)
672 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
674 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
676 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
677 s->decorr[i].samplesA[j] = T = S;
682 if (type == AV_SAMPLE_FMT_FLT) {
683 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
684 dstfl += channel_stride;
685 } else if (type == AV_SAMPLE_FMT_S32) {
686 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
687 dst32 += channel_stride;
689 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
690 dst16 += channel_stride;
693 } while (!last && count < s->samples);
695 wv_reset_saved_context(s);
696 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
697 wv_check_crc(s, crc, crc_extra_bits))
698 return AVERROR_INVALIDDATA;
703 static av_cold int wv_alloc_frame_context(WavpackContext *c)
706 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
709 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
710 if (!c->fdec[c->fdec_num])
713 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
714 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
719 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
721 WavpackContext *s = avctx->priv_data;
724 if (avctx->bits_per_coded_sample <= 16)
725 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
727 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
728 if (avctx->channels <= 2 && !avctx->channel_layout)
729 avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO :
732 s->multichannel = avctx->channels > 2;
733 /* lavf demuxer does not provide extradata, Matroska stores 0x403
734 there, use this to detect decoding mode for multichannel */
736 if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
737 int ver = AV_RL16(avctx->extradata);
738 if (ver >= 0x402 && ver <= 0x410)
744 avcodec_get_frame_defaults(&s->frame);
745 avctx->coded_frame = &s->frame;
750 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
752 WavpackContext *s = avctx->priv_data;
755 for (i = 0; i < s->fdec_num; i++)
756 av_freep(&s->fdec[i]);
762 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
763 void *data, int *got_frame_ptr,
764 const uint8_t *buf, int buf_size)
766 WavpackContext *wc = avctx->priv_data;
767 WavpackFrameContext *s;
768 void *samples = data;
770 int got_terms = 0, got_weights = 0, got_samples = 0,
771 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
772 const uint8_t *orig_buf = buf;
773 const uint8_t *buf_end = buf + buf_size;
774 int i, j, id, size, ssize, weights, t;
775 int bpp, chan, chmask, orig_bpp;
782 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
783 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
787 s = wc->fdec[block_no];
789 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
793 if (wc->ch_offset >= avctx->channels) {
794 av_log(avctx, AV_LOG_ERROR, "too many channels\n");
798 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
799 memset(s->ch, 0, sizeof(s->ch));
801 s->and = s->or = s->shift = 0;
802 s->got_extra_bits = 0;
805 s->samples = AV_RL32(buf); buf += 4;
810 if (s->samples > wc->samples) {
811 av_log(avctx, AV_LOG_ERROR, "too many samples in block");
815 s->samples = wc->samples;
817 s->frame_flags = AV_RL32(buf); buf += 4;
818 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
819 samples = (uint8_t*)samples + bpp * wc->ch_offset;
820 orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
822 s->stereo = !(s->frame_flags & WV_MONO);
823 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
824 s->joint = s->frame_flags & WV_JOINT_STEREO;
825 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
826 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
827 s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
828 s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1);
829 s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
830 s->CRC = AV_RL32(buf); buf += 4;
832 buf += 4; //skip block size;
834 wc->ch_offset += 1 + s->stereo;
836 // parse metadata blocks
837 while (buf < buf_end) {
840 if (id & WP_IDF_LONG) {
841 size |= (*buf++) << 8;
842 size |= (*buf++) << 16;
844 size <<= 1; // size is specified in words
849 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
852 if (buf + ssize > buf_end) {
853 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
856 if (id & WP_IDF_IGNORE) {
860 switch (id & WP_IDF_MASK) {
862 if (size > MAX_TERMS) {
863 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
869 for (i = 0; i < s->terms; i++) {
870 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
871 s->decorr[s->terms - i - 1].delta = *buf >> 5;
876 case WP_ID_DECWEIGHTS:
878 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
881 weights = size >> s->stereo_in;
882 if (weights > MAX_TERMS || weights > s->terms) {
883 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
887 for (i = 0; i < weights; i++) {
888 t = (int8_t)(*buf++);
889 s->decorr[s->terms - i - 1].weightA = t << 3;
890 if (s->decorr[s->terms - i - 1].weightA > 0)
891 s->decorr[s->terms - i - 1].weightA +=
892 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
894 t = (int8_t)(*buf++);
895 s->decorr[s->terms - i - 1].weightB = t << 3;
896 if (s->decorr[s->terms - i - 1].weightB > 0)
897 s->decorr[s->terms - i - 1].weightB +=
898 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
903 case WP_ID_DECSAMPLES:
905 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
909 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
910 if (s->decorr[i].value > 8) {
911 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
912 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
914 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
915 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
919 } else if (s->decorr[i].value < 0) {
920 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
921 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
924 for (j = 0; j < s->decorr[i].value; j++) {
925 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
927 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
930 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
936 if (size != 6 * (s->stereo_in + 1)) {
937 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
938 "got %i", 6 * (s->stereo_in + 1), size);
942 for (j = 0; j <= s->stereo_in; j++) {
943 for (i = 0; i < 3; i++) {
944 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
951 if (s->hybrid_bitrate) {
952 for (i = 0; i <= s->stereo_in; i++) {
953 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
958 for (i = 0; i < (s->stereo_in + 1); i++) {
959 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
964 for (i = 0; i < (s->stereo_in + 1); i++) {
965 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
969 for (i = 0; i < (s->stereo_in + 1); i++)
970 s->ch[i].bitrate_delta = 0;
974 case WP_ID_INT32INFO:
976 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
981 s->extra_bits = buf[0];
991 /* original WavPack decoder forces 32-bit lossy sound to be treated
992 * as 24-bit one in order to have proper clipping
994 if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
997 s->hybrid_maxclip >>= 8;
998 s->hybrid_minclip >>= 8;
1002 case WP_ID_FLOATINFO:
1004 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
1008 s->float_flag = buf[0];
1009 s->float_shift = buf[1];
1010 s->float_max_exp = buf[2];
1015 s->sc.offset = buf - orig_buf;
1016 s->sc.size = size * 8;
1017 init_get_bits(&s->gb, buf, size * 8);
1018 s->data_size = size * 8;
1022 case WP_ID_EXTRABITS:
1024 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1029 s->extra_sc.offset = buf - orig_buf;
1030 s->extra_sc.size = size * 8;
1031 init_get_bits(&s->gb_extra_bits, buf, size * 8);
1032 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1034 s->got_extra_bits = 1;
1036 case WP_ID_CHANINFO:
1038 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1043 case 0: chmask = *buf; break;
1044 case 1: chmask = AV_RL16(buf); break;
1045 case 2: chmask = AV_RL24(buf); break;
1046 case 3: chmask = AV_RL32(buf); break;
1048 chan |= (buf[1] & 0xF) << 8;
1049 chmask = AV_RL24(buf + 2);
1052 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1054 chan = avctx->channels;
1055 chmask = avctx->channel_layout;
1057 if (chan != avctx->channels) {
1058 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1059 "decoder believes it's %d channels\n", chan,
1063 if (!avctx->channel_layout)
1064 avctx->channel_layout = chmask;
1070 if (id & WP_IDF_ODD)
1075 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1079 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1083 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1087 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1090 if (s->hybrid && !got_hybrid) {
1091 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1095 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1098 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1099 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1102 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1103 const int size = get_bits_left(&s->gb_extra_bits);
1104 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1105 if (size < wanted) {
1106 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1107 s->got_extra_bits = 0;
1112 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1113 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1114 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1115 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1117 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1119 if (samplecount < 0)
1124 const int channel_stride = avctx->channels;
1126 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1127 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1128 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1129 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1131 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1133 if (samplecount < 0)
1136 if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1137 int16_t *dst = (int16_t*)samples + 1;
1138 int16_t *src = (int16_t*)samples;
1139 int cnt = samplecount;
1142 src += channel_stride;
1143 dst += channel_stride;
1145 } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1146 int32_t *dst = (int32_t*)samples + 1;
1147 int32_t *src = (int32_t*)samples;
1148 int cnt = samplecount;
1151 src += channel_stride;
1152 dst += channel_stride;
1154 } else if (s->stereo) {
1155 float *dst = (float*)samples + 1;
1156 float *src = (float*)samples;
1157 int cnt = samplecount;
1160 src += channel_stride;
1161 dst += channel_stride;
1168 return samplecount * bpp;
1171 static void wavpack_decode_flush(AVCodecContext *avctx)
1173 WavpackContext *s = avctx->priv_data;
1176 for (i = 0; i < s->fdec_num; i++)
1177 wv_reset_saved_context(s->fdec[i]);
1180 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1181 int *got_frame_ptr, AVPacket *avpkt)
1183 WavpackContext *s = avctx->priv_data;
1184 const uint8_t *buf = avpkt->data;
1185 int buf_size = avpkt->size;
1186 int frame_size, ret, frame_flags;
1187 int samplecount = 0;
1192 /* determine number of samples */
1194 s->samples = AV_RL32(buf); buf += 4;
1195 frame_flags = AV_RL32(buf);
1197 if (s->multichannel) {
1198 s->samples = AV_RL32(buf + 4);
1199 frame_flags = AV_RL32(buf + 8);
1201 s->samples = AV_RL32(buf);
1202 frame_flags = AV_RL32(buf + 4);
1205 if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1206 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1208 return AVERROR(EINVAL);
1211 if (frame_flags & 0x80) {
1212 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1213 } else if ((frame_flags & 0x03) <= 1) {
1214 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1216 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1217 avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1220 /* get output buffer */
1221 s->frame.nb_samples = s->samples + 1;
1222 if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
1223 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1226 s->frame.nb_samples = s->samples;
1228 while (buf_size > 0) {
1229 if (!s->multichannel) {
1230 frame_size = buf_size;
1233 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1235 if (buf_size < 12) //MKV files can have zero flags after last block
1237 frame_size = AV_RL32(buf + 8) + 12;
1240 if (frame_size < 0 || frame_size > buf_size) {
1241 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1242 "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1243 wavpack_decode_flush(avctx);
1244 return AVERROR_INVALIDDATA;
1246 if ((samplecount = wavpack_decode_block(avctx, s->block,
1247 s->frame.data[0], got_frame_ptr,
1248 buf, frame_size)) < 0) {
1249 wavpack_decode_flush(avctx);
1250 return AVERROR_INVALIDDATA;
1253 buf += frame_size; buf_size -= frame_size;
1257 *(AVFrame *)data = s->frame;
1262 AVCodec ff_wavpack_decoder = {
1264 .type = AVMEDIA_TYPE_AUDIO,
1265 .id = AV_CODEC_ID_WAVPACK,
1266 .priv_data_size = sizeof(WavpackContext),
1267 .init = wavpack_decode_init,
1268 .close = wavpack_decode_end,
1269 .decode = wavpack_decode_frame,
1270 .flush = wavpack_decode_flush,
1271 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1272 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),