wavpack: don't set sample format in init.
[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
720     if (avctx->channels <= 2 && !avctx->channel_layout)
721         avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO
722                                                        : AV_CH_LAYOUT_MONO;
723
724     s->multichannel = avctx->channels > 2;
725     /* lavf demuxer does not provide extradata, Matroska stores 0x403
726      * there, use this to detect decoding mode for multichannel */
727     s->mkv_mode = 0;
728     if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
729         int ver = AV_RL16(avctx->extradata);
730         if (ver >= 0x402 && ver <= 0x410)
731             s->mkv_mode = 1;
732     }
733
734     s->fdec_num = 0;
735
736     return 0;
737 }
738
739 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
740 {
741     WavpackContext *s = avctx->priv_data;
742     int i;
743
744     for (i = 0; i < s->fdec_num; i++)
745         av_freep(&s->fdec[i]);
746     s->fdec_num = 0;
747
748     return 0;
749 }
750
751 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
752                                 uint8_t **data, const uint8_t *buf, int buf_size)
753 {
754     WavpackContext *wc = avctx->priv_data;
755     WavpackFrameContext *s;
756     GetByteContext gb;
757     void *samples_l, *samples_r;
758     int ret;
759     int got_terms   = 0, got_weights = 0, got_samples = 0,
760         got_entropy = 0, got_bs      = 0, got_float   = 0, got_hybrid = 0;
761     int i, j, id, size, ssize, weights, t;
762     int bpp, chan, chmask, orig_bpp;
763
764     if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
765         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
766         return AVERROR_INVALIDDATA;
767     }
768
769     s = wc->fdec[block_no];
770     if (!s) {
771         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n",
772                block_no);
773         return AVERROR_INVALIDDATA;
774     }
775
776     memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
777     memset(s->ch, 0, sizeof(s->ch));
778     s->extra_bits     = 0;
779     s->and            = s->or = s->shift = 0;
780     s->got_extra_bits = 0;
781
782     bytestream2_init(&gb, buf, buf_size);
783
784     if (!wc->mkv_mode) {
785         s->samples = bytestream2_get_le32(&gb);
786         if (s->samples != wc->samples) {
787             av_log(avctx, AV_LOG_ERROR, "Mismatching number of samples in "
788                    "a sequence: %d and %d\n", wc->samples, s->samples);
789             return AVERROR_INVALIDDATA;
790         }
791     } else {
792         s->samples = wc->samples;
793     }
794     s->frame_flags = bytestream2_get_le32(&gb);
795     bpp            = av_get_bytes_per_sample(avctx->sample_fmt);
796     orig_bpp       = ((s->frame_flags & 0x03) + 1) << 3;
797
798     s->stereo         = !(s->frame_flags & WV_MONO);
799     s->stereo_in      =  (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
800     s->joint          =   s->frame_flags & WV_JOINT_STEREO;
801     s->hybrid         =   s->frame_flags & WV_HYBRID_MODE;
802     s->hybrid_bitrate =   s->frame_flags & WV_HYBRID_BITRATE;
803     s->post_shift     = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
804     s->hybrid_maxclip =  ((1LL << (orig_bpp - 1)) - 1);
805     s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
806     s->CRC            = bytestream2_get_le32(&gb);
807
808     samples_l = data[wc->ch_offset];
809     if (s->stereo)
810         samples_r = data[wc->ch_offset + 1];
811
812     if (wc->mkv_mode)
813         bytestream2_skip(&gb, 4);  // skip block size;
814
815     wc->ch_offset += 1 + s->stereo;
816
817     // parse metadata blocks
818     while (bytestream2_get_bytes_left(&gb)) {
819         id   = bytestream2_get_byte(&gb);
820         size = bytestream2_get_byte(&gb);
821         if (id & WP_IDF_LONG) {
822             size |= (bytestream2_get_byte(&gb)) << 8;
823             size |= (bytestream2_get_byte(&gb)) << 16;
824         }
825         size <<= 1; // size is specified in words
826         ssize  = size;
827         if (id & WP_IDF_ODD)
828             size--;
829         if (size < 0) {
830             av_log(avctx, AV_LOG_ERROR,
831                    "Got incorrect block %02X with size %i\n", id, size);
832             break;
833         }
834         if (bytestream2_get_bytes_left(&gb) < ssize) {
835             av_log(avctx, AV_LOG_ERROR,
836                    "Block size %i is out of bounds\n", size);
837             break;
838         }
839         if (id & WP_IDF_IGNORE) {
840             bytestream2_skip(&gb, ssize);
841             continue;
842         }
843         switch (id & WP_IDF_MASK) {
844         case WP_ID_DECTERMS:
845             if (size > MAX_TERMS) {
846                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
847                 s->terms = 0;
848                 bytestream2_skip(&gb, ssize);
849                 continue;
850             }
851             s->terms = size;
852             for (i = 0; i < s->terms; i++) {
853                 uint8_t val = bytestream2_get_byte(&gb);
854                 s->decorr[s->terms - i - 1].value = (val & 0x1F) - 5;
855                 s->decorr[s->terms - i - 1].delta =  val >> 5;
856             }
857             got_terms = 1;
858             break;
859         case WP_ID_DECWEIGHTS:
860             if (!got_terms) {
861                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
862                 continue;
863             }
864             weights = size >> s->stereo_in;
865             if (weights > MAX_TERMS || weights > s->terms) {
866                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
867                 bytestream2_skip(&gb, ssize);
868                 continue;
869             }
870             for (i = 0; i < weights; i++) {
871                 t = (int8_t)bytestream2_get_byte(&gb);
872                 s->decorr[s->terms - i - 1].weightA = t << 3;
873                 if (s->decorr[s->terms - i - 1].weightA > 0)
874                     s->decorr[s->terms - i - 1].weightA +=
875                         (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
876                 if (s->stereo_in) {
877                     t = (int8_t)bytestream2_get_byte(&gb);
878                     s->decorr[s->terms - i - 1].weightB = t << 3;
879                     if (s->decorr[s->terms - i - 1].weightB > 0)
880                         s->decorr[s->terms - i - 1].weightB +=
881                             (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
882                 }
883             }
884             got_weights = 1;
885             break;
886         case WP_ID_DECSAMPLES:
887             if (!got_terms) {
888                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
889                 continue;
890             }
891             t = 0;
892             for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
893                 if (s->decorr[i].value > 8) {
894                     s->decorr[i].samplesA[0] =
895                         wp_exp2(bytestream2_get_le16(&gb));
896                     s->decorr[i].samplesA[1] =
897                         wp_exp2(bytestream2_get_le16(&gb));
898
899                     if (s->stereo_in) {
900                         s->decorr[i].samplesB[0] =
901                             wp_exp2(bytestream2_get_le16(&gb));
902                         s->decorr[i].samplesB[1] =
903                             wp_exp2(bytestream2_get_le16(&gb));
904                         t                       += 4;
905                     }
906                     t += 4;
907                 } else if (s->decorr[i].value < 0) {
908                     s->decorr[i].samplesA[0] =
909                         wp_exp2(bytestream2_get_le16(&gb));
910                     s->decorr[i].samplesB[0] =
911                         wp_exp2(bytestream2_get_le16(&gb));
912                     t                       += 4;
913                 } else {
914                     for (j = 0; j < s->decorr[i].value; j++) {
915                         s->decorr[i].samplesA[j] =
916                             wp_exp2(bytestream2_get_le16(&gb));
917                         if (s->stereo_in) {
918                             s->decorr[i].samplesB[j] =
919                                 wp_exp2(bytestream2_get_le16(&gb));
920                         }
921                     }
922                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
923                 }
924             }
925             got_samples = 1;
926             break;
927         case WP_ID_ENTROPY:
928             if (size != 6 * (s->stereo_in + 1)) {
929                 av_log(avctx, AV_LOG_ERROR,
930                        "Entropy vars size should be %i, got %i",
931                        6 * (s->stereo_in + 1), size);
932                 bytestream2_skip(&gb, ssize);
933                 continue;
934             }
935             for (j = 0; j <= s->stereo_in; j++)
936                 for (i = 0; i < 3; i++) {
937                     s->ch[j].median[i] = wp_exp2(bytestream2_get_le16(&gb));
938                 }
939             got_entropy = 1;
940             break;
941         case WP_ID_HYBRID:
942             if (s->hybrid_bitrate) {
943                 for (i = 0; i <= s->stereo_in; i++) {
944                     s->ch[i].slow_level = wp_exp2(bytestream2_get_le16(&gb));
945                     size               -= 2;
946                 }
947             }
948             for (i = 0; i < (s->stereo_in + 1); i++) {
949                 s->ch[i].bitrate_acc = bytestream2_get_le16(&gb) << 16;
950                 size                -= 2;
951             }
952             if (size > 0) {
953                 for (i = 0; i < (s->stereo_in + 1); i++) {
954                     s->ch[i].bitrate_delta =
955                         wp_exp2((int16_t)bytestream2_get_le16(&gb));
956                 }
957             } else {
958                 for (i = 0; i < (s->stereo_in + 1); i++)
959                     s->ch[i].bitrate_delta = 0;
960             }
961             got_hybrid = 1;
962             break;
963         case WP_ID_INT32INFO: {
964             uint8_t val[4];
965             if (size != 4) {
966                 av_log(avctx, AV_LOG_ERROR,
967                        "Invalid INT32INFO, size = %i\n",
968                        size);
969                 bytestream2_skip(&gb, ssize - 4);
970                 continue;
971             }
972             bytestream2_get_buffer(&gb, val, 4);
973             if (val[0]) {
974                 s->extra_bits = val[0];
975             } else if (val[1]) {
976                 s->shift = val[1];
977             } else if (val[2]) {
978                 s->and   = s->or = 1;
979                 s->shift = val[2];
980             } else if (val[3]) {
981                 s->and   = 1;
982                 s->shift = val[3];
983             }
984             /* original WavPack decoder forces 32-bit lossy sound to be treated
985              * as 24-bit one in order to have proper clipping */
986             if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
987                 s->post_shift      += 8;
988                 s->shift           -= 8;
989                 s->hybrid_maxclip >>= 8;
990                 s->hybrid_minclip >>= 8;
991             }
992             break;
993         }
994         case WP_ID_FLOATINFO:
995             if (size != 4) {
996                 av_log(avctx, AV_LOG_ERROR,
997                        "Invalid FLOATINFO, size = %i\n", size);
998                 bytestream2_skip(&gb, ssize);
999                 continue;
1000             }
1001             s->float_flag    = bytestream2_get_byte(&gb);
1002             s->float_shift   = bytestream2_get_byte(&gb);
1003             s->float_max_exp = bytestream2_get_byte(&gb);
1004             got_float        = 1;
1005             bytestream2_skip(&gb, 1);
1006             break;
1007         case WP_ID_DATA:
1008             s->sc.offset = bytestream2_tell(&gb);
1009             s->sc.size   = size * 8;
1010             init_get_bits(&s->gb, gb.buffer, size * 8);
1011             s->data_size = size * 8;
1012             bytestream2_skip(&gb, size);
1013             got_bs       = 1;
1014             break;
1015         case WP_ID_EXTRABITS:
1016             if (size <= 4) {
1017                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1018                        size);
1019                 bytestream2_skip(&gb, size);
1020                 continue;
1021             }
1022             s->extra_sc.offset = bytestream2_tell(&gb);
1023             s->extra_sc.size   = size * 8;
1024             init_get_bits(&s->gb_extra_bits, gb.buffer, size * 8);
1025             s->crc_extra_bits  = get_bits_long(&s->gb_extra_bits, 32);
1026             bytestream2_skip(&gb, size);
1027             s->got_extra_bits  = 1;
1028             break;
1029         case WP_ID_CHANINFO:
1030             if (size <= 1) {
1031                 av_log(avctx, AV_LOG_ERROR,
1032                        "Insufficient channel information\n");
1033                 return AVERROR_INVALIDDATA;
1034             }
1035             chan = bytestream2_get_byte(&gb);
1036             switch (size - 2) {
1037             case 0:
1038                 chmask = bytestream2_get_byte(&gb);
1039                 break;
1040             case 1:
1041                 chmask = bytestream2_get_le16(&gb);
1042                 break;
1043             case 2:
1044                 chmask = bytestream2_get_le24(&gb);
1045                 break;
1046             case 3:
1047                 chmask = bytestream2_get_le32(&gb);;
1048                 break;
1049             case 5:
1050                 bytestream2_skip(&gb, 1);
1051                 chan  |= (bytestream2_get_byte(&gb) & 0xF) << 8;
1052                 chmask = bytestream2_get_le16(&gb);
1053                 break;
1054             default:
1055                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1056                        size);
1057                 chan   = avctx->channels;
1058                 chmask = avctx->channel_layout;
1059             }
1060             if (chan != avctx->channels) {
1061                 av_log(avctx, AV_LOG_ERROR,
1062                        "Block reports total %d channels, "
1063                        "decoder believes it's %d channels\n",
1064                        chan, avctx->channels);
1065                 return AVERROR_INVALIDDATA;
1066             }
1067             if (!avctx->channel_layout)
1068                 avctx->channel_layout = chmask;
1069             break;
1070         default:
1071             bytestream2_skip(&gb, size);
1072         }
1073         if (id & WP_IDF_ODD)
1074             bytestream2_skip(&gb, 1);
1075     }
1076
1077     if (!got_terms) {
1078         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1079         return AVERROR_INVALIDDATA;
1080     }
1081     if (!got_weights) {
1082         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1083         return AVERROR_INVALIDDATA;
1084     }
1085     if (!got_samples) {
1086         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1087         return AVERROR_INVALIDDATA;
1088     }
1089     if (!got_entropy) {
1090         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1091         return AVERROR_INVALIDDATA;
1092     }
1093     if (s->hybrid && !got_hybrid) {
1094         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1095         return AVERROR_INVALIDDATA;
1096     }
1097     if (!got_bs) {
1098         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1099         return AVERROR_INVALIDDATA;
1100     }
1101     if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) {
1102         av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1103         return AVERROR_INVALIDDATA;
1104     }
1105     if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) {
1106         const int size   = get_bits_left(&s->gb_extra_bits);
1107         const int wanted = s->samples * s->extra_bits << s->stereo_in;
1108         if (size < wanted) {
1109             av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1110             s->got_extra_bits = 0;
1111         }
1112     }
1113
1114     if (s->stereo_in) {
1115         ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt);
1116         if (ret < 0)
1117             return ret;
1118     } else {
1119         ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt);
1120         if (ret < 0)
1121             return ret;
1122
1123         if (s->stereo)
1124             memcpy(samples_r, samples_l, bpp * s->samples);
1125     }
1126
1127     return 0;
1128 }
1129
1130 static void wavpack_decode_flush(AVCodecContext *avctx)
1131 {
1132     WavpackContext *s = avctx->priv_data;
1133     int i;
1134
1135     for (i = 0; i < s->fdec_num; i++)
1136         wv_reset_saved_context(s->fdec[i]);
1137 }
1138
1139 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1140                                 int *got_frame_ptr, AVPacket *avpkt)
1141 {
1142     WavpackContext *s  = avctx->priv_data;
1143     const uint8_t *buf = avpkt->data;
1144     int buf_size       = avpkt->size;
1145     AVFrame *frame     = data;
1146     int frame_size, ret, frame_flags;
1147
1148     if (avpkt->size < 12 + s->multichannel * 4)
1149         return AVERROR_INVALIDDATA;
1150
1151     s->block     = 0;
1152     s->ch_offset = 0;
1153
1154     /* determine number of samples */
1155     if (s->mkv_mode) {
1156         s->samples  = AV_RL32(buf);
1157         buf        += 4;
1158         frame_flags = AV_RL32(buf);
1159     } else {
1160         if (s->multichannel) {
1161             s->samples  = AV_RL32(buf + 4);
1162             frame_flags = AV_RL32(buf + 8);
1163         } else {
1164             s->samples  = AV_RL32(buf);
1165             frame_flags = AV_RL32(buf + 4);
1166         }
1167     }
1168     if (s->samples <= 0) {
1169         av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1170                s->samples);
1171         return AVERROR_INVALIDDATA;
1172     }
1173
1174     if (frame_flags & 0x80) {
1175         avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1176     } else if ((frame_flags & 0x03) <= 1) {
1177         avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
1178     } else {
1179         avctx->sample_fmt          = AV_SAMPLE_FMT_S32P;
1180         avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1181     }
1182
1183     /* get output buffer */
1184     frame->nb_samples = s->samples;
1185     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1186         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1187         return ret;
1188     }
1189
1190     while (buf_size > 0) {
1191         if (!s->multichannel) {
1192             frame_size = buf_size;
1193         } else {
1194             if (!s->mkv_mode) {
1195                 frame_size = AV_RL32(buf) - 12;
1196                 buf       += 4;
1197                 buf_size  -= 4;
1198             } else {
1199                 if (buf_size < 12) // MKV files can have zero flags after last block
1200                     break;
1201                 frame_size = AV_RL32(buf + 8) + 12;
1202             }
1203         }
1204         if (frame_size <= 0 || frame_size > buf_size) {
1205             av_log(avctx, AV_LOG_ERROR,
1206                    "Block %d has invalid size (size %d vs. %d bytes left)\n",
1207                    s->block, frame_size, buf_size);
1208             wavpack_decode_flush(avctx);
1209             return AVERROR_INVALIDDATA;
1210         }
1211         if ((ret = wavpack_decode_block(avctx, s->block,
1212                                         frame->extended_data,
1213                                         buf, frame_size)) < 0) {
1214             wavpack_decode_flush(avctx);
1215             return ret;
1216         }
1217         s->block++;
1218         buf      += frame_size;
1219         buf_size -= frame_size;
1220     }
1221
1222     *got_frame_ptr = 1;
1223
1224     return avpkt->size;
1225 }
1226
1227 AVCodec ff_wavpack_decoder = {
1228     .name           = "wavpack",
1229     .type           = AVMEDIA_TYPE_AUDIO,
1230     .id             = AV_CODEC_ID_WAVPACK,
1231     .priv_data_size = sizeof(WavpackContext),
1232     .init           = wavpack_decode_init,
1233     .close          = wavpack_decode_end,
1234     .decode         = wavpack_decode_frame,
1235     .flush          = wavpack_decode_flush,
1236     .capabilities   = CODEC_CAP_DR1,
1237     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
1238 };