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