ffmpeg / libavcodec / wavpack.c @ 9106a698
History  View  Annotate  Download (24.3 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 
enum WP_ID_Flags{

41 
WP_IDF_MASK = 0x1F,

42 
WP_IDF_IGNORE = 0x20,

43 
WP_IDF_ODD = 0x40,

44 
WP_IDF_LONG = 0x80

45 
}; 
46  
47 
enum WP_ID{

48 
WP_ID_DUMMY = 0,

49 
WP_ID_ENCINFO, 
50 
WP_ID_DECTERMS, 
51 
WP_ID_DECWEIGHTS, 
52 
WP_ID_DECSAMPLES, 
53 
WP_ID_ENTROPY, 
54 
WP_ID_HYBRID, 
55 
WP_ID_SHAPING, 
56 
WP_ID_FLOATINFO, 
57 
WP_ID_INT32INFO, 
58 
WP_ID_DATA, 
59 
WP_ID_CORR, 
60 
WP_ID_FLT, 
61 
WP_ID_CHANINFO 
62 
}; 
63  
64 
#define MAX_TERMS 16 
65  
66 
typedef struct Decorr { 
67 
int delta;

68 
int value;

69 
int weightA;

70 
int weightB;

71 
int samplesA[8]; 
72 
int samplesB[8]; 
73 
} Decorr; 
74  
75 
typedef struct WvChannel { 
76 
int median[3]; 
77 
int slow_level, error_limit;

78 
int bitrate_acc, bitrate_delta;

79 
} WvChannel; 
80  
81 
typedef struct WavpackContext { 
82 
AVCodecContext *avctx; 
83 
int frame_flags;

84 
int stereo, stereo_in;

85 
int joint;

86 
uint32_t CRC; 
87 
GetBitContext gb; 
88 
int data_size; // in bits 
89 
int samples;

90 
int terms;

91 
Decorr decorr[MAX_TERMS]; 
92 
int zero, one, zeroes;

93 
int and, or, shift;

94 
int hybrid, hybrid_bitrate;

95 
WvChannel ch[2];

96 
} WavpackContext; 
97  
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 
116 
}; 
117  
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 
135 
}; 
136  
137 
static av_always_inline int wp_exp2(int16_t val) 
138 
{ 
139 
int res, neg = 0; 
140  
141 
if(val < 0){ 
142 
val = val; 
143 
neg = 1;

144 
} 
145  
146 
res = wp_exp2_table[val & 0xFF]  0x100; 
147 
val >>= 8;

148 
res = (val > 9) ? (res << (val  9)) : (res >> (9  val)); 
149 
return neg ? res : res;

150 
} 
151  
152 
static av_always_inline int wp_log2(int32_t val) 
153 
{ 
154 
int bits;

155  
156 
if(!val)

157 
return 0; 
158 
if(val == 1) 
159 
return 256; 
160 
val += val >> 9;

161 
bits = av_log2(val) + 1;

162 
if(bits < 9) 
163 
return (bits << 8) + wp_log2_table[(val << (9  bits)) & 0xFF]; 
164 
else

165 
return (bits << 8) + wp_log2_table[(val >> (bits  9)) & 0xFF]; 
166 
} 
167  
168 
#define LEVEL_DECAY(a) ((a + 0x80) >> 8) 
169  
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 
174  
175 
// macros for applying weight

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

177 
if(samples && in){ \

178 
if((samples ^ in) < 0){ \ 
179 
weight = delta; \ 
180 
if(weight < 1024) weight = 1024; \ 
181 
}else{ \

182 
weight += delta; \ 
183 
if(weight > 1024) weight = 1024; \ 
184 
} \ 
185 
} 
186  
187  
188 
static av_always_inline int get_tail(GetBitContext *gb, int k) 
189 
{ 
190 
int p, e, res;

191  
192 
if(k<1)return 0; 
193 
p = av_log2(k); 
194 
e = (1 << (p + 1))  k  1; 
195 
res = p ? get_bits(gb, p) : 0;

196 
if(res >= e){

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

198 
} 
199 
return res;

200 
} 
201  
202 
static void update_error_limit(WavpackContext *ctx) 
203 
{ 
204 
int i, br[2], sl[2]; 
205  
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); 
210 
} 
211 
if(ctx>stereo_in && ctx>hybrid_bitrate){

212 
int balance = (sl[1]  sl[0] + br[1] + 1) >> 1; 
213 
if(balance > br[0]){ 
214 
br[1] = br[0] << 1; 
215 
br[0] = 0; 
216 
}else if(balance > br[0]){ 
217 
br[0] <<= 1; 
218 
br[1] = 0; 
219 
}else{

220 
br[1] = br[0] + balance; 
221 
br[0] = br[0]  balance; 
222 
} 
223 
} 
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);

228 
else

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

230 
}else{

231 
ctx>ch[i].error_limit = wp_exp2(br[i]); 
232 
} 
233 
} 
234 
} 
235  
236 
static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last) 
237 
{ 
238 
int t, t2;

239 
int sign, base, add, ret;

240 
WvChannel *c = &ctx>ch[channel]; 
241  
242 
*last = 0;

243  
244 
if((ctx>ch[0].median[0] < 2U) && (ctx>ch[1].median[0] < 2U) && !ctx>zero && !ctx>one){ 
245 
if(ctx>zeroes){

246 
ctx>zeroes; 
247 
if(ctx>zeroes){

248 
c>slow_level = LEVEL_DECAY(c>slow_level); 
249 
return 0; 
250 
} 
251 
}else{

252 
t = get_unary_0_33(gb); 
253 
if(t >= 2) t = get_bits(gb, t  1)  (1 << (t1)); 
254 
ctx>zeroes = t; 
255 
if(ctx>zeroes){

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); 
259 
return 0; 
260 
} 
261 
} 
262 
} 
263  
264 
if(get_bits_count(gb) >= ctx>data_size){

265 
*last = 1;

266 
return 0; 
267 
} 
268  
269 
if(ctx>zero){

270 
t = 0;

271 
ctx>zero = 0;

272 
}else{

273 
t = get_unary_0_33(gb); 
274 
if(get_bits_count(gb) >= ctx>data_size){

275 
*last = 1;

276 
return 0; 
277 
} 
278 
if(t == 16) { 
279 
t2 = get_unary_0_33(gb); 
280 
if(t2 < 2) t += t2; 
281 
else t += get_bits(gb, t2  1)  (1 << (t2  1)); 
282 
} 
283  
284 
if(ctx>one){

285 
ctx>one = t&1;

286 
t = (t>>1) + 1; 
287 
}else{

288 
ctx>one = t&1;

289 
t >>= 1;

290 
} 
291 
ctx>zero = !ctx>one; 
292 
} 
293  
294 
if(ctx>hybrid && !channel)

295 
update_error_limit(ctx); 
296  
297 
if(!t){

298 
base = 0;

299 
add = GET_MED(0)  1; 
300 
DEC_MED(0);

301 
}else if(t == 1){ 
302 
base = GET_MED(0);

303 
add = GET_MED(1)  1; 
304 
INC_MED(0);

305 
DEC_MED(1);

306 
}else if(t == 2){ 
307 
base = GET_MED(0) + GET_MED(1); 
308 
add = GET_MED(2)  1; 
309 
INC_MED(0);

310 
INC_MED(1);

311 
DEC_MED(2);

312 
}else{

313 
base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t  2); 
314 
add = GET_MED(2)  1; 
315 
INC_MED(0);

316 
INC_MED(1);

317 
INC_MED(2);

318 
} 
319 
if(!c>error_limit){

320 
ret = base + get_tail(gb, add); 
321 
}else{

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

324 
if(get_bits1(gb)){

325 
add = (mid  base); 
326 
base = mid; 
327 
}else

328 
add = mid  base  1;

329 
mid = (base*2 + add + 1) >> 1; 
330 
} 
331 
ret = mid; 
332 
} 
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;

337 
} 
338  
339 
static int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, int16_t *dst) 
340 
{ 
341 
int i, j, count = 0; 
342 
int last, t;

343 
int A, B, L, L2, R, R2, bit;

344 
int pos = 0; 
345 
uint32_t crc = 0xFFFFFFFF;

346  
347 
s>one = s>zero = s>zeroes = 0;

348 
do{

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

350 
if(last) break; 
351 
R = wv_get_value(s, gb, 1, &last);

352 
if(last) break; 
353 
for(i = 0; i < s>terms; i++){ 
354 
t = s>decorr[i].value; 
355 
j = 0;

356 
if(t > 0){ 
357 
if(t > 8){ 
358 
if(t & 1){ 
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]; 
361 
}else{

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; 
364 
} 
365 
s>decorr[i].samplesA[1] = s>decorr[i].samplesA[0]; 
366 
s>decorr[i].samplesB[1] = s>decorr[i].samplesB[0]; 
367 
j = 0;

368 
}else{

369 
A = s>decorr[i].samplesA[pos]; 
370 
B = s>decorr[i].samplesB[pos]; 
371 
j = (pos + t) & 7;

372 
} 
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; 
379 
}else if(t == 1){ 
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);

382 
L = L2; 
383 
R2 = R + ((s>decorr[i].weightB * L2 + 512) >> 10); 
384 
UPDATE_WEIGHT_CLIP(s>decorr[i].weightB, s>decorr[i].delta, L2, R); 
385 
R = R2; 
386 
s>decorr[i].samplesA[0] = R;

387 
}else{

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);

390 
R = R2; 
391  
392 
if(t == 3){ 
393 
R2 = s>decorr[i].samplesA[0];

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

395 
} 
396  
397 
L2 = L + ((s>decorr[i].weightA * R2 + 512) >> 10); 
398 
UPDATE_WEIGHT_CLIP(s>decorr[i].weightA, s>decorr[i].delta, R2, L); 
399 
L = L2; 
400 
s>decorr[i].samplesB[0] = L;

401 
} 
402 
} 
403 
pos = (pos + 1) & 7; 
404 
if(s>joint)

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; 
411 
count++; 
412 
}while(!last && count < s>samples);

413  
414 
if(crc != s>CRC){

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

416 
return 1; 
417 
} 
418 
return count * 2; 
419 
} 
420  
421 
static int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, int16_t *dst) 
422 
{ 
423 
int i, j, count = 0; 
424 
int last, t;

425 
int A, S, T, bit;

426 
int pos = 0; 
427 
uint32_t crc = 0xFFFFFFFF;

428  
429 
s>one = s>zero = s>zeroes = 0;

430 
do{

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

432 
S = 0;

433 
if(last) break; 
434 
for(i = 0; i < s>terms; i++){ 
435 
t = s>decorr[i].value; 
436 
if(t > 8){ 
437 
if(t & 1) 
438 
A = 2 * s>decorr[i].samplesA[0]  s>decorr[i].samplesA[1]; 
439 
else

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]; 
442 
j = 0;

443 
}else{

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

446 
} 
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; 
450 
} 
451 
pos = (pos + 1) & 7; 
452 
crc = crc * 3 + S;

453 
bit = (S & s>and)  s>or; 
454 
*dst++ = ((S + bit) << s>shift)  bit; 
455 
count++; 
456 
}while(!last && count < s>samples);

457  
458 
if(crc != s>CRC){

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

460 
return 1; 
461 
} 
462 
return count;

463 
} 
464  
465 
static av_cold int wavpack_decode_init(AVCodecContext *avctx) 
466 
{ 
467 
WavpackContext *s = avctx>priv_data; 
468  
469 
s>avctx = avctx; 
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;

473  
474 
return 0; 
475 
} 
476  
477 
static int wavpack_decode_frame(AVCodecContext *avctx, 
478 
void *data, int *data_size, 
479 
AVPacket *avpkt) 
480 
{ 
481 
const uint8_t *buf = avpkt>data;

482 
int buf_size = avpkt>size;

483 
WavpackContext *s = avctx>priv_data; 
484 
int16_t *samples = data; 
485 
int samplecount;

486 
int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0; 
487 
int got_hybrid = 0; 
488 
const uint8_t* buf_end = buf + buf_size;

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

490  
491 
if (buf_size == 0){ 
492 
*data_size = 0;

493 
return 0; 
494 
} 
495  
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;

499  
500 
s>samples = AV_RL32(buf); buf += 4;

501 
if(!s>samples){

502 
*data_size = 0;

503 
return buf_size;

504 
} 
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");

508 
return 1; 
509 
} 
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){

518 
id = *buf++; 
519 
size = *buf++; 
520 
if(id & WP_IDF_LONG) {

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

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

523 
} 
524 
size <<= 1; // size is specified in words 
525 
ssize = size; 
526 
if(id & WP_IDF_ODD) size;

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

529 
break;

530 
} 
531 
if(buf + ssize > buf_end){

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

533 
break;

534 
} 
535 
if(id & WP_IDF_IGNORE){

536 
buf += ssize; 
537 
continue;

538 
} 
539 
switch(id & WP_IDF_MASK){

540 
case WP_ID_DECTERMS:

541 
s>terms = size; 
542 
if(s>terms > MAX_TERMS){

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

544 
buf += ssize; 
545 
continue;

546 
} 
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; 
550 
buf++; 
551 
} 
552 
got_terms = 1;

553 
break;

554 
case WP_ID_DECWEIGHTS:

555 
if(!got_terms){

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

557 
continue;

558 
} 
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");

562 
buf += ssize; 
563 
continue;

564 
} 
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; 
570 
if(s>stereo_in){

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; 
575 
} 
576 
} 
577 
got_weights = 1;

578 
break;

579 
case WP_ID_DECSAMPLES:

580 
if(!got_terms){

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

582 
continue;

583 
} 
584 
t = 0;

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; 
589 
if(s>stereo_in){

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; 
592 
t += 4;

593 
} 
594 
t += 4;

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; 
598 
t += 4;

599 
}else{

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

602 
if(s>stereo_in){

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

604 
} 
605 
} 
606 
t += s>decorr[i].value * 2 * (s>stereo_in + 1); 
607 
} 
608 
} 
609 
got_samples = 1;

610 
break;

611 
case WP_ID_ENTROPY:

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); 
614 
buf += ssize; 
615 
continue;

616 
} 
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)); 
620 
buf += 2;

621 
} 
622 
} 
623 
got_entropy = 1;

624 
break;

625 
case WP_ID_HYBRID:

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)); 
629 
buf += 2;

630 
size = 2;

631 
} 
632 
} 
633 
for(i = 0; i < (s>stereo_in + 1); i++){ 
634 
s>ch[i].bitrate_acc = AV_RL16(buf) << 16;

635 
buf += 2;

636 
size = 2;

637 
} 
638 
if(size > 0){ 
639 
for(i = 0; i < (s>stereo_in + 1); i++){ 
640 
s>ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf)); 
641 
buf += 2;

642 
} 
643 
}else{

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

646 
} 
647 
got_hybrid = 1;

648 
break;

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);

652 
buf += ssize; 
653 
continue;

654 
} 
655 
if(buf[1]) 
656 
s>shift = buf[1];

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

659 
s>shift = buf[2];

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

662 
s>shift = buf[3];

663 
} 
664 
buf += 4;

665 
break;

666 
case WP_ID_DATA:

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

668 
s>data_size = size * 8;

669 
buf += size; 
670 
got_bs = 1;

671 
break;

672 
default:

673 
buf += size; 
674 
} 
675 
if(id & WP_IDF_ODD) buf++;

676 
} 
677 
if(!got_terms){

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

679 
return 1; 
680 
} 
681 
if(!got_weights){

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

683 
return 1; 
684 
} 
685 
if(!got_samples){

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

687 
return 1; 
688 
} 
689 
if(!got_entropy){

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

691 
return 1; 
692 
} 
693 
if(s>hybrid && !got_hybrid){

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

695 
return 1; 
696 
} 
697 
if(!got_bs){

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

699 
return 1; 
700 
} 
701  
702 
if(s>stereo_in)

703 
samplecount = wv_unpack_stereo(s, &s>gb, samples); 
704 
else{

705 
samplecount = wv_unpack_mono(s, &s>gb, samples); 
706 
if(s>stereo){

707 
int16_t *dst = samples + samplecount * 2;

708 
int16_t *src = samples + samplecount; 
709 
int cnt = samplecount;

710 
while(cnt){

711 
*dst = *src; 
712 
*dst = *src; 
713 
} 
714 
samplecount *= 2;

715 
} 
716 
} 
717 
*data_size = samplecount * 2;

718  
719 
return buf_size;

720 
} 
721  
722 
AVCodec wavpack_decoder = { 
723 
"wavpack",

724 
CODEC_TYPE_AUDIO, 
725 
CODEC_ID_WAVPACK, 
726 
sizeof(WavpackContext),

727 
wavpack_decode_init, 
728 
NULL,

729 
NULL,

730 
wavpack_decode_frame, 
731 
.long_name = NULL_IF_CONFIG_SMALL("WavPack"),

732 
}; 