Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wavpack.c @ 69c78161

History | View | Annotate | Download (39.5 KB)

1
/*
2
 * WavPack lossless audio decoder
3
 * Copyright (c) 2006,2011 Konstantin Shishkov
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
#define ALT_BITSTREAM_READER_LE
22
#include "avcodec.h"
23
#include "get_bits.h"
24
#include "unary.h"
25

    
26
/**
27
 * @file
28
 * WavPack lossless audio decoder
29
 */
30

    
31
#define WV_MONO         0x00000004
32
#define WV_JOINT_STEREO 0x00000010
33
#define WV_FALSE_STEREO 0x40000000
34

    
35
#define WV_HYBRID_MODE    0x00000008
36
#define WV_HYBRID_SHAPE   0x00000008
37
#define WV_HYBRID_BITRATE 0x00000200
38
#define WV_HYBRID_BALANCE 0x00000400
39

    
40
#define WV_FLT_SHIFT_ONES 0x01
41
#define WV_FLT_SHIFT_SAME 0x02
42
#define WV_FLT_SHIFT_SENT 0x04
43
#define WV_FLT_ZERO_SENT  0x08
44
#define WV_FLT_ZERO_SIGN  0x10
45

    
46
enum WP_ID_Flags{
47
    WP_IDF_MASK   = 0x1F,
48
    WP_IDF_IGNORE = 0x20,
49
    WP_IDF_ODD    = 0x40,
50
    WP_IDF_LONG   = 0x80
51
};
52

    
53
enum WP_ID{
54
    WP_ID_DUMMY = 0,
55
    WP_ID_ENCINFO,
56
    WP_ID_DECTERMS,
57
    WP_ID_DECWEIGHTS,
58
    WP_ID_DECSAMPLES,
59
    WP_ID_ENTROPY,
60
    WP_ID_HYBRID,
61
    WP_ID_SHAPING,
62
    WP_ID_FLOATINFO,
63
    WP_ID_INT32INFO,
64
    WP_ID_DATA,
65
    WP_ID_CORR,
66
    WP_ID_EXTRABITS,
67
    WP_ID_CHANINFO
68
};
69

    
70
typedef struct SavedContext {
71
    int offset;
72
    int size;
73
    int bits_used;
74
    uint32_t crc;
75
} SavedContext;
76

    
77
#define MAX_TERMS 16
78

    
79
typedef struct Decorr {
80
    int delta;
81
    int value;
82
    int weightA;
83
    int weightB;
84
    int samplesA[8];
85
    int samplesB[8];
86
} Decorr;
87

    
88
typedef struct WvChannel {
89
    int median[3];
90
    int slow_level, error_limit;
91
    int bitrate_acc, bitrate_delta;
92
} WvChannel;
93

    
94
typedef struct WavpackFrameContext {
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
} WavpackFrameContext;
122

    
123
#define WV_MAX_FRAME_DECODERS 14
124

    
125
typedef struct WavpackContext {
126
    AVCodecContext *avctx;
127

    
128
    WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
129
    int fdec_num;
130

    
131
    int multichannel;
132
    int mkv_mode;
133
    int block;
134
    int samples;
135
    int samples_left;
136
    int ch_offset;
137
} WavpackContext;
138

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

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

    
178
static av_always_inline int wp_exp2(int16_t val)
179
{
180
    int res, neg = 0;
181

    
182
    if(val < 0){
183
        val = -val;
184
        neg = 1;
185
    }
186

    
187
    res = wp_exp2_table[val & 0xFF] | 0x100;
188
    val >>= 8;
189
    res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
190
    return neg ? -res : res;
191
}
192

    
193
static av_always_inline int wp_log2(int32_t val)
194
{
195
    int bits;
196

    
197
    if(!val)
198
        return 0;
199
    if(val == 1)
200
        return 256;
201
    val += val >> 9;
202
    bits = av_log2(val) + 1;
203
    if(bits < 9)
204
        return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
205
    else
206
        return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
207
}
208

    
209
#define LEVEL_DECAY(a)  ((a + 0x80) >> 8)
210

    
211
// macros for manipulating median values
212
#define GET_MED(n) ((c->median[n] >> 4) + 1)
213
#define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
214
#define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
215

    
216
// macros for applying weight
217
#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
218
        if(samples && in){ \
219
            if((samples ^ in) < 0){ \
220
                weight -= delta; \
221
                if(weight < -1024) weight = -1024; \
222
            }else{ \
223
                weight += delta; \
224
                if(weight > 1024) weight = 1024; \
225
            } \
226
        }
227

    
228

    
229
static av_always_inline int get_tail(GetBitContext *gb, int k)
230
{
231
    int p, e, res;
232

    
233
    if(k<1)return 0;
234
    p = av_log2(k);
235
    e = (1 << (p + 1)) - k - 1;
236
    res = p ? get_bits(gb, p) : 0;
237
    if(res >= e){
238
        res = (res<<1) - e + get_bits1(gb);
239
    }
240
    return res;
241
}
242

    
243
static void update_error_limit(WavpackFrameContext *ctx)
244
{
245
    int i, br[2], sl[2];
246

    
247
    for(i = 0; i <= ctx->stereo_in; i++){
248
        ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
249
        br[i] = ctx->ch[i].bitrate_acc >> 16;
250
        sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
251
    }
252
    if(ctx->stereo_in && ctx->hybrid_bitrate){
253
        int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
254
        if(balance > br[0]){
255
            br[1] = br[0] << 1;
256
            br[0] = 0;
257
        }else if(-balance > br[0]){
258
            br[0] <<= 1;
259
            br[1] = 0;
260
        }else{
261
            br[1] = br[0] + balance;
262
            br[0] = br[0] - balance;
263
        }
264
    }
265
    for(i = 0; i <= ctx->stereo_in; i++){
266
        if(ctx->hybrid_bitrate){
267
            if(sl[i] - br[i] > -0x100)
268
                ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
269
            else
270
                ctx->ch[i].error_limit = 0;
271
        }else{
272
            ctx->ch[i].error_limit = wp_exp2(br[i]);
273
        }
274
    }
275
}
276

    
277
static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, int channel, int *last)
278
{
279
    int t, t2;
280
    int sign, base, add, ret;
281
    WvChannel *c = &ctx->ch[channel];
282

    
283
    *last = 0;
284

    
285
    if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
286
        if(ctx->zeroes){
287
            ctx->zeroes--;
288
            if(ctx->zeroes){
289
                c->slow_level -= LEVEL_DECAY(c->slow_level);
290
                return 0;
291
            }
292
        }else{
293
            t = get_unary_0_33(gb);
294
            if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1));
295
            ctx->zeroes = t;
296
            if(ctx->zeroes){
297
                memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
298
                memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
299
                c->slow_level -= LEVEL_DECAY(c->slow_level);
300
                return 0;
301
            }
302
        }
303
    }
304

    
305
    if(get_bits_count(gb) >= ctx->data_size){
306
        *last = 1;
307
        return 0;
308
    }
309

    
310
    if(ctx->zero){
311
        t = 0;
312
        ctx->zero = 0;
313
    }else{
314
        t = get_unary_0_33(gb);
315
        if(get_bits_count(gb) >= ctx->data_size){
316
            *last = 1;
317
            return 0;
318
        }
319
        if(t == 16) {
320
            t2 = get_unary_0_33(gb);
321
            if(t2 < 2) t += t2;
322
            else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
323
        }
324

    
325
        if(ctx->one){
326
            ctx->one = t&1;
327
            t = (t>>1) + 1;
328
        }else{
329
            ctx->one = t&1;
330
            t >>= 1;
331
        }
332
        ctx->zero = !ctx->one;
333
    }
334

    
335
    if(ctx->hybrid && !channel)
336
        update_error_limit(ctx);
337

    
338
    if(!t){
339
        base = 0;
340
        add = GET_MED(0) - 1;
341
        DEC_MED(0);
342
    }else if(t == 1){
343
        base = GET_MED(0);
344
        add = GET_MED(1) - 1;
345
        INC_MED(0);
346
        DEC_MED(1);
347
    }else if(t == 2){
348
        base = GET_MED(0) + GET_MED(1);
349
        add = GET_MED(2) - 1;
350
        INC_MED(0);
351
        INC_MED(1);
352
        DEC_MED(2);
353
    }else{
354
        base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
355
        add = GET_MED(2) - 1;
356
        INC_MED(0);
357
        INC_MED(1);
358
        INC_MED(2);
359
    }
360
    if(!c->error_limit){
361
        ret = base + get_tail(gb, add);
362
    }else{
363
        int mid = (base*2 + add + 1) >> 1;
364
        while(add > c->error_limit){
365
            if(get_bits1(gb)){
366
                add -= (mid - base);
367
                base = mid;
368
            }else
369
                add = mid - base - 1;
370
            mid = (base*2 + add + 1) >> 1;
371
        }
372
        ret = mid;
373
    }
374
    sign = get_bits1(gb);
375
    if(ctx->hybrid_bitrate)
376
        c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
377
    return sign ? ~ret : ret;
378
}
379

    
380
static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
381
{
382
    int bit;
383

    
384
    if(s->extra_bits){
385
        S <<= s->extra_bits;
386

    
387
        if(s->got_extra_bits){
388
            S |= get_bits(&s->gb_extra_bits, s->extra_bits);
389
            *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
390
        }
391
    }
392
    bit = (S & s->and) | s->or;
393
    return (((S + bit) << s->shift) - bit) << s->post_shift;
394
}
395

    
396
static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
397
{
398
    union {
399
        float    f;
400
        uint32_t u;
401
    } value;
402

    
403
    int sign;
404
    int exp = s->float_max_exp;
405

    
406
    if(s->got_extra_bits){
407
        const int max_bits = 1 + 23 + 8 + 1;
408
        const int left_bits = get_bits_left(&s->gb_extra_bits);
409

    
410
        if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
411
            return 0.0;
412
    }
413

    
414
    if(S){
415
        S <<= s->float_shift;
416
        sign = S < 0;
417
        if(sign)
418
            S = -S;
419
        if(S >= 0x1000000){
420
            if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
421
                S = get_bits(&s->gb_extra_bits, 23);
422
            }else{
423
                S = 0;
424
            }
425
            exp = 255;
426
        }else if(exp){
427
            int shift = 23 - av_log2(S);
428
            exp = s->float_max_exp;
429
            if(exp <= shift){
430
                shift = --exp;
431
            }
432
            exp -= shift;
433

    
434
            if(shift){
435
                S <<= shift;
436
                if((s->float_flag & WV_FLT_SHIFT_ONES) ||
437
                   (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
438
                    S |= (1 << shift) - 1;
439
                } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
440
                    S |= get_bits(&s->gb_extra_bits, shift);
441
                }
442
            }
443
        }else{
444
            exp = s->float_max_exp;
445
        }
446
        S &= 0x7fffff;
447
    }else{
448
        sign = 0;
449
        exp = 0;
450
        if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
451
            if(get_bits1(&s->gb_extra_bits)){
452
                S = get_bits(&s->gb_extra_bits, 23);
453
                if(s->float_max_exp >= 25)
454
                    exp = get_bits(&s->gb_extra_bits, 8);
455
                sign = get_bits1(&s->gb_extra_bits);
456
            }else{
457
                if(s->float_flag & WV_FLT_ZERO_SIGN)
458
                    sign = get_bits1(&s->gb_extra_bits);
459
            }
460
        }
461
    }
462

    
463
    *crc = *crc * 27 + S * 9 + exp * 3 + sign;
464

    
465
    value.u = (sign << 31) | (exp << 23) | S;
466
    return value.f;
467
}
468

    
469
static void wv_reset_saved_context(WavpackFrameContext *s)
470
{
471
    s->pos = 0;
472
    s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
473
}
474

    
475
static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
476
{
477
    int i, j, count = 0;
478
    int last, t;
479
    int A, B, L, L2, R, R2;
480
    int pos = s->pos;
481
    uint32_t crc = s->sc.crc;
482
    uint32_t crc_extra_bits = s->extra_sc.crc;
483
    int16_t *dst16 = dst;
484
    int32_t *dst32 = dst;
485
    float   *dstfl = dst;
486
    const int channel_pad = s->avctx->channels - 2;
487

    
488
    if(s->samples_left == s->samples)
489
        s->one = s->zero = s->zeroes = 0;
490
    do{
491
        L = wv_get_value(s, gb, 0, &last);
492
        if(last) break;
493
        R = wv_get_value(s, gb, 1, &last);
494
        if(last) break;
495
        for(i = 0; i < s->terms; i++){
496
            t = s->decorr[i].value;
497
            if(t > 0){
498
                if(t > 8){
499
                    if(t & 1){
500
                        A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
501
                        B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
502
                    }else{
503
                        A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
504
                        B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
505
                    }
506
                    s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
507
                    s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
508
                    j = 0;
509
                }else{
510
                    A = s->decorr[i].samplesA[pos];
511
                    B = s->decorr[i].samplesB[pos];
512
                    j = (pos + t) & 7;
513
                }
514
                if(type != AV_SAMPLE_FMT_S16){
515
                    L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
516
                    R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
517
                }else{
518
                    L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
519
                    R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
520
                }
521
                if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
522
                if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
523
                s->decorr[i].samplesA[j] = L = L2;
524
                s->decorr[i].samplesB[j] = R = R2;
525
            }else if(t == -1){
526
                if(type != AV_SAMPLE_FMT_S16)
527
                    L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
528
                else
529
                    L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
530
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
531
                L = L2;
532
                if(type != AV_SAMPLE_FMT_S16)
533
                    R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
534
                else
535
                    R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
536
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
537
                R = R2;
538
                s->decorr[i].samplesA[0] = R;
539
            }else{
540
                if(type != AV_SAMPLE_FMT_S16)
541
                    R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
542
                else
543
                    R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
544
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
545
                R = R2;
546

    
547
                if(t == -3){
548
                    R2 = s->decorr[i].samplesA[0];
549
                    s->decorr[i].samplesA[0] = R;
550
                }
551

    
552
                if(type != AV_SAMPLE_FMT_S16)
553
                    L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
554
                else
555
                    L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
556
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
557
                L = L2;
558
                s->decorr[i].samplesB[0] = L;
559
            }
560
        }
561
        pos = (pos + 1) & 7;
562
        if(s->joint)
563
            L += (R -= (L >> 1));
564
        crc = (crc * 3 + L) * 3 + R;
565

    
566
        if(type == AV_SAMPLE_FMT_FLT){
567
            *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
568
            *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
569
            dstfl += channel_pad;
570
        } else if(type == AV_SAMPLE_FMT_S32){
571
            *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
572
            *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
573
            dst32 += channel_pad;
574
        } else {
575
            *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
576
            *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
577
            dst16 += channel_pad;
578
        }
579
        count++;
580
    }while(!last && count < s->max_samples);
581

    
582
    s->samples_left -= count;
583
    if(!s->samples_left){
584
        if(crc != s->CRC){
585
            av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
586
            return -1;
587
        }
588
        if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
589
            av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
590
            return -1;
591
        }
592
        wv_reset_saved_context(s);
593
    }else{
594
        s->pos = pos;
595
        s->sc.crc = crc;
596
        s->sc.bits_used = get_bits_count(&s->gb);
597
        if(s->got_extra_bits){
598
            s->extra_sc.crc = crc_extra_bits;
599
            s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
600
        }
601
    }
602
    return count * 2;
603
}
604

    
605
static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
606
{
607
    int i, j, count = 0;
608
    int last, t;
609
    int A, S, T;
610
    int pos = s->pos;
611
    uint32_t crc = s->sc.crc;
612
    uint32_t crc_extra_bits = s->extra_sc.crc;
613
    int16_t *dst16 = dst;
614
    int32_t *dst32 = dst;
615
    float   *dstfl = dst;
616
    const int channel_stride = s->avctx->channels;
617

    
618
    if(s->samples_left == s->samples)
619
        s->one = s->zero = s->zeroes = 0;
620
    do{
621
        T = wv_get_value(s, gb, 0, &last);
622
        S = 0;
623
        if(last) break;
624
        for(i = 0; i < s->terms; i++){
625
            t = s->decorr[i].value;
626
            if(t > 8){
627
                if(t & 1)
628
                    A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
629
                else
630
                    A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
631
                s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
632
                j = 0;
633
            }else{
634
                A = s->decorr[i].samplesA[pos];
635
                j = (pos + t) & 7;
636
            }
637
            if(type != AV_SAMPLE_FMT_S16)
638
                S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
639
            else
640
                S = T + ((s->decorr[i].weightA * A + 512) >> 10);
641
            if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
642
            s->decorr[i].samplesA[j] = T = S;
643
        }
644
        pos = (pos + 1) & 7;
645
        crc = crc * 3 + S;
646

    
647
        if(type == AV_SAMPLE_FMT_FLT){
648
            *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
649
            dstfl += channel_stride;
650
        }else if(type == AV_SAMPLE_FMT_S32){
651
            *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
652
            dst32 += channel_stride;
653
        }else{
654
            *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
655
            dst16 += channel_stride;
656
        }
657
        count++;
658
    }while(!last && count < s->max_samples);
659

    
660
    s->samples_left -= count;
661
    if(!s->samples_left){
662
        if(crc != s->CRC){
663
            av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
664
            return -1;
665
        }
666
        if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
667
            av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
668
            return -1;
669
        }
670
        wv_reset_saved_context(s);
671
    }else{
672
        s->pos = pos;
673
        s->sc.crc = crc;
674
        s->sc.bits_used = get_bits_count(&s->gb);
675
        if(s->got_extra_bits){
676
            s->extra_sc.crc = crc_extra_bits;
677
            s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
678
        }
679
    }
680
    return count;
681
}
682

    
683
static av_cold int wv_alloc_frame_context(WavpackContext *c)
684
{
685

    
686
    if(c->fdec_num == WV_MAX_FRAME_DECODERS)
687
        return -1;
688

    
689
    c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
690
    if(!c->fdec[c->fdec_num])
691
        return -1;
692
    c->fdec_num++;
693
    c->fdec[c->fdec_num - 1]->avctx = c->avctx;
694
    wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
695

    
696
    return 0;
697
}
698

    
699
static av_cold int wavpack_decode_init(AVCodecContext *avctx)
700
{
701
    WavpackContext *s = avctx->priv_data;
702

    
703
    s->avctx = avctx;
704
    if(avctx->bits_per_coded_sample <= 16)
705
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
706
    else
707
        avctx->sample_fmt = AV_SAMPLE_FMT_S32;
708
    if(avctx->channels <= 2 && !avctx->channel_layout)
709
        avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
710

    
711
    s->multichannel = avctx->channels > 2;
712
    /* lavf demuxer does not provide extradata, Matroska stores 0x403
713
       there, use this to detect decoding mode for multichannel */
714
    s->mkv_mode = 0;
715
    if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
716
        int ver = AV_RL16(avctx->extradata);
717
        if(ver >= 0x402 && ver <= 0x410)
718
            s->mkv_mode = 1;
719
    }
720

    
721
    s->fdec_num = 0;
722

    
723
    return 0;
724
}
725

    
726
static av_cold int wavpack_decode_end(AVCodecContext *avctx)
727
{
728
    WavpackContext *s = avctx->priv_data;
729
    int i;
730

    
731
    for(i = 0; i < s->fdec_num; i++)
732
        av_freep(&s->fdec[i]);
733
    s->fdec_num = 0;
734

    
735
    return 0;
736
}
737

    
738
static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
739
                                void *data, int *data_size,
740
                                const uint8_t *buf, int buf_size)
741
{
742
    WavpackContext *wc = avctx->priv_data;
743
    WavpackFrameContext *s;
744
    void *samples = data;
745
    int samplecount;
746
    int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
747
    int got_hybrid = 0;
748
    const uint8_t* orig_buf = buf;
749
    const uint8_t* buf_end = buf + buf_size;
750
    int i, j, id, size, ssize, weights, t;
751
    int bpp, chan, chmask;
752

    
753
    if (buf_size == 0){
754
        *data_size = 0;
755
        return 0;
756
    }
757

    
758
    if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
759
        av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
760
        return -1;
761
    }
762

    
763
    s = wc->fdec[block_no];
764
    if(!s){
765
        av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
766
        return -1;
767
    }
768

    
769
    if(!s->samples_left){
770
        memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
771
        memset(s->ch, 0, sizeof(s->ch));
772
        s->extra_bits = 0;
773
        s->and = s->or = s->shift = 0;
774
        s->got_extra_bits = 0;
775
    }
776

    
777
    if(!wc->mkv_mode){
778
        s->samples = AV_RL32(buf); buf += 4;
779
        if(!s->samples){
780
            *data_size = 0;
781
            return buf_size;
782
        }
783
    }else{
784
        s->samples = wc->samples;
785
    }
786
    s->frame_flags = AV_RL32(buf); buf += 4;
787
    if(s->frame_flags&0x80){
788
        bpp = sizeof(float);
789
        avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
790
    } else if((s->frame_flags&0x03) <= 1){
791
        bpp = 2;
792
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
793
    } else {
794
        bpp = 4;
795
        avctx->sample_fmt = AV_SAMPLE_FMT_S32;
796
    }
797
    samples = (uint8_t*)samples + bpp * wc->ch_offset;
798

    
799
    s->stereo = !(s->frame_flags & WV_MONO);
800
    s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
801
    s->joint = s->frame_flags & WV_JOINT_STEREO;
802
    s->hybrid = s->frame_flags & WV_HYBRID_MODE;
803
    s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
804
    s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
805
    s->CRC = AV_RL32(buf); buf += 4;
806
    if(wc->mkv_mode)
807
        buf += 4; //skip block size;
808

    
809
    wc->ch_offset += 1 + s->stereo;
810

    
811
    s->max_samples = *data_size / (bpp * avctx->channels);
812
    s->max_samples = FFMIN(s->max_samples, s->samples);
813
    if(s->samples_left > 0){
814
        s->max_samples = FFMIN(s->max_samples, s->samples_left);
815
        buf = buf_end;
816
    }
817

    
818
    // parse metadata blocks
819
    while(buf < buf_end){
820
        id = *buf++;
821
        size = *buf++;
822
        if(id & WP_IDF_LONG) {
823
            size |= (*buf++) << 8;
824
            size |= (*buf++) << 16;
825
        }
826
        size <<= 1; // size is specified in words
827
        ssize = size;
828
        if(id & WP_IDF_ODD) size--;
829
        if(size < 0){
830
            av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
831
            break;
832
        }
833
        if(buf + ssize > buf_end){
834
            av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
835
            break;
836
        }
837
        if(id & WP_IDF_IGNORE){
838
            buf += ssize;
839
            continue;
840
        }
841
        switch(id & WP_IDF_MASK){
842
        case WP_ID_DECTERMS:
843
            s->terms = size;
844
            if(s->terms > MAX_TERMS){
845
                av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
846
                buf += ssize;
847
                continue;
848
            }
849
            for(i = 0; i < s->terms; i++) {
850
                s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
851
                s->decorr[s->terms - i - 1].delta = *buf >> 5;
852
                buf++;
853
            }
854
            got_terms = 1;
855
            break;
856
        case WP_ID_DECWEIGHTS:
857
            if(!got_terms){
858
                av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
859
                continue;
860
            }
861
            weights = size >> s->stereo_in;
862
            if(weights > MAX_TERMS || weights > s->terms){
863
                av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
864
                buf += ssize;
865
                continue;
866
            }
867
            for(i = 0; i < weights; i++) {
868
                t = (int8_t)(*buf++);
869
                s->decorr[s->terms - i - 1].weightA = t << 3;
870
                if(s->decorr[s->terms - i - 1].weightA > 0)
871
                    s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
872
                if(s->stereo_in){
873
                    t = (int8_t)(*buf++);
874
                    s->decorr[s->terms - i - 1].weightB = t << 3;
875
                    if(s->decorr[s->terms - i - 1].weightB > 0)
876
                        s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
877
                }
878
            }
879
            got_weights = 1;
880
            break;
881
        case WP_ID_DECSAMPLES:
882
            if(!got_terms){
883
                av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
884
                continue;
885
            }
886
            t = 0;
887
            for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
888
                if(s->decorr[i].value > 8){
889
                    s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
890
                    s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
891
                    if(s->stereo_in){
892
                        s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
893
                        s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
894
                        t += 4;
895
                    }
896
                    t += 4;
897
                }else if(s->decorr[i].value < 0){
898
                    s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
899
                    s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
900
                    t += 4;
901
                }else{
902
                    for(j = 0; j < s->decorr[i].value; j++){
903
                        s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
904
                        if(s->stereo_in){
905
                            s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
906
                        }
907
                    }
908
                    t += s->decorr[i].value * 2 * (s->stereo_in + 1);
909
                }
910
            }
911
            got_samples = 1;
912
            break;
913
        case WP_ID_ENTROPY:
914
            if(size != 6 * (s->stereo_in + 1)){
915
                av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
916
                buf += ssize;
917
                continue;
918
            }
919
            for(j = 0; j <= s->stereo_in; j++){
920
                for(i = 0; i < 3; i++){
921
                    s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
922
                    buf += 2;
923
                }
924
            }
925
            got_entropy = 1;
926
            break;
927
        case WP_ID_HYBRID:
928
            if(s->hybrid_bitrate){
929
                for(i = 0; i <= s->stereo_in; i++){
930
                    s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
931
                    buf += 2;
932
                    size -= 2;
933
                }
934
            }
935
            for(i = 0; i < (s->stereo_in + 1); i++){
936
                s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
937
                buf += 2;
938
                size -= 2;
939
            }
940
            if(size > 0){
941
                for(i = 0; i < (s->stereo_in + 1); i++){
942
                    s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
943
                    buf += 2;
944
                }
945
            }else{
946
                for(i = 0; i < (s->stereo_in + 1); i++)
947
                    s->ch[i].bitrate_delta = 0;
948
            }
949
            got_hybrid = 1;
950
            break;
951
        case WP_ID_INT32INFO:
952
            if(size != 4){
953
                av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
954
                buf += ssize;
955
                continue;
956
            }
957
            if(buf[0])
958
                s->extra_bits = buf[0];
959
            else if(buf[1])
960
                s->shift = buf[1];
961
            else if(buf[2]){
962
                s->and = s->or = 1;
963
                s->shift = buf[2];
964
            }else if(buf[3]){
965
                s->and = 1;
966
                s->shift = buf[3];
967
            }
968
            buf += 4;
969
            break;
970
        case WP_ID_FLOATINFO:
971
            if(size != 4){
972
                av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
973
                buf += ssize;
974
                continue;
975
            }
976
            s->float_flag = buf[0];
977
            s->float_shift = buf[1];
978
            s->float_max_exp = buf[2];
979
            buf += 4;
980
            got_float = 1;
981
            break;
982
        case WP_ID_DATA:
983
            s->sc.offset = buf - orig_buf;
984
            s->sc.size   = size * 8;
985
            init_get_bits(&s->gb, buf, size * 8);
986
            s->data_size = size * 8;
987
            buf += size;
988
            got_bs = 1;
989
            break;
990
        case WP_ID_EXTRABITS:
991
            if(size <= 4){
992
                av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
993
                buf += size;
994
                continue;
995
            }
996
            s->extra_sc.offset = buf - orig_buf;
997
            s->extra_sc.size   = size * 8;
998
            init_get_bits(&s->gb_extra_bits, buf, size * 8);
999
            s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
1000
            buf += size;
1001
            s->got_extra_bits = 1;
1002
            break;
1003
        case WP_ID_CHANINFO:
1004
            if(size <= 1){
1005
                av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1006
                return -1;
1007
            }
1008
            chan = *buf++;
1009
            switch(size - 2){
1010
            case 0:
1011
                chmask = *buf;
1012
                break;
1013
            case 1:
1014
                chmask = AV_RL16(buf);
1015
                break;
1016
            case 2:
1017
                chmask = AV_RL24(buf);
1018
                break;
1019
            case 3:
1020
                chmask = AV_RL32(buf);
1021
                break;
1022
            case 5:
1023
                chan |= (buf[1] & 0xF) << 8;
1024
                chmask = AV_RL24(buf + 2);
1025
                break;
1026
            default:
1027
                av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
1028
                chan = avctx->channels;
1029
                chmask = avctx->channel_layout;
1030
            }
1031
            if(chan != avctx->channels){
1032
                av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
1033
                       chan, avctx->channels);
1034
                return -1;
1035
            }
1036
            if(!avctx->channel_layout)
1037
                avctx->channel_layout = chmask;
1038
            buf += size - 1;
1039
            break;
1040
        default:
1041
            buf += size;
1042
        }
1043
        if(id & WP_IDF_ODD) buf++;
1044
    }
1045
    if(!s->samples_left){
1046
        if(!got_terms){
1047
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1048
            return -1;
1049
        }
1050
        if(!got_weights){
1051
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1052
            return -1;
1053
        }
1054
        if(!got_samples){
1055
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1056
            return -1;
1057
        }
1058
        if(!got_entropy){
1059
            av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1060
            return -1;
1061
        }
1062
        if(s->hybrid && !got_hybrid){
1063
            av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1064
            return -1;
1065
        }
1066
        if(!got_bs){
1067
            av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1068
            return -1;
1069
        }
1070
        if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
1071
            av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1072
            return -1;
1073
        }
1074
        if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
1075
            const int size = get_bits_left(&s->gb_extra_bits);
1076
            const int wanted = s->samples * s->extra_bits << s->stereo_in;
1077
            if(size < wanted){
1078
                av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1079
                s->got_extra_bits = 0;
1080
            }
1081
        }
1082
        s->samples_left = s->samples;
1083
    }else{
1084
        init_get_bits(&s->gb, orig_buf + s->sc.offset, s->sc.size);
1085
        skip_bits_long(&s->gb, s->sc.bits_used);
1086
        if(s->got_extra_bits){
1087
            init_get_bits(&s->gb_extra_bits, orig_buf + s->extra_sc.offset,
1088
                          s->extra_sc.size);
1089
            skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
1090
        }
1091
    }
1092

    
1093
    if(s->stereo_in){
1094
        if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1095
            samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1096
        else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1097
            samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1098
        else
1099
            samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1100
        samplecount >>= 1;
1101
    }else{
1102
        const int channel_stride = avctx->channels;
1103

    
1104
        if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1105
            samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1106
        else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1107
            samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1108
        else
1109
            samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1110

    
1111
        if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
1112
            int16_t *dst = (int16_t*)samples + 1;
1113
            int16_t *src = (int16_t*)samples;
1114
            int cnt = samplecount;
1115
            while(cnt--){
1116
                *dst = *src;
1117
                src += channel_stride;
1118
                dst += channel_stride;
1119
            }
1120
        }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
1121
            int32_t *dst = (int32_t*)samples + 1;
1122
            int32_t *src = (int32_t*)samples;
1123
            int cnt = samplecount;
1124
            while(cnt--){
1125
                *dst = *src;
1126
                src += channel_stride;
1127
                dst += channel_stride;
1128
            }
1129
        }else if(s->stereo){
1130
            float *dst = (float*)samples + 1;
1131
            float *src = (float*)samples;
1132
            int cnt = samplecount;
1133
            while(cnt--){
1134
                *dst = *src;
1135
                src += channel_stride;
1136
                dst += channel_stride;
1137
            }
1138
        }
1139
    }
1140

    
1141
    wc->samples_left = s->samples_left;
1142

    
1143
    return samplecount * bpp;
1144
}
1145

    
1146
static int wavpack_decode_frame(AVCodecContext *avctx,
1147
                            void *data, int *data_size,
1148
                            AVPacket *avpkt)
1149
{
1150
    WavpackContext *s = avctx->priv_data;
1151
    const uint8_t *buf = avpkt->data;
1152
    int buf_size = avpkt->size;
1153
    int frame_size;
1154
    int samplecount = 0;
1155

    
1156
    s->block = 0;
1157
    s->samples_left = 0;
1158
    s->ch_offset = 0;
1159

    
1160
    if(s->mkv_mode){
1161
        s->samples = AV_RL32(buf); buf += 4;
1162
    }
1163
    while(buf_size > 0){
1164
        if(!s->multichannel){
1165
            frame_size = buf_size;
1166
        }else{
1167
            if(!s->mkv_mode){
1168
                frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1169
            }else{
1170
                if(buf_size < 12) //MKV files can have zero flags after last block
1171
                    break;
1172
                frame_size = AV_RL32(buf + 8) + 12;
1173
            }
1174
        }
1175
        if(frame_size < 0 || frame_size > buf_size){
1176
            av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
1177
                   s->block, frame_size, buf_size);
1178
            return -1;
1179
        }
1180
        if((samplecount = wavpack_decode_block(avctx, s->block, data,
1181
                                               data_size, buf, frame_size)) < 0)
1182
            return -1;
1183
        s->block++;
1184
        buf += frame_size; buf_size -= frame_size;
1185
    }
1186
    *data_size = samplecount * avctx->channels;
1187

    
1188
    return s->samples_left > 0 ? 0 : avpkt->size;
1189
}
1190

    
1191
AVCodec wavpack_decoder = {
1192
    "wavpack",
1193
    AVMEDIA_TYPE_AUDIO,
1194
    CODEC_ID_WAVPACK,
1195
    sizeof(WavpackContext),
1196
    wavpack_decode_init,
1197
    NULL,
1198
    wavpack_decode_end,
1199
    wavpack_decode_frame,
1200
    .capabilities = CODEC_CAP_SUBFRAMES,
1201
    .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1202
};