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