Add functions for decoding >16 bits WavPack files.
[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 int wv_unpack_stereo_hires(WavpackContext *s, GetBitContext *gb, int32_t *dst)
467 {
468     int i, j, count = 0;
469     int last, t;
470     int A, B, L, L2, R, R2, bit;
471     int pos = 0;
472     uint32_t crc = 0xFFFFFFFF;
473
474     s->one = s->zero = s->zeroes = 0;
475     do{
476         L = wv_get_value(s, gb, 0, &last);
477         if(last) break;
478         R = wv_get_value(s, gb, 1, &last);
479         if(last) break;
480         for(i = 0; i < s->terms; i++){
481             t = s->decorr[i].value;
482             j = 0;
483             if(t > 0){
484                 if(t > 8){
485                     if(t & 1){
486                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
487                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
488                     }else{
489                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
490                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
491                     }
492                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
493                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
494                     j = 0;
495                 }else{
496                     A = s->decorr[i].samplesA[pos];
497                     B = s->decorr[i].samplesB[pos];
498                     j = (pos + t) & 7;
499                 }
500                 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
501                 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
502                 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
503                 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
504                 s->decorr[i].samplesA[j] = L = L2;
505                 s->decorr[i].samplesB[j] = R = R2;
506             }else if(t == -1){
507                 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
508                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
509                 L = L2;
510                 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
511                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
512                 R = R2;
513                 s->decorr[i].samplesA[0] = R;
514             }else{
515                 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
516                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
517                 R = R2;
518
519                 if(t == -3){
520                     R2 = s->decorr[i].samplesA[0];
521                     s->decorr[i].samplesA[0] = R;
522                 }
523
524                 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
525                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
526                 L = L2;
527                 s->decorr[i].samplesB[0] = L;
528             }
529         }
530         pos = (pos + 1) & 7;
531         if(s->joint)
532             L += (R -= (L >> 1));
533         crc = (crc * 3 + L) * 3 + R;
534         bit = (L & s->and) | s->or;
535         *dst++ = (((L + bit) << s->shift) - bit) << s->post_shift;
536         bit = (R & s->and) | s->or;
537         *dst++ = (((R + bit) << s->shift) - bit) << s->post_shift;
538         count++;
539     }while(!last && count < s->samples);
540
541     if(crc != s->CRC){
542         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
543         return -1;
544     }
545     return count * 2;
546 }
547
548 static int wv_unpack_mono_hires(WavpackContext *s, GetBitContext *gb, int32_t *dst)
549 {
550     int i, j, count = 0;
551     int last, t;
552     int A, S, T, bit;
553     int pos = 0;
554     uint32_t crc = 0xFFFFFFFF;
555
556     s->one = s->zero = s->zeroes = 0;
557     do{
558         T = wv_get_value(s, gb, 0, &last);
559         S = 0;
560         if(last) break;
561         for(i = 0; i < s->terms; i++){
562             t = s->decorr[i].value;
563             if(t > 8){
564                 if(t & 1)
565                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
566                 else
567                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
568                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
569                 j = 0;
570             }else{
571                 A = s->decorr[i].samplesA[pos];
572                 j = (pos + t) & 7;
573             }
574             S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
575             if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
576             s->decorr[i].samplesA[j] = T = S;
577         }
578         pos = (pos + 1) & 7;
579         crc = crc * 3 + S;
580         bit = (S & s->and) | s->or;
581         *dst++ = (((S + bit) << s->shift) - bit) << s->post_shift;
582         count++;
583     }while(!last && count < s->samples);
584
585     if(crc != s->CRC){
586         av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
587         return -1;
588     }
589     return count;
590 }
591
592 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
593 {
594     WavpackContext *s = avctx->priv_data;
595
596     s->avctx = avctx;
597     s->stereo = (avctx->channels == 2);
598     if(avctx->bits_per_coded_sample <= 16)
599         avctx->sample_fmt = SAMPLE_FMT_S16;
600     else
601         avctx->sample_fmt = SAMPLE_FMT_S32;
602     avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
603
604     return 0;
605 }
606
607 static int wavpack_decode_frame(AVCodecContext *avctx,
608                             void *data, int *data_size,
609                             AVPacket *avpkt)
610 {
611     const uint8_t *buf = avpkt->data;
612     int buf_size = avpkt->size;
613     WavpackContext *s = avctx->priv_data;
614     int16_t *samples = data;
615     int32_t *samples32 = data;
616     int samplecount;
617     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0;
618     int got_hybrid = 0;
619     const uint8_t* buf_end = buf + buf_size;
620     int i, j, id, size, ssize, weights, t;
621     int bpp = avctx->bits_per_coded_sample <= 16 ? 2 : 4;
622
623     if (buf_size == 0){
624         *data_size = 0;
625         return 0;
626     }
627
628     memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
629     memset(s->ch, 0, sizeof(s->ch));
630     s->and = s->or = s->shift = 0;
631
632     s->samples = AV_RL32(buf); buf += 4;
633     if(!s->samples){
634         *data_size = 0;
635         return buf_size;
636     }
637     /* should not happen but who knows */
638     if(s->samples * bpp * avctx->channels > *data_size){
639         av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n");
640         return -1;
641     }
642     s->frame_flags = AV_RL32(buf); buf += 4;
643     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
644     s->joint = s->frame_flags & WV_JOINT_STEREO;
645     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
646     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
647     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
648     s->CRC = AV_RL32(buf); buf += 4;
649     // parse metadata blocks
650     while(buf < buf_end){
651         id = *buf++;
652         size = *buf++;
653         if(id & WP_IDF_LONG) {
654             size |= (*buf++) << 8;
655             size |= (*buf++) << 16;
656         }
657         size <<= 1; // size is specified in words
658         ssize = size;
659         if(id & WP_IDF_ODD) size--;
660         if(size < 0){
661             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
662             break;
663         }
664         if(buf + ssize > buf_end){
665             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
666             break;
667         }
668         if(id & WP_IDF_IGNORE){
669             buf += ssize;
670             continue;
671         }
672         switch(id & WP_IDF_MASK){
673         case WP_ID_DECTERMS:
674             s->terms = size;
675             if(s->terms > MAX_TERMS){
676                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
677                 buf += ssize;
678                 continue;
679             }
680             for(i = 0; i < s->terms; i++) {
681                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
682                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
683                 buf++;
684             }
685             got_terms = 1;
686             break;
687         case WP_ID_DECWEIGHTS:
688             if(!got_terms){
689                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
690                 continue;
691             }
692             weights = size >> s->stereo_in;
693             if(weights > MAX_TERMS || weights > s->terms){
694                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
695                 buf += ssize;
696                 continue;
697             }
698             for(i = 0; i < weights; i++) {
699                 t = (int8_t)(*buf++);
700                 s->decorr[s->terms - i - 1].weightA = t << 3;
701                 if(s->decorr[s->terms - i - 1].weightA > 0)
702                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
703                 if(s->stereo_in){
704                     t = (int8_t)(*buf++);
705                     s->decorr[s->terms - i - 1].weightB = t << 3;
706                     if(s->decorr[s->terms - i - 1].weightB > 0)
707                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
708                 }
709             }
710             got_weights = 1;
711             break;
712         case WP_ID_DECSAMPLES:
713             if(!got_terms){
714                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
715                 continue;
716             }
717             t = 0;
718             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
719                 if(s->decorr[i].value > 8){
720                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
721                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
722                     if(s->stereo_in){
723                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
724                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
725                         t += 4;
726                     }
727                     t += 4;
728                 }else if(s->decorr[i].value < 0){
729                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
730                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
731                     t += 4;
732                 }else{
733                     for(j = 0; j < s->decorr[i].value; j++){
734                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
735                         if(s->stereo_in){
736                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
737                         }
738                     }
739                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
740                 }
741             }
742             got_samples = 1;
743             break;
744         case WP_ID_ENTROPY:
745             if(size != 6 * (s->stereo_in + 1)){
746                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
747                 buf += ssize;
748                 continue;
749             }
750             for(j = 0; j <= s->stereo_in; j++){
751                 for(i = 0; i < 3; i++){
752                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
753                     buf += 2;
754                 }
755             }
756             got_entropy = 1;
757             break;
758         case WP_ID_HYBRID:
759             if(s->hybrid_bitrate){
760                 for(i = 0; i <= s->stereo_in; i++){
761                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
762                     buf += 2;
763                     size -= 2;
764                 }
765             }
766             for(i = 0; i < (s->stereo_in + 1); i++){
767                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
768                 buf += 2;
769                 size -= 2;
770             }
771             if(size > 0){
772                 for(i = 0; i < (s->stereo_in + 1); i++){
773                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
774                     buf += 2;
775                 }
776             }else{
777                 for(i = 0; i < (s->stereo_in + 1); i++)
778                     s->ch[i].bitrate_delta = 0;
779             }
780             got_hybrid = 1;
781             break;
782         case WP_ID_INT32INFO:
783             if(size != 4 || *buf){
784                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
785                 buf += ssize;
786                 continue;
787             }
788             if(buf[1])
789                 s->shift = buf[1];
790             else if(buf[2]){
791                 s->and = s->or = 1;
792                 s->shift = buf[2];
793             }else if(buf[3]){
794                 s->and = 1;
795                 s->shift = buf[3];
796             }
797             buf += 4;
798             break;
799         case WP_ID_DATA:
800             init_get_bits(&s->gb, buf, size * 8);
801             s->data_size = size * 8;
802             buf += size;
803             got_bs = 1;
804             break;
805         default:
806             buf += size;
807         }
808         if(id & WP_IDF_ODD) buf++;
809     }
810     if(!got_terms){
811         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
812         return -1;
813     }
814     if(!got_weights){
815         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
816         return -1;
817     }
818     if(!got_samples){
819         av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
820         return -1;
821     }
822     if(!got_entropy){
823         av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
824         return -1;
825     }
826     if(s->hybrid && !got_hybrid){
827         av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
828         return -1;
829     }
830     if(!got_bs){
831         av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
832         return -1;
833     }
834
835     if(s->stereo_in){
836         if(bpp == 2)
837             samplecount = wv_unpack_stereo(s, &s->gb, samples);
838         else
839             samplecount = wv_unpack_stereo_hires(s, &s->gb, samples32);
840     }else{
841         if(bpp == 2)
842             samplecount = wv_unpack_mono(s, &s->gb, samples);
843         else
844             samplecount = wv_unpack_mono_hires(s, &s->gb, samples32);
845         if(s->stereo && bpp == 2){
846             int16_t *dst = samples + samplecount * 2;
847             int16_t *src = samples + samplecount;
848             int cnt = samplecount;
849             while(cnt--){
850                 *--dst = *--src;
851                 *--dst = *src;
852             }
853             samplecount *= 2;
854         }else if(s->stereo){ //32-bit output
855             int32_t *dst = samples32 + samplecount * 2;
856             int32_t *src = samples32 + samplecount;
857             int cnt = samplecount;
858             while(cnt--){
859                 *--dst = *--src;
860                 *--dst = *src;
861             }
862             samplecount *= 2;
863         }
864     }
865     *data_size = samplecount * bpp;
866
867     return buf_size;
868 }
869
870 AVCodec wavpack_decoder = {
871     "wavpack",
872     CODEC_TYPE_AUDIO,
873     CODEC_ID_WAVPACK,
874     sizeof(WavpackContext),
875     wavpack_decode_init,
876     NULL,
877     NULL,
878     wavpack_decode_frame,
879     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
880 };