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