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