61a75fd765f211cee32edb1c44611eec294367b5
[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 FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 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;
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){
296                 if(get_bits_left(gb) < t-1)
297                     goto error;
298                 t = get_bits(gb, t - 1) | (1 << (t-1));
299             }else{
300                 if(get_bits_left(gb) < 0)
301                     goto error;
302             }
303             ctx->zeroes = t;
304             if(ctx->zeroes){
305                 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
306                 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
307                 c->slow_level -= LEVEL_DECAY(c->slow_level);
308                 return 0;
309             }
310         }
311     }
312
313     if(ctx->zero){
314         t = 0;
315         ctx->zero = 0;
316     }else{
317         t = get_unary_0_33(gb);
318         if(get_bits_left(gb) < 0)
319             goto error;
320         if(t == 16) {
321             t2 = get_unary_0_33(gb);
322             if(t2 < 2){
323                 if(get_bits_left(gb) < 0)
324                     goto error;
325                 t += t2;
326             }else{
327                 if(get_bits_left(gb) < t2 - 1)
328                     goto error;
329                 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
330             }
331         }
332
333         if(ctx->one){
334             ctx->one = t&1;
335             t = (t>>1) + 1;
336         }else{
337             ctx->one = t&1;
338             t >>= 1;
339         }
340         ctx->zero = !ctx->one;
341     }
342
343     if(ctx->hybrid && !channel)
344         update_error_limit(ctx);
345
346     if(!t){
347         base = 0;
348         add = GET_MED(0) - 1;
349         DEC_MED(0);
350     }else if(t == 1){
351         base = GET_MED(0);
352         add = GET_MED(1) - 1;
353         INC_MED(0);
354         DEC_MED(1);
355     }else if(t == 2){
356         base = GET_MED(0) + GET_MED(1);
357         add = GET_MED(2) - 1;
358         INC_MED(0);
359         INC_MED(1);
360         DEC_MED(2);
361     }else{
362         base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
363         add = GET_MED(2) - 1;
364         INC_MED(0);
365         INC_MED(1);
366         INC_MED(2);
367     }
368     if(!c->error_limit){
369         ret = base + get_tail(gb, add);
370         if (get_bits_left(gb) <= 0)
371             goto error;
372     }else{
373         int mid = (base*2 + add + 1) >> 1;
374         while(add > c->error_limit){
375             if(get_bits_left(gb) <= 0)
376                 goto error;
377             if(get_bits1(gb)){
378                 add -= (mid - base);
379                 base = mid;
380             }else
381                 add = mid - base - 1;
382             mid = (base*2 + add + 1) >> 1;
383         }
384         ret = mid;
385     }
386     sign = get_bits1(gb);
387     if(ctx->hybrid_bitrate)
388         c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
389     return sign ? ~ret : ret;
390
391 error:
392     *last = 1;
393     return 0;
394 }
395
396 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
397 {
398     int bit;
399
400     if(s->extra_bits){
401         S <<= s->extra_bits;
402
403         if(s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits){
404             S |= get_bits(&s->gb_extra_bits, s->extra_bits);
405             *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
406         }
407     }
408     bit = (S & s->and) | s->or;
409     return (((S + bit) << s->shift) - bit) << s->post_shift;
410 }
411
412 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
413 {
414     union {
415         float    f;
416         uint32_t u;
417     } value;
418
419     int sign;
420     int exp = s->float_max_exp;
421
422     if(s->got_extra_bits){
423         const int max_bits = 1 + 23 + 8 + 1;
424         const int left_bits = get_bits_left(&s->gb_extra_bits);
425
426         if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
427             return 0.0;
428     }
429
430     if(S){
431         S <<= s->float_shift;
432         sign = S < 0;
433         if(sign)
434             S = -S;
435         if(S >= 0x1000000){
436             if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
437                 S = get_bits(&s->gb_extra_bits, 23);
438             }else{
439                 S = 0;
440             }
441             exp = 255;
442         }else if(exp){
443             int shift = 23 - av_log2(S);
444             exp = s->float_max_exp;
445             if(exp <= shift){
446                 shift = --exp;
447             }
448             exp -= shift;
449
450             if(shift){
451                 S <<= shift;
452                 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
453                    (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
454                     S |= (1 << shift) - 1;
455                 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
456                     S |= get_bits(&s->gb_extra_bits, shift);
457                 }
458             }
459         }else{
460             exp = s->float_max_exp;
461         }
462         S &= 0x7fffff;
463     }else{
464         sign = 0;
465         exp = 0;
466         if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
467             if(get_bits1(&s->gb_extra_bits)){
468                 S = get_bits(&s->gb_extra_bits, 23);
469                 if(s->float_max_exp >= 25)
470                     exp = get_bits(&s->gb_extra_bits, 8);
471                 sign = get_bits1(&s->gb_extra_bits);
472             }else{
473                 if(s->float_flag & WV_FLT_ZERO_SIGN)
474                     sign = get_bits1(&s->gb_extra_bits);
475             }
476         }
477     }
478
479     *crc = *crc * 27 + S * 9 + exp * 3 + sign;
480
481     value.u = (sign << 31) | (exp << 23) | S;
482     return value.f;
483 }
484
485 static void wv_reset_saved_context(WavpackFrameContext *s)
486 {
487     s->pos = 0;
488     s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
489 }
490
491 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
492 {
493     int i, j, count = 0;
494     int last, t;
495     int A, B, L, L2, R, R2;
496     int pos = s->pos;
497     uint32_t crc = s->sc.crc;
498     uint32_t crc_extra_bits = s->extra_sc.crc;
499     int16_t *dst16 = dst;
500     int32_t *dst32 = dst;
501     float   *dstfl = dst;
502     const int channel_pad = s->avctx->channels - 2;
503
504     if(s->samples_left == s->samples)
505         s->one = s->zero = s->zeroes = 0;
506     do{
507         L = wv_get_value(s, gb, 0, &last);
508         if(last) break;
509         R = wv_get_value(s, gb, 1, &last);
510         if(last) break;
511         for(i = 0; i < s->terms; i++){
512             t = s->decorr[i].value;
513             if(t > 0){
514                 if(t > 8){
515                     if(t & 1){
516                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
517                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
518                     }else{
519                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
520                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
521                     }
522                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
523                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
524                     j = 0;
525                 }else{
526                     A = s->decorr[i].samplesA[pos];
527                     B = s->decorr[i].samplesB[pos];
528                     j = (pos + t) & 7;
529                 }
530                 if(type != AV_SAMPLE_FMT_S16){
531                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
532                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
533                 }else{
534                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
535                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
536                 }
537                 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
538                 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
539                 s->decorr[i].samplesA[j] = L = L2;
540                 s->decorr[i].samplesB[j] = R = R2;
541             }else if(t == -1){
542                 if(type != AV_SAMPLE_FMT_S16)
543                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
544                 else
545                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
546                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
547                 L = L2;
548                 if(type != AV_SAMPLE_FMT_S16)
549                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
550                 else
551                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
552                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
553                 R = R2;
554                 s->decorr[i].samplesA[0] = R;
555             }else{
556                 if(type != AV_SAMPLE_FMT_S16)
557                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
558                 else
559                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
560                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
561                 R = R2;
562
563                 if(t == -3){
564                     R2 = s->decorr[i].samplesA[0];
565                     s->decorr[i].samplesA[0] = R;
566                 }
567
568                 if(type != AV_SAMPLE_FMT_S16)
569                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
570                 else
571                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
572                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
573                 L = L2;
574                 s->decorr[i].samplesB[0] = L;
575             }
576         }
577         pos = (pos + 1) & 7;
578         if(s->joint)
579             L += (R -= (L >> 1));
580         crc = (crc * 3 + L) * 3 + R;
581
582         if(type == AV_SAMPLE_FMT_FLT){
583             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
584             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
585             dstfl += channel_pad;
586         } else if(type == AV_SAMPLE_FMT_S32){
587             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
588             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
589             dst32 += channel_pad;
590         } else {
591             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
592             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
593             dst16 += channel_pad;
594         }
595         count++;
596     }while(!last && count < s->max_samples);
597
598     if (last)
599         s->samples_left = 0;
600     else
601         s->samples_left -= count;
602     if(!s->samples_left){
603         if(crc != s->CRC){
604             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
605             return -1;
606         }
607         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
608             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
609             return -1;
610         }
611         wv_reset_saved_context(s);
612     }else{
613         s->pos = pos;
614         s->sc.crc = crc;
615         s->sc.bits_used = get_bits_count(&s->gb);
616         if(s->got_extra_bits){
617             s->extra_sc.crc = crc_extra_bits;
618             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
619         }
620     }
621     return count * 2;
622 }
623
624 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
625 {
626     int i, j, count = 0;
627     int last, t;
628     int A, S, T;
629     int pos = s->pos;
630     uint32_t crc = s->sc.crc;
631     uint32_t crc_extra_bits = s->extra_sc.crc;
632     int16_t *dst16 = dst;
633     int32_t *dst32 = dst;
634     float   *dstfl = dst;
635     const int channel_stride = s->avctx->channels;
636
637     if(s->samples_left == s->samples)
638         s->one = s->zero = s->zeroes = 0;
639     do{
640         T = wv_get_value(s, gb, 0, &last);
641         S = 0;
642         if(last) break;
643         for(i = 0; i < s->terms; i++){
644             t = s->decorr[i].value;
645             if(t > 8){
646                 if(t & 1)
647                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
648                 else
649                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
650                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
651                 j = 0;
652             }else{
653                 A = s->decorr[i].samplesA[pos];
654                 j = (pos + t) & 7;
655             }
656             if(type != AV_SAMPLE_FMT_S16)
657                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
658             else
659                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
660             if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
661             s->decorr[i].samplesA[j] = T = S;
662         }
663         pos = (pos + 1) & 7;
664         crc = crc * 3 + S;
665
666         if(type == AV_SAMPLE_FMT_FLT){
667             *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
668             dstfl += channel_stride;
669         }else if(type == AV_SAMPLE_FMT_S32){
670             *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
671             dst32 += channel_stride;
672         }else{
673             *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
674             dst16 += channel_stride;
675         }
676         count++;
677     }while(!last && count < s->max_samples);
678
679     if (last)
680         s->samples_left = 0;
681     else
682         s->samples_left -= count;
683     if(!s->samples_left){
684         if(crc != s->CRC){
685             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
686             return -1;
687         }
688         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
689             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
690             return -1;
691         }
692         wv_reset_saved_context(s);
693     }else{
694         s->pos = pos;
695         s->sc.crc = crc;
696         s->sc.bits_used = get_bits_count(&s->gb);
697         if(s->got_extra_bits){
698             s->extra_sc.crc = crc_extra_bits;
699             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
700         }
701     }
702     return count;
703 }
704
705 static av_cold int wv_alloc_frame_context(WavpackContext *c)
706 {
707
708     if(c->fdec_num == WV_MAX_FRAME_DECODERS)
709         return -1;
710
711     c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
712     if(!c->fdec[c->fdec_num])
713         return -1;
714     c->fdec_num++;
715     c->fdec[c->fdec_num - 1]->avctx = c->avctx;
716     wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
717
718     return 0;
719 }
720
721 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
722 {
723     WavpackContext *s = avctx->priv_data;
724
725     s->avctx = avctx;
726     if(avctx->bits_per_coded_sample <= 16)
727         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
728     else
729         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
730     if(avctx->channels <= 2 && !avctx->channel_layout)
731         avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
732
733     s->multichannel = avctx->channels > 2;
734     /* lavf demuxer does not provide extradata, Matroska stores 0x403
735        there, use this to detect decoding mode for multichannel */
736     s->mkv_mode = 0;
737     if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
738         int ver = AV_RL16(avctx->extradata);
739         if(ver >= 0x402 && ver <= 0x410)
740             s->mkv_mode = 1;
741     }
742
743     s->fdec_num = 0;
744
745     return 0;
746 }
747
748 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
749 {
750     WavpackContext *s = avctx->priv_data;
751     int i;
752
753     for(i = 0; i < s->fdec_num; i++)
754         av_freep(&s->fdec[i]);
755     s->fdec_num = 0;
756
757     return 0;
758 }
759
760 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
761                                 void *data, int *data_size,
762                                 const uint8_t *buf, int buf_size)
763 {
764     WavpackContext *wc = avctx->priv_data;
765     WavpackFrameContext *s;
766     void *samples = data;
767     int samplecount;
768     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
769     int got_hybrid = 0;
770     const uint8_t* orig_buf = buf;
771     const uint8_t* buf_end = buf + buf_size;
772     int i, j, id, size, ssize, weights, t;
773     int bpp, chan, chmask;
774
775     if (buf_size == 0){
776         *data_size = 0;
777         return 0;
778     }
779
780     if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
781         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
782         return -1;
783     }
784
785     s = wc->fdec[block_no];
786     if(!s){
787         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
788         return -1;
789     }
790
791     if(!s->samples_left){
792         memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
793         memset(s->ch, 0, sizeof(s->ch));
794         s->extra_bits = 0;
795         s->and = s->or = s->shift = 0;
796         s->got_extra_bits = 0;
797     }
798
799     if(!wc->mkv_mode){
800         s->samples = AV_RL32(buf); buf += 4;
801         if(!s->samples){
802             *data_size = 0;
803             return 0;
804         }
805     }else{
806         s->samples = wc->samples;
807     }
808     s->frame_flags = AV_RL32(buf); buf += 4;
809     if(s->frame_flags&0x80){
810         bpp = sizeof(float);
811         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
812     } else if((s->frame_flags&0x03) <= 1){
813         bpp = 2;
814         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
815     } else {
816         bpp = 4;
817         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
818     }
819     samples = (uint8_t*)samples + bpp * wc->ch_offset;
820
821     s->stereo = !(s->frame_flags & WV_MONO);
822     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
823     s->joint = s->frame_flags & WV_JOINT_STEREO;
824     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
825     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
826     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
827     s->CRC = AV_RL32(buf); buf += 4;
828     if(wc->mkv_mode)
829         buf += 4; //skip block size;
830
831     wc->ch_offset += 1 + s->stereo;
832
833     s->max_samples = *data_size / (bpp * avctx->channels);
834     s->max_samples = FFMIN(s->max_samples, s->samples);
835     if(s->samples_left > 0){
836         s->max_samples = FFMIN(s->max_samples, s->samples_left);
837         buf = buf_end;
838     }
839
840     // parse metadata blocks
841     while(buf < buf_end){
842         id = *buf++;
843         size = *buf++;
844         if(id & WP_IDF_LONG) {
845             size |= (*buf++) << 8;
846             size |= (*buf++) << 16;
847         }
848         size <<= 1; // size is specified in words
849         ssize = size;
850         if(id & WP_IDF_ODD) size--;
851         if(size < 0){
852             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
853             break;
854         }
855         if(buf + ssize > buf_end){
856             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
857             break;
858         }
859         if(id & WP_IDF_IGNORE){
860             buf += ssize;
861             continue;
862         }
863         switch(id & WP_IDF_MASK){
864         case WP_ID_DECTERMS:
865             s->terms = size;
866             if(s->terms > MAX_TERMS){
867                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
868                 buf += ssize;
869                 continue;
870             }
871             for(i = 0; i < s->terms; i++) {
872                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
873                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
874                 buf++;
875             }
876             got_terms = 1;
877             break;
878         case WP_ID_DECWEIGHTS:
879             if(!got_terms){
880                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
881                 continue;
882             }
883             weights = size >> s->stereo_in;
884             if(weights > MAX_TERMS || weights > s->terms){
885                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
886                 buf += ssize;
887                 continue;
888             }
889             for(i = 0; i < weights; i++) {
890                 t = (int8_t)(*buf++);
891                 s->decorr[s->terms - i - 1].weightA = t << 3;
892                 if(s->decorr[s->terms - i - 1].weightA > 0)
893                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
894                 if(s->stereo_in){
895                     t = (int8_t)(*buf++);
896                     s->decorr[s->terms - i - 1].weightB = t << 3;
897                     if(s->decorr[s->terms - i - 1].weightB > 0)
898                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
899                 }
900             }
901             got_weights = 1;
902             break;
903         case WP_ID_DECSAMPLES:
904             if(!got_terms){
905                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
906                 continue;
907             }
908             t = 0;
909             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
910                 if(s->decorr[i].value > 8){
911                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
912                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
913                     if(s->stereo_in){
914                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
915                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
916                         t += 4;
917                     }
918                     t += 4;
919                 }else if(s->decorr[i].value < 0){
920                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
921                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
922                     t += 4;
923                 }else{
924                     for(j = 0; j < s->decorr[i].value; j++){
925                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
926                         if(s->stereo_in){
927                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
928                         }
929                     }
930                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
931                 }
932             }
933             got_samples = 1;
934             break;
935         case WP_ID_ENTROPY:
936             if(size != 6 * (s->stereo_in + 1)){
937                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
938                 buf += ssize;
939                 continue;
940             }
941             for(j = 0; j <= s->stereo_in; j++){
942                 for(i = 0; i < 3; i++){
943                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
944                     buf += 2;
945                 }
946             }
947             got_entropy = 1;
948             break;
949         case WP_ID_HYBRID:
950             if(s->hybrid_bitrate){
951                 for(i = 0; i <= s->stereo_in; i++){
952                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
953                     buf += 2;
954                     size -= 2;
955                 }
956             }
957             for(i = 0; i < (s->stereo_in + 1); i++){
958                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
959                 buf += 2;
960                 size -= 2;
961             }
962             if(size > 0){
963                 for(i = 0; i < (s->stereo_in + 1); i++){
964                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
965                     buf += 2;
966                 }
967             }else{
968                 for(i = 0; i < (s->stereo_in + 1); i++)
969                     s->ch[i].bitrate_delta = 0;
970             }
971             got_hybrid = 1;
972             break;
973         case WP_ID_INT32INFO:
974             if(size != 4){
975                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
976                 buf += ssize;
977                 continue;
978             }
979             if(buf[0])
980                 s->extra_bits = buf[0];
981             else if(buf[1])
982                 s->shift = buf[1];
983             else if(buf[2]){
984                 s->and = s->or = 1;
985                 s->shift = buf[2];
986             }else if(buf[3]){
987                 s->and = 1;
988                 s->shift = buf[3];
989             }
990             buf += 4;
991             break;
992         case WP_ID_FLOATINFO:
993             if(size != 4){
994                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
995                 buf += ssize;
996                 continue;
997             }
998             s->float_flag = buf[0];
999             s->float_shift = buf[1];
1000             s->float_max_exp = buf[2];
1001             buf += 4;
1002             got_float = 1;
1003             break;
1004         case WP_ID_DATA:
1005             s->sc.offset = buf - orig_buf;
1006             s->sc.size   = size * 8;
1007             init_get_bits(&s->gb, buf, size * 8);
1008             s->data_size = size * 8;
1009             buf += size;
1010             got_bs = 1;
1011             break;
1012         case WP_ID_EXTRABITS:
1013             if(size <= 4){
1014                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
1015                 buf += size;
1016                 continue;
1017             }
1018             s->extra_sc.offset = buf - orig_buf;
1019             s->extra_sc.size   = size * 8;
1020             init_get_bits(&s->gb_extra_bits, buf, size * 8);
1021             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1022             buf += size;
1023             s->got_extra_bits = 1;
1024             break;
1025         case WP_ID_CHANINFO:
1026             if(size <= 1){
1027                 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1028                 return -1;
1029             }
1030             chan = *buf++;
1031             switch(size - 2){
1032             case 0:
1033                 chmask = *buf;
1034                 break;
1035             case 1:
1036                 chmask = AV_RL16(buf);
1037                 break;
1038             case 2:
1039                 chmask = AV_RL24(buf);
1040                 break;
1041             case 3:
1042                 chmask = AV_RL32(buf);
1043                 break;
1044             case 5:
1045                 chan |= (buf[1] & 0xF) << 8;
1046                 chmask = AV_RL24(buf + 2);
1047                 break;
1048             default:
1049                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
1050                 chan = avctx->channels;
1051                 chmask = avctx->channel_layout;
1052             }
1053             if(chan != avctx->channels){
1054                 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
1055                        chan, avctx->channels);
1056                 return -1;
1057             }
1058             if(!avctx->channel_layout)
1059                 avctx->channel_layout = chmask;
1060             buf += size - 1;
1061             break;
1062         default:
1063             buf += size;
1064         }
1065         if(id & WP_IDF_ODD) buf++;
1066     }
1067     if(!s->samples_left){
1068         if(!got_terms){
1069             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1070             return -1;
1071         }
1072         if(!got_weights){
1073             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1074             return -1;
1075         }
1076         if(!got_samples){
1077             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1078             return -1;
1079         }
1080         if(!got_entropy){
1081             av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1082             return -1;
1083         }
1084         if(s->hybrid && !got_hybrid){
1085             av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1086             return -1;
1087         }
1088         if(!got_bs){
1089             av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1090             return -1;
1091         }
1092         if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
1093             av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1094             return -1;
1095         }
1096         if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
1097             const int size = get_bits_left(&s->gb_extra_bits);
1098             const int wanted = s->samples * s->extra_bits << s->stereo_in;
1099             if(size < wanted){
1100                 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1101                 s->got_extra_bits = 0;
1102             }
1103         }
1104         s->samples_left = s->samples;
1105     }else{
1106         init_get_bits(&s->gb, orig_buf + s->sc.offset, s->sc.size);
1107         skip_bits_long(&s->gb, s->sc.bits_used);
1108         if(s->got_extra_bits){
1109             init_get_bits(&s->gb_extra_bits, orig_buf + s->extra_sc.offset,
1110                           s->extra_sc.size);
1111             skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
1112         }
1113     }
1114
1115     if(s->stereo_in){
1116         if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1117             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1118         else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1119             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1120         else
1121             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1122
1123         if (samplecount < 0)
1124             return -1;
1125
1126         samplecount >>= 1;
1127     }else{
1128         const int channel_stride = avctx->channels;
1129
1130         if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1131             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1132         else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1133             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1134         else
1135             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1136
1137         if (samplecount < 0)
1138             return -1;
1139
1140         if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
1141             int16_t *dst = (int16_t*)samples + 1;
1142             int16_t *src = (int16_t*)samples;
1143             int cnt = samplecount;
1144             while(cnt--){
1145                 *dst = *src;
1146                 src += channel_stride;
1147                 dst += channel_stride;
1148             }
1149         }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
1150             int32_t *dst = (int32_t*)samples + 1;
1151             int32_t *src = (int32_t*)samples;
1152             int cnt = samplecount;
1153             while(cnt--){
1154                 *dst = *src;
1155                 src += channel_stride;
1156                 dst += channel_stride;
1157             }
1158         }else if(s->stereo){
1159             float *dst = (float*)samples + 1;
1160             float *src = (float*)samples;
1161             int cnt = samplecount;
1162             while(cnt--){
1163                 *dst = *src;
1164                 src += channel_stride;
1165                 dst += channel_stride;
1166             }
1167         }
1168     }
1169
1170     wc->samples_left = s->samples_left;
1171
1172     return samplecount * bpp;
1173 }
1174
1175 static int wavpack_decode_frame(AVCodecContext *avctx,
1176                             void *data, int *data_size,
1177                             AVPacket *avpkt)
1178 {
1179     WavpackContext *s = avctx->priv_data;
1180     const uint8_t *buf = avpkt->data;
1181     int buf_size = avpkt->size;
1182     int frame_size;
1183     int samplecount = 0;
1184
1185     s->block = 0;
1186     s->samples_left = 0;
1187     s->ch_offset = 0;
1188
1189     if(s->mkv_mode){
1190         s->samples = AV_RL32(buf); buf += 4;
1191     }
1192     while(buf_size > 0){
1193         if(!s->multichannel){
1194             frame_size = buf_size;
1195         }else{
1196             if(!s->mkv_mode){
1197                 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1198             }else{
1199                 if(buf_size < 12) //MKV files can have zero flags after last block
1200                     break;
1201                 frame_size = AV_RL32(buf + 8) + 12;
1202             }
1203         }
1204         if(frame_size < 0 || frame_size > buf_size){
1205             av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1206                    s->block, frame_size, buf_size);
1207             return -1;
1208         }
1209         if((samplecount = wavpack_decode_block(avctx, s->block, data,
1210                                                data_size, buf, frame_size)) < 0)
1211             return -1;
1212         s->block++;
1213         buf += frame_size; buf_size -= frame_size;
1214     }
1215     *data_size = samplecount * avctx->channels;
1216
1217     return s->samples_left > 0 ? 0 : avpkt->size;
1218 }
1219
1220 AVCodec ff_wavpack_decoder = {
1221     "wavpack",
1222     AVMEDIA_TYPE_AUDIO,
1223     CODEC_ID_WAVPACK,
1224     sizeof(WavpackContext),
1225     wavpack_decode_init,
1226     NULL,
1227     wavpack_decode_end,
1228     wavpack_decode_frame,
1229     .capabilities = CODEC_CAP_SUBFRAMES,
1230     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1231 };