2 * WavPack lossless audio decoder
3 * Copyright (c) 2006 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
21 #define ALT_BITSTREAM_READER_LE
27 * @file libavcodec/wavpack.c
28 * WavPack lossless audio decoder
31 #define WV_MONO 0x00000004
32 #define WV_JOINT_STEREO 0x00000010
33 #define WV_FALSE_STEREO 0x40000000
35 #define WV_HYBRID_MODE 0x00000008
36 #define WV_HYBRID_SHAPE 0x00000008
37 #define WV_HYBRID_BITRATE 0x00000200
38 #define WV_HYBRID_BALANCE 0x00000400
66 typedef struct Decorr {
75 typedef struct WvChannel {
77 int slow_level, error_limit;
78 int bitrate_acc, bitrate_delta;
81 typedef struct WavpackContext {
82 AVCodecContext *avctx;
84 int stereo, stereo_in;
88 int data_size; // in bits
91 Decorr decorr[MAX_TERMS];
92 int zero, one, zeroes;
94 int hybrid, hybrid_bitrate;
98 // exponent table copied from WavPack source
99 static const uint8_t wp_exp2_table [256] = {
100 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
101 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
102 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
103 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
104 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
105 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
106 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
107 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
108 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
109 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
110 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
111 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
112 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
113 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
114 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
115 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
118 static const uint8_t wp_log2_table [] = {
119 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
120 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
121 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
122 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
123 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
124 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
125 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
126 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
127 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
128 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
129 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
130 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
131 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
132 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
133 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
134 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
137 static av_always_inline int wp_exp2(int16_t val)
146 res = wp_exp2_table[val & 0xFF] | 0x100;
148 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
149 return neg ? -res : res;
152 static av_always_inline int wp_log2(int32_t val)
161 bits = av_log2(val) + 1;
163 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
165 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
168 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
170 // macros for manipulating median values
171 #define GET_MED(n) ((c->median[n] >> 4) + 1)
172 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
173 #define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
175 // macros for applying weight
176 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
178 if((samples ^ in) < 0){ \
180 if(weight < -1024) weight = -1024; \
183 if(weight > 1024) weight = 1024; \
188 static av_always_inline int get_tail(GetBitContext *gb, int k)
194 e = (1 << (p + 1)) - k - 1;
195 res = p ? get_bits(gb, p) : 0;
197 res = (res<<1) - e + get_bits1(gb);
202 static void update_error_limit(WavpackContext *ctx)
206 for(i = 0; i <= ctx->stereo_in; i++){
207 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
208 br[i] = ctx->ch[i].bitrate_acc >> 16;
209 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
211 if(ctx->stereo_in && ctx->hybrid_bitrate){
212 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
216 }else if(-balance > br[0]){
220 br[1] = br[0] + balance;
221 br[0] = br[0] - balance;
224 for(i = 0; i <= ctx->stereo_in; i++){
225 if(ctx->hybrid_bitrate){
226 if(sl[i] - br[i] > -0x100)
227 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
229 ctx->ch[i].error_limit = 0;
231 ctx->ch[i].error_limit = wp_exp2(br[i]);
236 static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last)
239 int sign, base, add, ret;
240 WvChannel *c = &ctx->ch[channel];
244 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
248 c->slow_level -= LEVEL_DECAY(c->slow_level);
252 t = get_unary_0_33(gb);
253 if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1));
256 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
257 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
258 c->slow_level -= LEVEL_DECAY(c->slow_level);
264 if(get_bits_count(gb) >= ctx->data_size){
273 t = get_unary_0_33(gb);
274 if(get_bits_count(gb) >= ctx->data_size){
279 t2 = get_unary_0_33(gb);
281 else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
291 ctx->zero = !ctx->one;
294 if(ctx->hybrid && !channel)
295 update_error_limit(ctx);
299 add = GET_MED(0) - 1;
303 add = GET_MED(1) - 1;
307 base = GET_MED(0) + GET_MED(1);
308 add = GET_MED(2) - 1;
313 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
314 add = GET_MED(2) - 1;
320 ret = base + get_tail(gb, add);
322 int mid = (base*2 + add + 1) >> 1;
323 while(add > c->error_limit){
328 add = mid - base - 1;
329 mid = (base*2 + add + 1) >> 1;
333 sign = get_bits1(gb);
334 if(ctx->hybrid_bitrate)
335 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
336 return sign ? ~ret : ret;
339 static int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, int16_t *dst)
343 int A, B, L, L2, R, R2, bit;
345 uint32_t crc = 0xFFFFFFFF;
347 s->one = s->zero = s->zeroes = 0;
349 L = wv_get_value(s, gb, 0, &last);
351 R = wv_get_value(s, gb, 1, &last);
353 for(i = 0; i < s->terms; i++){
354 t = s->decorr[i].value;
359 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
360 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
362 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
363 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
365 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
366 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
369 A = s->decorr[i].samplesA[pos];
370 B = s->decorr[i].samplesB[pos];
373 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
374 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
375 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
376 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
377 s->decorr[i].samplesA[j] = L = L2;
378 s->decorr[i].samplesB[j] = R = R2;
380 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
381 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
383 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
384 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
386 s->decorr[i].samplesA[0] = R;
388 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
389 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
393 R2 = s->decorr[i].samplesA[0];
394 s->decorr[i].samplesA[0] = R;
397 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
398 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
400 s->decorr[i].samplesB[0] = L;
405 L += (R -= (L >> 1));
406 crc = (crc * 3 + L) * 3 + R;
407 bit = (L & s->and) | s->or;
408 *dst++ = ((L + bit) << s->shift) - bit;
409 bit = (R & s->and) | s->or;
410 *dst++ = ((R + bit) << s->shift) - bit;
412 }while(!last && count < s->samples);
415 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
421 static int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, int16_t *dst)
427 uint32_t crc = 0xFFFFFFFF;
429 s->one = s->zero = s->zeroes = 0;
431 T = wv_get_value(s, gb, 0, &last);
434 for(i = 0; i < s->terms; i++){
435 t = s->decorr[i].value;
438 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
440 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
441 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
444 A = s->decorr[i].samplesA[pos];
447 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
448 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
449 s->decorr[i].samplesA[j] = T = S;
453 bit = (S & s->and) | s->or;
454 *dst++ = ((S + bit) << s->shift) - bit;
456 }while(!last && count < s->samples);
459 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
465 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
467 WavpackContext *s = avctx->priv_data;
470 s->stereo = (avctx->channels == 2);
471 avctx->sample_fmt = SAMPLE_FMT_S16;
472 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
477 static int wavpack_decode_frame(AVCodecContext *avctx,
478 void *data, int *data_size,
481 const uint8_t *buf = avpkt->data;
482 int buf_size = avpkt->size;
483 WavpackContext *s = avctx->priv_data;
484 int16_t *samples = data;
486 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0;
488 const uint8_t* buf_end = buf + buf_size;
489 int i, j, id, size, ssize, weights, t;
496 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
497 memset(s->ch, 0, sizeof(s->ch));
498 s->and = s->or = s->shift = 0;
500 s->samples = AV_RL32(buf); buf += 4;
505 /* should not happen but who knows */
506 if(s->samples * 2 * avctx->channels > *data_size){
507 av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n");
510 s->frame_flags = AV_RL32(buf); buf += 4;
511 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
512 s->joint = s->frame_flags & WV_JOINT_STEREO;
513 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
514 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
515 s->CRC = AV_RL32(buf); buf += 4;
516 // parse metadata blocks
517 while(buf < buf_end){
520 if(id & WP_IDF_LONG) {
521 size |= (*buf++) << 8;
522 size |= (*buf++) << 16;
524 size <<= 1; // size is specified in words
526 if(id & WP_IDF_ODD) size--;
528 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
531 if(buf + ssize > buf_end){
532 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
535 if(id & WP_IDF_IGNORE){
539 switch(id & WP_IDF_MASK){
542 if(s->terms > MAX_TERMS){
543 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
547 for(i = 0; i < s->terms; i++) {
548 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
549 s->decorr[s->terms - i - 1].delta = *buf >> 5;
554 case WP_ID_DECWEIGHTS:
556 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
559 weights = size >> s->stereo_in;
560 if(weights > MAX_TERMS || weights > s->terms){
561 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
565 for(i = 0; i < weights; i++) {
566 t = (int8_t)(*buf++);
567 s->decorr[s->terms - i - 1].weightA = t << 3;
568 if(s->decorr[s->terms - i - 1].weightA > 0)
569 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
571 t = (int8_t)(*buf++);
572 s->decorr[s->terms - i - 1].weightB = t << 3;
573 if(s->decorr[s->terms - i - 1].weightB > 0)
574 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
579 case WP_ID_DECSAMPLES:
581 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
585 for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
586 if(s->decorr[i].value > 8){
587 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
588 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
590 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
591 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
595 }else if(s->decorr[i].value < 0){
596 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
597 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
600 for(j = 0; j < s->decorr[i].value; j++){
601 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
603 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
606 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
612 if(size != 6 * (s->stereo_in + 1)){
613 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
617 for(j = 0; j <= s->stereo_in; j++){
618 for(i = 0; i < 3; i++){
619 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
626 if(s->hybrid_bitrate){
627 for(i = 0; i <= s->stereo_in; i++){
628 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
633 for(i = 0; i < (s->stereo_in + 1); i++){
634 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
639 for(i = 0; i < (s->stereo_in + 1); i++){
640 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
644 for(i = 0; i < (s->stereo_in + 1); i++)
645 s->ch[i].bitrate_delta = 0;
649 case WP_ID_INT32INFO:
650 if(size != 4 || *buf){
651 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
667 init_get_bits(&s->gb, buf, size * 8);
668 s->data_size = size * 8;
675 if(id & WP_IDF_ODD) buf++;
678 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
682 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
686 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
690 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
693 if(s->hybrid && !got_hybrid){
694 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
698 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
703 samplecount = wv_unpack_stereo(s, &s->gb, samples);
705 samplecount = wv_unpack_mono(s, &s->gb, samples);
707 int16_t *dst = samples + samplecount * 2;
708 int16_t *src = samples + samplecount;
709 int cnt = samplecount;
717 *data_size = samplecount * 2;
722 AVCodec wavpack_decoder = {
726 sizeof(WavpackContext),
730 wavpack_decode_frame,
731 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),