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