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
23 #include "bitstream.h"
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
,
479 const uint8_t *buf
, int buf_size
)
481 WavpackContext
*s
= avctx
->priv_data
;
482 int16_t *samples
= data
;
484 int got_terms
= 0, got_weights
= 0, got_samples
= 0, got_entropy
= 0, got_bs
= 0;
486 const uint8_t* buf_end
= buf
+ buf_size
;
487 int i
, j
, id
, size
, ssize
, weights
, t
;
494 memset(s
->decorr
, 0, MAX_TERMS
* sizeof(Decorr
));
495 memset(s
->ch
, 0, sizeof(s
->ch
));
496 s
->and = s
->or = s
->shift
= 0;
498 s
->samples
= AV_RL32(buf
); buf
+= 4;
503 /* should not happen but who knows */
504 if(s
->samples
* 2 * avctx
->channels
> *data_size
){
505 av_log(avctx
, AV_LOG_ERROR
, "Packet size is too big to be handled in lavc!\n");
508 s
->frame_flags
= AV_RL32(buf
); buf
+= 4;
509 s
->stereo_in
= (s
->frame_flags
& WV_FALSE_STEREO
) ? 0 : s
->stereo
;
510 s
->joint
= s
->frame_flags
& WV_JOINT_STEREO
;
511 s
->hybrid
= s
->frame_flags
& WV_HYBRID_MODE
;
512 s
->hybrid_bitrate
= s
->frame_flags
& WV_HYBRID_BITRATE
;
513 s
->CRC
= AV_RL32(buf
); buf
+= 4;
514 // parse metadata blocks
515 while(buf
< buf_end
){
518 if(id
& WP_IDF_LONG
) {
519 size
|= (*buf
++) << 8;
520 size
|= (*buf
++) << 16;
522 size
<<= 1; // size is specified in words
524 if(id
& WP_IDF_ODD
) size
--;
526 av_log(avctx
, AV_LOG_ERROR
, "Got incorrect block %02X with size %i\n", id
, size
);
529 if(buf
+ ssize
> buf_end
){
530 av_log(avctx
, AV_LOG_ERROR
, "Block size %i is out of bounds\n", size
);
533 if(id
& WP_IDF_IGNORE
){
537 switch(id
& WP_IDF_MASK
){
540 if(s
->terms
> MAX_TERMS
){
541 av_log(avctx
, AV_LOG_ERROR
, "Too many decorrelation terms\n");
545 for(i
= 0; i
< s
->terms
; i
++) {
546 s
->decorr
[s
->terms
- i
- 1].value
= (*buf
& 0x1F) - 5;
547 s
->decorr
[s
->terms
- i
- 1].delta
= *buf
>> 5;
552 case WP_ID_DECWEIGHTS
:
554 av_log(avctx
, AV_LOG_ERROR
, "No decorrelation terms met\n");
557 weights
= size
>> s
->stereo_in
;
558 if(weights
> MAX_TERMS
|| weights
> s
->terms
){
559 av_log(avctx
, AV_LOG_ERROR
, "Too many decorrelation weights\n");
563 for(i
= 0; i
< weights
; i
++) {
564 t
= (int8_t)(*buf
++);
565 s
->decorr
[s
->terms
- i
- 1].weightA
= t
<< 3;
566 if(s
->decorr
[s
->terms
- i
- 1].weightA
> 0)
567 s
->decorr
[s
->terms
- i
- 1].weightA
+= (s
->decorr
[s
->terms
- i
- 1].weightA
+ 64) >> 7;
569 t
= (int8_t)(*buf
++);
570 s
->decorr
[s
->terms
- i
- 1].weightB
= t
<< 3;
571 if(s
->decorr
[s
->terms
- i
- 1].weightB
> 0)
572 s
->decorr
[s
->terms
- i
- 1].weightB
+= (s
->decorr
[s
->terms
- i
- 1].weightB
+ 64) >> 7;
577 case WP_ID_DECSAMPLES
:
579 av_log(avctx
, AV_LOG_ERROR
, "No decorrelation terms met\n");
583 for(i
= s
->terms
- 1; (i
>= 0) && (t
< size
); i
--) {
584 if(s
->decorr
[i
].value
> 8){
585 s
->decorr
[i
].samplesA
[0] = wp_exp2(AV_RL16(buf
)); buf
+= 2;
586 s
->decorr
[i
].samplesA
[1] = wp_exp2(AV_RL16(buf
)); buf
+= 2;
588 s
->decorr
[i
].samplesB
[0] = wp_exp2(AV_RL16(buf
)); buf
+= 2;
589 s
->decorr
[i
].samplesB
[1] = wp_exp2(AV_RL16(buf
)); buf
+= 2;
593 }else if(s
->decorr
[i
].value
< 0){
594 s
->decorr
[i
].samplesA
[0] = wp_exp2(AV_RL16(buf
)); buf
+= 2;
595 s
->decorr
[i
].samplesB
[0] = wp_exp2(AV_RL16(buf
)); buf
+= 2;
598 for(j
= 0; j
< s
->decorr
[i
].value
; j
++){
599 s
->decorr
[i
].samplesA
[j
] = wp_exp2(AV_RL16(buf
)); buf
+= 2;
601 s
->decorr
[i
].samplesB
[j
] = wp_exp2(AV_RL16(buf
)); buf
+= 2;
604 t
+= s
->decorr
[i
].value
* 2 * (s
->stereo_in
+ 1);
610 if(size
!= 6 * (s
->stereo_in
+ 1)){
611 av_log(avctx
, AV_LOG_ERROR
, "Entropy vars size should be %i, got %i", 6 * (s
->stereo_in
+ 1), size
);
615 for(j
= 0; j
<= s
->stereo_in
; j
++){
616 for(i
= 0; i
< 3; i
++){
617 s
->ch
[j
].median
[i
] = wp_exp2(AV_RL16(buf
));
624 if(s
->hybrid_bitrate
){
625 for(i
= 0; i
<= s
->stereo_in
; i
++){
626 s
->ch
[i
].slow_level
= wp_exp2(AV_RL16(buf
));
631 for(i
= 0; i
< (s
->stereo_in
+ 1); i
++){
632 s
->ch
[i
].bitrate_acc
= AV_RL16(buf
) << 16;
637 for(i
= 0; i
< (s
->stereo_in
+ 1); i
++){
638 s
->ch
[i
].bitrate_delta
= wp_exp2((int16_t)AV_RL16(buf
));
642 for(i
= 0; i
< (s
->stereo_in
+ 1); i
++)
643 s
->ch
[i
].bitrate_delta
= 0;
647 case WP_ID_INT32INFO
:
648 if(size
!= 4 || *buf
){
649 av_log(avctx
, AV_LOG_ERROR
, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size
, *buf
);
665 init_get_bits(&s
->gb
, buf
, size
* 8);
666 s
->data_size
= size
* 8;
673 if(id
& WP_IDF_ODD
) buf
++;
676 av_log(avctx
, AV_LOG_ERROR
, "No block with decorrelation terms\n");
680 av_log(avctx
, AV_LOG_ERROR
, "No block with decorrelation weights\n");
684 av_log(avctx
, AV_LOG_ERROR
, "No block with decorrelation samples\n");
688 av_log(avctx
, AV_LOG_ERROR
, "No block with entropy info\n");
691 if(s
->hybrid
&& !got_hybrid
){
692 av_log(avctx
, AV_LOG_ERROR
, "Hybrid config not found\n");
696 av_log(avctx
, AV_LOG_ERROR
, "Packed samples not found\n");
701 samplecount
= wv_unpack_stereo(s
, &s
->gb
, samples
);
703 samplecount
= wv_unpack_mono(s
, &s
->gb
, samples
);
705 int16_t *dst
= samples
+ samplecount
* 2;
706 int16_t *src
= samples
+ samplecount
;
707 int cnt
= samplecount
;
715 *data_size
= samplecount
* 2;
720 AVCodec wavpack_decoder
= {
724 sizeof(WavpackContext
),
728 wavpack_decode_frame
,
729 .long_name
= NULL_IF_CONFIG_SMALL("WavPack"),