Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wavpack.c @ 0638c2ae

History | View | Annotate | Download (29.9 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
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
};