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/audioconvert.h"
31 * WavPack lossless audio decoder
34 #define WV_MONO 0x00000004
35 #define WV_JOINT_STEREO 0x00000010
36 #define WV_FALSE_STEREO 0x40000000
38 #define WV_HYBRID_MODE 0x00000008
39 #define WV_HYBRID_SHAPE 0x00000008
40 #define WV_HYBRID_BITRATE 0x00000200
41 #define WV_HYBRID_BALANCE 0x00000400
43 #define WV_FLT_SHIFT_ONES 0x01
44 #define WV_FLT_SHIFT_SAME 0x02
45 #define WV_FLT_SHIFT_SENT 0x04
46 #define WV_FLT_ZERO_SENT 0x08
47 #define WV_FLT_ZERO_SIGN 0x10
73 typedef struct SavedContext {
82 typedef struct Decorr {
91 typedef struct WvChannel {
93 int slow_level, error_limit;
94 int bitrate_acc, bitrate_delta;
97 typedef struct WavpackFrameContext {
98 AVCodecContext *avctx;
100 int stereo, stereo_in;
105 uint32_t crc_extra_bits;
106 GetBitContext gb_extra_bits;
107 int data_size; // in bits
110 Decorr decorr[MAX_TERMS];
111 int zero, one, zeroes;
115 int hybrid, hybrid_bitrate, hybrid_maxclip;
121 SavedContext sc, extra_sc;
122 } WavpackFrameContext;
124 #define WV_MAX_FRAME_DECODERS 14
126 typedef struct WavpackContext {
127 AVCodecContext *avctx;
130 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
140 // exponent table copied from WavPack source
141 static const uint8_t wp_exp2_table [256] = {
142 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
143 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
144 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
145 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
146 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
147 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
148 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
149 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
150 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
151 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
152 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
153 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
154 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
155 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
156 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
157 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
160 static const uint8_t wp_log2_table [] = {
161 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
162 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
163 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
164 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
165 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
166 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
167 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
168 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
169 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
170 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
171 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
172 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
173 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
174 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
175 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
176 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
179 static av_always_inline int wp_exp2(int16_t val)
188 res = wp_exp2_table[val & 0xFF] | 0x100;
190 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
191 return neg ? -res : res;
194 static av_always_inline int wp_log2(int32_t val)
203 bits = av_log2(val) + 1;
205 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
207 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
210 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
212 // macros for manipulating median values
213 #define GET_MED(n) ((c->median[n] >> 4) + 1)
214 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
215 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
217 // macros for applying weight
218 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
219 if (samples && in) { \
220 if ((samples ^ in) < 0) { \
222 if (weight < -1024) \
232 static av_always_inline int get_tail(GetBitContext *gb, int k)
239 e = (1 << (p + 1)) - k - 1;
240 res = p ? get_bits(gb, p) : 0;
242 res = (res << 1) - e + get_bits1(gb);
246 static void update_error_limit(WavpackFrameContext *ctx)
250 for (i = 0; i <= ctx->stereo_in; i++) {
251 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
252 br[i] = ctx->ch[i].bitrate_acc >> 16;
253 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
255 if (ctx->stereo_in && ctx->hybrid_bitrate) {
256 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
257 if (balance > br[0]) {
260 } else if (-balance > br[0]) {
264 br[1] = br[0] + balance;
265 br[0] = br[0] - balance;
268 for (i = 0; i <= ctx->stereo_in; i++) {
269 if (ctx->hybrid_bitrate) {
270 if (sl[i] - br[i] > -0x100)
271 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
273 ctx->ch[i].error_limit = 0;
275 ctx->ch[i].error_limit = wp_exp2(br[i]);
280 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
281 int channel, int *last)
284 int sign, base, add, ret;
285 WvChannel *c = &ctx->ch[channel];
289 if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
290 !ctx->zero && !ctx->one) {
294 c->slow_level -= LEVEL_DECAY(c->slow_level);
298 t = get_unary_0_33(gb);
300 if (get_bits_left(gb) < t - 1)
302 t = get_bits(gb, t - 1) | (1 << (t-1));
304 if (get_bits_left(gb) < 0)
309 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
310 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
311 c->slow_level -= LEVEL_DECAY(c->slow_level);
321 t = get_unary_0_33(gb);
322 if (get_bits_left(gb) < 0)
325 t2 = get_unary_0_33(gb);
327 if (get_bits_left(gb) < 0)
331 if (get_bits_left(gb) < t2 - 1)
333 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
344 ctx->zero = !ctx->one;
347 if (ctx->hybrid && !channel)
348 update_error_limit(ctx);
352 add = GET_MED(0) - 1;
356 add = GET_MED(1) - 1;
360 base = GET_MED(0) + GET_MED(1);
361 add = GET_MED(2) - 1;
366 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
367 add = GET_MED(2) - 1;
372 if (!c->error_limit) {
373 ret = base + get_tail(gb, add);
374 if (get_bits_left(gb) <= 0)
377 int mid = (base * 2 + add + 1) >> 1;
378 while (add > c->error_limit) {
379 if (get_bits_left(gb) <= 0)
385 add = mid - base - 1;
386 mid = (base * 2 + add + 1) >> 1;
390 sign = get_bits1(gb);
391 if (ctx->hybrid_bitrate)
392 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
393 return sign ? ~ret : ret;
400 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
408 if (s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
409 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
410 *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
414 bit = (S & s->and) | s->or;
415 bit = (((S + bit) << s->shift) - bit) << s->post_shift;
418 bit = av_clip(bit, -s->hybrid_maxclip - 1, s->hybrid_maxclip);
423 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
431 int exp = s->float_max_exp;
433 if (s->got_extra_bits) {
434 const int max_bits = 1 + 23 + 8 + 1;
435 const int left_bits = get_bits_left(&s->gb_extra_bits);
437 if (left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
442 S <<= s->float_shift;
446 if (S >= 0x1000000) {
447 if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
448 S = get_bits(&s->gb_extra_bits, 23);
453 int shift = 23 - av_log2(S);
454 exp = s->float_max_exp;
461 if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
462 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) &&
463 get_bits1(&s->gb_extra_bits))) {
464 S |= (1 << shift) - 1;
465 } else if (s->got_extra_bits &&
466 (s->float_flag & WV_FLT_SHIFT_SENT)) {
467 S |= get_bits(&s->gb_extra_bits, shift);
471 exp = s->float_max_exp;
477 if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
478 if (get_bits1(&s->gb_extra_bits)) {
479 S = get_bits(&s->gb_extra_bits, 23);
480 if (s->float_max_exp >= 25)
481 exp = get_bits(&s->gb_extra_bits, 8);
482 sign = get_bits1(&s->gb_extra_bits);
484 if (s->float_flag & WV_FLT_ZERO_SIGN)
485 sign = get_bits1(&s->gb_extra_bits);
490 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
492 value.u = (sign << 31) | (exp << 23) | S;
496 static void wv_reset_saved_context(WavpackFrameContext *s)
499 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
502 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
503 void *dst, const int type)
507 int A, B, L, L2, R, R2;
509 uint32_t crc = s->sc.crc;
510 uint32_t crc_extra_bits = s->extra_sc.crc;
511 int16_t *dst16 = dst;
512 int32_t *dst32 = dst;
514 const int channel_pad = s->avctx->channels - 2;
516 s->one = s->zero = s->zeroes = 0;
518 L = wv_get_value(s, gb, 0, &last);
521 R = wv_get_value(s, gb, 1, &last);
524 for (i = 0; i < s->terms; i++) {
525 t = s->decorr[i].value;
529 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
530 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
532 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
533 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
535 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
536 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
539 A = s->decorr[i].samplesA[pos];
540 B = s->decorr[i].samplesB[pos];
543 if (type != AV_SAMPLE_FMT_S16) {
544 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
545 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
547 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
548 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
550 if (A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
551 if (B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
552 s->decorr[i].samplesA[j] = L = L2;
553 s->decorr[i].samplesB[j] = R = R2;
554 } else if (t == -1) {
555 if (type != AV_SAMPLE_FMT_S16)
556 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
558 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
559 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
561 if (type != AV_SAMPLE_FMT_S16)
562 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
564 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
565 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
567 s->decorr[i].samplesA[0] = R;
569 if (type != AV_SAMPLE_FMT_S16)
570 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
572 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
573 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
577 R2 = s->decorr[i].samplesA[0];
578 s->decorr[i].samplesA[0] = R;
581 if (type != AV_SAMPLE_FMT_S16)
582 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
584 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
585 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
587 s->decorr[i].samplesB[0] = L;
592 L += (R -= (L >> 1));
593 crc = (crc * 3 + L) * 3 + R;
595 if (type == AV_SAMPLE_FMT_FLT) {
596 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
597 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
598 dstfl += channel_pad;
599 } else if (type == AV_SAMPLE_FMT_S32) {
600 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
601 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
602 dst32 += channel_pad;
604 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
605 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
606 dst16 += channel_pad;
609 } while (!last && count < s->samples);
611 wv_reset_saved_context(s);
613 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
616 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
617 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
624 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
625 void *dst, const int type)
631 uint32_t crc = s->sc.crc;
632 uint32_t crc_extra_bits = s->extra_sc.crc;
633 int16_t *dst16 = dst;
634 int32_t *dst32 = dst;
636 const int channel_stride = s->avctx->channels;
638 s->one = s->zero = s->zeroes = 0;
640 T = wv_get_value(s, gb, 0, &last);
644 for (i = 0; i < s->terms; i++) {
645 t = s->decorr[i].value;
648 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
650 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
651 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
654 A = s->decorr[i].samplesA[pos];
657 if (type != AV_SAMPLE_FMT_S16)
658 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
660 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
662 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
663 s->decorr[i].samplesA[j] = T = S;
668 if (type == AV_SAMPLE_FMT_FLT) {
669 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
670 dstfl += channel_stride;
671 } else if (type == AV_SAMPLE_FMT_S32) {
672 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
673 dst32 += channel_stride;
675 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
676 dst16 += channel_stride;
679 } while (!last && count < s->samples);
681 wv_reset_saved_context(s);
683 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
686 if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
687 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
694 static av_cold int wv_alloc_frame_context(WavpackContext *c)
697 if (c->fdec_num == WV_MAX_FRAME_DECODERS)
700 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
701 if (!c->fdec[c->fdec_num])
704 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
705 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
710 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
712 WavpackContext *s = avctx->priv_data;
715 if (avctx->bits_per_coded_sample <= 16)
716 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
718 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
719 if (avctx->channels <= 2 && !avctx->channel_layout)
720 avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO :
723 s->multichannel = avctx->channels > 2;
724 /* lavf demuxer does not provide extradata, Matroska stores 0x403
725 there, use this to detect decoding mode for multichannel */
727 if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
728 int ver = AV_RL16(avctx->extradata);
729 if (ver >= 0x402 && ver <= 0x410)
735 avcodec_get_frame_defaults(&s->frame);
736 avctx->coded_frame = &s->frame;
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 void *data, int *got_frame_ptr,
755 const uint8_t *buf, int buf_size)
757 WavpackContext *wc = avctx->priv_data;
758 WavpackFrameContext *s;
759 void *samples = data;
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 const uint8_t *orig_buf = buf;
764 const uint8_t *buf_end = buf + buf_size;
765 int i, j, id, size, ssize, weights, t;
766 int bpp, chan, chmask;
773 if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
774 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
778 s = wc->fdec[block_no];
780 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
784 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
785 memset(s->ch, 0, sizeof(s->ch));
787 s->and = s->or = s->shift = 0;
788 s->got_extra_bits = 0;
791 s->samples = AV_RL32(buf); buf += 4;
797 s->samples = wc->samples;
799 s->frame_flags = AV_RL32(buf); buf += 4;
800 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
801 samples = (uint8_t*)samples + bpp * wc->ch_offset;
803 s->stereo = !(s->frame_flags & WV_MONO);
804 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
805 s->joint = s->frame_flags & WV_JOINT_STEREO;
806 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
807 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
808 s->hybrid_maxclip = (1LL << ((((s->frame_flags & 0x03) + 1) << 3) - 1)) - 1;
809 s->post_shift = 8 * (bpp - 1 - (s->frame_flags & 0x03)) +
810 ((s->frame_flags >> 13) & 0x1f);
811 s->CRC = AV_RL32(buf); buf += 4;
813 buf += 4; //skip block size;
815 wc->ch_offset += 1 + s->stereo;
817 // parse metadata blocks
818 while (buf < buf_end) {
821 if (id & WP_IDF_LONG) {
822 size |= (*buf++) << 8;
823 size |= (*buf++) << 16;
825 size <<= 1; // size is specified in words
830 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
833 if (buf + ssize > buf_end) {
834 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
837 if (id & WP_IDF_IGNORE) {
841 switch (id & WP_IDF_MASK) {
843 if (size > MAX_TERMS) {
844 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
850 for (i = 0; i < s->terms; i++) {
851 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
852 s->decorr[s->terms - i - 1].delta = *buf >> 5;
857 case WP_ID_DECWEIGHTS:
859 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
862 weights = size >> s->stereo_in;
863 if (weights > MAX_TERMS || weights > s->terms) {
864 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
868 for (i = 0; i < weights; i++) {
869 t = (int8_t)(*buf++);
870 s->decorr[s->terms - i - 1].weightA = t << 3;
871 if (s->decorr[s->terms - i - 1].weightA > 0)
872 s->decorr[s->terms - i - 1].weightA +=
873 (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
875 t = (int8_t)(*buf++);
876 s->decorr[s->terms - i - 1].weightB = t << 3;
877 if (s->decorr[s->terms - i - 1].weightB > 0)
878 s->decorr[s->terms - i - 1].weightB +=
879 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
884 case WP_ID_DECSAMPLES:
886 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
890 for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
891 if (s->decorr[i].value > 8) {
892 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
893 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
895 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
896 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
900 } else if (s->decorr[i].value < 0) {
901 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
902 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
905 for (j = 0; j < s->decorr[i].value; j++) {
906 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
908 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
910 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
916 if (size != 6 * (s->stereo_in + 1)) {
917 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
918 "got %i", 6 * (s->stereo_in + 1), size);
922 for (j = 0; j <= s->stereo_in; j++) {
923 for (i = 0; i < 3; i++) {
924 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
931 if (s->hybrid_bitrate) {
932 for (i = 0; i <= s->stereo_in; i++) {
933 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
938 for (i = 0; i < (s->stereo_in + 1); i++) {
939 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
944 for (i = 0; i < (s->stereo_in + 1); i++) {
945 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
949 for (i = 0; i < (s->stereo_in + 1); i++)
950 s->ch[i].bitrate_delta = 0;
954 case WP_ID_INT32INFO:
956 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
961 s->extra_bits = buf[0];
973 case WP_ID_FLOATINFO:
975 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
979 s->float_flag = buf[0];
980 s->float_shift = buf[1];
981 s->float_max_exp = buf[2];
986 s->sc.offset = buf - orig_buf;
987 s->sc.size = size * 8;
988 init_get_bits(&s->gb, buf, size * 8);
989 s->data_size = size * 8;
993 case WP_ID_EXTRABITS:
995 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1000 s->extra_sc.offset = buf - orig_buf;
1001 s->extra_sc.size = size * 8;
1002 init_get_bits(&s->gb_extra_bits, buf, size * 8);
1003 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1005 s->got_extra_bits = 1;
1007 case WP_ID_CHANINFO:
1009 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1014 case 0: chmask = *buf; break;
1015 case 1: chmask = AV_RL16(buf); break;
1016 case 2: chmask = AV_RL24(buf); break;
1017 case 3: chmask = AV_RL32(buf); break;
1019 chan |= (buf[1] & 0xF) << 8;
1020 chmask = AV_RL24(buf + 2);
1023 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1025 chan = avctx->channels;
1026 chmask = avctx->channel_layout;
1028 if (chan != avctx->channels) {
1029 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1030 "decoder believes it's %d channels\n", chan,
1034 if (!avctx->channel_layout)
1035 avctx->channel_layout = chmask;
1041 if (id & WP_IDF_ODD)
1046 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1050 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1054 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1058 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1061 if (s->hybrid && !got_hybrid) {
1062 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1066 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1069 if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1070 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1073 if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1074 const int size = get_bits_left(&s->gb_extra_bits);
1075 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1076 if (size < wanted) {
1077 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1078 s->got_extra_bits = 0;
1083 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1084 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1085 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1086 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1088 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1090 if (samplecount < 0)
1095 const int channel_stride = avctx->channels;
1097 if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1098 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1099 else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1100 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1102 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1104 if (samplecount < 0)
1107 if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1108 int16_t *dst = (int16_t*)samples + 1;
1109 int16_t *src = (int16_t*)samples;
1110 int cnt = samplecount;
1113 src += channel_stride;
1114 dst += channel_stride;
1116 } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1117 int32_t *dst = (int32_t*)samples + 1;
1118 int32_t *src = (int32_t*)samples;
1119 int cnt = samplecount;
1122 src += channel_stride;
1123 dst += channel_stride;
1125 } else if (s->stereo) {
1126 float *dst = (float*)samples + 1;
1127 float *src = (float*)samples;
1128 int cnt = samplecount;
1131 src += channel_stride;
1132 dst += channel_stride;
1139 return samplecount * bpp;
1142 static void wavpack_decode_flush(AVCodecContext *avctx)
1144 WavpackContext *s = avctx->priv_data;
1147 for (i = 0; i < s->fdec_num; i++)
1148 wv_reset_saved_context(s->fdec[i]);
1151 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1152 int *got_frame_ptr, AVPacket *avpkt)
1154 WavpackContext *s = avctx->priv_data;
1155 const uint8_t *buf = avpkt->data;
1156 int buf_size = avpkt->size;
1157 int frame_size, ret, frame_flags;
1158 int samplecount = 0;
1163 /* determine number of samples */
1165 s->samples = AV_RL32(buf); buf += 4;
1166 frame_flags = AV_RL32(buf);
1168 if (s->multichannel) {
1169 s->samples = AV_RL32(buf + 4);
1170 frame_flags = AV_RL32(buf + 8);
1172 s->samples = AV_RL32(buf);
1173 frame_flags = AV_RL32(buf + 4);
1176 if (s->samples <= 0) {
1177 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1179 return AVERROR(EINVAL);
1182 if (frame_flags & 0x80) {
1183 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1184 } else if ((frame_flags & 0x03) <= 1) {
1185 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1187 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1190 /* get output buffer */
1191 s->frame.nb_samples = s->samples;
1192 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1193 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1197 while (buf_size > 0) {
1198 if (!s->multichannel) {
1199 frame_size = buf_size;
1202 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1204 if (buf_size < 12) //MKV files can have zero flags after last block
1206 frame_size = AV_RL32(buf + 8) + 12;
1209 if (frame_size < 0 || frame_size > buf_size) {
1210 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1211 "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1212 wavpack_decode_flush(avctx);
1215 if ((samplecount = wavpack_decode_block(avctx, s->block,
1216 s->frame.data[0], got_frame_ptr,
1217 buf, frame_size)) < 0) {
1218 wavpack_decode_flush(avctx);
1222 buf += frame_size; buf_size -= frame_size;
1226 *(AVFrame *)data = s->frame;
1231 AVCodec ff_wavpack_decoder = {
1233 .type = AVMEDIA_TYPE_AUDIO,
1234 .id = CODEC_ID_WAVPACK,
1235 .priv_data_size = sizeof(WavpackContext),
1236 .init = wavpack_decode_init,
1237 .close = wavpack_decode_end,
1238 .decode = wavpack_decode_frame,
1239 .flush = wavpack_decode_flush,
1240 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1241 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),