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