Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wavpack.c @ 9106a698

History | View | Annotate | Download (24.3 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 hybrid, hybrid_bitrate;
95
    WvChannel ch[2];
96
} WavpackContext;
97

    
98
// exponent table copied from WavPack source
99
static const uint8_t wp_exp2_table [256] = {
100
    0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
101
    0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
102
    0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
103
    0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
104
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
105
    0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
106
    0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
107
    0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
108
    0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
109
    0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
110
    0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
111
    0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
112
    0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
113
    0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
114
    0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
115
    0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
116
};
117

    
118
static const uint8_t wp_log2_table [] = {
119
    0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
120
    0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
121
    0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
122
    0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
123
    0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
124
    0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
125
    0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
126
    0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
127
    0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
128
    0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
129
    0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
130
    0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
131
    0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
132
    0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
133
    0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
134
    0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
135
};
136

    
137
static av_always_inline int wp_exp2(int16_t val)
138
{
139
    int res, neg = 0;
140

    
141
    if(val < 0){
142
        val = -val;
143
        neg = 1;
144
    }
145

    
146
    res = wp_exp2_table[val & 0xFF] | 0x100;
147
    val >>= 8;
148
    res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
149
    return neg ? -res : res;
150
}
151

    
152
static av_always_inline int wp_log2(int32_t val)
153
{
154
    int bits;
155

    
156
    if(!val)
157
        return 0;
158
    if(val == 1)
159
        return 256;
160
    val += val >> 9;
161
    bits = av_log2(val) + 1;
162
    if(bits < 9)
163
        return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
164
    else
165
        return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
166
}
167

    
168
#define LEVEL_DECAY(a)  ((a + 0x80) >> 8)
169

    
170
// macros for manipulating median values
171
#define GET_MED(n) ((c->median[n] >> 4) + 1)
172
#define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
173
#define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
174

    
175
// macros for applying weight
176
#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
177
        if(samples && in){ \
178
            if((samples ^ in) < 0){ \
179
                weight -= delta; \
180
                if(weight < -1024) weight = -1024; \
181
            }else{ \
182
                weight += delta; \
183
                if(weight > 1024) weight = 1024; \
184
            } \
185
        }
186

    
187

    
188
static av_always_inline int get_tail(GetBitContext *gb, int k)
189
{
190
    int p, e, res;
191

    
192
    if(k<1)return 0;
193
    p = av_log2(k);
194
    e = (1 << (p + 1)) - k - 1;
195
    res = p ? get_bits(gb, p) : 0;
196
    if(res >= e){
197
        res = (res<<1) - e + get_bits1(gb);
198
    }
199
    return res;
200
}
201

    
202
static void update_error_limit(WavpackContext *ctx)
203
{
204
    int i, br[2], sl[2];
205

    
206
    for(i = 0; i <= ctx->stereo_in; i++){
207
        ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
208
        br[i] = ctx->ch[i].bitrate_acc >> 16;
209
        sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
210
    }
211
    if(ctx->stereo_in && ctx->hybrid_bitrate){
212
        int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
213
        if(balance > br[0]){
214
            br[1] = br[0] << 1;
215
            br[0] = 0;
216
        }else if(-balance > br[0]){
217
            br[0] <<= 1;
218
            br[1] = 0;
219
        }else{
220
            br[1] = br[0] + balance;
221
            br[0] = br[0] - balance;
222
        }
223
    }
224
    for(i = 0; i <= ctx->stereo_in; i++){
225
        if(ctx->hybrid_bitrate){
226
            if(sl[i] - br[i] > -0x100)
227
                ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
228
            else
229
                ctx->ch[i].error_limit = 0;
230
        }else{
231
            ctx->ch[i].error_limit = wp_exp2(br[i]);
232
        }
233
    }
234
}
235

    
236
static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last)
237
{
238
    int t, t2;
239
    int sign, base, add, ret;
240
    WvChannel *c = &ctx->ch[channel];
241

    
242
    *last = 0;
243

    
244
    if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
245
        if(ctx->zeroes){
246
            ctx->zeroes--;
247
            if(ctx->zeroes){
248
                c->slow_level -= LEVEL_DECAY(c->slow_level);
249
                return 0;
250
            }
251
        }else{
252
            t = get_unary_0_33(gb);
253
            if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1));
254
            ctx->zeroes = t;
255
            if(ctx->zeroes){
256
                memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
257
                memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
258
                c->slow_level -= LEVEL_DECAY(c->slow_level);
259
                return 0;
260
            }
261
        }
262
    }
263

    
264
    if(get_bits_count(gb) >= ctx->data_size){
265
        *last = 1;
266
        return 0;
267
    }
268

    
269
    if(ctx->zero){
270
        t = 0;
271
        ctx->zero = 0;
272
    }else{
273
        t = get_unary_0_33(gb);
274
        if(get_bits_count(gb) >= ctx->data_size){
275
            *last = 1;
276
            return 0;
277
        }
278
        if(t == 16) {
279
            t2 = get_unary_0_33(gb);
280
            if(t2 < 2) t += t2;
281
            else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
282
        }
283

    
284
        if(ctx->one){
285
            ctx->one = t&1;
286
            t = (t>>1) + 1;
287
        }else{
288
            ctx->one = t&1;
289
            t >>= 1;
290
        }
291
        ctx->zero = !ctx->one;
292
    }
293

    
294
    if(ctx->hybrid && !channel)
295
        update_error_limit(ctx);
296

    
297
    if(!t){
298
        base = 0;
299
        add = GET_MED(0) - 1;
300
        DEC_MED(0);
301
    }else if(t == 1){
302
        base = GET_MED(0);
303
        add = GET_MED(1) - 1;
304
        INC_MED(0);
305
        DEC_MED(1);
306
    }else if(t == 2){
307
        base = GET_MED(0) + GET_MED(1);
308
        add = GET_MED(2) - 1;
309
        INC_MED(0);
310
        INC_MED(1);
311
        DEC_MED(2);
312
    }else{
313
        base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
314
        add = GET_MED(2) - 1;
315
        INC_MED(0);
316
        INC_MED(1);
317
        INC_MED(2);
318
    }
319
    if(!c->error_limit){
320
        ret = base + get_tail(gb, add);
321
    }else{
322
        int mid = (base*2 + add + 1) >> 1;
323
        while(add > c->error_limit){
324
            if(get_bits1(gb)){
325
                add -= (mid - base);
326
                base = mid;
327
            }else
328
                add = mid - base - 1;
329
            mid = (base*2 + add + 1) >> 1;
330
        }
331
        ret = mid;
332
    }
333
    sign = get_bits1(gb);
334
    if(ctx->hybrid_bitrate)
335
        c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
336
    return sign ? ~ret : ret;
337
}
338

    
339
static int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, int16_t *dst)
340
{
341
    int i, j, count = 0;
342
    int last, t;
343
    int A, B, L, L2, R, R2, bit;
344
    int pos = 0;
345
    uint32_t crc = 0xFFFFFFFF;
346

    
347
    s->one = s->zero = s->zeroes = 0;
348
    do{
349
        L = wv_get_value(s, gb, 0, &last);
350
        if(last) break;
351
        R = wv_get_value(s, gb, 1, &last);
352
        if(last) break;
353
        for(i = 0; i < s->terms; i++){
354
            t = s->decorr[i].value;
355
            j = 0;
356
            if(t > 0){
357
                if(t > 8){
358
                    if(t & 1){
359
                        A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
360
                        B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
361
                    }else{
362
                        A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
363
                        B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
364
                    }
365
                    s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
366
                    s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
367
                    j = 0;
368
                }else{
369
                    A = s->decorr[i].samplesA[pos];
370
                    B = s->decorr[i].samplesB[pos];
371
                    j = (pos + t) & 7;
372
                }
373
                L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
374
                R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
375
                if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
376
                if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
377
                s->decorr[i].samplesA[j] = L = L2;
378
                s->decorr[i].samplesB[j] = R = R2;
379
            }else if(t == -1){
380
                L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
381
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
382
                L = L2;
383
                R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
384
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
385
                R = R2;
386
                s->decorr[i].samplesA[0] = R;
387
            }else{
388
                R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
389
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
390
                R = R2;
391

    
392
                if(t == -3){
393
                    R2 = s->decorr[i].samplesA[0];
394
                    s->decorr[i].samplesA[0] = R;
395
                }
396

    
397
                L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
398
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
399
                L = L2;
400
                s->decorr[i].samplesB[0] = L;
401
            }
402
        }
403
        pos = (pos + 1) & 7;
404
        if(s->joint)
405
            L += (R -= (L >> 1));
406
        crc = (crc * 3 + L) * 3 + R;
407
        bit = (L & s->and) | s->or;
408
        *dst++ = ((L + bit) << s->shift) - bit;
409
        bit = (R & s->and) | s->or;
410
        *dst++ = ((R + bit) << s->shift) - bit;
411
        count++;
412
    }while(!last && count < s->samples);
413

    
414
    if(crc != s->CRC){
415
        av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
416
        return -1;
417
    }
418
    return count * 2;
419
}
420

    
421
static int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, int16_t *dst)
422
{
423
    int i, j, count = 0;
424
    int last, t;
425
    int A, S, T, bit;
426
    int pos = 0;
427
    uint32_t crc = 0xFFFFFFFF;
428

    
429
    s->one = s->zero = s->zeroes = 0;
430
    do{
431
        T = wv_get_value(s, gb, 0, &last);
432
        S = 0;
433
        if(last) break;
434
        for(i = 0; i < s->terms; i++){
435
            t = s->decorr[i].value;
436
            if(t > 8){
437
                if(t & 1)
438
                    A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
439
                else
440
                    A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
441
                s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
442
                j = 0;
443
            }else{
444
                A = s->decorr[i].samplesA[pos];
445
                j = (pos + t) & 7;
446
            }
447
            S = T + ((s->decorr[i].weightA * A + 512) >> 10);
448
            if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
449
            s->decorr[i].samplesA[j] = T = S;
450
        }
451
        pos = (pos + 1) & 7;
452
        crc = crc * 3 + S;
453
        bit = (S & s->and) | s->or;
454
        *dst++ = ((S + bit) << s->shift) - bit;
455
        count++;
456
    }while(!last && count < s->samples);
457

    
458
    if(crc != s->CRC){
459
        av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
460
        return -1;
461
    }
462
    return count;
463
}
464

    
465
static av_cold int wavpack_decode_init(AVCodecContext *avctx)
466
{
467
    WavpackContext *s = avctx->priv_data;
468

    
469
    s->avctx = avctx;
470
    s->stereo = (avctx->channels == 2);
471
    avctx->sample_fmt = SAMPLE_FMT_S16;
472
    avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
473

    
474
    return 0;
475
}
476

    
477
static int wavpack_decode_frame(AVCodecContext *avctx,
478
                            void *data, int *data_size,
479
                            AVPacket *avpkt)
480
{
481
    const uint8_t *buf = avpkt->data;
482
    int buf_size = avpkt->size;
483
    WavpackContext *s = avctx->priv_data;
484
    int16_t *samples = data;
485
    int samplecount;
486
    int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0;
487
    int got_hybrid = 0;
488
    const uint8_t* buf_end = buf + buf_size;
489
    int i, j, id, size, ssize, weights, t;
490

    
491
    if (buf_size == 0){
492
        *data_size = 0;
493
        return 0;
494
    }
495

    
496
    memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
497
    memset(s->ch, 0, sizeof(s->ch));
498
    s->and = s->or = s->shift = 0;
499

    
500
    s->samples = AV_RL32(buf); buf += 4;
501
    if(!s->samples){
502
        *data_size = 0;
503
        return buf_size;
504
    }
505
    /* should not happen but who knows */
506
    if(s->samples * 2 * avctx->channels > *data_size){
507
        av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n");
508
        return -1;
509
    }
510
    s->frame_flags = AV_RL32(buf); buf += 4;
511
    s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
512
    s->joint = s->frame_flags & WV_JOINT_STEREO;
513
    s->hybrid = s->frame_flags & WV_HYBRID_MODE;
514
    s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
515
    s->CRC = AV_RL32(buf); buf += 4;
516
    // parse metadata blocks
517
    while(buf < buf_end){
518
        id = *buf++;
519
        size = *buf++;
520
        if(id & WP_IDF_LONG) {
521
            size |= (*buf++) << 8;
522
            size |= (*buf++) << 16;
523
        }
524
        size <<= 1; // size is specified in words
525
        ssize = size;
526
        if(id & WP_IDF_ODD) size--;
527
        if(size < 0){
528
            av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
529
            break;
530
        }
531
        if(buf + ssize > buf_end){
532
            av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
533
            break;
534
        }
535
        if(id & WP_IDF_IGNORE){
536
            buf += ssize;
537
            continue;
538
        }
539
        switch(id & WP_IDF_MASK){
540
        case WP_ID_DECTERMS:
541
            s->terms = size;
542
            if(s->terms > MAX_TERMS){
543
                av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
544
                buf += ssize;
545
                continue;
546
            }
547
            for(i = 0; i < s->terms; i++) {
548
                s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
549
                s->decorr[s->terms - i - 1].delta = *buf >> 5;
550
                buf++;
551
            }
552
            got_terms = 1;
553
            break;
554
        case WP_ID_DECWEIGHTS:
555
            if(!got_terms){
556
                av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
557
                continue;
558
            }
559
            weights = size >> s->stereo_in;
560
            if(weights > MAX_TERMS || weights > s->terms){
561
                av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
562
                buf += ssize;
563
                continue;
564
            }
565
            for(i = 0; i < weights; i++) {
566
                t = (int8_t)(*buf++);
567
                s->decorr[s->terms - i - 1].weightA = t << 3;
568
                if(s->decorr[s->terms - i - 1].weightA > 0)
569
                    s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
570
                if(s->stereo_in){
571
                    t = (int8_t)(*buf++);
572
                    s->decorr[s->terms - i - 1].weightB = t << 3;
573
                    if(s->decorr[s->terms - i - 1].weightB > 0)
574
                        s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
575
                }
576
            }
577
            got_weights = 1;
578
            break;
579
        case WP_ID_DECSAMPLES:
580
            if(!got_terms){
581
                av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
582
                continue;
583
            }
584
            t = 0;
585
            for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
586
                if(s->decorr[i].value > 8){
587
                    s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
588
                    s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
589
                    if(s->stereo_in){
590
                        s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
591
                        s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
592
                        t += 4;
593
                    }
594
                    t += 4;
595
                }else if(s->decorr[i].value < 0){
596
                    s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
597
                    s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
598
                    t += 4;
599
                }else{
600
                    for(j = 0; j < s->decorr[i].value; j++){
601
                        s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
602
                        if(s->stereo_in){
603
                            s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
604
                        }
605
                    }
606
                    t += s->decorr[i].value * 2 * (s->stereo_in + 1);
607
                }
608
            }
609
            got_samples = 1;
610
            break;
611
        case WP_ID_ENTROPY:
612
            if(size != 6 * (s->stereo_in + 1)){
613
                av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
614
                buf += ssize;
615
                continue;
616
            }
617
            for(j = 0; j <= s->stereo_in; j++){
618
                for(i = 0; i < 3; i++){
619
                    s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
620
                    buf += 2;
621
                }
622
            }
623
            got_entropy = 1;
624
            break;
625
        case WP_ID_HYBRID:
626
            if(s->hybrid_bitrate){
627
                for(i = 0; i <= s->stereo_in; i++){
628
                    s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
629
                    buf += 2;
630
                    size -= 2;
631
                }
632
            }
633
            for(i = 0; i < (s->stereo_in + 1); i++){
634
                s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
635
                buf += 2;
636
                size -= 2;
637
            }
638
            if(size > 0){
639
                for(i = 0; i < (s->stereo_in + 1); i++){
640
                    s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
641
                    buf += 2;
642
                }
643
            }else{
644
                for(i = 0; i < (s->stereo_in + 1); i++)
645
                    s->ch[i].bitrate_delta = 0;
646
            }
647
            got_hybrid = 1;
648
            break;
649
        case WP_ID_INT32INFO:
650
            if(size != 4 || *buf){
651
                av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
652
                buf += ssize;
653
                continue;
654
            }
655
            if(buf[1])
656
                s->shift = buf[1];
657
            else if(buf[2]){
658
                s->and = s->or = 1;
659
                s->shift = buf[2];
660
            }else if(buf[3]){
661
                s->and = 1;
662
                s->shift = buf[3];
663
            }
664
            buf += 4;
665
            break;
666
        case WP_ID_DATA:
667
            init_get_bits(&s->gb, buf, size * 8);
668
            s->data_size = size * 8;
669
            buf += size;
670
            got_bs = 1;
671
            break;
672
        default:
673
            buf += size;
674
        }
675
        if(id & WP_IDF_ODD) buf++;
676
    }
677
    if(!got_terms){
678
        av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
679
        return -1;
680
    }
681
    if(!got_weights){
682
        av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
683
        return -1;
684
    }
685
    if(!got_samples){
686
        av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
687
        return -1;
688
    }
689
    if(!got_entropy){
690
        av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
691
        return -1;
692
    }
693
    if(s->hybrid && !got_hybrid){
694
        av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
695
        return -1;
696
    }
697
    if(!got_bs){
698
        av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
699
        return -1;
700
    }
701

    
702
    if(s->stereo_in)
703
        samplecount = wv_unpack_stereo(s, &s->gb, samples);
704
    else{
705
        samplecount = wv_unpack_mono(s, &s->gb, samples);
706
        if(s->stereo){
707
            int16_t *dst = samples + samplecount * 2;
708
            int16_t *src = samples + samplecount;
709
            int cnt = samplecount;
710
            while(cnt--){
711
                *--dst = *--src;
712
                *--dst = *src;
713
            }
714
            samplecount *= 2;
715
        }
716
    }
717
    *data_size = samplecount * 2;
718

    
719
    return buf_size;
720
}
721

    
722
AVCodec wavpack_decoder = {
723
    "wavpack",
724
    CODEC_TYPE_AUDIO,
725
    CODEC_ID_WAVPACK,
726
    sizeof(WavpackContext),
727
    wavpack_decode_init,
728
    NULL,
729
    NULL,
730
    wavpack_decode_frame,
731
    .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
732
};