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