ffmpeg / libavcodec / wavpack.c @ 72415b2a
History  View  Annotate  Download (34.5 KB)
1 
/*


2 
* WavPack lossless audio decoder

3 
* Copyright (c) 2006 Konstantin Shishkov

4 
*

5 
* This file is part of FFmpeg.

6 
*

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.

11 
*

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.

16 
*

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 021101301 USA

20 
*/

21 
#define ALT_BITSTREAM_READER_LE

22 
#include "avcodec.h" 
23 
#include "get_bits.h" 
24 
#include "unary.h" 
25  
26 
/**

27 
* @file libavcodec/wavpack.c

28 
* WavPack lossless audio decoder

29 
*/

30  
31 
#define WV_MONO 0x00000004 
32 
#define WV_JOINT_STEREO 0x00000010 
33 
#define WV_FALSE_STEREO 0x40000000 
34  
35 
#define WV_HYBRID_MODE 0x00000008 
36 
#define WV_HYBRID_SHAPE 0x00000008 
37 
#define WV_HYBRID_BITRATE 0x00000200 
38 
#define WV_HYBRID_BALANCE 0x00000400 
39  
40 
#define WV_FLT_SHIFT_ONES 0x01 
41 
#define WV_FLT_SHIFT_SAME 0x02 
42 
#define WV_FLT_SHIFT_SENT 0x04 
43 
#define WV_FLT_ZERO_SENT 0x08 
44 
#define WV_FLT_ZERO_SIGN 0x10 
45  
46 
enum WP_ID_Flags{

47 
WP_IDF_MASK = 0x1F,

48 
WP_IDF_IGNORE = 0x20,

49 
WP_IDF_ODD = 0x40,

50 
WP_IDF_LONG = 0x80

51 
}; 
52  
53 
enum WP_ID{

54 
WP_ID_DUMMY = 0,

55 
WP_ID_ENCINFO, 
56 
WP_ID_DECTERMS, 
57 
WP_ID_DECWEIGHTS, 
58 
WP_ID_DECSAMPLES, 
59 
WP_ID_ENTROPY, 
60 
WP_ID_HYBRID, 
61 
WP_ID_SHAPING, 
62 
WP_ID_FLOATINFO, 
63 
WP_ID_INT32INFO, 
64 
WP_ID_DATA, 
65 
WP_ID_CORR, 
66 
WP_ID_EXTRABITS, 
67 
WP_ID_CHANINFO 
68 
}; 
69  
70 
typedef struct SavedContext { 
71 
int offset;

72 
int size;

73 
int bits_used;

74 
uint32_t crc; 
75 
} SavedContext; 
76  
77 
#define MAX_TERMS 16 
78  
79 
typedef struct Decorr { 
80 
int delta;

81 
int value;

82 
int weightA;

83 
int weightB;

84 
int samplesA[8]; 
85 
int samplesB[8]; 
86 
} Decorr; 
87  
88 
typedef struct WvChannel { 
89 
int median[3]; 
90 
int slow_level, error_limit;

91 
int bitrate_acc, bitrate_delta;

92 
} WvChannel; 
93  
94 
typedef struct WavpackContext { 
95 
AVCodecContext *avctx; 
96 
int frame_flags;

97 
int stereo, stereo_in;

98 
int joint;

99 
uint32_t CRC; 
100 
GetBitContext gb; 
101 
int got_extra_bits;

102 
uint32_t crc_extra_bits; 
103 
GetBitContext gb_extra_bits; 
104 
int data_size; // in bits 
105 
int samples;

106 
int terms;

107 
Decorr decorr[MAX_TERMS]; 
108 
int zero, one, zeroes;

109 
int extra_bits;

110 
int and, or, shift;

111 
int post_shift;

112 
int hybrid, hybrid_bitrate;

113 
int float_flag;

114 
int float_shift;

115 
int float_max_exp;

116 
WvChannel ch[2];

117 
int samples_left;

118 
int max_samples;

119 
int pos;

120 
SavedContext sc, extra_sc; 
121 
} WavpackContext; 
122  
123 
// exponent table copied from WavPack source

124 
static const uint8_t wp_exp2_table [256] = { 
125 
0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b, 
126 
0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16, 
127 
0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23, 
128 
0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 
129 
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d, 
130 
0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b, 
131 
0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 
132 
0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 
133 
0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 
134 
0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a, 
135 
0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 
136 
0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 
137 
0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 
138 
0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4, 
139 
0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9, 
140 
0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff 
141 
}; 
142  
143 
static const uint8_t wp_log2_table [] = { 
144 
0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15, 
145 
0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, 
146 
0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e, 
147 
0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 
148 
0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 
149 
0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75, 
150 
0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 
151 
0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 
152 
0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 
153 
0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2, 
154 
0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0, 
155 
0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce, 
156 
0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb, 
157 
0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7, 
158 
0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 
159 
0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff 
160 
}; 
161  
162 
static av_always_inline int wp_exp2(int16_t val) 
163 
{ 
164 
int res, neg = 0; 
165  
166 
if(val < 0){ 
167 
val = val; 
168 
neg = 1;

169 
} 
170  
171 
res = wp_exp2_table[val & 0xFF]  0x100; 
172 
val >>= 8;

173 
res = (val > 9) ? (res << (val  9)) : (res >> (9  val)); 
174 
return neg ? res : res;

175 
} 
176  
177 
static av_always_inline int wp_log2(int32_t val) 
178 
{ 
179 
int bits;

180  
181 
if(!val)

182 
return 0; 
183 
if(val == 1) 
184 
return 256; 
185 
val += val >> 9;

186 
bits = av_log2(val) + 1;

187 
if(bits < 9) 
188 
return (bits << 8) + wp_log2_table[(val << (9  bits)) & 0xFF]; 
189 
else

190 
return (bits << 8) + wp_log2_table[(val >> (bits  9)) & 0xFF]; 
191 
} 
192  
193 
#define LEVEL_DECAY(a) ((a + 0x80) >> 8) 
194  
195 
// macros for manipulating median values

196 
#define GET_MED(n) ((c>median[n] >> 4) + 1) 
197 
#define DEC_MED(n) c>median[n] = ((c>median[n] + (128>>n)  2) / (128>>n)) * 2 
198 
#define INC_MED(n) c>median[n] += ((c>median[n] + (128>>n)) / (128>>n)) * 5 
199  
200 
// macros for applying weight

201 
#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \

202 
if(samples && in){ \

203 
if((samples ^ in) < 0){ \ 
204 
weight = delta; \ 
205 
if(weight < 1024) weight = 1024; \ 
206 
}else{ \

207 
weight += delta; \ 
208 
if(weight > 1024) weight = 1024; \ 
209 
} \ 
210 
} 
211  
212  
213 
static av_always_inline int get_tail(GetBitContext *gb, int k) 
214 
{ 
215 
int p, e, res;

216  
217 
if(k<1)return 0; 
218 
p = av_log2(k); 
219 
e = (1 << (p + 1))  k  1; 
220 
res = p ? get_bits(gb, p) : 0;

221 
if(res >= e){

222 
res = (res<<1)  e + get_bits1(gb);

223 
} 
224 
return res;

225 
} 
226  
227 
static void update_error_limit(WavpackContext *ctx) 
228 
{ 
229 
int i, br[2], sl[2]; 
230  
231 
for(i = 0; i <= ctx>stereo_in; i++){ 
232 
ctx>ch[i].bitrate_acc += ctx>ch[i].bitrate_delta; 
233 
br[i] = ctx>ch[i].bitrate_acc >> 16;

234 
sl[i] = LEVEL_DECAY(ctx>ch[i].slow_level); 
235 
} 
236 
if(ctx>stereo_in && ctx>hybrid_bitrate){

237 
int balance = (sl[1]  sl[0] + br[1] + 1) >> 1; 
238 
if(balance > br[0]){ 
239 
br[1] = br[0] << 1; 
240 
br[0] = 0; 
241 
}else if(balance > br[0]){ 
242 
br[0] <<= 1; 
243 
br[1] = 0; 
244 
}else{

245 
br[1] = br[0] + balance; 
246 
br[0] = br[0]  balance; 
247 
} 
248 
} 
249 
for(i = 0; i <= ctx>stereo_in; i++){ 
250 
if(ctx>hybrid_bitrate){

251 
if(sl[i]  br[i] > 0x100) 
252 
ctx>ch[i].error_limit = wp_exp2(sl[i]  br[i] + 0x100);

253 
else

254 
ctx>ch[i].error_limit = 0;

255 
}else{

256 
ctx>ch[i].error_limit = wp_exp2(br[i]); 
257 
} 
258 
} 
259 
} 
260  
261 
static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last) 
262 
{ 
263 
int t, t2;

264 
int sign, base, add, ret;

265 
WvChannel *c = &ctx>ch[channel]; 
266  
267 
*last = 0;

268  
269 
if((ctx>ch[0].median[0] < 2U) && (ctx>ch[1].median[0] < 2U) && !ctx>zero && !ctx>one){ 
270 
if(ctx>zeroes){

271 
ctx>zeroes; 
272 
if(ctx>zeroes){

273 
c>slow_level = LEVEL_DECAY(c>slow_level); 
274 
return 0; 
275 
} 
276 
}else{

277 
t = get_unary_0_33(gb); 
278 
if(t >= 2) t = get_bits(gb, t  1)  (1 << (t1)); 
279 
ctx>zeroes = t; 
280 
if(ctx>zeroes){

281 
memset(ctx>ch[0].median, 0, sizeof(ctx>ch[0].median)); 
282 
memset(ctx>ch[1].median, 0, sizeof(ctx>ch[1].median)); 
283 
c>slow_level = LEVEL_DECAY(c>slow_level); 
284 
return 0; 
285 
} 
286 
} 
287 
} 
288  
289 
if(get_bits_count(gb) >= ctx>data_size){

290 
*last = 1;

291 
return 0; 
292 
} 
293  
294 
if(ctx>zero){

295 
t = 0;

296 
ctx>zero = 0;

297 
}else{

298 
t = get_unary_0_33(gb); 
299 
if(get_bits_count(gb) >= ctx>data_size){

300 
*last = 1;

301 
return 0; 
302 
} 
303 
if(t == 16) { 
304 
t2 = get_unary_0_33(gb); 
305 
if(t2 < 2) t += t2; 
306 
else t += get_bits(gb, t2  1)  (1 << (t2  1)); 
307 
} 
308  
309 
if(ctx>one){

310 
ctx>one = t&1;

311 
t = (t>>1) + 1; 
312 
}else{

313 
ctx>one = t&1;

314 
t >>= 1;

315 
} 
316 
ctx>zero = !ctx>one; 
317 
} 
318  
319 
if(ctx>hybrid && !channel)

320 
update_error_limit(ctx); 
321  
322 
if(!t){

323 
base = 0;

324 
add = GET_MED(0)  1; 
325 
DEC_MED(0);

326 
}else if(t == 1){ 
327 
base = GET_MED(0);

328 
add = GET_MED(1)  1; 
329 
INC_MED(0);

330 
DEC_MED(1);

331 
}else if(t == 2){ 
332 
base = GET_MED(0) + GET_MED(1); 
333 
add = GET_MED(2)  1; 
334 
INC_MED(0);

335 
INC_MED(1);

336 
DEC_MED(2);

337 
}else{

338 
base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t  2); 
339 
add = GET_MED(2)  1; 
340 
INC_MED(0);

341 
INC_MED(1);

342 
INC_MED(2);

343 
} 
344 
if(!c>error_limit){

345 
ret = base + get_tail(gb, add); 
346 
}else{

347 
int mid = (base*2 + add + 1) >> 1; 
348 
while(add > c>error_limit){

349 
if(get_bits1(gb)){

350 
add = (mid  base); 
351 
base = mid; 
352 
}else

353 
add = mid  base  1;

354 
mid = (base*2 + add + 1) >> 1; 
355 
} 
356 
ret = mid; 
357 
} 
358 
sign = get_bits1(gb); 
359 
if(ctx>hybrid_bitrate)

360 
c>slow_level += wp_log2(ret)  LEVEL_DECAY(c>slow_level); 
361 
return sign ? ~ret : ret;

362 
} 
363  
364 
static inline int wv_get_value_integer(WavpackContext *s, uint32_t *crc, int S) 
365 
{ 
366 
int bit;

367  
368 
if(s>extra_bits){

369 
S <<= s>extra_bits; 
370  
371 
if(s>got_extra_bits){

372 
S = get_bits(&s>gb_extra_bits, s>extra_bits); 
373 
*crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16); 
374 
} 
375 
} 
376 
bit = (S & s>and)  s>or; 
377 
return (((S + bit) << s>shift)  bit) << s>post_shift;

378 
} 
379  
380 
static float wv_get_value_float(WavpackContext *s, uint32_t *crc, int S) 
381 
{ 
382 
union {

383 
float f;

384 
uint32_t u; 
385 
} value; 
386  
387 
int sign;

388 
int exp = s>float_max_exp;

389  
390 
if(s>got_extra_bits){

391 
const int max_bits = 1 + 23 + 8 + 1; 
392 
const int left_bits = get_bits_left(&s>gb_extra_bits); 
393  
394 
if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits) 
395 
return 0.0; 
396 
} 
397  
398 
if(S){

399 
S <<= s>float_shift; 
400 
sign = S < 0;

401 
if(sign)

402 
S = S; 
403 
if(S >= 0x1000000){ 
404 
if(s>got_extra_bits && get_bits1(&s>gb_extra_bits)){

405 
S = get_bits(&s>gb_extra_bits, 23);

406 
}else{

407 
S = 0;

408 
} 
409 
exp = 255;

410 
}else if(exp){ 
411 
int shift = 23  av_log2(S); 
412 
exp = s>float_max_exp; 
413 
if(exp <= shift){

414 
shift = exp; 
415 
} 
416 
exp = shift; 
417  
418 
if(shift){

419 
S <<= shift; 
420 
if((s>float_flag & WV_FLT_SHIFT_ONES) 

421 
(s>got_extra_bits && (s>float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s>gb_extra_bits)) ){ 
422 
S = (1 << shift)  1; 
423 
} else if(s>got_extra_bits && (s>float_flag & WV_FLT_SHIFT_SENT)){ 
424 
S = get_bits(&s>gb_extra_bits, shift); 
425 
} 
426 
} 
427 
}else{

428 
exp = s>float_max_exp; 
429 
} 
430 
S &= 0x7fffff;

431 
}else{

432 
sign = 0;

433 
exp = 0;

434 
if(s>got_extra_bits && (s>float_flag & WV_FLT_ZERO_SENT)){

435 
if(get_bits1(&s>gb_extra_bits)){

436 
S = get_bits(&s>gb_extra_bits, 23);

437 
if(s>float_max_exp >= 25) 
438 
exp = get_bits(&s>gb_extra_bits, 8);

439 
sign = get_bits1(&s>gb_extra_bits); 
440 
}else{

441 
if(s>float_flag & WV_FLT_ZERO_SIGN)

442 
sign = get_bits1(&s>gb_extra_bits); 
443 
} 
444 
} 
445 
} 
446  
447 
*crc = *crc * 27 + S * 9 + exp * 3 + sign; 
448  
449 
value.u = (sign << 31)  (exp << 23)  S; 
450 
return value.f;

451 
} 
452  
453 
static void wv_reset_saved_context(WavpackContext *s) 
454 
{ 
455 
s>pos = 0;

456 
s>sc.crc = s>extra_sc.crc = 0xFFFFFFFF;

457 
} 
458  
459 
static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type) 
460 
{ 
461 
int i, j, count = 0; 
462 
int last, t;

463 
int A, B, L, L2, R, R2;

464 
int pos = s>pos;

465 
uint32_t crc = s>sc.crc; 
466 
uint32_t crc_extra_bits = s>extra_sc.crc; 
467 
int16_t *dst16 = dst; 
468 
int32_t *dst32 = dst; 
469 
float *dstfl = dst;

470  
471 
if(s>samples_left == s>samples)

472 
s>one = s>zero = s>zeroes = 0;

473 
do{

474 
L = wv_get_value(s, gb, 0, &last);

475 
if(last) break; 
476 
R = wv_get_value(s, gb, 1, &last);

477 
if(last) break; 
478 
for(i = 0; i < s>terms; i++){ 
479 
t = s>decorr[i].value; 
480 
if(t > 0){ 
481 
if(t > 8){ 
482 
if(t & 1){ 
483 
A = 2 * s>decorr[i].samplesA[0]  s>decorr[i].samplesA[1]; 
484 
B = 2 * s>decorr[i].samplesB[0]  s>decorr[i].samplesB[1]; 
485 
}else{

486 
A = (3 * s>decorr[i].samplesA[0]  s>decorr[i].samplesA[1]) >> 1; 
487 
B = (3 * s>decorr[i].samplesB[0]  s>decorr[i].samplesB[1]) >> 1; 
488 
} 
489 
s>decorr[i].samplesA[1] = s>decorr[i].samplesA[0]; 
490 
s>decorr[i].samplesB[1] = s>decorr[i].samplesB[0]; 
491 
j = 0;

492 
}else{

493 
A = s>decorr[i].samplesA[pos]; 
494 
B = s>decorr[i].samplesB[pos]; 
495 
j = (pos + t) & 7;

496 
} 
497 
if(type != SAMPLE_FMT_S16){

498 
L2 = L + ((s>decorr[i].weightA * (int64_t)A + 512) >> 10); 
499 
R2 = R + ((s>decorr[i].weightB * (int64_t)B + 512) >> 10); 
500 
}else{

501 
L2 = L + ((s>decorr[i].weightA * A + 512) >> 10); 
502 
R2 = R + ((s>decorr[i].weightB * B + 512) >> 10); 
503 
} 
504 
if(A && L) s>decorr[i].weightA = ((((L ^ A) >> 30) & 2)  1) * s>decorr[i].delta; 
505 
if(B && R) s>decorr[i].weightB = ((((R ^ B) >> 30) & 2)  1) * s>decorr[i].delta; 
506 
s>decorr[i].samplesA[j] = L = L2; 
507 
s>decorr[i].samplesB[j] = R = R2; 
508 
}else if(t == 1){ 
509 
if(type != SAMPLE_FMT_S16)

510 
L2 = L + ((s>decorr[i].weightA * (int64_t)s>decorr[i].samplesA[0] + 512) >> 10); 
511 
else

512 
L2 = L + ((s>decorr[i].weightA * s>decorr[i].samplesA[0] + 512) >> 10); 
513 
UPDATE_WEIGHT_CLIP(s>decorr[i].weightA, s>decorr[i].delta, s>decorr[i].samplesA[0], L);

514 
L = L2; 
515 
if(type != SAMPLE_FMT_S16)

516 
R2 = R + ((s>decorr[i].weightB * (int64_t)L2 + 512) >> 10); 
517 
else

518 
R2 = R + ((s>decorr[i].weightB * L2 + 512) >> 10); 
519 
UPDATE_WEIGHT_CLIP(s>decorr[i].weightB, s>decorr[i].delta, L2, R); 
520 
R = R2; 
521 
s>decorr[i].samplesA[0] = R;

522 
}else{

523 
if(type != SAMPLE_FMT_S16)

524 
R2 = R + ((s>decorr[i].weightB * (int64_t)s>decorr[i].samplesB[0] + 512) >> 10); 
525 
else

526 
R2 = R + ((s>decorr[i].weightB * s>decorr[i].samplesB[0] + 512) >> 10); 
527 
UPDATE_WEIGHT_CLIP(s>decorr[i].weightB, s>decorr[i].delta, s>decorr[i].samplesB[0], R);

528 
R = R2; 
529  
530 
if(t == 3){ 
531 
R2 = s>decorr[i].samplesA[0];

532 
s>decorr[i].samplesA[0] = R;

533 
} 
534  
535 
if(type != SAMPLE_FMT_S16)

536 
L2 = L + ((s>decorr[i].weightA * (int64_t)R2 + 512) >> 10); 
537 
else

538 
L2 = L + ((s>decorr[i].weightA * R2 + 512) >> 10); 
539 
UPDATE_WEIGHT_CLIP(s>decorr[i].weightA, s>decorr[i].delta, R2, L); 
540 
L = L2; 
541 
s>decorr[i].samplesB[0] = L;

542 
} 
543 
} 
544 
pos = (pos + 1) & 7; 
545 
if(s>joint)

546 
L += (R = (L >> 1));

547 
crc = (crc * 3 + L) * 3 + R; 
548  
549 
if(type == SAMPLE_FMT_FLT){

550 
*dstfl++ = wv_get_value_float(s, &crc_extra_bits, L); 
551 
*dstfl++ = wv_get_value_float(s, &crc_extra_bits, R); 
552 
} else if(type == SAMPLE_FMT_S32){ 
553 
*dst32++ = wv_get_value_integer(s, &crc_extra_bits, L); 
554 
*dst32++ = wv_get_value_integer(s, &crc_extra_bits, R); 
555 
} else {

556 
*dst16++ = wv_get_value_integer(s, &crc_extra_bits, L); 
557 
*dst16++ = wv_get_value_integer(s, &crc_extra_bits, R); 
558 
} 
559 
count++; 
560 
}while(!last && count < s>max_samples);

561  
562 
s>samples_left = count; 
563 
if(!s>samples_left){

564 
if(crc != s>CRC){

565 
av_log(s>avctx, AV_LOG_ERROR, "CRC error\n");

566 
return 1; 
567 
} 
568 
if(s>got_extra_bits && crc_extra_bits != s>crc_extra_bits){

569 
av_log(s>avctx, AV_LOG_ERROR, "Extra bits CRC error\n");

570 
return 1; 
571 
} 
572 
wv_reset_saved_context(s); 
573 
}else{

574 
s>pos = pos; 
575 
s>sc.crc = crc; 
576 
s>sc.bits_used = get_bits_count(&s>gb); 
577 
if(s>got_extra_bits){

578 
s>extra_sc.crc = crc_extra_bits; 
579 
s>extra_sc.bits_used = get_bits_count(&s>gb_extra_bits); 
580 
} 
581 
} 
582 
return count * 2; 
583 
} 
584  
585 
static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type) 
586 
{ 
587 
int i, j, count = 0; 
588 
int last, t;

589 
int A, S, T;

590 
int pos = s>pos;

591 
uint32_t crc = s>sc.crc; 
592 
uint32_t crc_extra_bits = s>extra_sc.crc; 
593 
int16_t *dst16 = dst; 
594 
int32_t *dst32 = dst; 
595 
float *dstfl = dst;

596  
597 
if(s>samples_left == s>samples)

598 
s>one = s>zero = s>zeroes = 0;

599 
do{

600 
T = wv_get_value(s, gb, 0, &last);

601 
S = 0;

602 
if(last) break; 
603 
for(i = 0; i < s>terms; i++){ 
604 
t = s>decorr[i].value; 
605 
if(t > 8){ 
606 
if(t & 1) 
607 
A = 2 * s>decorr[i].samplesA[0]  s>decorr[i].samplesA[1]; 
608 
else

609 
A = (3 * s>decorr[i].samplesA[0]  s>decorr[i].samplesA[1]) >> 1; 
610 
s>decorr[i].samplesA[1] = s>decorr[i].samplesA[0]; 
611 
j = 0;

612 
}else{

613 
A = s>decorr[i].samplesA[pos]; 
614 
j = (pos + t) & 7;

615 
} 
616 
if(type != SAMPLE_FMT_S16)

617 
S = T + ((s>decorr[i].weightA * (int64_t)A + 512) >> 10); 
618 
else

619 
S = T + ((s>decorr[i].weightA * A + 512) >> 10); 
620 
if(A && T) s>decorr[i].weightA = ((((T ^ A) >> 30) & 2)  1) * s>decorr[i].delta; 
621 
s>decorr[i].samplesA[j] = T = S; 
622 
} 
623 
pos = (pos + 1) & 7; 
624 
crc = crc * 3 + S;

625  
626 
if(type == SAMPLE_FMT_FLT)

627 
*dstfl++ = wv_get_value_float(s, &crc_extra_bits, S); 
628 
else if(type == SAMPLE_FMT_S32) 
629 
*dst32++ = wv_get_value_integer(s, &crc_extra_bits, S); 
630 
else

631 
*dst16++ = wv_get_value_integer(s, &crc_extra_bits, S); 
632 
count++; 
633 
}while(!last && count < s>samples);

634  
635 
s>samples_left = count; 
636 
if(!s>samples_left){

637 
if(crc != s>CRC){

638 
av_log(s>avctx, AV_LOG_ERROR, "CRC error\n");

639 
return 1; 
640 
} 
641 
if(s>got_extra_bits && crc_extra_bits != s>crc_extra_bits){

642 
av_log(s>avctx, AV_LOG_ERROR, "Extra bits CRC error\n");

643 
return 1; 
644 
} 
645 
wv_reset_saved_context(s); 
646 
}else{

647 
s>pos = pos; 
648 
s>sc.crc = crc; 
649 
s>sc.bits_used = get_bits_count(&s>gb); 
650 
if(s>got_extra_bits){

651 
s>extra_sc.crc = crc_extra_bits; 
652 
s>extra_sc.bits_used = get_bits_count(&s>gb_extra_bits); 
653 
} 
654 
} 
655 
return count;

656 
} 
657  
658 
static av_cold int wavpack_decode_init(AVCodecContext *avctx) 
659 
{ 
660 
WavpackContext *s = avctx>priv_data; 
661  
662 
s>avctx = avctx; 
663 
s>stereo = (avctx>channels == 2);

664 
if(avctx>bits_per_coded_sample <= 16) 
665 
avctx>sample_fmt = SAMPLE_FMT_S16; 
666 
else

667 
avctx>sample_fmt = SAMPLE_FMT_S32; 
668 
avctx>channel_layout = (avctx>channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;

669  
670 
wv_reset_saved_context(s); 
671  
672 
return 0; 
673 
} 
674  
675 
static int wavpack_decode_frame(AVCodecContext *avctx, 
676 
void *data, int *data_size, 
677 
AVPacket *avpkt) 
678 
{ 
679 
const uint8_t *buf = avpkt>data;

680 
int buf_size = avpkt>size;

681 
WavpackContext *s = avctx>priv_data; 
682 
void *samples = data;

683 
int samplecount;

684 
int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0; 
685 
int got_hybrid = 0; 
686 
const uint8_t* buf_end = buf + buf_size;

687 
int i, j, id, size, ssize, weights, t;

688 
int bpp;

689  
690 
if (buf_size == 0){ 
691 
*data_size = 0;

692 
return 0; 
693 
} 
694  
695 
if(!s>samples_left){

696 
memset(s>decorr, 0, MAX_TERMS * sizeof(Decorr)); 
697 
memset(s>ch, 0, sizeof(s>ch)); 
698 
s>extra_bits = 0;

699 
s>and = s>or = s>shift = 0;

700 
s>got_extra_bits = 0;

701 
} 
702  
703 
s>samples = AV_RL32(buf); buf += 4;

704 
if(!s>samples){

705 
*data_size = 0;

706 
return buf_size;

707 
} 
708 
s>frame_flags = AV_RL32(buf); buf += 4;

709 
if(s>frame_flags&0x80){ 
710 
bpp = sizeof(float); 
711 
avctx>sample_fmt = SAMPLE_FMT_FLT; 
712 
} else if((s>frame_flags&0x03) <= 1){ 
713 
bpp = 2;

714 
avctx>sample_fmt = SAMPLE_FMT_S16; 
715 
} else {

716 
bpp = 4;

717 
avctx>sample_fmt = SAMPLE_FMT_S32; 
718 
} 
719 
s>stereo_in = (s>frame_flags & WV_FALSE_STEREO) ? 0 : s>stereo;

720 
s>joint = s>frame_flags & WV_JOINT_STEREO; 
721 
s>hybrid = s>frame_flags & WV_HYBRID_MODE; 
722 
s>hybrid_bitrate = s>frame_flags & WV_HYBRID_BITRATE; 
723 
s>post_shift = 8 * (bpp1(s>frame_flags&0x03)) + ((s>frame_flags >> 13) & 0x1f); 
724 
s>CRC = AV_RL32(buf); buf += 4;

725  
726 
s>max_samples = *data_size / (bpp * avctx>channels); 
727 
s>max_samples = FFMIN(s>max_samples, s>samples); 
728 
if(s>samples_left > 0){ 
729 
s>max_samples = FFMIN(s>max_samples, s>samples_left); 
730 
buf = buf_end; 
731 
} 
732  
733 
// parse metadata blocks

734 
while(buf < buf_end){

735 
id = *buf++; 
736 
size = *buf++; 
737 
if(id & WP_IDF_LONG) {

738 
size = (*buf++) << 8;

739 
size = (*buf++) << 16;

740 
} 
741 
size <<= 1; // size is specified in words 
742 
ssize = size; 
743 
if(id & WP_IDF_ODD) size;

744 
if(size < 0){ 
745 
av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);

746 
break;

747 
} 
748 
if(buf + ssize > buf_end){

749 
av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);

750 
break;

751 
} 
752 
if(id & WP_IDF_IGNORE){

753 
buf += ssize; 
754 
continue;

755 
} 
756 
switch(id & WP_IDF_MASK){

757 
case WP_ID_DECTERMS:

758 
s>terms = size; 
759 
if(s>terms > MAX_TERMS){

760 
av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");

761 
buf += ssize; 
762 
continue;

763 
} 
764 
for(i = 0; i < s>terms; i++) { 
765 
s>decorr[s>terms  i  1].value = (*buf & 0x1F)  5; 
766 
s>decorr[s>terms  i  1].delta = *buf >> 5; 
767 
buf++; 
768 
} 
769 
got_terms = 1;

770 
break;

771 
case WP_ID_DECWEIGHTS:

772 
if(!got_terms){

773 
av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");

774 
continue;

775 
} 
776 
weights = size >> s>stereo_in; 
777 
if(weights > MAX_TERMS  weights > s>terms){

778 
av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");

779 
buf += ssize; 
780 
continue;

781 
} 
782 
for(i = 0; i < weights; i++) { 
783 
t = (int8_t)(*buf++); 
784 
s>decorr[s>terms  i  1].weightA = t << 3; 
785 
if(s>decorr[s>terms  i  1].weightA > 0) 
786 
s>decorr[s>terms  i  1].weightA += (s>decorr[s>terms  i  1].weightA + 64) >> 7; 
787 
if(s>stereo_in){

788 
t = (int8_t)(*buf++); 
789 
s>decorr[s>terms  i  1].weightB = t << 3; 
790 
if(s>decorr[s>terms  i  1].weightB > 0) 
791 
s>decorr[s>terms  i  1].weightB += (s>decorr[s>terms  i  1].weightB + 64) >> 7; 
792 
} 
793 
} 
794 
got_weights = 1;

795 
break;

796 
case WP_ID_DECSAMPLES:

797 
if(!got_terms){

798 
av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");

799 
continue;

800 
} 
801 
t = 0;

802 
for(i = s>terms  1; (i >= 0) && (t < size); i) { 
803 
if(s>decorr[i].value > 8){ 
804 
s>decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2; 
805 
s>decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2; 
806 
if(s>stereo_in){

807 
s>decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2; 
808 
s>decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2; 
809 
t += 4;

810 
} 
811 
t += 4;

812 
}else if(s>decorr[i].value < 0){ 
813 
s>decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2; 
814 
s>decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2; 
815 
t += 4;

816 
}else{

817 
for(j = 0; j < s>decorr[i].value; j++){ 
818 
s>decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;

819 
if(s>stereo_in){

820 
s>decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;

821 
} 
822 
} 
823 
t += s>decorr[i].value * 2 * (s>stereo_in + 1); 
824 
} 
825 
} 
826 
got_samples = 1;

827 
break;

828 
case WP_ID_ENTROPY:

829 
if(size != 6 * (s>stereo_in + 1)){ 
830 
av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s>stereo_in + 1), size); 
831 
buf += ssize; 
832 
continue;

833 
} 
834 
for(j = 0; j <= s>stereo_in; j++){ 
835 
for(i = 0; i < 3; i++){ 
836 
s>ch[j].median[i] = wp_exp2(AV_RL16(buf)); 
837 
buf += 2;

838 
} 
839 
} 
840 
got_entropy = 1;

841 
break;

842 
case WP_ID_HYBRID:

843 
if(s>hybrid_bitrate){

844 
for(i = 0; i <= s>stereo_in; i++){ 
845 
s>ch[i].slow_level = wp_exp2(AV_RL16(buf)); 
846 
buf += 2;

847 
size = 2;

848 
} 
849 
} 
850 
for(i = 0; i < (s>stereo_in + 1); i++){ 
851 
s>ch[i].bitrate_acc = AV_RL16(buf) << 16;

852 
buf += 2;

853 
size = 2;

854 
} 
855 
if(size > 0){ 
856 
for(i = 0; i < (s>stereo_in + 1); i++){ 
857 
s>ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf)); 
858 
buf += 2;

859 
} 
860 
}else{

861 
for(i = 0; i < (s>stereo_in + 1); i++) 
862 
s>ch[i].bitrate_delta = 0;

863 
} 
864 
got_hybrid = 1;

865 
break;

866 
case WP_ID_INT32INFO:

867 
if(size != 4){ 
868 
av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);

869 
buf += ssize; 
870 
continue;

871 
} 
872 
if(buf[0]) 
873 
s>extra_bits = buf[0];

874 
else if(buf[1]) 
875 
s>shift = buf[1];

876 
else if(buf[2]){ 
877 
s>and = s>or = 1;

878 
s>shift = buf[2];

879 
}else if(buf[3]){ 
880 
s>and = 1;

881 
s>shift = buf[3];

882 
} 
883 
buf += 4;

884 
break;

885 
case WP_ID_FLOATINFO:

886 
if(size != 4){ 
887 
av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);

888 
buf += ssize; 
889 
continue;

890 
} 
891 
s>float_flag = buf[0];

892 
s>float_shift = buf[1];

893 
s>float_max_exp = buf[2];

894 
buf += 4;

895 
got_float = 1;

896 
break;

897 
case WP_ID_DATA:

898 
s>sc.offset = buf  avpkt>data; 
899 
s>sc.size = size * 8;

900 
init_get_bits(&s>gb, buf, size * 8);

901 
s>data_size = size * 8;

902 
buf += size; 
903 
got_bs = 1;

904 
break;

905 
case WP_ID_EXTRABITS:

906 
if(size <= 4){ 
907 
av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);

908 
buf += size; 
909 
continue;

910 
} 
911 
s>extra_sc.offset = buf  avpkt>data; 
912 
s>extra_sc.size = size * 8;

913 
init_get_bits(&s>gb_extra_bits, buf, size * 8);

914 
s>crc_extra_bits = get_bits_long(&s>gb_extra_bits, 32);

915 
buf += size; 
916 
s>got_extra_bits = 1;

917 
break;

918 
default:

919 
buf += size; 
920 
} 
921 
if(id & WP_IDF_ODD) buf++;

922 
} 
923 
if(!s>samples_left){

924 
if(!got_terms){

925 
av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");

926 
return 1; 
927 
} 
928 
if(!got_weights){

929 
av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");

930 
return 1; 
931 
} 
932 
if(!got_samples){

933 
av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");

934 
return 1; 
935 
} 
936 
if(!got_entropy){

937 
av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");

938 
return 1; 
939 
} 
940 
if(s>hybrid && !got_hybrid){

941 
av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");

942 
return 1; 
943 
} 
944 
if(!got_bs){

945 
av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");

946 
return 1; 
947 
} 
948 
if(!got_float && avctx>sample_fmt == SAMPLE_FMT_FLT){

949 
av_log(avctx, AV_LOG_ERROR, "Float information not found\n");

950 
return 1; 
951 
} 
952 
if(s>got_extra_bits && avctx>sample_fmt != SAMPLE_FMT_FLT){

953 
const int size = get_bits_left(&s>gb_extra_bits); 
954 
const int wanted = s>samples * s>extra_bits << s>stereo_in; 
955 
if(size < wanted){

956 
av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");

957 
s>got_extra_bits = 0;

958 
} 
959 
} 
960 
s>samples_left = s>samples; 
961 
}else{

962 
init_get_bits(&s>gb, avpkt>data + s>sc.offset, s>sc.size); 
963 
skip_bits_long(&s>gb, s>sc.bits_used); 
964 
if(s>got_extra_bits){

965 
init_get_bits(&s>gb_extra_bits, avpkt>data + s>extra_sc.offset, 
966 
s>extra_sc.size); 
967 
skip_bits_long(&s>gb_extra_bits, s>extra_sc.bits_used); 
968 
} 
969 
} 
970  
971 
if(s>stereo_in){

972 
if(avctx>sample_fmt == SAMPLE_FMT_S16)

973 
samplecount = wv_unpack_stereo(s, &s>gb, samples, SAMPLE_FMT_S16); 
974 
else if(avctx>sample_fmt == SAMPLE_FMT_S32) 
975 
samplecount = wv_unpack_stereo(s, &s>gb, samples, SAMPLE_FMT_S32); 
976 
else

977 
samplecount = wv_unpack_stereo(s, &s>gb, samples, SAMPLE_FMT_FLT); 
978  
979 
}else{

980 
if(avctx>sample_fmt == SAMPLE_FMT_S16)

981 
samplecount = wv_unpack_mono(s, &s>gb, samples, SAMPLE_FMT_S16); 
982 
else if(avctx>sample_fmt == SAMPLE_FMT_S32) 
983 
samplecount = wv_unpack_mono(s, &s>gb, samples, SAMPLE_FMT_S32); 
984 
else

985 
samplecount = wv_unpack_mono(s, &s>gb, samples, SAMPLE_FMT_FLT); 
986  
987 
if(s>stereo && avctx>sample_fmt == SAMPLE_FMT_S16){

988 
int16_t *dst = (int16_t*)samples + samplecount * 2;

989 
int16_t *src = (int16_t*)samples + samplecount; 
990 
int cnt = samplecount;

991 
while(cnt){

992 
*dst = *src; 
993 
*dst = *src; 
994 
} 
995 
samplecount *= 2;

996 
}else if(s>stereo && avctx>sample_fmt == SAMPLE_FMT_S32){ 
997 
int32_t *dst = (int32_t*)samples + samplecount * 2;

998 
int32_t *src = (int32_t*)samples + samplecount; 
999 
int cnt = samplecount;

1000 
while(cnt){

1001 
*dst = *src; 
1002 
*dst = *src; 
1003 
} 
1004 
samplecount *= 2;

1005 
}else if(s>stereo){ 
1006 
float *dst = (float*)samples + samplecount * 2; 
1007 
float *src = (float*)samples + samplecount; 
1008 
int cnt = samplecount;

1009 
while(cnt){

1010 
*dst = *src; 
1011 
*dst = *src; 
1012 
} 
1013 
samplecount *= 2;

1014 
} 
1015 
} 
1016 
*data_size = samplecount * bpp; 
1017  
1018 
return s>samples_left > 0 ? 0 : buf_size; 
1019 
} 
1020  
1021 
AVCodec wavpack_decoder = { 
1022 
"wavpack",

1023 
AVMEDIA_TYPE_AUDIO, 
1024 
CODEC_ID_WAVPACK, 
1025 
sizeof(WavpackContext),

1026 
wavpack_decode_init, 
1027 
NULL,

1028 
NULL,

1029 
wavpack_decode_frame, 
1030 
.capabilities = CODEC_CAP_SUBFRAMES, 
1031 
.long_name = NULL_IF_CONFIG_SMALL("WavPack"),

1032 
}; 