Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wavpack.c @ aa170ed6

History | View | Annotate | Download (34.5 KB)

1 730581f3 Kostya Shishkov
/*
2
 * WavPack lossless audio decoder
3
 * Copyright (c) 2006 Konstantin Shishkov
4
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 730581f3 Kostya Shishkov
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 730581f3 Kostya Shishkov
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 730581f3 Kostya Shishkov
 * 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 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 730581f3 Kostya Shishkov
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
#define ALT_BITSTREAM_READER_LE
22
#include "avcodec.h"
23 9106a698 Stefano Sabatini
#include "get_bits.h"
24 28296f9c Aurelien Jacobs
#include "unary.h"
25 730581f3 Kostya Shishkov
26
/**
27 bad5537e Diego Biurrun
 * @file libavcodec/wavpack.c
28 730581f3 Kostya Shishkov
 * WavPack lossless audio decoder
29
 */
30
31 2c96535a Kostya Shishkov
#define WV_MONO         0x00000004
32 11ead90e Kostya Shishkov
#define WV_JOINT_STEREO 0x00000010
33 a6ba65f7 David Bryant
#define WV_FALSE_STEREO 0x40000000
34 730581f3 Kostya Shishkov
35 2c96535a Kostya Shishkov
#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 992f7db0 Laurent Aimar
#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 730581f3 Kostya Shishkov
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 418f77ec Laurent Aimar
    WP_ID_EXTRABITS,
67 730581f3 Kostya Shishkov
    WP_ID_CHANINFO
68
};
69
70 965828bb Kostya Shishkov
typedef struct SavedContext {
71
    int offset;
72
    int size;
73
    int bits_used;
74
    uint32_t crc;
75
} SavedContext;
76
77 730581f3 Kostya Shishkov
#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 2c96535a Kostya Shishkov
typedef struct WvChannel {
89
    int median[3];
90
    int slow_level, error_limit;
91
    int bitrate_acc, bitrate_delta;
92
} WvChannel;
93
94 730581f3 Kostya Shishkov
typedef struct WavpackContext {
95
    AVCodecContext *avctx;
96 2c96535a Kostya Shishkov
    int frame_flags;
97 a6ba65f7 David Bryant
    int stereo, stereo_in;
98 730581f3 Kostya Shishkov
    int joint;
99
    uint32_t CRC;
100
    GetBitContext gb;
101 418f77ec Laurent Aimar
    int got_extra_bits;
102
    uint32_t crc_extra_bits;
103
    GetBitContext gb_extra_bits;
104 730581f3 Kostya Shishkov
    int data_size; // in bits
105
    int samples;
106
    int terms;
107
    Decorr decorr[MAX_TERMS];
108
    int zero, one, zeroes;
109 418f77ec Laurent Aimar
    int extra_bits;
110 6b05eb31 David Bryant
    int and, or, shift;
111 760db32a Laurent Aimar
    int post_shift;
112 2c96535a Kostya Shishkov
    int hybrid, hybrid_bitrate;
113 992f7db0 Laurent Aimar
    int float_flag;
114
    int float_shift;
115
    int float_max_exp;
116 2c96535a Kostya Shishkov
    WvChannel ch[2];
117 965828bb Kostya Shishkov
    int samples_left;
118
    int max_samples;
119
    int pos;
120
    SavedContext sc, extra_sc;
121 730581f3 Kostya Shishkov
} WavpackContext;
122
123
// exponent table copied from WavPack source
124
static const uint8_t wp_exp2_table [256] = {
125
    0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
126
    0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
127
    0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
128
    0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
129
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
130
    0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
131
    0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
132
    0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
133
    0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
134
    0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
135
    0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
136
    0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
137
    0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
138
    0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
139
    0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
140
    0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
141
};
142
143 2c96535a Kostya Shishkov
static const uint8_t wp_log2_table [] = {
144
    0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
145
    0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
146
    0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
147
    0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
148
    0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
149
    0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
150
    0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
151
    0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
152
    0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
153
    0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
154
    0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
155
    0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
156
    0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
157
    0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
158
    0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
159
    0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
160
};
161
162 849f1035 Måns Rullgård
static av_always_inline int wp_exp2(int16_t val)
163 730581f3 Kostya Shishkov
{
164
    int res, neg = 0;
165
166
    if(val < 0){
167
        val = -val;
168
        neg = 1;
169
    }
170
171
    res = wp_exp2_table[val & 0xFF] | 0x100;
172
    val >>= 8;
173
    res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
174
    return neg ? -res : res;
175
}
176
177 2c96535a Kostya Shishkov
static av_always_inline int wp_log2(int32_t val)
178
{
179
    int bits;
180
181
    if(!val)
182
        return 0;
183
    if(val == 1)
184
        return 256;
185
    val += val >> 9;
186
    bits = av_log2(val) + 1;
187
    if(bits < 9)
188
        return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
189
    else
190
        return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
191
}
192
193
#define LEVEL_DECAY(a)  ((a + 0x80) >> 8)
194
195 730581f3 Kostya Shishkov
// macros for manipulating median values
196 2c96535a Kostya Shishkov
#define GET_MED(n) ((c->median[n] >> 4) + 1)
197
#define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
198
#define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
199 730581f3 Kostya Shishkov
200
// macros for applying weight
201
#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
202
        if(samples && in){ \
203
            if((samples ^ in) < 0){ \
204
                weight -= delta; \
205
                if(weight < -1024) weight = -1024; \
206
            }else{ \
207
                weight += delta; \
208
                if(weight > 1024) weight = 1024; \
209
            } \
210
        }
211
212
213 849f1035 Måns Rullgård
static av_always_inline int get_tail(GetBitContext *gb, int k)
214 730581f3 Kostya Shishkov
{
215
    int p, e, res;
216
217 4b3b5a23 Kostya Shishkov
    if(k<1)return 0;
218
    p = av_log2(k);
219 730581f3 Kostya Shishkov
    e = (1 << (p + 1)) - k - 1;
220 8db0c25d Kostya Shishkov
    res = p ? get_bits(gb, p) : 0;
221 730581f3 Kostya Shishkov
    if(res >= e){
222
        res = (res<<1) - e + get_bits1(gb);
223
    }
224
    return res;
225
}
226
227 2c96535a Kostya Shishkov
static void update_error_limit(WavpackContext *ctx)
228
{
229
    int i, br[2], sl[2];
230
231
    for(i = 0; i <= ctx->stereo_in; i++){
232
        ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
233
        br[i] = ctx->ch[i].bitrate_acc >> 16;
234
        sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
235
    }
236
    if(ctx->stereo_in && ctx->hybrid_bitrate){
237
        int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
238
        if(balance > br[0]){
239
            br[1] = br[0] << 1;
240
            br[0] = 0;
241
        }else if(-balance > br[0]){
242
            br[0] <<= 1;
243
            br[1] = 0;
244
        }else{
245
            br[1] = br[0] + balance;
246
            br[0] = br[0] - balance;
247
        }
248
    }
249
    for(i = 0; i <= ctx->stereo_in; i++){
250
        if(ctx->hybrid_bitrate){
251
            if(sl[i] - br[i] > -0x100)
252
                ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
253
            else
254
                ctx->ch[i].error_limit = 0;
255
        }else{
256
            ctx->ch[i].error_limit = wp_exp2(br[i]);
257
        }
258
    }
259
}
260
261
static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last)
262 730581f3 Kostya Shishkov
{
263
    int t, t2;
264
    int sign, base, add, ret;
265 2c96535a Kostya Shishkov
    WvChannel *c = &ctx->ch[channel];
266 730581f3 Kostya Shishkov
267
    *last = 0;
268
269 2c96535a Kostya Shishkov
    if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
270 730581f3 Kostya Shishkov
        if(ctx->zeroes){
271
            ctx->zeroes--;
272 2c96535a Kostya Shishkov
            if(ctx->zeroes){
273
                c->slow_level -= LEVEL_DECAY(c->slow_level);
274 730581f3 Kostya Shishkov
                return 0;
275 2c96535a Kostya Shishkov
            }
276 730581f3 Kostya Shishkov
        }else{
277 ca1daf0a Aurelien Jacobs
            t = get_unary_0_33(gb);
278 730581f3 Kostya Shishkov
            if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1));
279
            ctx->zeroes = t;
280
            if(ctx->zeroes){
281 2c96535a Kostya Shishkov
                memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
282
                memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
283
                c->slow_level -= LEVEL_DECAY(c->slow_level);
284 730581f3 Kostya Shishkov
                return 0;
285
            }
286
        }
287
    }
288
289
    if(get_bits_count(gb) >= ctx->data_size){
290
        *last = 1;
291
        return 0;
292
    }
293
294
    if(ctx->zero){
295
        t = 0;
296
        ctx->zero = 0;
297
    }else{
298 ca1daf0a Aurelien Jacobs
        t = get_unary_0_33(gb);
299 730581f3 Kostya Shishkov
        if(get_bits_count(gb) >= ctx->data_size){
300
            *last = 1;
301
            return 0;
302
        }
303
        if(t == 16) {
304 ca1daf0a Aurelien Jacobs
            t2 = get_unary_0_33(gb);
305 730581f3 Kostya Shishkov
            if(t2 < 2) t += t2;
306
            else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
307
        }
308
309
        if(ctx->one){
310
            ctx->one = t&1;
311
            t = (t>>1) + 1;
312
        }else{
313
            ctx->one = t&1;
314
            t >>= 1;
315
        }
316
        ctx->zero = !ctx->one;
317
    }
318
319 2c96535a Kostya Shishkov
    if(ctx->hybrid && !channel)
320
        update_error_limit(ctx);
321
322 730581f3 Kostya Shishkov
    if(!t){
323
        base = 0;
324
        add = GET_MED(0) - 1;
325
        DEC_MED(0);
326
    }else if(t == 1){
327
        base = GET_MED(0);
328
        add = GET_MED(1) - 1;
329
        INC_MED(0);
330
        DEC_MED(1);
331
    }else if(t == 2){
332
        base = GET_MED(0) + GET_MED(1);
333
        add = GET_MED(2) - 1;
334
        INC_MED(0);
335
        INC_MED(1);
336
        DEC_MED(2);
337
    }else{
338
        base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
339
        add = GET_MED(2) - 1;
340
        INC_MED(0);
341
        INC_MED(1);
342
        INC_MED(2);
343
    }
344 2c96535a Kostya Shishkov
    if(!c->error_limit){
345
        ret = base + get_tail(gb, add);
346
    }else{
347
        int mid = (base*2 + add + 1) >> 1;
348
        while(add > c->error_limit){
349
            if(get_bits1(gb)){
350
                add -= (mid - base);
351
                base = mid;
352
            }else
353
                add = mid - base - 1;
354
            mid = (base*2 + add + 1) >> 1;
355
        }
356
        ret = mid;
357
    }
358 730581f3 Kostya Shishkov
    sign = get_bits1(gb);
359 2c96535a Kostya Shishkov
    if(ctx->hybrid_bitrate)
360
        c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
361 730581f3 Kostya Shishkov
    return sign ? ~ret : ret;
362
}
363
364 3cb08886 Laurent Aimar
static inline int wv_get_value_integer(WavpackContext *s, uint32_t *crc, int S)
365
{
366
    int bit;
367
368
    if(s->extra_bits){
369
        S <<= s->extra_bits;
370
371
        if(s->got_extra_bits){
372
            S |= get_bits(&s->gb_extra_bits, s->extra_bits);
373
            *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
374
        }
375
    }
376
    bit = (S & s->and) | s->or;
377
    return (((S + bit) << s->shift) - bit) << s->post_shift;
378
}
379
380 992f7db0 Laurent Aimar
static float wv_get_value_float(WavpackContext *s, uint32_t *crc, int S)
381
{
382
    union {
383
        float    f;
384
        uint32_t u;
385
    } value;
386
387
    int sign;
388
    int exp = s->float_max_exp;
389
390
    if(s->got_extra_bits){
391
        const int max_bits = 1 + 23 + 8 + 1;
392 6e44ba15 Ronald S. Bultje
        const int left_bits = get_bits_left(&s->gb_extra_bits);
393 992f7db0 Laurent Aimar
394
        if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
395
            return 0.0;
396
    }
397
398
    if(S){
399
        S <<= s->float_shift;
400
        sign = S < 0;
401
        if(sign)
402
            S = -S;
403
        if(S >= 0x1000000){
404
            if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
405
                S = get_bits(&s->gb_extra_bits, 23);
406
            }else{
407
                S = 0;
408
            }
409
            exp = 255;
410
        }else if(exp){
411
            int shift = 23 - av_log2(S);
412
            exp = s->float_max_exp;
413
            if(exp <= shift){
414
                shift = --exp;
415
            }
416
            exp -= shift;
417
418
            if(shift){
419
                S <<= shift;
420
                if((s->float_flag & WV_FLT_SHIFT_ONES) ||
421
                   (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
422
                    S |= (1 << shift) - 1;
423
                } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
424
                    S |= get_bits(&s->gb_extra_bits, shift);
425
                }
426
            }
427
        }else{
428
            exp = s->float_max_exp;
429
        }
430
        S &= 0x7fffff;
431
    }else{
432
        sign = 0;
433
        exp = 0;
434
        if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
435
            if(get_bits1(&s->gb_extra_bits)){
436
                S = get_bits(&s->gb_extra_bits, 23);
437
                if(s->float_max_exp >= 25)
438
                    exp = get_bits(&s->gb_extra_bits, 8);
439
                sign = get_bits1(&s->gb_extra_bits);
440
            }else{
441
                if(s->float_flag & WV_FLT_ZERO_SIGN)
442
                    sign = get_bits1(&s->gb_extra_bits);
443
            }
444
        }
445
    }
446
447
    *crc = *crc * 27 + S * 9 + exp * 3 + sign;
448
449
    value.u = (sign << 31) | (exp << 23) | S;
450
    return value.f;
451
}
452
453 965828bb Kostya Shishkov
static void wv_reset_saved_context(WavpackContext *s)
454
{
455
    s->pos = 0;
456
    s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
457
}
458
459 cabb8111 Laurent Aimar
static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
460 730581f3 Kostya Shishkov
{
461
    int i, j, count = 0;
462
    int last, t;
463 3cb08886 Laurent Aimar
    int A, B, L, L2, R, R2;
464 965828bb Kostya Shishkov
    int pos = s->pos;
465
    uint32_t crc = s->sc.crc;
466
    uint32_t crc_extra_bits = s->extra_sc.crc;
467 29ee6355 Kostya Shishkov
    int16_t *dst16 = dst;
468
    int32_t *dst32 = dst;
469 992f7db0 Laurent Aimar
    float   *dstfl = dst;
470 730581f3 Kostya Shishkov
471 965828bb Kostya Shishkov
    if(s->samples_left == s->samples)
472 aa170ed6 Kostya Shishkov
        s->one = s->zero = s->zeroes = 0;
473 730581f3 Kostya Shishkov
    do{
474 2c96535a Kostya Shishkov
        L = wv_get_value(s, gb, 0, &last);
475 730581f3 Kostya Shishkov
        if(last) break;
476 2c96535a Kostya Shishkov
        R = wv_get_value(s, gb, 1, &last);
477 730581f3 Kostya Shishkov
        if(last) break;
478
        for(i = 0; i < s->terms; i++){
479
            t = s->decorr[i].value;
480
            if(t > 0){
481
                if(t > 8){
482
                    if(t & 1){
483
                        A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
484
                        B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
485
                    }else{
486
                        A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
487
                        B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
488
                    }
489
                    s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
490
                    s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
491
                    j = 0;
492
                }else{
493
                    A = s->decorr[i].samplesA[pos];
494
                    B = s->decorr[i].samplesB[pos];
495
                    j = (pos + t) & 7;
496
                }
497 cabb8111 Laurent Aimar
                if(type != SAMPLE_FMT_S16){
498 29ee6355 Kostya Shishkov
                    L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
499
                    R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
500 0638c2ae Kostya Shishkov
                }else{
501 29ee6355 Kostya Shishkov
                    L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
502
                    R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
503 0638c2ae Kostya Shishkov
                }
504
                if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
505
                if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
506
                s->decorr[i].samplesA[j] = L = L2;
507
                s->decorr[i].samplesB[j] = R = R2;
508
            }else if(t == -1){
509 cabb8111 Laurent Aimar
                if(type != SAMPLE_FMT_S16)
510 29ee6355 Kostya Shishkov
                    L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
511
                else
512
                    L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
513 0638c2ae Kostya Shishkov
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
514
                L = L2;
515 cabb8111 Laurent Aimar
                if(type != SAMPLE_FMT_S16)
516 29ee6355 Kostya Shishkov
                    R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
517
                else
518
                    R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
519 0638c2ae Kostya Shishkov
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
520
                R = R2;
521
                s->decorr[i].samplesA[0] = R;
522
            }else{
523 cabb8111 Laurent Aimar
                if(type != SAMPLE_FMT_S16)
524 29ee6355 Kostya Shishkov
                    R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
525
                else
526
                    R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
527 0638c2ae Kostya Shishkov
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
528
                R = R2;
529
530
                if(t == -3){
531
                    R2 = s->decorr[i].samplesA[0];
532
                    s->decorr[i].samplesA[0] = R;
533
                }
534
535 cabb8111 Laurent Aimar
                if(type != SAMPLE_FMT_S16)
536 29ee6355 Kostya Shishkov
                    L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
537
                else
538
                    L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
539 0638c2ae Kostya Shishkov
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
540
                L = L2;
541
                s->decorr[i].samplesB[0] = L;
542
            }
543
        }
544
        pos = (pos + 1) & 7;
545
        if(s->joint)
546
            L += (R -= (L >> 1));
547
        crc = (crc * 3 + L) * 3 + R;
548 418f77ec Laurent Aimar
549 992f7db0 Laurent Aimar
        if(type == SAMPLE_FMT_FLT){
550
            *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
551
            *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
552
        } else if(type == SAMPLE_FMT_S32){
553 3cb08886 Laurent Aimar
            *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
554
            *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
555
        } else {
556
            *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
557
            *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
558 418f77ec Laurent Aimar
        }
559 0638c2ae Kostya Shishkov
        count++;
560 965828bb Kostya Shishkov
    }while(!last && count < s->max_samples);
561 0638c2ae Kostya Shishkov
562 965828bb Kostya Shishkov
    s->samples_left -= count;
563
    if(!s->samples_left){
564 aa170ed6 Kostya Shishkov
        if(crc != s->CRC){
565
            av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
566
            return -1;
567
        }
568
        if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
569
            av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
570
            return -1;
571
        }
572
        wv_reset_saved_context(s);
573 965828bb Kostya Shishkov
    }else{
574
        s->pos = pos;
575
        s->sc.crc = crc;
576
        s->sc.bits_used = get_bits_count(&s->gb);
577
        if(s->got_extra_bits){
578
            s->extra_sc.crc = crc_extra_bits;
579
            s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
580
        }
581
    }
582 0638c2ae Kostya Shishkov
    return count * 2;
583
}
584
585 cabb8111 Laurent Aimar
static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
586 0638c2ae Kostya Shishkov
{
587
    int i, j, count = 0;
588
    int last, t;
589 3cb08886 Laurent Aimar
    int A, S, T;
590 965828bb Kostya Shishkov
    int pos = s->pos;
591
    uint32_t crc = s->sc.crc;
592
    uint32_t crc_extra_bits = s->extra_sc.crc;
593 29ee6355 Kostya Shishkov
    int16_t *dst16 = dst;
594
    int32_t *dst32 = dst;
595 992f7db0 Laurent Aimar
    float   *dstfl = dst;
596 0638c2ae Kostya Shishkov
597 965828bb Kostya Shishkov
    if(s->samples_left == s->samples)
598 aa170ed6 Kostya Shishkov
        s->one = s->zero = s->zeroes = 0;
599 0638c2ae Kostya Shishkov
    do{
600
        T = wv_get_value(s, gb, 0, &last);
601
        S = 0;
602
        if(last) break;
603
        for(i = 0; i < s->terms; i++){
604
            t = s->decorr[i].value;
605
            if(t > 8){
606
                if(t & 1)
607
                    A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
608
                else
609
                    A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
610
                s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
611
                j = 0;
612
            }else{
613
                A = s->decorr[i].samplesA[pos];
614
                j = (pos + t) & 7;
615
            }
616 cabb8111 Laurent Aimar
            if(type != SAMPLE_FMT_S16)
617 29ee6355 Kostya Shishkov
                S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
618
            else
619
                S = T + ((s->decorr[i].weightA * A + 512) >> 10);
620 0638c2ae Kostya Shishkov
            if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
621
            s->decorr[i].samplesA[j] = T = S;
622
        }
623
        pos = (pos + 1) & 7;
624
        crc = crc * 3 + S;
625 418f77ec Laurent Aimar
626 992f7db0 Laurent Aimar
        if(type == SAMPLE_FMT_FLT)
627
            *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
628
        else if(type == SAMPLE_FMT_S32)
629 3cb08886 Laurent Aimar
            *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
630 29ee6355 Kostya Shishkov
        else
631 3cb08886 Laurent Aimar
            *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
632 0638c2ae Kostya Shishkov
        count++;
633
    }while(!last && count < s->samples);
634
635 965828bb Kostya Shishkov
    s->samples_left -= count;
636
    if(!s->samples_left){
637 aa170ed6 Kostya Shishkov
        if(crc != s->CRC){
638
            av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
639
            return -1;
640
        }
641
        if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
642
            av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
643
            return -1;
644
        }
645
        wv_reset_saved_context(s);
646 965828bb Kostya Shishkov
    }else{
647
        s->pos = pos;
648
        s->sc.crc = crc;
649
        s->sc.bits_used = get_bits_count(&s->gb);
650
        if(s->got_extra_bits){
651
            s->extra_sc.crc = crc_extra_bits;
652
            s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
653
        }
654
    }
655 0638c2ae Kostya Shishkov
    return count;
656
}
657
658 98a6fff9 Zuxy Meng
static av_cold int wavpack_decode_init(AVCodecContext *avctx)
659 730581f3 Kostya Shishkov
{
660
    WavpackContext *s = avctx->priv_data;
661
662
    s->avctx = avctx;
663
    s->stereo = (avctx->channels == 2);
664 0638c2ae Kostya Shishkov
    if(avctx->bits_per_coded_sample <= 16)
665
        avctx->sample_fmt = SAMPLE_FMT_S16;
666
    else
667
        avctx->sample_fmt = SAMPLE_FMT_S32;
668 eeee48b2 Kostya Shishkov
    avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
669 730581f3 Kostya Shishkov
670 965828bb Kostya Shishkov
    wv_reset_saved_context(s);
671
672 730581f3 Kostya Shishkov
    return 0;
673
}
674
675
static int wavpack_decode_frame(AVCodecContext *avctx,
676
                            void *data, int *data_size,
677 7a00bbad Thilo Borgmann
                            AVPacket *avpkt)
678 730581f3 Kostya Shishkov
{
679 7a00bbad Thilo Borgmann
    const uint8_t *buf = avpkt->data;
680
    int buf_size = avpkt->size;
681 730581f3 Kostya Shishkov
    WavpackContext *s = avctx->priv_data;
682 29ee6355 Kostya Shishkov
    void *samples = data;
683 730581f3 Kostya Shishkov
    int samplecount;
684 992f7db0 Laurent Aimar
    int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
685 2c96535a Kostya Shishkov
    int got_hybrid = 0;
686 94ef6d11 Michael Niedermayer
    const uint8_t* buf_end = buf + buf_size;
687 730581f3 Kostya Shishkov
    int i, j, id, size, ssize, weights, t;
688 60294c59 Laurent Aimar
    int bpp;
689 730581f3 Kostya Shishkov
690 b314cfe7 Kostya Shishkov
    if (buf_size == 0){
691
        *data_size = 0;
692
        return 0;
693
    }
694 730581f3 Kostya Shishkov
695 965828bb Kostya Shishkov
    if(!s->samples_left){
696 aa170ed6 Kostya Shishkov
        memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
697
        memset(s->ch, 0, sizeof(s->ch));
698
        s->extra_bits = 0;
699
        s->and = s->or = s->shift = 0;
700
        s->got_extra_bits = 0;
701 965828bb Kostya Shishkov
    }
702 730581f3 Kostya Shishkov
703 fead30d4 Alex Beregszaszi
    s->samples = AV_RL32(buf); buf += 4;
704 b314cfe7 Kostya Shishkov
    if(!s->samples){
705
        *data_size = 0;
706
        return buf_size;
707
    }
708 2c96535a Kostya Shishkov
    s->frame_flags = AV_RL32(buf); buf += 4;
709 992f7db0 Laurent Aimar
    if(s->frame_flags&0x80){
710
        bpp = sizeof(float);
711
        avctx->sample_fmt = SAMPLE_FMT_FLT;
712
    } else if((s->frame_flags&0x03) <= 1){
713 60294c59 Laurent Aimar
        bpp = 2;
714
        avctx->sample_fmt = SAMPLE_FMT_S16;
715
    } else {
716
        bpp = 4;
717
        avctx->sample_fmt = SAMPLE_FMT_S32;
718
    }
719 2c96535a Kostya Shishkov
    s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
720
    s->joint = s->frame_flags & WV_JOINT_STEREO;
721
    s->hybrid = s->frame_flags & WV_HYBRID_MODE;
722
    s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
723 0638c2ae Kostya Shishkov
    s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
724 fead30d4 Alex Beregszaszi
    s->CRC = AV_RL32(buf); buf += 4;
725 60294c59 Laurent Aimar
726 965828bb Kostya Shishkov
    s->max_samples = *data_size / (bpp * avctx->channels);
727
    s->max_samples = FFMIN(s->max_samples, s->samples);
728
    if(s->samples_left > 0){
729
        s->max_samples = FFMIN(s->max_samples, s->samples_left);
730
        buf = buf_end;
731 60294c59 Laurent Aimar
    }
732
733 730581f3 Kostya Shishkov
    // parse metadata blocks
734
    while(buf < buf_end){
735
        id = *buf++;
736
        size = *buf++;
737
        if(id & WP_IDF_LONG) {
738
            size |= (*buf++) << 8;
739
            size |= (*buf++) << 16;
740
        }
741
        size <<= 1; // size is specified in words
742
        ssize = size;
743
        if(id & WP_IDF_ODD) size--;
744
        if(size < 0){
745
            av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
746
            break;
747
        }
748
        if(buf + ssize > buf_end){
749
            av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
750
            break;
751
        }
752
        if(id & WP_IDF_IGNORE){
753
            buf += ssize;
754
            continue;
755
        }
756
        switch(id & WP_IDF_MASK){
757
        case WP_ID_DECTERMS:
758
            s->terms = size;
759
            if(s->terms > MAX_TERMS){
760
                av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
761
                buf += ssize;
762
                continue;
763
            }
764
            for(i = 0; i < s->terms; i++) {
765
                s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
766
                s->decorr[s->terms - i - 1].delta = *buf >> 5;
767
                buf++;
768
            }
769
            got_terms = 1;
770
            break;
771
        case WP_ID_DECWEIGHTS:
772
            if(!got_terms){
773
                av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
774
                continue;
775
            }
776 a6ba65f7 David Bryant
            weights = size >> s->stereo_in;
777 730581f3 Kostya Shishkov
            if(weights > MAX_TERMS || weights > s->terms){
778
                av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
779
                buf += ssize;
780
                continue;
781
            }
782
            for(i = 0; i < weights; i++) {
783
                t = (int8_t)(*buf++);
784
                s->decorr[s->terms - i - 1].weightA = t << 3;
785
                if(s->decorr[s->terms - i - 1].weightA > 0)
786
                    s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
787 a6ba65f7 David Bryant
                if(s->stereo_in){
788 730581f3 Kostya Shishkov
                    t = (int8_t)(*buf++);
789
                    s->decorr[s->terms - i - 1].weightB = t << 3;
790
                    if(s->decorr[s->terms - i - 1].weightB > 0)
791
                        s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
792
                }
793
            }
794
            got_weights = 1;
795
            break;
796
        case WP_ID_DECSAMPLES:
797
            if(!got_terms){
798
                av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
799
                continue;
800
            }
801
            t = 0;
802
            for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
803
                if(s->decorr[i].value > 8){
804 fead30d4 Alex Beregszaszi
                    s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
805
                    s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
806 a6ba65f7 David Bryant
                    if(s->stereo_in){
807 fead30d4 Alex Beregszaszi
                        s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
808
                        s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
809 730581f3 Kostya Shishkov
                        t += 4;
810
                    }
811
                    t += 4;
812
                }else if(s->decorr[i].value < 0){
813 fead30d4 Alex Beregszaszi
                    s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
814
                    s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
815 730581f3 Kostya Shishkov
                    t += 4;
816
                }else{
817
                    for(j = 0; j < s->decorr[i].value; j++){
818 fead30d4 Alex Beregszaszi
                        s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
819 a6ba65f7 David Bryant
                        if(s->stereo_in){
820 fead30d4 Alex Beregszaszi
                            s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
821 730581f3 Kostya Shishkov
                        }
822
                    }
823 a6ba65f7 David Bryant
                    t += s->decorr[i].value * 2 * (s->stereo_in + 1);
824 730581f3 Kostya Shishkov
                }
825
            }
826
            got_samples = 1;
827
            break;
828
        case WP_ID_ENTROPY:
829 a6ba65f7 David Bryant
            if(size != 6 * (s->stereo_in + 1)){
830
                av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
831 730581f3 Kostya Shishkov
                buf += ssize;
832
                continue;
833
            }
834 2c96535a Kostya Shishkov
            for(j = 0; j <= s->stereo_in; j++){
835
                for(i = 0; i < 3; i++){
836
                    s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
837
                    buf += 2;
838
                }
839 730581f3 Kostya Shishkov
            }
840
            got_entropy = 1;
841
            break;
842 2c96535a Kostya Shishkov
        case WP_ID_HYBRID:
843
            if(s->hybrid_bitrate){
844
                for(i = 0; i <= s->stereo_in; i++){
845
                    s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
846
                    buf += 2;
847
                    size -= 2;
848
                }
849
            }
850
            for(i = 0; i < (s->stereo_in + 1); i++){
851
                s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
852
                buf += 2;
853
                size -= 2;
854
            }
855
            if(size > 0){
856
                for(i = 0; i < (s->stereo_in + 1); i++){
857
                    s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
858
                    buf += 2;
859
                }
860
            }else{
861
                for(i = 0; i < (s->stereo_in + 1); i++)
862
                    s->ch[i].bitrate_delta = 0;
863
            }
864
            got_hybrid = 1;
865
            break;
866 6b05eb31 David Bryant
        case WP_ID_INT32INFO:
867 6e0f746d Kostya Shishkov
            if(size != 4){
868 6b05eb31 David Bryant
                av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
869
                buf += ssize;
870
                continue;
871
            }
872 6e0f746d Kostya Shishkov
            if(buf[0])
873 418f77ec Laurent Aimar
                s->extra_bits = buf[0];
874 6e0f746d Kostya Shishkov
            else if(buf[1])
875 6b05eb31 David Bryant
                s->shift = buf[1];
876
            else if(buf[2]){
877
                s->and = s->or = 1;
878
                s->shift = buf[2];
879
            }else if(buf[3]){
880
                s->and = 1;
881
                s->shift = buf[3];
882
            }
883
            buf += 4;
884
            break;
885 992f7db0 Laurent Aimar
        case WP_ID_FLOATINFO:
886
            if(size != 4){
887
                av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
888
                buf += ssize;
889
                continue;
890
            }
891
            s->float_flag = buf[0];
892
            s->float_shift = buf[1];
893
            s->float_max_exp = buf[2];
894
            buf += 4;
895
            got_float = 1;
896
            break;
897 730581f3 Kostya Shishkov
        case WP_ID_DATA:
898 965828bb Kostya Shishkov
            s->sc.offset = buf - avpkt->data;
899
            s->sc.size   = size * 8;
900 730581f3 Kostya Shishkov
            init_get_bits(&s->gb, buf, size * 8);
901
            s->data_size = size * 8;
902
            buf += size;
903
            got_bs = 1;
904
            break;
905 418f77ec Laurent Aimar
        case WP_ID_EXTRABITS:
906
            if(size <= 4){
907
                av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
908
                buf += size;
909
                continue;
910
            }
911 965828bb Kostya Shishkov
            s->extra_sc.offset = buf - avpkt->data;
912
            s->extra_sc.size   = size * 8;
913 418f77ec Laurent Aimar
            init_get_bits(&s->gb_extra_bits, buf, size * 8);
914
            s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
915
            buf += size;
916
            s->got_extra_bits = 1;
917
            break;
918 730581f3 Kostya Shishkov
        default:
919
            buf += size;
920
        }
921
        if(id & WP_IDF_ODD) buf++;
922
    }
923 965828bb Kostya Shishkov
    if(!s->samples_left){
924 aa170ed6 Kostya Shishkov
        if(!got_terms){
925
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
926
            return -1;
927 66311f86 Laurent Aimar
        }
928 aa170ed6 Kostya Shishkov
        if(!got_weights){
929
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
930
            return -1;
931
        }
932
        if(!got_samples){
933
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
934
            return -1;
935
        }
936
        if(!got_entropy){
937
            av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
938
            return -1;
939
        }
940
        if(s->hybrid && !got_hybrid){
941
            av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
942
            return -1;
943
        }
944
        if(!got_bs){
945
            av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
946
            return -1;
947
        }
948
        if(!got_float && avctx->sample_fmt == SAMPLE_FMT_FLT){
949
            av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
950
            return -1;
951
        }
952
        if(s->got_extra_bits && avctx->sample_fmt != SAMPLE_FMT_FLT){
953
            const int size = get_bits_left(&s->gb_extra_bits);
954
            const int wanted = s->samples * s->extra_bits << s->stereo_in;
955
            if(size < wanted){
956
                av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
957
                s->got_extra_bits = 0;
958
            }
959
        }
960
        s->samples_left = s->samples;
961 965828bb Kostya Shishkov
    }else{
962
        init_get_bits(&s->gb, avpkt->data + s->sc.offset, s->sc.size);
963
        skip_bits_long(&s->gb, s->sc.bits_used);
964
        if(s->got_extra_bits){
965
            init_get_bits(&s->gb_extra_bits, avpkt->data + s->extra_sc.offset,
966
                          s->extra_sc.size);
967
            skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
968
        }
969
    }
970 730581f3 Kostya Shishkov
971 0638c2ae Kostya Shishkov
    if(s->stereo_in){
972 cabb8111 Laurent Aimar
        if(avctx->sample_fmt == SAMPLE_FMT_S16)
973
            samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S16);
974 992f7db0 Laurent Aimar
        else if(avctx->sample_fmt == SAMPLE_FMT_S32)
975 cabb8111 Laurent Aimar
            samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S32);
976 992f7db0 Laurent Aimar
        else
977
            samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_FLT);
978
979 0638c2ae Kostya Shishkov
    }else{
980 cabb8111 Laurent Aimar
        if(avctx->sample_fmt == SAMPLE_FMT_S16)
981
            samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S16);
982 992f7db0 Laurent Aimar
        else if(avctx->sample_fmt == SAMPLE_FMT_S32)
983 cabb8111 Laurent Aimar
            samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S32);
984 992f7db0 Laurent Aimar
        else
985
            samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_FLT);
986
987 cabb8111 Laurent Aimar
        if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S16){
988 29ee6355 Kostya Shishkov
            int16_t *dst = (int16_t*)samples + samplecount * 2;
989
            int16_t *src = (int16_t*)samples + samplecount;
990 a6ba65f7 David Bryant
            int cnt = samplecount;
991
            while(cnt--){
992
                *--dst = *--src;
993
                *--dst = *src;
994
            }
995
            samplecount *= 2;
996 992f7db0 Laurent Aimar
        }else if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S32){
997 29ee6355 Kostya Shishkov
            int32_t *dst = (int32_t*)samples + samplecount * 2;
998
            int32_t *src = (int32_t*)samples + samplecount;
999 0638c2ae Kostya Shishkov
            int cnt = samplecount;
1000
            while(cnt--){
1001
                *--dst = *--src;
1002
                *--dst = *src;
1003
            }
1004
            samplecount *= 2;
1005 992f7db0 Laurent Aimar
        }else if(s->stereo){
1006
            float *dst = (float*)samples + samplecount * 2;
1007
            float *src = (float*)samples + samplecount;
1008
            int cnt = samplecount;
1009
            while(cnt--){
1010
                *--dst = *--src;
1011
                *--dst = *src;
1012
            }
1013
            samplecount *= 2;
1014 a6ba65f7 David Bryant
        }
1015
    }
1016 0638c2ae Kostya Shishkov
    *data_size = samplecount * bpp;
1017 730581f3 Kostya Shishkov
1018 965828bb Kostya Shishkov
    return s->samples_left > 0 ? 0 : buf_size;
1019 730581f3 Kostya Shishkov
}
1020
1021
AVCodec wavpack_decoder = {
1022
    "wavpack",
1023
    CODEC_TYPE_AUDIO,
1024
    CODEC_ID_WAVPACK,
1025
    sizeof(WavpackContext),
1026
    wavpack_decode_init,
1027
    NULL,
1028 28e7453c Aurelien Jacobs
    NULL,
1029 730581f3 Kostya Shishkov
    wavpack_decode_frame,
1030 d859bb1d Sascha Sommer
    .capabilities = CODEC_CAP_SUBFRAMES,
1031 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1032 730581f3 Kostya Shishkov
};