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