ffmpeg / libavcodec / wavpack.c @ 2912e87a
History  View  Annotate  Download (39.6 KB)
1 
/*


2 
* WavPack lossless audio decoder

3 
* Copyright (c) 2006,2011 Konstantin Shishkov

4 
*

5 
* This file is part of Libav.

6 
*

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.

11 
*

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.

16 
*

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

20 
*/

21 
#define ALT_BITSTREAM_READER_LE

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

28 
* @file

29 
* WavPack lossless audio decoder

30 
*/

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

48 
WP_IDF_MASK = 0x1F,

49 
WP_IDF_IGNORE = 0x20,

50 
WP_IDF_ODD = 0x40,

51 
WP_IDF_LONG = 0x80

52 
}; 
53  
54 
enum WP_ID{

55 
WP_ID_DUMMY = 0,

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

73 
int size;

74 
int bits_used;

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

82 
int value;

83 
int weightA;

84 
int weightB;

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

92 
int bitrate_acc, bitrate_delta;

93 
} WvChannel; 
94  
95 
typedef struct WavpackFrameContext { 
96 
AVCodecContext *avctx; 
97 
int frame_flags;

98 
int stereo, stereo_in;

99 
int joint;

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

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

107 
int terms;

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

110 
int extra_bits;

111 
int and, or, shift;

112 
int post_shift;

113 
int hybrid, hybrid_bitrate;

114 
int float_flag;

115 
int float_shift;

116 
int float_max_exp;

117 
WvChannel ch[2];

118 
int samples_left;

119 
int max_samples;

120 
int pos;

121 
SavedContext sc, extra_sc; 
122 
} WavpackFrameContext; 
123  
124 
#define WV_MAX_FRAME_DECODERS 14 
125  
126 
typedef struct WavpackContext { 
127 
AVCodecContext *avctx; 
128  
129 
WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS]; 
130 
int fdec_num;

131  
132 
int multichannel;

133 
int mkv_mode;

134 
int block;

135 
int samples;

136 
int samples_left;

137 
int ch_offset;

138 
} WavpackContext; 
139  
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 
158 
}; 
159  
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 
177 
}; 
178  
179 
static av_always_inline int wp_exp2(int16_t val) 
180 
{ 
181 
int res, neg = 0; 
182  
183 
if(val < 0){ 
184 
val = val; 
185 
neg = 1;

186 
} 
187  
188 
res = wp_exp2_table[val & 0xFF]  0x100; 
189 
val >>= 8;

190 
res = (val > 9) ? (res << (val  9)) : (res >> (9  val)); 
191 
return neg ? res : res;

192 
} 
193  
194 
static av_always_inline int wp_log2(int32_t val) 
195 
{ 
196 
int bits;

197  
198 
if(!val)

199 
return 0; 
200 
if(val == 1) 
201 
return 256; 
202 
val += val >> 9;

203 
bits = av_log2(val) + 1;

204 
if(bits < 9) 
205 
return (bits << 8) + wp_log2_table[(val << (9  bits)) & 0xFF]; 
206 
else

207 
return (bits << 8) + wp_log2_table[(val >> (bits  9)) & 0xFF]; 
208 
} 
209  
210 
#define LEVEL_DECAY(a) ((a + 0x80) >> 8) 
211  
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 
216  
217 
// macros for applying weight

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

219 
if(samples && in){ \

220 
if((samples ^ in) < 0){ \ 
221 
weight = delta; \ 
222 
if(weight < 1024) weight = 1024; \ 
223 
}else{ \

224 
weight += delta; \ 
225 
if(weight > 1024) weight = 1024; \ 
226 
} \ 
227 
} 
228  
229  
230 
static av_always_inline int get_tail(GetBitContext *gb, int k) 
231 
{ 
232 
int p, e, res;

233  
234 
if(k<1)return 0; 
235 
p = av_log2(k); 
236 
e = (1 << (p + 1))  k  1; 
237 
res = p ? get_bits(gb, p) : 0;

238 
if(res >= e){

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

240 
} 
241 
return res;

242 
} 
243  
244 
static void update_error_limit(WavpackFrameContext *ctx) 
245 
{ 
246 
int i, br[2], sl[2]; 
247  
248 
for(i = 0; i <= ctx>stereo_in; i++){ 
249 
ctx>ch[i].bitrate_acc += ctx>ch[i].bitrate_delta; 
250 
br[i] = ctx>ch[i].bitrate_acc >> 16;

251 
sl[i] = LEVEL_DECAY(ctx>ch[i].slow_level); 
252 
} 
253 
if(ctx>stereo_in && ctx>hybrid_bitrate){

254 
int balance = (sl[1]  sl[0] + br[1] + 1) >> 1; 
255 
if(balance > br[0]){ 
256 
br[1] = br[0] << 1; 
257 
br[0] = 0; 
258 
}else if(balance > br[0]){ 
259 
br[0] <<= 1; 
260 
br[1] = 0; 
261 
}else{

262 
br[1] = br[0] + balance; 
263 
br[0] = br[0]  balance; 
264 
} 
265 
} 
266 
for(i = 0; i <= ctx>stereo_in; i++){ 
267 
if(ctx>hybrid_bitrate){

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

270 
else

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

272 
}else{

273 
ctx>ch[i].error_limit = wp_exp2(br[i]); 
274 
} 
275 
} 
276 
} 
277  
278 
static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, int channel, int *last) 
279 
{ 
280 
int t, t2;

281 
int sign, base, add, ret;

282 
WvChannel *c = &ctx>ch[channel]; 
283  
284 
*last = 0;

285  
286 
if((ctx>ch[0].median[0] < 2U) && (ctx>ch[1].median[0] < 2U) && !ctx>zero && !ctx>one){ 
287 
if(ctx>zeroes){

288 
ctx>zeroes; 
289 
if(ctx>zeroes){

290 
c>slow_level = LEVEL_DECAY(c>slow_level); 
291 
return 0; 
292 
} 
293 
}else{

294 
t = get_unary_0_33(gb); 
295 
if(t >= 2) t = get_bits(gb, t  1)  (1 << (t1)); 
296 
ctx>zeroes = t; 
297 
if(ctx>zeroes){

298 
memset(ctx>ch[0].median, 0, sizeof(ctx>ch[0].median)); 
299 
memset(ctx>ch[1].median, 0, sizeof(ctx>ch[1].median)); 
300 
c>slow_level = LEVEL_DECAY(c>slow_level); 
301 
return 0; 
302 
} 
303 
} 
304 
} 
305  
306 
if(get_bits_count(gb) >= ctx>data_size){

307 
*last = 1;

308 
return 0; 
309 
} 
310  
311 
if(ctx>zero){

312 
t = 0;

313 
ctx>zero = 0;

314 
}else{

315 
t = get_unary_0_33(gb); 
316 
if(get_bits_count(gb) >= ctx>data_size){

317 
*last = 1;

318 
return 0; 
319 
} 
320 
if(t == 16) { 
321 
t2 = get_unary_0_33(gb); 
322 
if(t2 < 2) t += t2; 
323 
else t += get_bits(gb, t2  1)  (1 << (t2  1)); 
324 
} 
325  
326 
if(ctx>one){

327 
ctx>one = t&1;

328 
t = (t>>1) + 1; 
329 
}else{

330 
ctx>one = t&1;

331 
t >>= 1;

332 
} 
333 
ctx>zero = !ctx>one; 
334 
} 
335  
336 
if(ctx>hybrid && !channel)

337 
update_error_limit(ctx); 
338  
339 
if(!t){

340 
base = 0;

341 
add = GET_MED(0)  1; 
342 
DEC_MED(0);

343 
}else if(t == 1){ 
344 
base = GET_MED(0);

345 
add = GET_MED(1)  1; 
346 
INC_MED(0);

347 
DEC_MED(1);

348 
}else if(t == 2){ 
349 
base = GET_MED(0) + GET_MED(1); 
350 
add = GET_MED(2)  1; 
351 
INC_MED(0);

352 
INC_MED(1);

353 
DEC_MED(2);

354 
}else{

355 
base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t  2); 
356 
add = GET_MED(2)  1; 
357 
INC_MED(0);

358 
INC_MED(1);

359 
INC_MED(2);

360 
} 
361 
if(!c>error_limit){

362 
ret = base + get_tail(gb, add); 
363 
}else{

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

366 
if(get_bits1(gb)){

367 
add = (mid  base); 
368 
base = mid; 
369 
}else

370 
add = mid  base  1;

371 
mid = (base*2 + add + 1) >> 1; 
372 
} 
373 
ret = mid; 
374 
} 
375 
sign = get_bits1(gb); 
376 
if(ctx>hybrid_bitrate)

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

379 
} 
380  
381 
static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S) 
382 
{ 
383 
int bit;

384  
385 
if(s>extra_bits){

386 
S <<= s>extra_bits; 
387  
388 
if(s>got_extra_bits){

389 
S = get_bits(&s>gb_extra_bits, s>extra_bits); 
390 
*crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16); 
391 
} 
392 
} 
393 
bit = (S & s>and)  s>or; 
394 
return (((S + bit) << s>shift)  bit) << s>post_shift;

395 
} 
396  
397 
static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S) 
398 
{ 
399 
union {

400 
float f;

401 
uint32_t u; 
402 
} value; 
403  
404 
int sign;

405 
int exp = s>float_max_exp;

406  
407 
if(s>got_extra_bits){

408 
const int max_bits = 1 + 23 + 8 + 1; 
409 
const int left_bits = get_bits_left(&s>gb_extra_bits); 
410  
411 
if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits) 
412 
return 0.0; 
413 
} 
414  
415 
if(S){

416 
S <<= s>float_shift; 
417 
sign = S < 0;

418 
if(sign)

419 
S = S; 
420 
if(S >= 0x1000000){ 
421 
if(s>got_extra_bits && get_bits1(&s>gb_extra_bits)){

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

423 
}else{

424 
S = 0;

425 
} 
426 
exp = 255;

427 
}else if(exp){ 
428 
int shift = 23  av_log2(S); 
429 
exp = s>float_max_exp; 
430 
if(exp <= shift){

431 
shift = exp; 
432 
} 
433 
exp = shift; 
434  
435 
if(shift){

436 
S <<= shift; 
437 
if((s>float_flag & WV_FLT_SHIFT_ONES) 

438 
(s>got_extra_bits && (s>float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s>gb_extra_bits)) ){ 
439 
S = (1 << shift)  1; 
440 
} else if(s>got_extra_bits && (s>float_flag & WV_FLT_SHIFT_SENT)){ 
441 
S = get_bits(&s>gb_extra_bits, shift); 
442 
} 
443 
} 
444 
}else{

445 
exp = s>float_max_exp; 
446 
} 
447 
S &= 0x7fffff;

448 
}else{

449 
sign = 0;

450 
exp = 0;

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

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

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

454 
if(s>float_max_exp >= 25) 
455 
exp = get_bits(&s>gb_extra_bits, 8);

456 
sign = get_bits1(&s>gb_extra_bits); 
457 
}else{

458 
if(s>float_flag & WV_FLT_ZERO_SIGN)

459 
sign = get_bits1(&s>gb_extra_bits); 
460 
} 
461 
} 
462 
} 
463  
464 
*crc = *crc * 27 + S * 9 + exp * 3 + sign; 
465  
466 
value.u = (sign << 31)  (exp << 23)  S; 
467 
return value.f;

468 
} 
469  
470 
static void wv_reset_saved_context(WavpackFrameContext *s) 
471 
{ 
472 
s>pos = 0;

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

474 
} 
475  
476 
static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type) 
477 
{ 
478 
int i, j, count = 0; 
479 
int last, t;

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

481 
int pos = s>pos;

482 
uint32_t crc = s>sc.crc; 
483 
uint32_t crc_extra_bits = s>extra_sc.crc; 
484 
int16_t *dst16 = dst; 
485 
int32_t *dst32 = dst; 
486 
float *dstfl = dst;

487 
const int channel_pad = s>avctx>channels  2; 
488  
489 
if(s>samples_left == s>samples)

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

491 
do{

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

493 
if(last) break; 
494 
R = wv_get_value(s, gb, 1, &last);

495 
if(last) break; 
496 
for(i = 0; i < s>terms; i++){ 
497 
t = s>decorr[i].value; 
498 
if(t > 0){ 
499 
if(t > 8){ 
500 
if(t & 1){ 
501 
A = 2 * s>decorr[i].samplesA[0]  s>decorr[i].samplesA[1]; 
502 
B = 2 * s>decorr[i].samplesB[0]  s>decorr[i].samplesB[1]; 
503 
}else{

504 
A = (3 * s>decorr[i].samplesA[0]  s>decorr[i].samplesA[1]) >> 1; 
505 
B = (3 * s>decorr[i].samplesB[0]  s>decorr[i].samplesB[1]) >> 1; 
506 
} 
507 
s>decorr[i].samplesA[1] = s>decorr[i].samplesA[0]; 
508 
s>decorr[i].samplesB[1] = s>decorr[i].samplesB[0]; 
509 
j = 0;

510 
}else{

511 
A = s>decorr[i].samplesA[pos]; 
512 
B = s>decorr[i].samplesB[pos]; 
513 
j = (pos + t) & 7;

514 
} 
515 
if(type != AV_SAMPLE_FMT_S16){

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

519 
L2 = L + ((s>decorr[i].weightA * A + 512) >> 10); 
520 
R2 = R + ((s>decorr[i].weightB * B + 512) >> 10); 
521 
} 
522 
if(A && L) s>decorr[i].weightA = ((((L ^ A) >> 30) & 2)  1) * s>decorr[i].delta; 
523 
if(B && R) s>decorr[i].weightB = ((((R ^ B) >> 30) & 2)  1) * s>decorr[i].delta; 
524 
s>decorr[i].samplesA[j] = L = L2; 
525 
s>decorr[i].samplesB[j] = R = R2; 
526 
}else if(t == 1){ 
527 
if(type != AV_SAMPLE_FMT_S16)

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

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

532 
L = L2; 
533 
if(type != AV_SAMPLE_FMT_S16)

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

536 
R2 = R + ((s>decorr[i].weightB * L2 + 512) >> 10); 
537 
UPDATE_WEIGHT_CLIP(s>decorr[i].weightB, s>decorr[i].delta, L2, R); 
538 
R = R2; 
539 
s>decorr[i].samplesA[0] = R;

540 
}else{

541 
if(type != AV_SAMPLE_FMT_S16)

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

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

546 
R = R2; 
547  
548 
if(t == 3){ 
549 
R2 = s>decorr[i].samplesA[0];

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

551 
} 
552  
553 
if(type != AV_SAMPLE_FMT_S16)

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

556 
L2 = L + ((s>decorr[i].weightA * R2 + 512) >> 10); 
557 
UPDATE_WEIGHT_CLIP(s>decorr[i].weightA, s>decorr[i].delta, R2, L); 
558 
L = L2; 
559 
s>decorr[i].samplesB[0] = L;

560 
} 
561 
} 
562 
pos = (pos + 1) & 7; 
563 
if(s>joint)

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

565 
crc = (crc * 3 + L) * 3 + R; 
566  
567 
if(type == AV_SAMPLE_FMT_FLT){

568 
*dstfl++ = wv_get_value_float(s, &crc_extra_bits, L); 
569 
*dstfl++ = wv_get_value_float(s, &crc_extra_bits, R); 
570 
dstfl += channel_pad; 
571 
} else if(type == AV_SAMPLE_FMT_S32){ 
572 
*dst32++ = wv_get_value_integer(s, &crc_extra_bits, L); 
573 
*dst32++ = wv_get_value_integer(s, &crc_extra_bits, R); 
574 
dst32 += channel_pad; 
575 
} else {

576 
*dst16++ = wv_get_value_integer(s, &crc_extra_bits, L); 
577 
*dst16++ = wv_get_value_integer(s, &crc_extra_bits, R); 
578 
dst16 += channel_pad; 
579 
} 
580 
count++; 
581 
}while(!last && count < s>max_samples);

582  
583 
s>samples_left = count; 
584 
if(!s>samples_left){

585 
if(crc != s>CRC){

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

587 
return 1; 
588 
} 
589 
if(s>got_extra_bits && crc_extra_bits != s>crc_extra_bits){

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

591 
return 1; 
592 
} 
593 
wv_reset_saved_context(s); 
594 
}else{

595 
s>pos = pos; 
596 
s>sc.crc = crc; 
597 
s>sc.bits_used = get_bits_count(&s>gb); 
598 
if(s>got_extra_bits){

599 
s>extra_sc.crc = crc_extra_bits; 
600 
s>extra_sc.bits_used = get_bits_count(&s>gb_extra_bits); 
601 
} 
602 
} 
603 
return count * 2; 
604 
} 
605  
606 
static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type) 
607 
{ 
608 
int i, j, count = 0; 
609 
int last, t;

610 
int A, S, T;

611 
int pos = s>pos;

612 
uint32_t crc = s>sc.crc; 
613 
uint32_t crc_extra_bits = s>extra_sc.crc; 
614 
int16_t *dst16 = dst; 
615 
int32_t *dst32 = dst; 
616 
float *dstfl = dst;

617 
const int channel_stride = s>avctx>channels; 
618  
619 
if(s>samples_left == s>samples)

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

621 
do{

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

623 
S = 0;

624 
if(last) break; 
625 
for(i = 0; i < s>terms; i++){ 
626 
t = s>decorr[i].value; 
627 
if(t > 8){ 
628 
if(t & 1) 
629 
A = 2 * s>decorr[i].samplesA[0]  s>decorr[i].samplesA[1]; 
630 
else

631 
A = (3 * s>decorr[i].samplesA[0]  s>decorr[i].samplesA[1]) >> 1; 
632 
s>decorr[i].samplesA[1] = s>decorr[i].samplesA[0]; 
633 
j = 0;

634 
}else{

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

637 
} 
638 
if(type != AV_SAMPLE_FMT_S16)

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

641 
S = T + ((s>decorr[i].weightA * A + 512) >> 10); 
642 
if(A && T) s>decorr[i].weightA = ((((T ^ A) >> 30) & 2)  1) * s>decorr[i].delta; 
643 
s>decorr[i].samplesA[j] = T = S; 
644 
} 
645 
pos = (pos + 1) & 7; 
646 
crc = crc * 3 + S;

647  
648 
if(type == AV_SAMPLE_FMT_FLT){

649 
*dstfl = wv_get_value_float(s, &crc_extra_bits, S); 
650 
dstfl += channel_stride; 
651 
}else if(type == AV_SAMPLE_FMT_S32){ 
652 
*dst32 = wv_get_value_integer(s, &crc_extra_bits, S); 
653 
dst32 += channel_stride; 
654 
}else{

655 
*dst16 = wv_get_value_integer(s, &crc_extra_bits, S); 
656 
dst16 += channel_stride; 
657 
} 
658 
count++; 
659 
}while(!last && count < s>max_samples);

660  
661 
s>samples_left = count; 
662 
if(!s>samples_left){

663 
if(crc != s>CRC){

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

665 
return 1; 
666 
} 
667 
if(s>got_extra_bits && crc_extra_bits != s>crc_extra_bits){

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

669 
return 1; 
670 
} 
671 
wv_reset_saved_context(s); 
672 
}else{

673 
s>pos = pos; 
674 
s>sc.crc = crc; 
675 
s>sc.bits_used = get_bits_count(&s>gb); 
676 
if(s>got_extra_bits){

677 
s>extra_sc.crc = crc_extra_bits; 
678 
s>extra_sc.bits_used = get_bits_count(&s>gb_extra_bits); 
679 
} 
680 
} 
681 
return count;

682 
} 
683  
684 
static av_cold int wv_alloc_frame_context(WavpackContext *c) 
685 
{ 
686  
687 
if(c>fdec_num == WV_MAX_FRAME_DECODERS)

688 
return 1; 
689  
690 
c>fdec[c>fdec_num] = av_mallocz(sizeof(**c>fdec));

691 
if(!c>fdec[c>fdec_num])

692 
return 1; 
693 
c>fdec_num++; 
694 
c>fdec[c>fdec_num  1]>avctx = c>avctx;

695 
wv_reset_saved_context(c>fdec[c>fdec_num  1]);

696  
697 
return 0; 
698 
} 
699  
700 
static av_cold int wavpack_decode_init(AVCodecContext *avctx) 
701 
{ 
702 
WavpackContext *s = avctx>priv_data; 
703  
704 
s>avctx = avctx; 
705 
if(avctx>bits_per_coded_sample <= 16) 
706 
avctx>sample_fmt = AV_SAMPLE_FMT_S16; 
707 
else

708 
avctx>sample_fmt = AV_SAMPLE_FMT_S32; 
709 
if(avctx>channels <= 2 && !avctx>channel_layout) 
710 
avctx>channel_layout = (avctx>channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;

711  
712 
s>multichannel = avctx>channels > 2;

713 
/* lavf demuxer does not provide extradata, Matroska stores 0x403

714 
there, use this to detect decoding mode for multichannel */

715 
s>mkv_mode = 0;

716 
if(s>multichannel && avctx>extradata && avctx>extradata_size == 2){ 
717 
int ver = AV_RL16(avctx>extradata);

718 
if(ver >= 0x402 && ver <= 0x410) 
719 
s>mkv_mode = 1;

720 
} 
721  
722 
s>fdec_num = 0;

723  
724 
return 0; 
725 
} 
726  
727 
static av_cold int wavpack_decode_end(AVCodecContext *avctx) 
728 
{ 
729 
WavpackContext *s = avctx>priv_data; 
730 
int i;

731  
732 
for(i = 0; i < s>fdec_num; i++) 
733 
av_freep(&s>fdec[i]); 
734 
s>fdec_num = 0;

735  
736 
return 0; 
737 
} 
738  
739 
static int wavpack_decode_block(AVCodecContext *avctx, int block_no, 
740 
void *data, int *data_size, 
741 
const uint8_t *buf, int buf_size) 
742 
{ 
743 
WavpackContext *wc = avctx>priv_data; 
744 
WavpackFrameContext *s; 
745 
void *samples = data;

746 
int samplecount;

747 
int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0; 
748 
int got_hybrid = 0; 
749 
const uint8_t* orig_buf = buf;

750 
const uint8_t* buf_end = buf + buf_size;

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

752 
int bpp, chan, chmask;

753  
754 
if (buf_size == 0){ 
755 
*data_size = 0;

756 
return 0; 
757 
} 
758  
759 
if(block_no >= wc>fdec_num && wv_alloc_frame_context(wc) < 0){ 
760 
av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");

761 
return 1; 
762 
} 
763  
764 
s = wc>fdec[block_no]; 
765 
if(!s){

766 
av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);

767 
return 1; 
768 
} 
769  
770 
if(!s>samples_left){

771 
memset(s>decorr, 0, MAX_TERMS * sizeof(Decorr)); 
772 
memset(s>ch, 0, sizeof(s>ch)); 
773 
s>extra_bits = 0;

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

775 
s>got_extra_bits = 0;

776 
} 
777  
778 
if(!wc>mkv_mode){

779 
s>samples = AV_RL32(buf); buf += 4;

780 
if(!s>samples){

781 
*data_size = 0;

782 
return buf_size;

783 
} 
784 
}else{

785 
s>samples = wc>samples; 
786 
} 
787 
s>frame_flags = AV_RL32(buf); buf += 4;

788 
if(s>frame_flags&0x80){ 
789 
bpp = sizeof(float); 
790 
avctx>sample_fmt = AV_SAMPLE_FMT_FLT; 
791 
} else if((s>frame_flags&0x03) <= 1){ 
792 
bpp = 2;

793 
avctx>sample_fmt = AV_SAMPLE_FMT_S16; 
794 
} else {

795 
bpp = 4;

796 
avctx>sample_fmt = AV_SAMPLE_FMT_S32; 
797 
} 
798 
samples = (uint8_t*)samples + bpp * wc>ch_offset; 
799  
800 
s>stereo = !(s>frame_flags & WV_MONO); 
801 
s>stereo_in = (s>frame_flags & WV_FALSE_STEREO) ? 0 : s>stereo;

802 
s>joint = s>frame_flags & WV_JOINT_STEREO; 
803 
s>hybrid = s>frame_flags & WV_HYBRID_MODE; 
804 
s>hybrid_bitrate = s>frame_flags & WV_HYBRID_BITRATE; 
805 
s>post_shift = 8 * (bpp1(s>frame_flags&0x03)) + ((s>frame_flags >> 13) & 0x1f); 
806 
s>CRC = AV_RL32(buf); buf += 4;

807 
if(wc>mkv_mode)

808 
buf += 4; //skip block size; 
809  
810 
wc>ch_offset += 1 + s>stereo;

811  
812 
s>max_samples = *data_size / (bpp * avctx>channels); 
813 
s>max_samples = FFMIN(s>max_samples, s>samples); 
814 
if(s>samples_left > 0){ 
815 
s>max_samples = FFMIN(s>max_samples, s>samples_left); 
816 
buf = buf_end; 
817 
} 
818  
819 
// parse metadata blocks

820 
while(buf < buf_end){

821 
id = *buf++; 
822 
size = *buf++; 
823 
if(id & WP_IDF_LONG) {

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

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

826 
} 
827 
size <<= 1; // size is specified in words 
828 
ssize = size; 
829 
if(id & WP_IDF_ODD) size;

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

832 
break;

833 
} 
834 
if(buf + ssize > buf_end){

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

836 
break;

837 
} 
838 
if(id & WP_IDF_IGNORE){

839 
buf += ssize; 
840 
continue;

841 
} 
842 
switch(id & WP_IDF_MASK){

843 
case WP_ID_DECTERMS:

844 
s>terms = size; 
845 
if(s>terms > MAX_TERMS){

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

847 
buf += ssize; 
848 
continue;

849 
} 
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; 
853 
buf++; 
854 
} 
855 
got_terms = 1;

856 
break;

857 
case WP_ID_DECWEIGHTS:

858 
if(!got_terms){

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

860 
continue;

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

865 
buf += ssize; 
866 
continue;

867 
} 
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 += (s>decorr[s>terms  i  1].weightA + 64) >> 7; 
873 
if(s>stereo_in){

874 
t = (int8_t)(*buf++); 
875 
s>decorr[s>terms  i  1].weightB = t << 3; 
876 
if(s>decorr[s>terms  i  1].weightB > 0) 
877 
s>decorr[s>terms  i  1].weightB += (s>decorr[s>terms  i  1].weightB + 64) >> 7; 
878 
} 
879 
} 
880 
got_weights = 1;

881 
break;

882 
case WP_ID_DECSAMPLES:

883 
if(!got_terms){

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

885 
continue;

886 
} 
887 
t = 0;

888 
for(i = s>terms  1; (i >= 0) && (t < size); i) { 
889 
if(s>decorr[i].value > 8){ 
890 
s>decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2; 
891 
s>decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2; 
892 
if(s>stereo_in){

893 
s>decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2; 
894 
s>decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2; 
895 
t += 4;

896 
} 
897 
t += 4;

898 
}else if(s>decorr[i].value < 0){ 
899 
s>decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2; 
900 
s>decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2; 
901 
t += 4;

902 
}else{

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

905 
if(s>stereo_in){

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

907 
} 
908 
} 
909 
t += s>decorr[i].value * 2 * (s>stereo_in + 1); 
910 
} 
911 
} 
912 
got_samples = 1;

913 
break;

914 
case WP_ID_ENTROPY:

915 
if(size != 6 * (s>stereo_in + 1)){ 
916 
av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s>stereo_in + 1), size); 
917 
buf += ssize; 
918 
continue;

919 
} 
920 
for(j = 0; j <= s>stereo_in; j++){ 
921 
for(i = 0; i < 3; i++){ 
922 
s>ch[j].median[i] = wp_exp2(AV_RL16(buf)); 
923 
buf += 2;

924 
} 
925 
} 
926 
got_entropy = 1;

927 
break;

928 
case WP_ID_HYBRID:

929 
if(s>hybrid_bitrate){

930 
for(i = 0; i <= s>stereo_in; i++){ 
931 
s>ch[i].slow_level = wp_exp2(AV_RL16(buf)); 
932 
buf += 2;

933 
size = 2;

934 
} 
935 
} 
936 
for(i = 0; i < (s>stereo_in + 1); i++){ 
937 
s>ch[i].bitrate_acc = AV_RL16(buf) << 16;

938 
buf += 2;

939 
size = 2;

940 
} 
941 
if(size > 0){ 
942 
for(i = 0; i < (s>stereo_in + 1); i++){ 
943 
s>ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf)); 
944 
buf += 2;

945 
} 
946 
}else{

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

949 
} 
950 
got_hybrid = 1;

951 
break;

952 
case WP_ID_INT32INFO:

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

955 
buf += ssize; 
956 
continue;

957 
} 
958 
if(buf[0]) 
959 
s>extra_bits = buf[0];

960 
else if(buf[1]) 
961 
s>shift = buf[1];

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

964 
s>shift = buf[2];

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

967 
s>shift = buf[3];

968 
} 
969 
buf += 4;

970 
break;

971 
case WP_ID_FLOATINFO:

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

974 
buf += ssize; 
975 
continue;

976 
} 
977 
s>float_flag = buf[0];

978 
s>float_shift = buf[1];

979 
s>float_max_exp = buf[2];

980 
buf += 4;

981 
got_float = 1;

982 
break;

983 
case WP_ID_DATA:

984 
s>sc.offset = buf  orig_buf; 
985 
s>sc.size = size * 8;

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

987 
s>data_size = size * 8;

988 
buf += size; 
989 
got_bs = 1;

990 
break;

991 
case WP_ID_EXTRABITS:

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

994 
buf += size; 
995 
continue;

996 
} 
997 
s>extra_sc.offset = buf  orig_buf; 
998 
s>extra_sc.size = size * 8;

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

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

1001 
buf += size; 
1002 
s>got_extra_bits = 1;

1003 
break;

1004 
case WP_ID_CHANINFO:

1005 
if(size <= 1){ 
1006 
av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");

1007 
return 1; 
1008 
} 
1009 
chan = *buf++; 
1010 
switch(size  2){ 
1011 
case 0: 
1012 
chmask = *buf; 
1013 
break;

1014 
case 1: 
1015 
chmask = AV_RL16(buf); 
1016 
break;

1017 
case 2: 
1018 
chmask = AV_RL24(buf); 
1019 
break;

1020 
case 3: 
1021 
chmask = AV_RL32(buf); 
1022 
break;

1023 
case 5: 
1024 
chan = (buf[1] & 0xF) << 8; 
1025 
chmask = AV_RL24(buf + 2);

1026 
break;

1027 
default:

1028 
av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);

1029 
chan = avctx>channels; 
1030 
chmask = avctx>channel_layout; 
1031 
} 
1032 
if(chan != avctx>channels){

1033 
av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",

1034 
chan, avctx>channels); 
1035 
return 1; 
1036 
} 
1037 
if(!avctx>channel_layout)

1038 
avctx>channel_layout = chmask; 
1039 
buf += size  1;

1040 
break;

1041 
default:

1042 
buf += size; 
1043 
} 
1044 
if(id & WP_IDF_ODD) buf++;

1045 
} 
1046 
if(!s>samples_left){

1047 
if(!got_terms){

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

1049 
return 1; 
1050 
} 
1051 
if(!got_weights){

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

1053 
return 1; 
1054 
} 
1055 
if(!got_samples){

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

1057 
return 1; 
1058 
} 
1059 
if(!got_entropy){

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

1061 
return 1; 
1062 
} 
1063 
if(s>hybrid && !got_hybrid){

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

1065 
return 1; 
1066 
} 
1067 
if(!got_bs){

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

1069 
return 1; 
1070 
} 
1071 
if(!got_float && avctx>sample_fmt == AV_SAMPLE_FMT_FLT){

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

1073 
return 1; 
1074 
} 
1075 
if(s>got_extra_bits && avctx>sample_fmt != AV_SAMPLE_FMT_FLT){

1076 
const int size = get_bits_left(&s>gb_extra_bits); 
1077 
const int wanted = s>samples * s>extra_bits << s>stereo_in; 
1078 
if(size < wanted){

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

1080 
s>got_extra_bits = 0;

1081 
} 
1082 
} 
1083 
s>samples_left = s>samples; 
1084 
}else{

1085 
init_get_bits(&s>gb, orig_buf + s>sc.offset, s>sc.size); 
1086 
skip_bits_long(&s>gb, s>sc.bits_used); 
1087 
if(s>got_extra_bits){

1088 
init_get_bits(&s>gb_extra_bits, orig_buf + s>extra_sc.offset, 
1089 
s>extra_sc.size); 
1090 
skip_bits_long(&s>gb_extra_bits, s>extra_sc.bits_used); 
1091 
} 
1092 
} 
1093  
1094 
if(s>stereo_in){

1095 
if(avctx>sample_fmt == AV_SAMPLE_FMT_S16)

1096 
samplecount = wv_unpack_stereo(s, &s>gb, samples, AV_SAMPLE_FMT_S16); 
1097 
else if(avctx>sample_fmt == AV_SAMPLE_FMT_S32) 
1098 
samplecount = wv_unpack_stereo(s, &s>gb, samples, AV_SAMPLE_FMT_S32); 
1099 
else

1100 
samplecount = wv_unpack_stereo(s, &s>gb, samples, AV_SAMPLE_FMT_FLT); 
1101 
samplecount >>= 1;

1102 
}else{

1103 
const int channel_stride = avctx>channels; 
1104  
1105 
if(avctx>sample_fmt == AV_SAMPLE_FMT_S16)

1106 
samplecount = wv_unpack_mono(s, &s>gb, samples, AV_SAMPLE_FMT_S16); 
1107 
else if(avctx>sample_fmt == AV_SAMPLE_FMT_S32) 
1108 
samplecount = wv_unpack_mono(s, &s>gb, samples, AV_SAMPLE_FMT_S32); 
1109 
else

1110 
samplecount = wv_unpack_mono(s, &s>gb, samples, AV_SAMPLE_FMT_FLT); 
1111  
1112 
if(s>stereo && avctx>sample_fmt == AV_SAMPLE_FMT_S16){

1113 
int16_t *dst = (int16_t*)samples + 1;

1114 
int16_t *src = (int16_t*)samples; 
1115 
int cnt = samplecount;

1116 
while(cnt){

1117 
*dst = *src; 
1118 
src += channel_stride; 
1119 
dst += channel_stride; 
1120 
} 
1121 
}else if(s>stereo && avctx>sample_fmt == AV_SAMPLE_FMT_S32){ 
1122 
int32_t *dst = (int32_t*)samples + 1;

1123 
int32_t *src = (int32_t*)samples; 
1124 
int cnt = samplecount;

1125 
while(cnt){

1126 
*dst = *src; 
1127 
src += channel_stride; 
1128 
dst += channel_stride; 
1129 
} 
1130 
}else if(s>stereo){ 
1131 
float *dst = (float*)samples + 1; 
1132 
float *src = (float*)samples; 
1133 
int cnt = samplecount;

1134 
while(cnt){

1135 
*dst = *src; 
1136 
src += channel_stride; 
1137 
dst += channel_stride; 
1138 
} 
1139 
} 
1140 
} 
1141  
1142 
wc>samples_left = s>samples_left; 
1143  
1144 
return samplecount * bpp;

1145 
} 
1146  
1147 
static int wavpack_decode_frame(AVCodecContext *avctx, 
1148 
void *data, int *data_size, 
1149 
AVPacket *avpkt) 
1150 
{ 
1151 
WavpackContext *s = avctx>priv_data; 
1152 
const uint8_t *buf = avpkt>data;

1153 
int buf_size = avpkt>size;

1154 
int frame_size;

1155 
int samplecount = 0; 
1156  
1157 
s>block = 0;

1158 
s>samples_left = 0;

1159 
s>ch_offset = 0;

1160  
1161 
if(s>mkv_mode){

1162 
s>samples = AV_RL32(buf); buf += 4;

1163 
} 
1164 
while(buf_size > 0){ 
1165 
if(!s>multichannel){

1166 
frame_size = buf_size; 
1167 
}else{

1168 
if(!s>mkv_mode){

1169 
frame_size = AV_RL32(buf)  12; buf += 4; buf_size = 4; 
1170 
}else{

1171 
if(buf_size < 12) //MKV files can have zero flags after last block 
1172 
break;

1173 
frame_size = AV_RL32(buf + 8) + 12; 
1174 
} 
1175 
} 
1176 
if(frame_size < 0  frame_size > buf_size){ 
1177 
av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",

1178 
s>block, frame_size, buf_size); 
1179 
return 1; 
1180 
} 
1181 
if((samplecount = wavpack_decode_block(avctx, s>block, data,

1182 
data_size, buf, frame_size)) < 0)

1183 
return 1; 
1184 
s>block++; 
1185 
buf += frame_size; buf_size = frame_size; 
1186 
} 
1187 
*data_size = samplecount * avctx>channels; 
1188  
1189 
return s>samples_left > 0 ? 0 : avpkt>size; 
1190 
} 
1191  
1192 
AVCodec ff_wavpack_decoder = { 
1193 
"wavpack",

1194 
AVMEDIA_TYPE_AUDIO, 
1195 
CODEC_ID_WAVPACK, 
1196 
sizeof(WavpackContext),

1197 
wavpack_decode_init, 
1198 
NULL,

1199 
wavpack_decode_end, 
1200 
wavpack_decode_frame, 
1201 
.capabilities = CODEC_CAP_SUBFRAMES, 
1202 
.long_name = NULL_IF_CONFIG_SMALL("WavPack"),

1203 
}; 