Shift 9-15 bit samples to use full 16-bit range.
[ffmpeg.git] / libavcodec / wavpack.c
1 /*
2  * WavPack lossless audio decoder
3  * Copyright (c) 2006 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 libavcodec/wavpack.c
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 enum WP_ID_Flags{
41     WP_IDF_MASK   = 0x1F,
42     WP_IDF_IGNORE = 0x20,
43     WP_IDF_ODD    = 0x40,
44     WP_IDF_LONG   = 0x80
45 };
46
47 enum WP_ID{
48     WP_ID_DUMMY = 0,
49     WP_ID_ENCINFO,
50     WP_ID_DECTERMS,
51     WP_ID_DECWEIGHTS,
52     WP_ID_DECSAMPLES,
53     WP_ID_ENTROPY,
54     WP_ID_HYBRID,
55     WP_ID_SHAPING,
56     WP_ID_FLOATINFO,
57     WP_ID_INT32INFO,
58     WP_ID_DATA,
59     WP_ID_CORR,
60     WP_ID_FLT,
61     WP_ID_CHANINFO
62 };
63
64 #define MAX_TERMS 16
65
66 typedef struct Decorr {
67     int delta;
68     int value;
69     int weightA;
70     int weightB;
71     int samplesA[8];
72     int samplesB[8];
73 } Decorr;
74
75 typedef struct WvChannel {
76     int median[3];
77     int slow_level, error_limit;
78     int bitrate_acc, bitrate_delta;
79 } WvChannel;
80
81 typedef struct WavpackContext {
82     AVCodecContext *avctx;
83     int frame_flags;
84     int stereo, stereo_in;
85     int joint;
86     uint32_t CRC;
87     GetBitContext gb;
88     int data_size; // in bits
89     int samples;
90     int terms;
91     Decorr decorr[MAX_TERMS];
92     int zero, one, zeroes;
93     int and, or, shift;
94     int post_shift;
95     int hybrid, hybrid_bitrate;
96     WvChannel ch[2];
97 } WavpackContext;
98
99 // exponent table copied from WavPack source
100 static const uint8_t wp_exp2_table [256] = {
101     0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
102     0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
103     0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
104     0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
105     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
106     0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
107     0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
108     0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
109     0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
110     0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
111     0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
112     0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
113     0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
114     0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
115     0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
116     0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
117 };
118
119 static const uint8_t wp_log2_table [] = {
120     0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
121     0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
122     0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
123     0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
124     0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
125     0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
126     0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
127     0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
128     0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
129     0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
130     0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
131     0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
132     0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
133     0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
134     0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
135     0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
136 };
137
138 static av_always_inline int wp_exp2(int16_t val)
139 {
140     int res, neg = 0;
141
142     if(val < 0){
143         val = -val;
144         neg = 1;
145     }
146
147     res = wp_exp2_table[val & 0xFF] | 0x100;
148     val >>= 8;
149     res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
150     return neg ? -res : res;
151 }
152
153 static av_always_inline int wp_log2(int32_t val)
154 {
155     int bits;
156
157     if(!val)
158         return 0;
159     if(val == 1)
160         return 256;
161     val += val >> 9;
162     bits = av_log2(val) + 1;
163     if(bits < 9)
164         return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
165     else
166         return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
167 }
168
169 #define LEVEL_DECAY(a)  ((a + 0x80) >> 8)
170
171 // macros for manipulating median values
172 #define GET_MED(n) ((c->median[n] >> 4) + 1)
173 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
174 #define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
175
176 // macros for applying weight
177 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
178         if(samples && in){ \
179             if((samples ^ in) < 0){ \
180                 weight -= delta; \
181                 if(weight < -1024) weight = -1024; \
182             }else{ \
183                 weight += delta; \
184                 if(weight > 1024) weight = 1024; \
185             } \
186         }
187
188
189 static av_always_inline int get_tail(GetBitContext *gb, int k)
190 {
191     int p, e, res;
192
193     if(k<1)return 0;
194     p = av_log2(k);
195     e = (1 << (p + 1)) - k - 1;
196     res = p ? get_bits(gb, p) : 0;
197     if(res >= e){
198         res = (res<<1) - e + get_bits1(gb);
199     }
200     return res;
201 }
202
203 static void update_error_limit(WavpackContext *ctx)
204 {
205     int i, br[2], sl[2];
206
207     for(i = 0; i <= ctx->stereo_in; i++){
208         ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
209         br[i] = ctx->ch[i].bitrate_acc >> 16;
210         sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
211     }
212     if(ctx->stereo_in && ctx->hybrid_bitrate){
213         int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
214         if(balance > br[0]){
215             br[1] = br[0] << 1;
216             br[0] = 0;
217         }else if(-balance > br[0]){
218             br[0] <<= 1;
219             br[1] = 0;
220         }else{
221             br[1] = br[0] + balance;
222             br[0] = br[0] - balance;
223         }
224     }
225     for(i = 0; i <= ctx->stereo_in; i++){
226         if(ctx->hybrid_bitrate){
227             if(sl[i] - br[i] > -0x100)
228                 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
229             else
230                 ctx->ch[i].error_limit = 0;
231         }else{
232             ctx->ch[i].error_limit = wp_exp2(br[i]);
233         }
234     }
235 }
236
237 static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last)
238 {
239     int t, t2;
240     int sign, base, add, ret;
241     WvChannel *c = &ctx->ch[channel];
242
243     *last = 0;
244
245     if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
246         if(ctx->zeroes){
247             ctx->zeroes--;
248             if(ctx->zeroes){
249                 c->slow_level -= LEVEL_DECAY(c->slow_level);
250                 return 0;
251             }
252         }else{
253             t = get_unary_0_33(gb);
254             if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1));
255             ctx->zeroes = t;
256             if(ctx->zeroes){
257                 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
258                 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
259                 c->slow_level -= LEVEL_DECAY(c->slow_level);
260                 return 0;
261             }
262         }
263     }
264
265     if(get_bits_count(gb) >= ctx->data_size){
266         *last = 1;
267         return 0;
268     }
269
270     if(ctx->zero){
271         t = 0;
272         ctx->zero = 0;
273     }else{
274         t = get_unary_0_33(gb);
275         if(get_bits_count(gb) >= ctx->data_size){
276             *last = 1;
277             return 0;
278         }
279         if(t == 16) {
280             t2 = get_unary_0_33(gb);
281             if(t2 < 2) t += t2;
282             else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
283         }
284
285         if(ctx->one){
286             ctx->one = t&1;
287             t = (t>>1) + 1;
288         }else{
289             ctx->one = t&1;
290             t >>= 1;
291         }
292         ctx->zero = !ctx->one;
293     }
294
295     if(ctx->hybrid && !channel)
296         update_error_limit(ctx);
297
298     if(!t){
299         base = 0;
300         add = GET_MED(0) - 1;
301         DEC_MED(0);
302     }else if(t == 1){
303         base = GET_MED(0);
304         add = GET_MED(1) - 1;
305         INC_MED(0);
306         DEC_MED(1);
307     }else if(t == 2){
308         base = GET_MED(0) + GET_MED(1);
309         add = GET_MED(2) - 1;
310         INC_MED(0);
311         INC_MED(1);
312         DEC_MED(2);
313     }else{
314         base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
315         add = GET_MED(2) - 1;
316         INC_MED(0);
317         INC_MED(1);
318         INC_MED(2);
319     }
320     if(!c->error_limit){
321         ret = base + get_tail(gb, add);
322     }else{
323         int mid = (base*2 + add + 1) >> 1;
324         while(add > c->error_limit){
325             if(get_bits1(gb)){
326                 add -= (mid - base);
327                 base = mid;
328             }else
329                 add = mid - base - 1;
330             mid = (base*2 + add + 1) >> 1;
331         }
332         ret = mid;
333     }
334     sign = get_bits1(gb);
335     if(ctx->hybrid_bitrate)
336         c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
337     return sign ? ~ret : ret;
338 }
339
340 static int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, int16_t *dst)
341 {
342     int i, j, count = 0;
343     int last, t;
344     int A, B, L, L2, R, R2, bit;
345     int pos = 0;
346     uint32_t crc = 0xFFFFFFFF;
347
348     s->one = s->zero = s->zeroes = 0;
349     do{
350         L = wv_get_value(s, gb, 0, &last);
351         if(last) break;
352         R = wv_get_value(s, gb, 1, &last);
353         if(last) break;
354         for(i = 0; i < s->terms; i++){
355             t = s->decorr[i].value;
356             j = 0;
357             if(t > 0){
358                 if(t > 8){
359                     if(t & 1){
360                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
361                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
362                     }else{
363                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
364                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
365                     }
366                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
367                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
368                     j = 0;
369                 }else{
370                     A = s->decorr[i].samplesA[pos];
371                     B = s->decorr[i].samplesB[pos];
372                     j = (pos + t) & 7;
373                 }
374                 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
375                 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
376                 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
377                 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
378                 s->decorr[i].samplesA[j] = L = L2;
379                 s->decorr[i].samplesB[j] = R = R2;
380             }else if(t == -1){
381                 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
382                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
383                 L = L2;
384                 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
385                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
386                 R = R2;
387                 s->decorr[i].samplesA[0] = R;
388             }else{
389                 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
390                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
391                 R = R2;
392
393                 if(t == -3){
394                     R2 = s->decorr[i].samplesA[0];
395                     s->decorr[i].samplesA[0] = R;
396                 }
397
398                 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
399                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
400                 L = L2;
401                 s->decorr[i].samplesB[0] = L;
402             }
403         }
404         pos = (pos + 1) & 7;
405         if(s->joint)
406             L += (R -= (L >> 1));
407         crc = (crc * 3 + L) * 3 + R;
408         bit = (L & s->and) | s->or;
409         *dst++ = (((L + bit) << s->shift) - bit) << s->post_shift;
410         bit = (R & s->and) | s->or;
411         *dst++ = (((R + bit) << s->shift) - bit) << s->post_shift;
412         count++;
413     }while(!last && count < s->samples);
414
415     if(crc != s->CRC){
416         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
417         return -1;
418     }
419     return count * 2;
420 }
421
422 static int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, int16_t *dst)
423 {
424     int i, j, count = 0;
425     int last, t;
426     int A, S, T, bit;
427     int pos = 0;
428     uint32_t crc = 0xFFFFFFFF;
429
430     s->one = s->zero = s->zeroes = 0;
431     do{
432         T = wv_get_value(s, gb, 0, &last);
433         S = 0;
434         if(last) break;
435         for(i = 0; i < s->terms; i++){
436             t = s->decorr[i].value;
437             if(t > 8){
438                 if(t & 1)
439                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
440                 else
441                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
442                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
443                 j = 0;
444             }else{
445                 A = s->decorr[i].samplesA[pos];
446                 j = (pos + t) & 7;
447             }
448             S = T + ((s->decorr[i].weightA * A + 512) >> 10);
449             if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
450             s->decorr[i].samplesA[j] = T = S;
451         }
452         pos = (pos + 1) & 7;
453         crc = crc * 3 + S;
454         bit = (S & s->and) | s->or;
455         *dst++ = (((S + bit) << s->shift) - bit) << s->post_shift;
456         count++;
457     }while(!last && count < s->samples);
458
459     if(crc != s->CRC){
460         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
461         return -1;
462     }
463     return count;
464 }
465
466 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
467 {
468     WavpackContext *s = avctx->priv_data;
469
470     s->avctx = avctx;
471     s->stereo = (avctx->channels == 2);
472     avctx->sample_fmt = SAMPLE_FMT_S16;
473     avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
474
475     return 0;
476 }
477
478 static int wavpack_decode_frame(AVCodecContext *avctx,
479                             void *data, int *data_size,
480                             AVPacket *avpkt)
481 {
482     const uint8_t *buf = avpkt->data;
483     int buf_size = avpkt->size;
484     WavpackContext *s = avctx->priv_data;
485     int16_t *samples = data;
486     int samplecount;
487     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0;
488     int got_hybrid = 0;
489     const uint8_t* buf_end = buf + buf_size;
490     int i, j, id, size, ssize, weights, t;
491
492     if (buf_size == 0){
493         *data_size = 0;
494         return 0;
495     }
496
497     memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
498     memset(s->ch, 0, sizeof(s->ch));
499     s->and = s->or = s->shift = 0;
500
501     s->samples = AV_RL32(buf); buf += 4;
502     if(!s->samples){
503         *data_size = 0;
504         return buf_size;
505     }
506     /* should not happen but who knows */
507     if(s->samples * 2 * avctx->channels > *data_size){
508         av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n");
509         return -1;
510     }
511     s->frame_flags = AV_RL32(buf); buf += 4;
512     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
513     s->joint = s->frame_flags & WV_JOINT_STEREO;
514     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
515     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
516     s->post_shift = (s->frame_flags >> 13) & 0x1f;
517     s->CRC = AV_RL32(buf); buf += 4;
518     // parse metadata blocks
519     while(buf < buf_end){
520         id = *buf++;
521         size = *buf++;
522         if(id & WP_IDF_LONG) {
523             size |= (*buf++) << 8;
524             size |= (*buf++) << 16;
525         }
526         size <<= 1; // size is specified in words
527         ssize = size;
528         if(id & WP_IDF_ODD) size--;
529         if(size < 0){
530             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
531             break;
532         }
533         if(buf + ssize > buf_end){
534             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
535             break;
536         }
537         if(id & WP_IDF_IGNORE){
538             buf += ssize;
539             continue;
540         }
541         switch(id & WP_IDF_MASK){
542         case WP_ID_DECTERMS:
543             s->terms = size;
544             if(s->terms > MAX_TERMS){
545                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
546                 buf += ssize;
547                 continue;
548             }
549             for(i = 0; i < s->terms; i++) {
550                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
551                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
552                 buf++;
553             }
554             got_terms = 1;
555             break;
556         case WP_ID_DECWEIGHTS:
557             if(!got_terms){
558                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
559                 continue;
560             }
561             weights = size >> s->stereo_in;
562             if(weights > MAX_TERMS || weights > s->terms){
563                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
564                 buf += ssize;
565                 continue;
566             }
567             for(i = 0; i < weights; i++) {
568                 t = (int8_t)(*buf++);
569                 s->decorr[s->terms - i - 1].weightA = t << 3;
570                 if(s->decorr[s->terms - i - 1].weightA > 0)
571                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
572                 if(s->stereo_in){
573                     t = (int8_t)(*buf++);
574                     s->decorr[s->terms - i - 1].weightB = t << 3;
575                     if(s->decorr[s->terms - i - 1].weightB > 0)
576                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
577                 }
578             }
579             got_weights = 1;
580             break;
581         case WP_ID_DECSAMPLES:
582             if(!got_terms){
583                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
584                 continue;
585             }
586             t = 0;
587             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
588                 if(s->decorr[i].value > 8){
589                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
590                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
591                     if(s->stereo_in){
592                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
593                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
594                         t += 4;
595                     }
596                     t += 4;
597                 }else if(s->decorr[i].value < 0){
598                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
599                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
600                     t += 4;
601                 }else{
602                     for(j = 0; j < s->decorr[i].value; j++){
603                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
604                         if(s->stereo_in){
605                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
606                         }
607                     }
608                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
609                 }
610             }
611             got_samples = 1;
612             break;
613         case WP_ID_ENTROPY:
614             if(size != 6 * (s->stereo_in + 1)){
615                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
616                 buf += ssize;
617                 continue;
618             }
619             for(j = 0; j <= s->stereo_in; j++){
620                 for(i = 0; i < 3; i++){
621                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
622                     buf += 2;
623                 }
624             }
625             got_entropy = 1;
626             break;
627         case WP_ID_HYBRID:
628             if(s->hybrid_bitrate){
629                 for(i = 0; i <= s->stereo_in; i++){
630                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
631                     buf += 2;
632                     size -= 2;
633                 }
634             }
635             for(i = 0; i < (s->stereo_in + 1); i++){
636                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
637                 buf += 2;
638                 size -= 2;
639             }
640             if(size > 0){
641                 for(i = 0; i < (s->stereo_in + 1); i++){
642                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
643                     buf += 2;
644                 }
645             }else{
646                 for(i = 0; i < (s->stereo_in + 1); i++)
647                     s->ch[i].bitrate_delta = 0;
648             }
649             got_hybrid = 1;
650             break;
651         case WP_ID_INT32INFO:
652             if(size != 4 || *buf){
653                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
654                 buf += ssize;
655                 continue;
656             }
657             if(buf[1])
658                 s->shift = buf[1];
659             else if(buf[2]){
660                 s->and = s->or = 1;
661                 s->shift = buf[2];
662             }else if(buf[3]){
663                 s->and = 1;
664                 s->shift = buf[3];
665             }
666             buf += 4;
667             break;
668         case WP_ID_DATA:
669             init_get_bits(&s->gb, buf, size * 8);
670             s->data_size = size * 8;
671             buf += size;
672             got_bs = 1;
673             break;
674         default:
675             buf += size;
676         }
677         if(id & WP_IDF_ODD) buf++;
678     }
679     if(!got_terms){
680         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
681         return -1;
682     }
683     if(!got_weights){
684         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
685         return -1;
686     }
687     if(!got_samples){
688         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
689         return -1;
690     }
691     if(!got_entropy){
692         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
693         return -1;
694     }
695     if(s->hybrid && !got_hybrid){
696         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
697         return -1;
698     }
699     if(!got_bs){
700         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
701         return -1;
702     }
703
704     if(s->stereo_in)
705         samplecount = wv_unpack_stereo(s, &s->gb, samples);
706     else{
707         samplecount = wv_unpack_mono(s, &s->gb, samples);
708         if(s->stereo){
709             int16_t *dst = samples + samplecount * 2;
710             int16_t *src = samples + samplecount;
711             int cnt = samplecount;
712             while(cnt--){
713                 *--dst = *--src;
714                 *--dst = *src;
715             }
716             samplecount *= 2;
717         }
718     }
719     *data_size = samplecount * 2;
720
721     return buf_size;
722 }
723
724 AVCodec wavpack_decoder = {
725     "wavpack",
726     CODEC_TYPE_AUDIO,
727     CODEC_ID_WAVPACK,
728     sizeof(WavpackContext),
729     wavpack_decode_init,
730     NULL,
731     NULL,
732     wavpack_decode_frame,
733     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
734 };