Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wavpack.c @ 72415b2a

History | View | Annotate | Download (34.5 KB)

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
#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 != 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 != 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 != 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 != 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 != 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 == 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 == 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 != 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 == SAMPLE_FMT_FLT)
627
            *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
628
        else if(type == 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->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
    s->stereo = (avctx->channels == 2);
664
    if(avctx->bits_per_coded_sample <= 16)
665
        avctx->sample_fmt = SAMPLE_FMT_S16;
666
    else
667
        avctx->sample_fmt = SAMPLE_FMT_S32;
668
    avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
669

    
670
    wv_reset_saved_context(s);
671

    
672
    return 0;
673
}
674

    
675
static int wavpack_decode_frame(AVCodecContext *avctx,
676
                            void *data, int *data_size,
677
                            AVPacket *avpkt)
678
{
679
    const uint8_t *buf = avpkt->data;
680
    int buf_size = avpkt->size;
681
    WavpackContext *s = avctx->priv_data;
682
    void *samples = data;
683
    int samplecount;
684
    int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
685
    int got_hybrid = 0;
686
    const uint8_t* buf_end = buf + buf_size;
687
    int i, j, id, size, ssize, weights, t;
688
    int bpp;
689

    
690
    if (buf_size == 0){
691
        *data_size = 0;
692
        return 0;
693
    }
694

    
695
    if(!s->samples_left){
696
        memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
697
        memset(s->ch, 0, sizeof(s->ch));
698
        s->extra_bits = 0;
699
        s->and = s->or = s->shift = 0;
700
        s->got_extra_bits = 0;
701
    }
702

    
703
    s->samples = AV_RL32(buf); buf += 4;
704
    if(!s->samples){
705
        *data_size = 0;
706
        return buf_size;
707
    }
708
    s->frame_flags = AV_RL32(buf); buf += 4;
709
    if(s->frame_flags&0x80){
710
        bpp = sizeof(float);
711
        avctx->sample_fmt = SAMPLE_FMT_FLT;
712
    } else if((s->frame_flags&0x03) <= 1){
713
        bpp = 2;
714
        avctx->sample_fmt = SAMPLE_FMT_S16;
715
    } else {
716
        bpp = 4;
717
        avctx->sample_fmt = SAMPLE_FMT_S32;
718
    }
719
    s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
720
    s->joint = s->frame_flags & WV_JOINT_STEREO;
721
    s->hybrid = s->frame_flags & WV_HYBRID_MODE;
722
    s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
723
    s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
724
    s->CRC = AV_RL32(buf); buf += 4;
725

    
726
    s->max_samples = *data_size / (bpp * avctx->channels);
727
    s->max_samples = FFMIN(s->max_samples, s->samples);
728
    if(s->samples_left > 0){
729
        s->max_samples = FFMIN(s->max_samples, s->samples_left);
730
        buf = buf_end;
731
    }
732

    
733
    // parse metadata blocks
734
    while(buf < buf_end){
735
        id = *buf++;
736
        size = *buf++;
737
        if(id & WP_IDF_LONG) {
738
            size |= (*buf++) << 8;
739
            size |= (*buf++) << 16;
740
        }
741
        size <<= 1; // size is specified in words
742
        ssize = size;
743
        if(id & WP_IDF_ODD) size--;
744
        if(size < 0){
745
            av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
746
            break;
747
        }
748
        if(buf + ssize > buf_end){
749
            av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
750
            break;
751
        }
752
        if(id & WP_IDF_IGNORE){
753
            buf += ssize;
754
            continue;
755
        }
756
        switch(id & WP_IDF_MASK){
757
        case WP_ID_DECTERMS:
758
            s->terms = size;
759
            if(s->terms > MAX_TERMS){
760
                av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
761
                buf += ssize;
762
                continue;
763
            }
764
            for(i = 0; i < s->terms; i++) {
765
                s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
766
                s->decorr[s->terms - i - 1].delta = *buf >> 5;
767
                buf++;
768
            }
769
            got_terms = 1;
770
            break;
771
        case WP_ID_DECWEIGHTS:
772
            if(!got_terms){
773
                av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
774
                continue;
775
            }
776
            weights = size >> s->stereo_in;
777
            if(weights > MAX_TERMS || weights > s->terms){
778
                av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
779
                buf += ssize;
780
                continue;
781
            }
782
            for(i = 0; i < weights; i++) {
783
                t = (int8_t)(*buf++);
784
                s->decorr[s->terms - i - 1].weightA = t << 3;
785
                if(s->decorr[s->terms - i - 1].weightA > 0)
786
                    s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
787
                if(s->stereo_in){
788
                    t = (int8_t)(*buf++);
789
                    s->decorr[s->terms - i - 1].weightB = t << 3;
790
                    if(s->decorr[s->terms - i - 1].weightB > 0)
791
                        s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
792
                }
793
            }
794
            got_weights = 1;
795
            break;
796
        case WP_ID_DECSAMPLES:
797
            if(!got_terms){
798
                av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
799
                continue;
800
            }
801
            t = 0;
802
            for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
803
                if(s->decorr[i].value > 8){
804
                    s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
805
                    s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
806
                    if(s->stereo_in){
807
                        s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
808
                        s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
809
                        t += 4;
810
                    }
811
                    t += 4;
812
                }else if(s->decorr[i].value < 0){
813
                    s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
814
                    s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
815
                    t += 4;
816
                }else{
817
                    for(j = 0; j < s->decorr[i].value; j++){
818
                        s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
819
                        if(s->stereo_in){
820
                            s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
821
                        }
822
                    }
823
                    t += s->decorr[i].value * 2 * (s->stereo_in + 1);
824
                }
825
            }
826
            got_samples = 1;
827
            break;
828
        case WP_ID_ENTROPY:
829
            if(size != 6 * (s->stereo_in + 1)){
830
                av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
831
                buf += ssize;
832
                continue;
833
            }
834
            for(j = 0; j <= s->stereo_in; j++){
835
                for(i = 0; i < 3; i++){
836
                    s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
837
                    buf += 2;
838
                }
839
            }
840
            got_entropy = 1;
841
            break;
842
        case WP_ID_HYBRID:
843
            if(s->hybrid_bitrate){
844
                for(i = 0; i <= s->stereo_in; i++){
845
                    s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
846
                    buf += 2;
847
                    size -= 2;
848
                }
849
            }
850
            for(i = 0; i < (s->stereo_in + 1); i++){
851
                s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
852
                buf += 2;
853
                size -= 2;
854
            }
855
            if(size > 0){
856
                for(i = 0; i < (s->stereo_in + 1); i++){
857
                    s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
858
                    buf += 2;
859
                }
860
            }else{
861
                for(i = 0; i < (s->stereo_in + 1); i++)
862
                    s->ch[i].bitrate_delta = 0;
863
            }
864
            got_hybrid = 1;
865
            break;
866
        case WP_ID_INT32INFO:
867
            if(size != 4){
868
                av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
869
                buf += ssize;
870
                continue;
871
            }
872
            if(buf[0])
873
                s->extra_bits = buf[0];
874
            else if(buf[1])
875
                s->shift = buf[1];
876
            else if(buf[2]){
877
                s->and = s->or = 1;
878
                s->shift = buf[2];
879
            }else if(buf[3]){
880
                s->and = 1;
881
                s->shift = buf[3];
882
            }
883
            buf += 4;
884
            break;
885
        case WP_ID_FLOATINFO:
886
            if(size != 4){
887
                av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
888
                buf += ssize;
889
                continue;
890
            }
891
            s->float_flag = buf[0];
892
            s->float_shift = buf[1];
893
            s->float_max_exp = buf[2];
894
            buf += 4;
895
            got_float = 1;
896
            break;
897
        case WP_ID_DATA:
898
            s->sc.offset = buf - avpkt->data;
899
            s->sc.size   = size * 8;
900
            init_get_bits(&s->gb, buf, size * 8);
901
            s->data_size = size * 8;
902
            buf += size;
903
            got_bs = 1;
904
            break;
905
        case WP_ID_EXTRABITS:
906
            if(size <= 4){
907
                av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
908
                buf += size;
909
                continue;
910
            }
911
            s->extra_sc.offset = buf - avpkt->data;
912
            s->extra_sc.size   = size * 8;
913
            init_get_bits(&s->gb_extra_bits, buf, size * 8);
914
            s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
915
            buf += size;
916
            s->got_extra_bits = 1;
917
            break;
918
        default:
919
            buf += size;
920
        }
921
        if(id & WP_IDF_ODD) buf++;
922
    }
923
    if(!s->samples_left){
924
        if(!got_terms){
925
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
926
            return -1;
927
        }
928
        if(!got_weights){
929
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
930
            return -1;
931
        }
932
        if(!got_samples){
933
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
934
            return -1;
935
        }
936
        if(!got_entropy){
937
            av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
938
            return -1;
939
        }
940
        if(s->hybrid && !got_hybrid){
941
            av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
942
            return -1;
943
        }
944
        if(!got_bs){
945
            av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
946
            return -1;
947
        }
948
        if(!got_float && avctx->sample_fmt == SAMPLE_FMT_FLT){
949
            av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
950
            return -1;
951
        }
952
        if(s->got_extra_bits && avctx->sample_fmt != SAMPLE_FMT_FLT){
953
            const int size = get_bits_left(&s->gb_extra_bits);
954
            const int wanted = s->samples * s->extra_bits << s->stereo_in;
955
            if(size < wanted){
956
                av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
957
                s->got_extra_bits = 0;
958
            }
959
        }
960
        s->samples_left = s->samples;
961
    }else{
962
        init_get_bits(&s->gb, avpkt->data + s->sc.offset, s->sc.size);
963
        skip_bits_long(&s->gb, s->sc.bits_used);
964
        if(s->got_extra_bits){
965
            init_get_bits(&s->gb_extra_bits, avpkt->data + s->extra_sc.offset,
966
                          s->extra_sc.size);
967
            skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
968
        }
969
    }
970

    
971
    if(s->stereo_in){
972
        if(avctx->sample_fmt == SAMPLE_FMT_S16)
973
            samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S16);
974
        else if(avctx->sample_fmt == SAMPLE_FMT_S32)
975
            samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S32);
976
        else
977
            samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_FLT);
978

    
979
    }else{
980
        if(avctx->sample_fmt == SAMPLE_FMT_S16)
981
            samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S16);
982
        else if(avctx->sample_fmt == SAMPLE_FMT_S32)
983
            samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S32);
984
        else
985
            samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_FLT);
986

    
987
        if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S16){
988
            int16_t *dst = (int16_t*)samples + samplecount * 2;
989
            int16_t *src = (int16_t*)samples + samplecount;
990
            int cnt = samplecount;
991
            while(cnt--){
992
                *--dst = *--src;
993
                *--dst = *src;
994
            }
995
            samplecount *= 2;
996
        }else if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S32){
997
            int32_t *dst = (int32_t*)samples + samplecount * 2;
998
            int32_t *src = (int32_t*)samples + samplecount;
999
            int cnt = samplecount;
1000
            while(cnt--){
1001
                *--dst = *--src;
1002
                *--dst = *src;
1003
            }
1004
            samplecount *= 2;
1005
        }else if(s->stereo){
1006
            float *dst = (float*)samples + samplecount * 2;
1007
            float *src = (float*)samples + samplecount;
1008
            int cnt = samplecount;
1009
            while(cnt--){
1010
                *--dst = *--src;
1011
                *--dst = *src;
1012
            }
1013
            samplecount *= 2;
1014
        }
1015
    }
1016
    *data_size = samplecount * bpp;
1017

    
1018
    return s->samples_left > 0 ? 0 : buf_size;
1019
}
1020

    
1021
AVCodec wavpack_decoder = {
1022
    "wavpack",
1023
    AVMEDIA_TYPE_AUDIO,
1024
    CODEC_ID_WAVPACK,
1025
    sizeof(WavpackContext),
1026
    wavpack_decode_init,
1027
    NULL,
1028
    NULL,
1029
    wavpack_decode_frame,
1030
    .capabilities = CODEC_CAP_SUBFRAMES,
1031
    .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1032
};