11e99049831fcf491539bc2351c1ec1a268e50b3
[libav.git] / libavcodec / wavpack.c
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 02110-1301 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, hybrid_maxclip;
114 int float_flag;
115 int float_shift;
116 int float_max_exp;
117 WvChannel ch[2];
118 int pos;
119 SavedContext sc, extra_sc;
120 } WavpackFrameContext;
121
122 #define WV_MAX_FRAME_DECODERS 14
123
124 typedef struct WavpackContext {
125 AVCodecContext *avctx;
126 AVFrame frame;
127
128 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
129 int fdec_num;
130
131 int multichannel;
132 int mkv_mode;
133 int block;
134 int samples;
135 int ch_offset;
136 } WavpackContext;
137
138 // exponent table copied from WavPack source
139 static const uint8_t wp_exp2_table [256] = {
140 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
141 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
142 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
143 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
144 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
145 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
146 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
147 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
148 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
149 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
150 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
151 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
152 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
153 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
154 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
155 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
156 };
157
158 static const uint8_t wp_log2_table [] = {
159 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
160 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
161 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
162 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
163 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
164 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
165 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
166 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
167 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
168 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
169 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
170 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
171 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
172 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
173 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
174 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
175 };
176
177 static av_always_inline int wp_exp2(int16_t val)
178 {
179 int res, neg = 0;
180
181 if(val < 0){
182 val = -val;
183 neg = 1;
184 }
185
186 res = wp_exp2_table[val & 0xFF] | 0x100;
187 val >>= 8;
188 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
189 return neg ? -res : res;
190 }
191
192 static av_always_inline int wp_log2(int32_t val)
193 {
194 int bits;
195
196 if(!val)
197 return 0;
198 if(val == 1)
199 return 256;
200 val += val >> 9;
201 bits = av_log2(val) + 1;
202 if(bits < 9)
203 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
204 else
205 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
206 }
207
208 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
209
210 // macros for manipulating median values
211 #define GET_MED(n) ((c->median[n] >> 4) + 1)
212 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
213 #define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
214
215 // macros for applying weight
216 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
217 if(samples && in){ \
218 if((samples ^ in) < 0){ \
219 weight -= delta; \
220 if(weight < -1024) weight = -1024; \
221 }else{ \
222 weight += delta; \
223 if(weight > 1024) weight = 1024; \
224 } \
225 }
226
227
228 static av_always_inline int get_tail(GetBitContext *gb, int k)
229 {
230 int p, e, res;
231
232 if(k<1)return 0;
233 p = av_log2(k);
234 e = (1 << (p + 1)) - k - 1;
235 res = p ? get_bits(gb, p) : 0;
236 if(res >= e){
237 res = (res<<1) - e + get_bits1(gb);
238 }
239 return res;
240 }
241
242 static void update_error_limit(WavpackFrameContext *ctx)
243 {
244 int i, br[2], sl[2];
245
246 for(i = 0; i <= ctx->stereo_in; i++){
247 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
248 br[i] = ctx->ch[i].bitrate_acc >> 16;
249 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
250 }
251 if(ctx->stereo_in && ctx->hybrid_bitrate){
252 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
253 if(balance > br[0]){
254 br[1] = br[0] << 1;
255 br[0] = 0;
256 }else if(-balance > br[0]){
257 br[0] <<= 1;
258 br[1] = 0;
259 }else{
260 br[1] = br[0] + balance;
261 br[0] = br[0] - balance;
262 }
263 }
264 for(i = 0; i <= ctx->stereo_in; i++){
265 if(ctx->hybrid_bitrate){
266 if(sl[i] - br[i] > -0x100)
267 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
268 else
269 ctx->ch[i].error_limit = 0;
270 }else{
271 ctx->ch[i].error_limit = wp_exp2(br[i]);
272 }
273 }
274 }
275
276 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, int channel, int *last)
277 {
278 int t, t2;
279 int sign, base, add, ret;
280 WvChannel *c = &ctx->ch[channel];
281
282 *last = 0;
283
284 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
285 if(ctx->zeroes){
286 ctx->zeroes--;
287 if(ctx->zeroes){
288 c->slow_level -= LEVEL_DECAY(c->slow_level);
289 return 0;
290 }
291 }else{
292 t = get_unary_0_33(gb);
293 if(t >= 2){
294 if(get_bits_left(gb) < t-1)
295 goto error;
296 t = get_bits(gb, t - 1) | (1 << (t-1));
297 }else{
298 if(get_bits_left(gb) < 0)
299 goto error;
300 }
301 ctx->zeroes = t;
302 if(ctx->zeroes){
303 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
304 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
305 c->slow_level -= LEVEL_DECAY(c->slow_level);
306 return 0;
307 }
308 }
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_left(gb) < 0)
317 goto error;
318 if(t == 16) {
319 t2 = get_unary_0_33(gb);
320 if(t2 < 2){
321 if(get_bits_left(gb) < 0)
322 goto error;
323 t += t2;
324 }else{
325 if(get_bits_left(gb) < t2 - 1)
326 goto error;
327 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
328 }
329 }
330
331 if(ctx->one){
332 ctx->one = t&1;
333 t = (t>>1) + 1;
334 }else{
335 ctx->one = t&1;
336 t >>= 1;
337 }
338 ctx->zero = !ctx->one;
339 }
340
341 if(ctx->hybrid && !channel)
342 update_error_limit(ctx);
343
344 if(!t){
345 base = 0;
346 add = GET_MED(0) - 1;
347 DEC_MED(0);
348 }else if(t == 1){
349 base = GET_MED(0);
350 add = GET_MED(1) - 1;
351 INC_MED(0);
352 DEC_MED(1);
353 }else if(t == 2){
354 base = GET_MED(0) + GET_MED(1);
355 add = GET_MED(2) - 1;
356 INC_MED(0);
357 INC_MED(1);
358 DEC_MED(2);
359 }else{
360 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
361 add = GET_MED(2) - 1;
362 INC_MED(0);
363 INC_MED(1);
364 INC_MED(2);
365 }
366 if(!c->error_limit){
367 ret = base + get_tail(gb, add);
368 if (get_bits_left(gb) <= 0)
369 goto error;
370 }else{
371 int mid = (base*2 + add + 1) >> 1;
372 while(add > c->error_limit){
373 if(get_bits_left(gb) <= 0)
374 goto error;
375 if(get_bits1(gb)){
376 add -= (mid - base);
377 base = mid;
378 }else
379 add = mid - base - 1;
380 mid = (base*2 + add + 1) >> 1;
381 }
382 ret = mid;
383 }
384 sign = get_bits1(gb);
385 if(ctx->hybrid_bitrate)
386 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
387 return sign ? ~ret : ret;
388
389 error:
390 *last = 1;
391 return 0;
392 }
393
394 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
395 {
396 int bit;
397
398 if(s->extra_bits){
399 S <<= s->extra_bits;
400
401 if(s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits){
402 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
403 *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
404 }
405 }
406
407 bit = (S & s->and) | s->or;
408 bit = (((S + bit) << s->shift) - bit);
409
410 if(s->hybrid)
411 bit = av_clip(bit, -s->hybrid_maxclip, s->hybrid_maxclip - 1);
412
413 return bit << s->post_shift;
414 }
415
416 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
417 {
418 union {
419 float f;
420 uint32_t u;
421 } value;
422
423 int sign;
424 int exp = s->float_max_exp;
425
426 if(s->got_extra_bits){
427 const int max_bits = 1 + 23 + 8 + 1;
428 const int left_bits = get_bits_left(&s->gb_extra_bits);
429
430 if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
431 return 0.0;
432 }
433
434 if(S){
435 S <<= s->float_shift;
436 sign = S < 0;
437 if(sign)
438 S = -S;
439 if(S >= 0x1000000){
440 if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
441 S = get_bits(&s->gb_extra_bits, 23);
442 }else{
443 S = 0;
444 }
445 exp = 255;
446 }else if(exp){
447 int shift = 23 - av_log2(S);
448 exp = s->float_max_exp;
449 if(exp <= shift){
450 shift = --exp;
451 }
452 exp -= shift;
453
454 if(shift){
455 S <<= shift;
456 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
457 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
458 S |= (1 << shift) - 1;
459 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
460 S |= get_bits(&s->gb_extra_bits, shift);
461 }
462 }
463 }else{
464 exp = s->float_max_exp;
465 }
466 S &= 0x7fffff;
467 }else{
468 sign = 0;
469 exp = 0;
470 if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
471 if(get_bits1(&s->gb_extra_bits)){
472 S = get_bits(&s->gb_extra_bits, 23);
473 if(s->float_max_exp >= 25)
474 exp = get_bits(&s->gb_extra_bits, 8);
475 sign = get_bits1(&s->gb_extra_bits);
476 }else{
477 if(s->float_flag & WV_FLT_ZERO_SIGN)
478 sign = get_bits1(&s->gb_extra_bits);
479 }
480 }
481 }
482
483 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
484
485 value.u = (sign << 31) | (exp << 23) | S;
486 return value.f;
487 }
488
489 static void wv_reset_saved_context(WavpackFrameContext *s)
490 {
491 s->pos = 0;
492 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
493 }
494
495 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
496 {
497 int i, j, count = 0;
498 int last, t;
499 int A, B, L, L2, R, R2;
500 int pos = s->pos;
501 uint32_t crc = s->sc.crc;
502 uint32_t crc_extra_bits = s->extra_sc.crc;
503 int16_t *dst16 = dst;
504 int32_t *dst32 = dst;
505 float *dstfl = dst;
506 const int channel_pad = s->avctx->channels - 2;
507
508 s->one = s->zero = s->zeroes = 0;
509 do{
510 L = wv_get_value(s, gb, 0, &last);
511 if(last) break;
512 R = wv_get_value(s, gb, 1, &last);
513 if(last) break;
514 for(i = 0; i < s->terms; i++){
515 t = s->decorr[i].value;
516 if(t > 0){
517 if(t > 8){
518 if(t & 1){
519 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
520 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
521 }else{
522 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
523 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
524 }
525 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
526 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
527 j = 0;
528 }else{
529 A = s->decorr[i].samplesA[pos];
530 B = s->decorr[i].samplesB[pos];
531 j = (pos + t) & 7;
532 }
533 if(type != AV_SAMPLE_FMT_S16){
534 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
535 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
536 }else{
537 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
538 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
539 }
540 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
541 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
542 s->decorr[i].samplesA[j] = L = L2;
543 s->decorr[i].samplesB[j] = R = R2;
544 }else if(t == -1){
545 if(type != AV_SAMPLE_FMT_S16)
546 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
547 else
548 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
549 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
550 L = L2;
551 if(type != AV_SAMPLE_FMT_S16)
552 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
553 else
554 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
555 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
556 R = R2;
557 s->decorr[i].samplesA[0] = R;
558 }else{
559 if(type != AV_SAMPLE_FMT_S16)
560 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
561 else
562 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
563 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
564 R = R2;
565
566 if(t == -3){
567 R2 = s->decorr[i].samplesA[0];
568 s->decorr[i].samplesA[0] = R;
569 }
570
571 if(type != AV_SAMPLE_FMT_S16)
572 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
573 else
574 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
575 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
576 L = L2;
577 s->decorr[i].samplesB[0] = L;
578 }
579 }
580 pos = (pos + 1) & 7;
581 if(s->joint)
582 L += (R -= (L >> 1));
583 crc = (crc * 3 + L) * 3 + R;
584
585 if(type == AV_SAMPLE_FMT_FLT){
586 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
587 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
588 dstfl += channel_pad;
589 } else if(type == AV_SAMPLE_FMT_S32){
590 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
591 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
592 dst32 += channel_pad;
593 } else {
594 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
595 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
596 dst16 += channel_pad;
597 }
598 count++;
599 } while (!last && count < s->samples);
600
601 wv_reset_saved_context(s);
602 if(crc != s->CRC){
603 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
604 return -1;
605 }
606 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
607 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
608 return -1;
609 }
610
611 return count * 2;
612 }
613
614 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
615 {
616 int i, j, count = 0;
617 int last, t;
618 int A, S, T;
619 int pos = s->pos;
620 uint32_t crc = s->sc.crc;
621 uint32_t crc_extra_bits = s->extra_sc.crc;
622 int16_t *dst16 = dst;
623 int32_t *dst32 = dst;
624 float *dstfl = dst;
625 const int channel_stride = s->avctx->channels;
626
627 s->one = s->zero = s->zeroes = 0;
628 do{
629 T = wv_get_value(s, gb, 0, &last);
630 S = 0;
631 if(last) break;
632 for(i = 0; i < s->terms; i++){
633 t = s->decorr[i].value;
634 if(t > 8){
635 if(t & 1)
636 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
637 else
638 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
639 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
640 j = 0;
641 }else{
642 A = s->decorr[i].samplesA[pos];
643 j = (pos + t) & 7;
644 }
645 if(type != AV_SAMPLE_FMT_S16)
646 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
647 else
648 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
649 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
650 s->decorr[i].samplesA[j] = T = S;
651 }
652 pos = (pos + 1) & 7;
653 crc = crc * 3 + S;
654
655 if(type == AV_SAMPLE_FMT_FLT){
656 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
657 dstfl += channel_stride;
658 }else if(type == AV_SAMPLE_FMT_S32){
659 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
660 dst32 += channel_stride;
661 }else{
662 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
663 dst16 += channel_stride;
664 }
665 count++;
666 } while (!last && count < s->samples);
667
668 wv_reset_saved_context(s);
669 if(crc != s->CRC){
670 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
671 return -1;
672 }
673 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
674 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
675 return -1;
676 }
677
678 return count;
679 }
680
681 static av_cold int wv_alloc_frame_context(WavpackContext *c)
682 {
683
684 if(c->fdec_num == WV_MAX_FRAME_DECODERS)
685 return -1;
686
687 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
688 if(!c->fdec[c->fdec_num])
689 return -1;
690 c->fdec_num++;
691 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
692 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
693
694 return 0;
695 }
696
697 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
698 {
699 WavpackContext *s = avctx->priv_data;
700
701 s->avctx = avctx;
702 if(avctx->bits_per_coded_sample <= 16)
703 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
704 else
705 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
706 if(avctx->channels <= 2 && !avctx->channel_layout)
707 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
708
709 s->multichannel = avctx->channels > 2;
710 /* lavf demuxer does not provide extradata, Matroska stores 0x403
711 there, use this to detect decoding mode for multichannel */
712 s->mkv_mode = 0;
713 if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
714 int ver = AV_RL16(avctx->extradata);
715 if(ver >= 0x402 && ver <= 0x410)
716 s->mkv_mode = 1;
717 }
718
719 s->fdec_num = 0;
720
721 avcodec_get_frame_defaults(&s->frame);
722 avctx->coded_frame = &s->frame;
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 *got_frame_ptr,
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 *got_frame_ptr = 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 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
771 memset(s->ch, 0, sizeof(s->ch));
772 s->extra_bits = 0;
773 s->and = s->or = s->shift = 0;
774 s->got_extra_bits = 0;
775
776 if(!wc->mkv_mode){
777 s->samples = AV_RL32(buf); buf += 4;
778 if(!s->samples){
779 *got_frame_ptr = 0;
780 return 0;
781 }
782 }else{
783 s->samples = wc->samples;
784 }
785 s->frame_flags = AV_RL32(buf); buf += 4;
786 if(s->frame_flags&0x80){
787 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
788 } else if((s->frame_flags&0x03) <= 1){
789 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
790 } else {
791 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
792 }
793 bpp = av_get_bytes_per_sample(avctx->sample_fmt);
794 samples = (uint8_t*)samples + bpp * wc->ch_offset;
795
796 s->stereo = !(s->frame_flags & WV_MONO);
797 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
798 s->joint = s->frame_flags & WV_JOINT_STEREO;
799 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
800 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
801 s->hybrid_maxclip = 1 << ((((s->frame_flags & 0x03) + 1) << 3) - 1);
802 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
803 s->CRC = AV_RL32(buf); buf += 4;
804 if(wc->mkv_mode)
805 buf += 4; //skip block size;
806
807 wc->ch_offset += 1 + s->stereo;
808
809 // parse metadata blocks
810 while(buf < buf_end){
811 id = *buf++;
812 size = *buf++;
813 if(id & WP_IDF_LONG) {
814 size |= (*buf++) << 8;
815 size |= (*buf++) << 16;
816 }
817 size <<= 1; // size is specified in words
818 ssize = size;
819 if(id & WP_IDF_ODD) size--;
820 if(size < 0){
821 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
822 break;
823 }
824 if(buf + ssize > buf_end){
825 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
826 break;
827 }
828 if(id & WP_IDF_IGNORE){
829 buf += ssize;
830 continue;
831 }
832 switch(id & WP_IDF_MASK){
833 case WP_ID_DECTERMS:
834 if(size > MAX_TERMS){
835 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
836 s->terms = 0;
837 buf += ssize;
838 continue;
839 }
840 s->terms = size;
841 for(i = 0; i < s->terms; i++) {
842 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
843 s->decorr[s->terms - i - 1].delta = *buf >> 5;
844 buf++;
845 }
846 got_terms = 1;
847 break;
848 case WP_ID_DECWEIGHTS:
849 if(!got_terms){
850 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
851 continue;
852 }
853 weights = size >> s->stereo_in;
854 if(weights > MAX_TERMS || weights > s->terms){
855 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
856 buf += ssize;
857 continue;
858 }
859 for(i = 0; i < weights; i++) {
860 t = (int8_t)(*buf++);
861 s->decorr[s->terms - i - 1].weightA = t << 3;
862 if(s->decorr[s->terms - i - 1].weightA > 0)
863 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
864 if(s->stereo_in){
865 t = (int8_t)(*buf++);
866 s->decorr[s->terms - i - 1].weightB = t << 3;
867 if(s->decorr[s->terms - i - 1].weightB > 0)
868 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
869 }
870 }
871 got_weights = 1;
872 break;
873 case WP_ID_DECSAMPLES:
874 if(!got_terms){
875 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
876 continue;
877 }
878 t = 0;
879 for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
880 if(s->decorr[i].value > 8){
881 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
882 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
883 if(s->stereo_in){
884 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
885 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
886 t += 4;
887 }
888 t += 4;
889 }else if(s->decorr[i].value < 0){
890 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
891 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
892 t += 4;
893 }else{
894 for(j = 0; j < s->decorr[i].value; j++){
895 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
896 if(s->stereo_in){
897 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
898 }
899 }
900 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
901 }
902 }
903 got_samples = 1;
904 break;
905 case WP_ID_ENTROPY:
906 if(size != 6 * (s->stereo_in + 1)){
907 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
908 buf += ssize;
909 continue;
910 }
911 for(j = 0; j <= s->stereo_in; j++){
912 for(i = 0; i < 3; i++){
913 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
914 buf += 2;
915 }
916 }
917 got_entropy = 1;
918 break;
919 case WP_ID_HYBRID:
920 if(s->hybrid_bitrate){
921 for(i = 0; i <= s->stereo_in; i++){
922 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
923 buf += 2;
924 size -= 2;
925 }
926 }
927 for(i = 0; i < (s->stereo_in + 1); i++){
928 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
929 buf += 2;
930 size -= 2;
931 }
932 if(size > 0){
933 for(i = 0; i < (s->stereo_in + 1); i++){
934 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
935 buf += 2;
936 }
937 }else{
938 for(i = 0; i < (s->stereo_in + 1); i++)
939 s->ch[i].bitrate_delta = 0;
940 }
941 got_hybrid = 1;
942 break;
943 case WP_ID_INT32INFO:
944 if(size != 4){
945 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
946 buf += ssize;
947 continue;
948 }
949 if(buf[0])
950 s->extra_bits = buf[0];
951 else if(buf[1])
952 s->shift = buf[1];
953 else if(buf[2]){
954 s->and = s->or = 1;
955 s->shift = buf[2];
956 }else if(buf[3]){
957 s->and = 1;
958 s->shift = buf[3];
959 }
960 buf += 4;
961 break;
962 case WP_ID_FLOATINFO:
963 if(size != 4){
964 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
965 buf += ssize;
966 continue;
967 }
968 s->float_flag = buf[0];
969 s->float_shift = buf[1];
970 s->float_max_exp = buf[2];
971 buf += 4;
972 got_float = 1;
973 break;
974 case WP_ID_DATA:
975 s->sc.offset = buf - orig_buf;
976 s->sc.size = size * 8;
977 init_get_bits(&s->gb, buf, size * 8);
978 s->data_size = size * 8;
979 buf += size;
980 got_bs = 1;
981 break;
982 case WP_ID_EXTRABITS:
983 if(size <= 4){
984 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
985 buf += size;
986 continue;
987 }
988 s->extra_sc.offset = buf - orig_buf;
989 s->extra_sc.size = size * 8;
990 init_get_bits(&s->gb_extra_bits, buf, size * 8);
991 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
992 buf += size;
993 s->got_extra_bits = 1;
994 break;
995 case WP_ID_CHANINFO:
996 if(size <= 1){
997 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
998 return -1;
999 }
1000 chan = *buf++;
1001 switch(size - 2){
1002 case 0:
1003 chmask = *buf;
1004 break;
1005 case 1:
1006 chmask = AV_RL16(buf);
1007 break;
1008 case 2:
1009 chmask = AV_RL24(buf);
1010 break;
1011 case 3:
1012 chmask = AV_RL32(buf);
1013 break;
1014 case 5:
1015 chan |= (buf[1] & 0xF) << 8;
1016 chmask = AV_RL24(buf + 2);
1017 break;
1018 default:
1019 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
1020 chan = avctx->channels;
1021 chmask = avctx->channel_layout;
1022 }
1023 if(chan != avctx->channels){
1024 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
1025 chan, avctx->channels);
1026 return -1;
1027 }
1028 if(!avctx->channel_layout)
1029 avctx->channel_layout = chmask;
1030 buf += size - 1;
1031 break;
1032 default:
1033 buf += size;
1034 }
1035 if(id & WP_IDF_ODD) buf++;
1036 }
1037
1038 if(!got_terms){
1039 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1040 return -1;
1041 }
1042 if(!got_weights){
1043 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1044 return -1;
1045 }
1046 if(!got_samples){
1047 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1048 return -1;
1049 }
1050 if(!got_entropy){
1051 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1052 return -1;
1053 }
1054 if(s->hybrid && !got_hybrid){
1055 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1056 return -1;
1057 }
1058 if(!got_bs){
1059 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1060 return -1;
1061 }
1062 if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
1063 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1064 return -1;
1065 }
1066 if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
1067 const int size = get_bits_left(&s->gb_extra_bits);
1068 const int wanted = s->samples * s->extra_bits << s->stereo_in;
1069 if(size < wanted){
1070 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1071 s->got_extra_bits = 0;
1072 }
1073 }
1074
1075 if(s->stereo_in){
1076 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1077 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1078 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1079 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1080 else
1081 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1082
1083 if (samplecount < 0)
1084 return -1;
1085
1086 samplecount >>= 1;
1087 }else{
1088 const int channel_stride = avctx->channels;
1089
1090 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1091 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1092 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1093 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1094 else
1095 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1096
1097 if (samplecount < 0)
1098 return -1;
1099
1100 if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
1101 int16_t *dst = (int16_t*)samples + 1;
1102 int16_t *src = (int16_t*)samples;
1103 int cnt = samplecount;
1104 while(cnt--){
1105 *dst = *src;
1106 src += channel_stride;
1107 dst += channel_stride;
1108 }
1109 }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
1110 int32_t *dst = (int32_t*)samples + 1;
1111 int32_t *src = (int32_t*)samples;
1112 int cnt = samplecount;
1113 while(cnt--){
1114 *dst = *src;
1115 src += channel_stride;
1116 dst += channel_stride;
1117 }
1118 }else if(s->stereo){
1119 float *dst = (float*)samples + 1;
1120 float *src = (float*)samples;
1121 int cnt = samplecount;
1122 while(cnt--){
1123 *dst = *src;
1124 src += channel_stride;
1125 dst += channel_stride;
1126 }
1127 }
1128 }
1129
1130 *got_frame_ptr = 1;
1131
1132 return samplecount * bpp;
1133 }
1134
1135 static void wavpack_decode_flush(AVCodecContext *avctx)
1136 {
1137 WavpackContext *s = avctx->priv_data;
1138 int i;
1139
1140 for (i = 0; i < s->fdec_num; i++)
1141 wv_reset_saved_context(s->fdec[i]);
1142 }
1143
1144 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1145 int *got_frame_ptr, AVPacket *avpkt)
1146 {
1147 WavpackContext *s = avctx->priv_data;
1148 const uint8_t *buf = avpkt->data;
1149 int buf_size = avpkt->size;
1150 int frame_size, ret;
1151 int samplecount = 0;
1152
1153 s->block = 0;
1154 s->ch_offset = 0;
1155
1156 /* determine number of samples */
1157 if(s->mkv_mode){
1158 s->samples = AV_RL32(buf); buf += 4;
1159 } else {
1160 if (s->multichannel)
1161 s->samples = AV_RL32(buf + 4);
1162 else
1163 s->samples = AV_RL32(buf);
1164 }
1165 if (s->samples <= 0) {
1166 av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1167 s->samples);
1168 return AVERROR(EINVAL);
1169 }
1170
1171 /* get output buffer */
1172 s->frame.nb_samples = s->samples;
1173 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1174 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1175 return ret;
1176 }
1177
1178 while(buf_size > 0){
1179 if(!s->multichannel){
1180 frame_size = buf_size;
1181 }else{
1182 if(!s->mkv_mode){
1183 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1184 }else{
1185 if(buf_size < 12) //MKV files can have zero flags after last block
1186 break;
1187 frame_size = AV_RL32(buf + 8) + 12;
1188 }
1189 }
1190 if(frame_size < 0 || frame_size > buf_size){
1191 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1192 s->block, frame_size, buf_size);
1193 wavpack_decode_flush(avctx);
1194 return -1;
1195 }
1196 if((samplecount = wavpack_decode_block(avctx, s->block, s->frame.data[0],
1197 got_frame_ptr, buf, frame_size)) < 0) {
1198 wavpack_decode_flush(avctx);
1199 return -1;
1200 }
1201 s->block++;
1202 buf += frame_size; buf_size -= frame_size;
1203 }
1204
1205 if (*got_frame_ptr)
1206 *(AVFrame *)data = s->frame;
1207
1208 return avpkt->size;
1209 }
1210
1211 AVCodec ff_wavpack_decoder = {
1212 .name = "wavpack",
1213 .type = AVMEDIA_TYPE_AUDIO,
1214 .id = CODEC_ID_WAVPACK,
1215 .priv_data_size = sizeof(WavpackContext),
1216 .init = wavpack_decode_init,
1217 .close = wavpack_decode_end,
1218 .decode = wavpack_decode_frame,
1219 .flush = wavpack_decode_flush,
1220 .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1221 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1222 };