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