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