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