wavpack: determine sample_fmt before requesting a buffer
[ffmpeg.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 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) << s->post_shift;
409
410     if(s->hybrid)
411         bit = av_clip(bit, -s->hybrid_maxclip - 1, s->hybrid_maxclip);
412
413     return bit;
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     bpp = av_get_bytes_per_sample(avctx->sample_fmt);
787     samples = (uint8_t*)samples + bpp * wc->ch_offset;
788
789     s->stereo = !(s->frame_flags & WV_MONO);
790     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
791     s->joint = s->frame_flags & WV_JOINT_STEREO;
792     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
793     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
794     s->hybrid_maxclip = (1LL << ((((s->frame_flags & 0x03) + 1) << 3) - 1)) - 1;
795     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
796     s->CRC = AV_RL32(buf); buf += 4;
797     if(wc->mkv_mode)
798         buf += 4; //skip block size;
799
800     wc->ch_offset += 1 + s->stereo;
801
802     // parse metadata blocks
803     while(buf < buf_end){
804         id = *buf++;
805         size = *buf++;
806         if(id & WP_IDF_LONG) {
807             size |= (*buf++) << 8;
808             size |= (*buf++) << 16;
809         }
810         size <<= 1; // size is specified in words
811         ssize = size;
812         if(id & WP_IDF_ODD) size--;
813         if(size < 0){
814             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
815             break;
816         }
817         if(buf + ssize > buf_end){
818             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
819             break;
820         }
821         if(id & WP_IDF_IGNORE){
822             buf += ssize;
823             continue;
824         }
825         switch(id & WP_IDF_MASK){
826         case WP_ID_DECTERMS:
827             if(size > MAX_TERMS){
828                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
829                 s->terms = 0;
830                 buf += ssize;
831                 continue;
832             }
833             s->terms = size;
834             for(i = 0; i < s->terms; i++) {
835                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
836                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
837                 buf++;
838             }
839             got_terms = 1;
840             break;
841         case WP_ID_DECWEIGHTS:
842             if(!got_terms){
843                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
844                 continue;
845             }
846             weights = size >> s->stereo_in;
847             if(weights > MAX_TERMS || weights > s->terms){
848                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
849                 buf += ssize;
850                 continue;
851             }
852             for(i = 0; i < weights; i++) {
853                 t = (int8_t)(*buf++);
854                 s->decorr[s->terms - i - 1].weightA = t << 3;
855                 if(s->decorr[s->terms - i - 1].weightA > 0)
856                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
857                 if(s->stereo_in){
858                     t = (int8_t)(*buf++);
859                     s->decorr[s->terms - i - 1].weightB = t << 3;
860                     if(s->decorr[s->terms - i - 1].weightB > 0)
861                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
862                 }
863             }
864             got_weights = 1;
865             break;
866         case WP_ID_DECSAMPLES:
867             if(!got_terms){
868                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
869                 continue;
870             }
871             t = 0;
872             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
873                 if(s->decorr[i].value > 8){
874                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
875                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
876                     if(s->stereo_in){
877                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
878                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
879                         t += 4;
880                     }
881                     t += 4;
882                 }else if(s->decorr[i].value < 0){
883                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
884                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
885                     t += 4;
886                 }else{
887                     for(j = 0; j < s->decorr[i].value; j++){
888                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
889                         if(s->stereo_in){
890                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
891                         }
892                     }
893                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
894                 }
895             }
896             got_samples = 1;
897             break;
898         case WP_ID_ENTROPY:
899             if(size != 6 * (s->stereo_in + 1)){
900                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
901                 buf += ssize;
902                 continue;
903             }
904             for(j = 0; j <= s->stereo_in; j++){
905                 for(i = 0; i < 3; i++){
906                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
907                     buf += 2;
908                 }
909             }
910             got_entropy = 1;
911             break;
912         case WP_ID_HYBRID:
913             if(s->hybrid_bitrate){
914                 for(i = 0; i <= s->stereo_in; i++){
915                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
916                     buf += 2;
917                     size -= 2;
918                 }
919             }
920             for(i = 0; i < (s->stereo_in + 1); i++){
921                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
922                 buf += 2;
923                 size -= 2;
924             }
925             if(size > 0){
926                 for(i = 0; i < (s->stereo_in + 1); i++){
927                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
928                     buf += 2;
929                 }
930             }else{
931                 for(i = 0; i < (s->stereo_in + 1); i++)
932                     s->ch[i].bitrate_delta = 0;
933             }
934             got_hybrid = 1;
935             break;
936         case WP_ID_INT32INFO:
937             if(size != 4){
938                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
939                 buf += ssize;
940                 continue;
941             }
942             if(buf[0])
943                 s->extra_bits = buf[0];
944             else if(buf[1])
945                 s->shift = buf[1];
946             else if(buf[2]){
947                 s->and = s->or = 1;
948                 s->shift = buf[2];
949             }else if(buf[3]){
950                 s->and = 1;
951                 s->shift = buf[3];
952             }
953             buf += 4;
954             break;
955         case WP_ID_FLOATINFO:
956             if(size != 4){
957                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
958                 buf += ssize;
959                 continue;
960             }
961             s->float_flag = buf[0];
962             s->float_shift = buf[1];
963             s->float_max_exp = buf[2];
964             buf += 4;
965             got_float = 1;
966             break;
967         case WP_ID_DATA:
968             s->sc.offset = buf - orig_buf;
969             s->sc.size   = size * 8;
970             init_get_bits(&s->gb, buf, size * 8);
971             s->data_size = size * 8;
972             buf += size;
973             got_bs = 1;
974             break;
975         case WP_ID_EXTRABITS:
976             if(size <= 4){
977                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
978                 buf += size;
979                 continue;
980             }
981             s->extra_sc.offset = buf - orig_buf;
982             s->extra_sc.size   = size * 8;
983             init_get_bits(&s->gb_extra_bits, buf, size * 8);
984             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
985             buf += size;
986             s->got_extra_bits = 1;
987             break;
988         case WP_ID_CHANINFO:
989             if(size <= 1){
990                 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
991                 return -1;
992             }
993             chan = *buf++;
994             switch(size - 2){
995             case 0:
996                 chmask = *buf;
997                 break;
998             case 1:
999                 chmask = AV_RL16(buf);
1000                 break;
1001             case 2:
1002                 chmask = AV_RL24(buf);
1003                 break;
1004             case 3:
1005                 chmask = AV_RL32(buf);
1006                 break;
1007             case 5:
1008                 chan |= (buf[1] & 0xF) << 8;
1009                 chmask = AV_RL24(buf + 2);
1010                 break;
1011             default:
1012                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
1013                 chan = avctx->channels;
1014                 chmask = avctx->channel_layout;
1015             }
1016             if(chan != avctx->channels){
1017                 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
1018                        chan, avctx->channels);
1019                 return -1;
1020             }
1021             if(!avctx->channel_layout)
1022                 avctx->channel_layout = chmask;
1023             buf += size - 1;
1024             break;
1025         default:
1026             buf += size;
1027         }
1028         if(id & WP_IDF_ODD) buf++;
1029     }
1030
1031         if(!got_terms){
1032             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1033             return -1;
1034         }
1035         if(!got_weights){
1036             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1037             return -1;
1038         }
1039         if(!got_samples){
1040             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1041             return -1;
1042         }
1043         if(!got_entropy){
1044             av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1045             return -1;
1046         }
1047         if(s->hybrid && !got_hybrid){
1048             av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1049             return -1;
1050         }
1051         if(!got_bs){
1052             av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1053             return -1;
1054         }
1055         if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
1056             av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1057             return -1;
1058         }
1059         if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
1060             const int size = get_bits_left(&s->gb_extra_bits);
1061             const int wanted = s->samples * s->extra_bits << s->stereo_in;
1062             if(size < wanted){
1063                 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1064                 s->got_extra_bits = 0;
1065             }
1066         }
1067
1068     if(s->stereo_in){
1069         if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1070             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1071         else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1072             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1073         else
1074             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1075
1076         if (samplecount < 0)
1077             return -1;
1078
1079         samplecount >>= 1;
1080     }else{
1081         const int channel_stride = avctx->channels;
1082
1083         if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1084             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1085         else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1086             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1087         else
1088             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1089
1090         if (samplecount < 0)
1091             return -1;
1092
1093         if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
1094             int16_t *dst = (int16_t*)samples + 1;
1095             int16_t *src = (int16_t*)samples;
1096             int cnt = samplecount;
1097             while(cnt--){
1098                 *dst = *src;
1099                 src += channel_stride;
1100                 dst += channel_stride;
1101             }
1102         }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
1103             int32_t *dst = (int32_t*)samples + 1;
1104             int32_t *src = (int32_t*)samples;
1105             int cnt = samplecount;
1106             while(cnt--){
1107                 *dst = *src;
1108                 src += channel_stride;
1109                 dst += channel_stride;
1110             }
1111         }else if(s->stereo){
1112             float *dst = (float*)samples + 1;
1113             float *src = (float*)samples;
1114             int cnt = samplecount;
1115             while(cnt--){
1116                 *dst = *src;
1117                 src += channel_stride;
1118                 dst += channel_stride;
1119             }
1120         }
1121     }
1122
1123     *got_frame_ptr = 1;
1124
1125     return samplecount * bpp;
1126 }
1127
1128 static void wavpack_decode_flush(AVCodecContext *avctx)
1129 {
1130     WavpackContext *s = avctx->priv_data;
1131     int i;
1132
1133     for (i = 0; i < s->fdec_num; i++)
1134         wv_reset_saved_context(s->fdec[i]);
1135 }
1136
1137 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1138                                 int *got_frame_ptr, AVPacket *avpkt)
1139 {
1140     WavpackContext *s = avctx->priv_data;
1141     const uint8_t *buf = avpkt->data;
1142     int buf_size = avpkt->size;
1143     int frame_size, ret, frame_flags;
1144     int samplecount = 0;
1145
1146     s->block = 0;
1147     s->ch_offset = 0;
1148
1149     /* determine number of samples */
1150     if(s->mkv_mode){
1151         s->samples  = AV_RL32(buf); buf += 4;
1152         frame_flags = AV_RL32(buf);
1153     } else {
1154         if (s->multichannel) {
1155             s->samples  = AV_RL32(buf + 4);
1156             frame_flags = AV_RL32(buf + 8);
1157         } else {
1158             s->samples  = AV_RL32(buf);
1159             frame_flags = AV_RL32(buf + 4);
1160         }
1161     }
1162     if (s->samples <= 0) {
1163         av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1164                s->samples);
1165         return AVERROR(EINVAL);
1166     }
1167
1168     if (frame_flags & 0x80) {
1169         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1170     } else if ((frame_flags & 0x03) <= 1) {
1171         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1172     } else {
1173         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1174     }
1175
1176     /* get output buffer */
1177     s->frame.nb_samples = s->samples;
1178     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1179         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1180         return ret;
1181     }
1182
1183     while(buf_size > 0){
1184         if(!s->multichannel){
1185             frame_size = buf_size;
1186         }else{
1187             if(!s->mkv_mode){
1188                 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1189             }else{
1190                 if(buf_size < 12) //MKV files can have zero flags after last block
1191                     break;
1192                 frame_size = AV_RL32(buf + 8) + 12;
1193             }
1194         }
1195         if(frame_size < 0 || frame_size > buf_size){
1196             av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1197                    s->block, frame_size, buf_size);
1198             wavpack_decode_flush(avctx);
1199             return -1;
1200         }
1201         if((samplecount = wavpack_decode_block(avctx, s->block, s->frame.data[0],
1202                                                got_frame_ptr, buf, frame_size)) < 0) {
1203             wavpack_decode_flush(avctx);
1204             return -1;
1205         }
1206         s->block++;
1207         buf += frame_size; buf_size -= frame_size;
1208     }
1209
1210     if (*got_frame_ptr)
1211         *(AVFrame *)data = s->frame;
1212
1213     return avpkt->size;
1214 }
1215
1216 AVCodec ff_wavpack_decoder = {
1217     .name           = "wavpack",
1218     .type           = AVMEDIA_TYPE_AUDIO,
1219     .id             = CODEC_ID_WAVPACK,
1220     .priv_data_size = sizeof(WavpackContext),
1221     .init           = wavpack_decode_init,
1222     .close          = wavpack_decode_end,
1223     .decode         = wavpack_decode_frame,
1224     .flush          = wavpack_decode_flush,
1225     .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1226     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1227 };