wavpack: fix clipping for 32-bit lossy mode
[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_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
504                                    void *dst, const int type)
505 {
506     int i, j, count = 0;
507     int last, t;
508     int A, B, L, L2, R, R2;
509     int pos = s->pos;
510     uint32_t crc = s->sc.crc;
511     uint32_t crc_extra_bits = s->extra_sc.crc;
512     int16_t *dst16 = dst;
513     int32_t *dst32 = dst;
514     float   *dstfl = dst;
515     const int channel_pad = s->avctx->channels - 2;
516
517     s->one = s->zero = s->zeroes = 0;
518     do {
519         L = wv_get_value(s, gb, 0, &last);
520         if (last)
521             break;
522         R = wv_get_value(s, gb, 1, &last);
523         if (last)
524             break;
525         for (i = 0; i < s->terms; i++) {
526             t = s->decorr[i].value;
527             if (t > 0) {
528                 if (t > 8) {
529                     if (t & 1) {
530                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
531                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
532                     } else {
533                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
534                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
535                     }
536                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
537                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
538                     j = 0;
539                 } else {
540                     A = s->decorr[i].samplesA[pos];
541                     B = s->decorr[i].samplesB[pos];
542                     j = (pos + t) & 7;
543                 }
544                 if (type != AV_SAMPLE_FMT_S16) {
545                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
546                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
547                 } else {
548                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
549                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
550                 }
551                 if (A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
552                 if (B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
553                 s->decorr[i].samplesA[j] = L = L2;
554                 s->decorr[i].samplesB[j] = R = R2;
555             } else if (t == -1) {
556                 if (type != AV_SAMPLE_FMT_S16)
557                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
558                 else
559                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
560                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
561                 L = L2;
562                 if (type != AV_SAMPLE_FMT_S16)
563                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
564                 else
565                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
566                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
567                 R = R2;
568                 s->decorr[i].samplesA[0] = R;
569             } else {
570                 if (type != AV_SAMPLE_FMT_S16)
571                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
572                 else
573                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
574                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
575                 R = R2;
576
577                 if (t == -3) {
578                     R2 = s->decorr[i].samplesA[0];
579                     s->decorr[i].samplesA[0] = R;
580                 }
581
582                 if (type != AV_SAMPLE_FMT_S16)
583                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
584                 else
585                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
586                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
587                 L = L2;
588                 s->decorr[i].samplesB[0] = L;
589             }
590         }
591         pos = (pos + 1) & 7;
592         if (s->joint)
593             L += (R -= (L >> 1));
594         crc = (crc * 3 + L) * 3 + R;
595
596         if (type == AV_SAMPLE_FMT_FLT) {
597             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
598             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
599             dstfl += channel_pad;
600         } else if (type == AV_SAMPLE_FMT_S32) {
601             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
602             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
603             dst32 += channel_pad;
604         } else {
605             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
606             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
607             dst16 += channel_pad;
608         }
609         count++;
610     } while (!last && count < s->samples);
611
612     wv_reset_saved_context(s);
613     if (crc != s->CRC) {
614         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
615         return -1;
616     }
617     if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
618         av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
619         return -1;
620     }
621
622     return count * 2;
623 }
624
625 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
626                                  void *dst, const int type)
627 {
628     int i, j, count = 0;
629     int last, t;
630     int A, S, T;
631     int pos = s->pos;
632     uint32_t crc = s->sc.crc;
633     uint32_t crc_extra_bits = s->extra_sc.crc;
634     int16_t *dst16 = dst;
635     int32_t *dst32 = dst;
636     float   *dstfl = dst;
637     const int channel_stride = s->avctx->channels;
638
639     s->one = s->zero = s->zeroes = 0;
640     do {
641         T = wv_get_value(s, gb, 0, &last);
642         S = 0;
643         if (last)
644             break;
645         for (i = 0; i < s->terms; i++) {
646             t = s->decorr[i].value;
647             if (t > 8) {
648                 if (t & 1)
649                     A =  2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
650                 else
651                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
652                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
653                 j = 0;
654             } else {
655                 A = s->decorr[i].samplesA[pos];
656                 j = (pos + t) & 7;
657             }
658             if (type != AV_SAMPLE_FMT_S16)
659                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
660             else
661                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
662             if (A && T)
663                 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
664             s->decorr[i].samplesA[j] = T = S;
665         }
666         pos = (pos + 1) & 7;
667         crc = crc * 3 + S;
668
669         if (type == AV_SAMPLE_FMT_FLT) {
670             *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
671             dstfl += channel_stride;
672         } else if (type == AV_SAMPLE_FMT_S32) {
673             *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
674             dst32 += channel_stride;
675         } else {
676             *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
677             dst16 += channel_stride;
678         }
679         count++;
680     } while (!last && count < s->samples);
681
682     wv_reset_saved_context(s);
683     if (crc != s->CRC) {
684         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
685         return -1;
686     }
687     if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
688         av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
689         return -1;
690     }
691
692     return count;
693 }
694
695 static av_cold int wv_alloc_frame_context(WavpackContext *c)
696 {
697
698     if (c->fdec_num == WV_MAX_FRAME_DECODERS)
699         return -1;
700
701     c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
702     if (!c->fdec[c->fdec_num])
703         return -1;
704     c->fdec_num++;
705     c->fdec[c->fdec_num - 1]->avctx = c->avctx;
706     wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
707
708     return 0;
709 }
710
711 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
712 {
713     WavpackContext *s = avctx->priv_data;
714
715     s->avctx = avctx;
716     if (avctx->bits_per_coded_sample <= 16)
717         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
718     else
719         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
720     if (avctx->channels <= 2 && !avctx->channel_layout)
721         avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO :
722                                                          AV_CH_LAYOUT_MONO;
723
724     s->multichannel = avctx->channels > 2;
725     /* lavf demuxer does not provide extradata, Matroska stores 0x403
726        there, use this to detect decoding mode for multichannel */
727     s->mkv_mode = 0;
728     if (s->multichannel && avctx->extradata && avctx->extradata_size == 2) {
729         int ver = AV_RL16(avctx->extradata);
730         if (ver >= 0x402 && ver <= 0x410)
731             s->mkv_mode = 1;
732     }
733
734     s->fdec_num = 0;
735
736     avcodec_get_frame_defaults(&s->frame);
737     avctx->coded_frame = &s->frame;
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                                 void *data, int *got_frame_ptr,
756                                 const uint8_t *buf, int buf_size)
757 {
758     WavpackContext *wc = avctx->priv_data;
759     WavpackFrameContext *s;
760     void *samples = data;
761     int samplecount;
762     int got_terms   = 0, got_weights = 0, got_samples = 0,
763         got_entropy = 0, got_bs      = 0, got_float   = 0, got_hybrid = 0;
764     const uint8_t *orig_buf = buf;
765     const uint8_t *buf_end  = buf + buf_size;
766     int i, j, id, size, ssize, weights, t;
767     int bpp, chan, chmask, orig_bpp;
768
769     if (buf_size == 0) {
770         *got_frame_ptr = 0;
771         return 0;
772     }
773
774     if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
775         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
776         return -1;
777     }
778
779     s = wc->fdec[block_no];
780     if (!s) {
781         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
782         return -1;
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     if (!wc->mkv_mode) {
792         s->samples = AV_RL32(buf); buf += 4;
793         if (!s->samples) {
794             *got_frame_ptr = 0;
795             return 0;
796         }
797     } else {
798         s->samples = wc->samples;
799     }
800     s->frame_flags = AV_RL32(buf); buf += 4;
801     bpp = av_get_bytes_per_sample(avctx->sample_fmt);
802     samples = (uint8_t*)samples + bpp * wc->ch_offset;
803     orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
804
805     s->stereo         = !(s->frame_flags & WV_MONO);
806     s->stereo_in      =  (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
807     s->joint          =   s->frame_flags & WV_JOINT_STEREO;
808     s->hybrid         =   s->frame_flags & WV_HYBRID_MODE;
809     s->hybrid_bitrate =   s->frame_flags & WV_HYBRID_BITRATE;
810     s->post_shift     = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
811     s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1) >> s->post_shift;
812     s->hybrid_minclip = ((-1LL << (orig_bpp - 1)))     >> s->post_shift;
813     s->CRC            = AV_RL32(buf); buf += 4;
814     if (wc->mkv_mode)
815         buf += 4; //skip block size;
816
817     wc->ch_offset += 1 + s->stereo;
818
819     // parse metadata blocks
820     while (buf < buf_end) {
821         id   = *buf++;
822         size = *buf++;
823         if (id & WP_IDF_LONG) {
824             size |= (*buf++) << 8;
825             size |= (*buf++) << 16;
826         }
827         size <<= 1; // size is specified in words
828         ssize = size;
829         if (id & WP_IDF_ODD)
830             size--;
831         if (size < 0) {
832             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
833             break;
834         }
835         if (buf + ssize > buf_end) {
836             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
837             break;
838         }
839         if (id & WP_IDF_IGNORE) {
840             buf += ssize;
841             continue;
842         }
843         switch (id & WP_IDF_MASK) {
844         case WP_ID_DECTERMS:
845             if (size > MAX_TERMS) {
846                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
847                 s->terms = 0;
848                 buf += ssize;
849                 continue;
850             }
851             s->terms = size;
852             for (i = 0; i < s->terms; i++) {
853                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
854                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
855                 buf++;
856             }
857             got_terms = 1;
858             break;
859         case WP_ID_DECWEIGHTS:
860             if (!got_terms) {
861                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
862                 continue;
863             }
864             weights = size >> s->stereo_in;
865             if (weights > MAX_TERMS || weights > s->terms) {
866                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
867                 buf += ssize;
868                 continue;
869             }
870             for (i = 0; i < weights; i++) {
871                 t = (int8_t)(*buf++);
872                 s->decorr[s->terms - i - 1].weightA = t << 3;
873                 if (s->decorr[s->terms - i - 1].weightA > 0)
874                     s->decorr[s->terms - i - 1].weightA +=
875                             (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
876                 if (s->stereo_in) {
877                     t = (int8_t)(*buf++);
878                     s->decorr[s->terms - i - 1].weightB = t << 3;
879                     if (s->decorr[s->terms - i - 1].weightB > 0)
880                         s->decorr[s->terms - i - 1].weightB +=
881                                 (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
882                 }
883             }
884             got_weights = 1;
885             break;
886         case WP_ID_DECSAMPLES:
887             if (!got_terms) {
888                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
889                 continue;
890             }
891             t = 0;
892             for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
893                 if (s->decorr[i].value > 8) {
894                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
895                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
896                     if (s->stereo_in) {
897                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
898                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
899                         t += 4;
900                     }
901                     t += 4;
902                 } else if (s->decorr[i].value < 0) {
903                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
904                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
905                     t += 4;
906                 } else {
907                     for (j = 0; j < s->decorr[i].value; j++) {
908                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
909                         if (s->stereo_in)
910                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
911                     }
912                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
913                 }
914             }
915             got_samples = 1;
916             break;
917         case WP_ID_ENTROPY:
918             if (size != 6 * (s->stereo_in + 1)) {
919                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
920                        "got %i", 6 * (s->stereo_in + 1), size);
921                 buf += ssize;
922                 continue;
923             }
924             for (j = 0; j <= s->stereo_in; j++) {
925                 for (i = 0; i < 3; i++) {
926                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
927                     buf += 2;
928                 }
929             }
930             got_entropy = 1;
931             break;
932         case WP_ID_HYBRID:
933             if (s->hybrid_bitrate) {
934                 for (i = 0; i <= s->stereo_in; i++) {
935                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
936                     buf += 2;
937                     size -= 2;
938                 }
939             }
940             for (i = 0; i < (s->stereo_in + 1); i++) {
941                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
942                 buf += 2;
943                 size -= 2;
944             }
945             if (size > 0) {
946                 for (i = 0; i < (s->stereo_in + 1); i++) {
947                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
948                     buf += 2;
949                 }
950             } else {
951                 for (i = 0; i < (s->stereo_in + 1); i++)
952                     s->ch[i].bitrate_delta = 0;
953             }
954             got_hybrid = 1;
955             break;
956         case WP_ID_INT32INFO:
957             if (size != 4) {
958                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
959                 buf += ssize;
960                 continue;
961             }
962             if (buf[0])
963                 s->extra_bits = buf[0];
964             else if (buf[1])
965                 s->shift = buf[1];
966             else if (buf[2]){
967                 s->and = s->or = 1;
968                 s->shift = buf[2];
969             } else if(buf[3]) {
970                 s->and   = 1;
971                 s->shift = buf[3];
972             }
973             /* original WavPack decoder forces 32-bit lossy sound to be treated
974              * as 24-bit one in order to have proper clipping
975              */
976             if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
977                 s->post_shift += 8;
978                 s->shift      -= 8;
979                 s->hybrid_maxclip >>= 8;
980                 s->hybrid_minclip >>= 8;
981             }
982             buf += 4;
983             break;
984         case WP_ID_FLOATINFO:
985             if (size != 4) {
986                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
987                 buf += ssize;
988                 continue;
989             }
990             s->float_flag    = buf[0];
991             s->float_shift   = buf[1];
992             s->float_max_exp = buf[2];
993             buf += 4;
994             got_float = 1;
995             break;
996         case WP_ID_DATA:
997             s->sc.offset = buf - orig_buf;
998             s->sc.size   = size * 8;
999             init_get_bits(&s->gb, buf, size * 8);
1000             s->data_size = size * 8;
1001             buf += size;
1002             got_bs = 1;
1003             break;
1004         case WP_ID_EXTRABITS:
1005             if (size <= 4) {
1006                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1007                        size);
1008                 buf += size;
1009                 continue;
1010             }
1011             s->extra_sc.offset = buf - orig_buf;
1012             s->extra_sc.size   = size * 8;
1013             init_get_bits(&s->gb_extra_bits, buf, size * 8);
1014             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1015             buf += size;
1016             s->got_extra_bits = 1;
1017             break;
1018         case WP_ID_CHANINFO:
1019             if (size <= 1) {
1020                 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1021                 return -1;
1022             }
1023             chan = *buf++;
1024             switch (size - 2) {
1025             case 0: chmask = *buf;         break;
1026             case 1: chmask = AV_RL16(buf); break;
1027             case 2: chmask = AV_RL24(buf); break;
1028             case 3: chmask = AV_RL32(buf); break;
1029             case 5:
1030                 chan |= (buf[1] & 0xF) << 8;
1031                 chmask = AV_RL24(buf + 2);
1032                 break;
1033             default:
1034                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1035                        size);
1036                 chan   = avctx->channels;
1037                 chmask = avctx->channel_layout;
1038             }
1039             if (chan != avctx->channels) {
1040                 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1041                        "decoder believes it's %d channels\n", chan,
1042                        avctx->channels);
1043                 return -1;
1044             }
1045             if (!avctx->channel_layout)
1046                 avctx->channel_layout = chmask;
1047             buf += size - 1;
1048             break;
1049         default:
1050             buf += size;
1051         }
1052         if (id & WP_IDF_ODD)
1053             buf++;
1054     }
1055
1056     if (!got_terms) {
1057         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1058         return -1;
1059     }
1060     if (!got_weights) {
1061         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1062         return -1;
1063     }
1064     if (!got_samples) {
1065         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1066         return -1;
1067     }
1068     if (!got_entropy) {
1069         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1070         return -1;
1071     }
1072     if (s->hybrid && !got_hybrid) {
1073         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1074         return -1;
1075     }
1076     if (!got_bs) {
1077         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1078         return -1;
1079     }
1080     if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1081         av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1082         return -1;
1083     }
1084     if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1085         const int size   = get_bits_left(&s->gb_extra_bits);
1086         const int wanted = s->samples * s->extra_bits << s->stereo_in;
1087         if (size < wanted) {
1088             av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1089             s->got_extra_bits = 0;
1090         }
1091     }
1092
1093     if (s->stereo_in) {
1094         if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1095             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1096         else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1097             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1098         else
1099             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1100
1101         if (samplecount < 0)
1102             return -1;
1103
1104         samplecount >>= 1;
1105     } else {
1106         const int channel_stride = avctx->channels;
1107
1108         if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1109             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1110         else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1111             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1112         else
1113             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1114
1115         if (samplecount < 0)
1116             return -1;
1117
1118         if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1119             int16_t *dst = (int16_t*)samples + 1;
1120             int16_t *src = (int16_t*)samples;
1121             int cnt = samplecount;
1122             while (cnt--) {
1123                 *dst = *src;
1124                 src += channel_stride;
1125                 dst += channel_stride;
1126             }
1127         } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1128             int32_t *dst = (int32_t*)samples + 1;
1129             int32_t *src = (int32_t*)samples;
1130             int cnt = samplecount;
1131             while (cnt--) {
1132                 *dst = *src;
1133                 src += channel_stride;
1134                 dst += channel_stride;
1135             }
1136         } else if (s->stereo) {
1137             float *dst = (float*)samples + 1;
1138             float *src = (float*)samples;
1139             int cnt = samplecount;
1140             while (cnt--) {
1141                 *dst = *src;
1142                 src += channel_stride;
1143                 dst += channel_stride;
1144             }
1145         }
1146     }
1147
1148     *got_frame_ptr = 1;
1149
1150     return samplecount * bpp;
1151 }
1152
1153 static void wavpack_decode_flush(AVCodecContext *avctx)
1154 {
1155     WavpackContext *s = avctx->priv_data;
1156     int i;
1157
1158     for (i = 0; i < s->fdec_num; i++)
1159         wv_reset_saved_context(s->fdec[i]);
1160 }
1161
1162 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1163                                 int *got_frame_ptr, AVPacket *avpkt)
1164 {
1165     WavpackContext *s  = avctx->priv_data;
1166     const uint8_t *buf = avpkt->data;
1167     int buf_size       = avpkt->size;
1168     int frame_size, ret, frame_flags;
1169     int samplecount = 0;
1170
1171     s->block     = 0;
1172     s->ch_offset = 0;
1173
1174     /* determine number of samples */
1175     if (s->mkv_mode) {
1176         s->samples  = AV_RL32(buf); buf += 4;
1177         frame_flags = AV_RL32(buf);
1178     } else {
1179         if (s->multichannel) {
1180             s->samples  = AV_RL32(buf + 4);
1181             frame_flags = AV_RL32(buf + 8);
1182         } else {
1183             s->samples  = AV_RL32(buf);
1184             frame_flags = AV_RL32(buf + 4);
1185         }
1186     }
1187     if (s->samples <= 0) {
1188         av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1189                s->samples);
1190         return AVERROR(EINVAL);
1191     }
1192
1193     if (frame_flags & 0x80) {
1194         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1195     } else if ((frame_flags & 0x03) <= 1) {
1196         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1197     } else {
1198         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1199     }
1200
1201     /* get output buffer */
1202     s->frame.nb_samples = s->samples;
1203     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1204         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1205         return ret;
1206     }
1207
1208     while (buf_size > 0) {
1209         if (!s->multichannel) {
1210             frame_size = buf_size;
1211         } else {
1212             if (!s->mkv_mode) {
1213                 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1214             } else {
1215                 if (buf_size < 12) //MKV files can have zero flags after last block
1216                     break;
1217                 frame_size = AV_RL32(buf + 8) + 12;
1218             }
1219         }
1220         if (frame_size < 0 || frame_size > buf_size) {
1221             av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1222                    "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1223             wavpack_decode_flush(avctx);
1224             return -1;
1225         }
1226         if ((samplecount = wavpack_decode_block(avctx, s->block,
1227                                                 s->frame.data[0], got_frame_ptr,
1228                                                 buf, frame_size)) < 0) {
1229             wavpack_decode_flush(avctx);
1230             return -1;
1231         }
1232         s->block++;
1233         buf += frame_size; buf_size -= frame_size;
1234     }
1235
1236     if (*got_frame_ptr)
1237         *(AVFrame *)data = s->frame;
1238
1239     return avpkt->size;
1240 }
1241
1242 AVCodec ff_wavpack_decoder = {
1243     .name           = "wavpack",
1244     .type           = AVMEDIA_TYPE_AUDIO,
1245     .id             = CODEC_ID_WAVPACK,
1246     .priv_data_size = sizeof(WavpackContext),
1247     .init           = wavpack_decode_init,
1248     .close          = wavpack_decode_end,
1249     .decode         = wavpack_decode_frame,
1250     .flush          = wavpack_decode_flush,
1251     .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1252     .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
1253 };