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