Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wavpack.c @ 2912e87a

History | View | Annotate | Download (39.6 KB)

1
/*
2
 * WavPack lossless audio decoder
3
 * Copyright (c) 2006,2011 Konstantin Shishkov
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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
#include "libavutil/audioconvert.h"
26

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

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

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

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

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

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

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

    
78
#define MAX_TERMS 16
79

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

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

    
95
typedef struct WavpackFrameContext {
96
    AVCodecContext *avctx;
97
    int frame_flags;
98
    int stereo, stereo_in;
99
    int joint;
100
    uint32_t CRC;
101
    GetBitContext gb;
102
    int got_extra_bits;
103
    uint32_t crc_extra_bits;
104
    GetBitContext gb_extra_bits;
105
    int data_size; // in bits
106
    int samples;
107
    int terms;
108
    Decorr decorr[MAX_TERMS];
109
    int zero, one, zeroes;
110
    int extra_bits;
111
    int and, or, shift;
112
    int post_shift;
113
    int hybrid, hybrid_bitrate;
114
    int float_flag;
115
    int float_shift;
116
    int float_max_exp;
117
    WvChannel ch[2];
118
    int samples_left;
119
    int max_samples;
120
    int pos;
121
    SavedContext sc, extra_sc;
122
} WavpackFrameContext;
123

    
124
#define WV_MAX_FRAME_DECODERS 14
125

    
126
typedef struct WavpackContext {
127
    AVCodecContext *avctx;
128

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

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

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

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

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

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

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

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

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

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

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

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

    
229

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

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

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

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

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

    
284
    *last = 0;
285

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
697
    return 0;
698
}
699

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

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

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

    
722
    s->fdec_num = 0;
723

    
724
    return 0;
725
}
726

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

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

    
736
    return 0;
737
}
738

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1144
    return samplecount * bpp;
1145
}
1146

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

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

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

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

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