← Back to branch summary

~ubuntu-branches/ubuntu/raring/libav/raring-security

« back to all changes in this revision

Viewing changes to .pc/post-0.7.1/0046-wavpack-Check-error-codes-rather-than-working-around.patch/libavcodec/wavpack.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2011-09-28 09:18:34 UTC
  • mfrom: (1.3.7 sid)
  • Revision ID: package-import@ubuntu.com-20110928091834-w415mnuh06h4zpvc
Tags: 4:0.7.1-7ubuntu2
Revert "Convert package to include multiarch support."

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/post-0.7.1/0046-wavpack-Check-error-codes-rather-than-working-around.patch/libavcodec/wavpack.c
 
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){
 
296
                if(get_bits_left(gb) < t-1)
 
297
                    goto error;
 
298
                t = get_bits(gb, t - 1) | (1 << (t-1));
 
299
            }else{
 
300
                if(get_bits_left(gb) < 0)
 
301
                    goto error;
 
302
            }
 
303
            ctx->zeroes = t;
 
304
            if(ctx->zeroes){
 
305
                memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
 
306
                memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
 
307
                c->slow_level -= LEVEL_DECAY(c->slow_level);
 
308
                return 0;
 
309
            }
 
310
        }
 
311
    }
 
312
 
 
313
    if(ctx->zero){
 
314
        t = 0;
 
315
        ctx->zero = 0;
 
316
    }else{
 
317
        t = get_unary_0_33(gb);
 
318
        if(get_bits_left(gb) < 0)
 
319
            goto error;
 
320
        if(t == 16) {
 
321
            t2 = get_unary_0_33(gb);
 
322
            if(t2 < 2){
 
323
                if(get_bits_left(gb) < 0)
 
324
                    goto error;
 
325
                t += t2;
 
326
            }else{
 
327
                if(get_bits_left(gb) < t2 - 1)
 
328
                    goto error;
 
329
                t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
 
330
            }
 
331
        }
 
332
 
 
333
        if(ctx->one){
 
334
            ctx->one = t&1;
 
335
            t = (t>>1) + 1;
 
336
        }else{
 
337
            ctx->one = t&1;
 
338
            t >>= 1;
 
339
        }
 
340
        ctx->zero = !ctx->one;
 
341
    }
 
342
 
 
343
    if(ctx->hybrid && !channel)
 
344
        update_error_limit(ctx);
 
345
 
 
346
    if(!t){
 
347
        base = 0;
 
348
        add = GET_MED(0) - 1;
 
349
        DEC_MED(0);
 
350
    }else if(t == 1){
 
351
        base = GET_MED(0);
 
352
        add = GET_MED(1) - 1;
 
353
        INC_MED(0);
 
354
        DEC_MED(1);
 
355
    }else if(t == 2){
 
356
        base = GET_MED(0) + GET_MED(1);
 
357
        add = GET_MED(2) - 1;
 
358
        INC_MED(0);
 
359
        INC_MED(1);
 
360
        DEC_MED(2);
 
361
    }else{
 
362
        base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
 
363
        add = GET_MED(2) - 1;
 
364
        INC_MED(0);
 
365
        INC_MED(1);
 
366
        INC_MED(2);
 
367
    }
 
368
    if(!c->error_limit){
 
369
        ret = base + get_tail(gb, add);
 
370
        if (get_bits_left(gb) <= 0)
 
371
            goto error;
 
372
    }else{
 
373
        int mid = (base*2 + add + 1) >> 1;
 
374
        while(add > c->error_limit){
 
375
            if(get_bits_left(gb) <= 0)
 
376
                goto error;
 
377
            if(get_bits1(gb)){
 
378
                add -= (mid - base);
 
379
                base = mid;
 
380
            }else
 
381
                add = mid - base - 1;
 
382
            mid = (base*2 + add + 1) >> 1;
 
383
        }
 
384
        ret = mid;
 
385
    }
 
386
    sign = get_bits1(gb);
 
387
    if(ctx->hybrid_bitrate)
 
388
        c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
 
389
    return sign ? ~ret : ret;
 
390
 
 
391
error:
 
392
    *last = 1;
 
393
    return 0;
 
394
}
 
395
 
 
396
static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
 
397
{
 
398
    int bit;
 
399
 
 
400
    if(s->extra_bits){
 
401
        S <<= s->extra_bits;
 
402
 
 
403
        if(s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits){
 
404
            S |= get_bits(&s->gb_extra_bits, s->extra_bits);
 
405
            *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
 
406
        }
 
407
    }
 
408
    bit = (S & s->and) | s->or;
 
409
    return (((S + bit) << s->shift) - bit) << s->post_shift;
 
410
}
 
411
 
 
412
static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
 
413
{
 
414
    union {
 
415
        float    f;
 
416
        uint32_t u;
 
417
    } value;
 
418
 
 
419
    int sign;
 
420
    int exp = s->float_max_exp;
 
421
 
 
422
    if(s->got_extra_bits){
 
423
        const int max_bits = 1 + 23 + 8 + 1;
 
424
        const int left_bits = get_bits_left(&s->gb_extra_bits);
 
425
 
 
426
        if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
 
427
            return 0.0;
 
428
    }
 
429
 
 
430
    if(S){
 
431
        S <<= s->float_shift;
 
432
        sign = S < 0;
 
433
        if(sign)
 
434
            S = -S;
 
435
        if(S >= 0x1000000){
 
436
            if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
 
437
                S = get_bits(&s->gb_extra_bits, 23);
 
438
            }else{
 
439
                S = 0;
 
440
            }
 
441
            exp = 255;
 
442
        }else if(exp){
 
443
            int shift = 23 - av_log2(S);
 
444
            exp = s->float_max_exp;
 
445
            if(exp <= shift){
 
446
                shift = --exp;
 
447
            }
 
448
            exp -= shift;
 
449
 
 
450
            if(shift){
 
451
                S <<= shift;
 
452
                if((s->float_flag & WV_FLT_SHIFT_ONES) ||
 
453
                   (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
 
454
                    S |= (1 << shift) - 1;
 
455
                } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
 
456
                    S |= get_bits(&s->gb_extra_bits, shift);
 
457
                }
 
458
            }
 
459
        }else{
 
460
            exp = s->float_max_exp;
 
461
        }
 
462
        S &= 0x7fffff;
 
463
    }else{
 
464
        sign = 0;
 
465
        exp = 0;
 
466
        if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
 
467
            if(get_bits1(&s->gb_extra_bits)){
 
468
                S = get_bits(&s->gb_extra_bits, 23);
 
469
                if(s->float_max_exp >= 25)
 
470
                    exp = get_bits(&s->gb_extra_bits, 8);
 
471
                sign = get_bits1(&s->gb_extra_bits);
 
472
            }else{
 
473
                if(s->float_flag & WV_FLT_ZERO_SIGN)
 
474
                    sign = get_bits1(&s->gb_extra_bits);
 
475
            }
 
476
        }
 
477
    }
 
478
 
 
479
    *crc = *crc * 27 + S * 9 + exp * 3 + sign;
 
480
 
 
481
    value.u = (sign << 31) | (exp << 23) | S;
 
482
    return value.f;
 
483
}
 
484
 
 
485
static void wv_reset_saved_context(WavpackFrameContext *s)
 
486
{
 
487
    s->pos = 0;
 
488
    s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
 
489
}
 
490
 
 
491
static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
 
492
{
 
493
    int i, j, count = 0;
 
494
    int last, t;
 
495
    int A, B, L, L2, R, R2;
 
496
    int pos = s->pos;
 
497
    uint32_t crc = s->sc.crc;
 
498
    uint32_t crc_extra_bits = s->extra_sc.crc;
 
499
    int16_t *dst16 = dst;
 
500
    int32_t *dst32 = dst;
 
501
    float   *dstfl = dst;
 
502
    const int channel_pad = s->avctx->channels - 2;
 
503
 
 
504
    if(s->samples_left == s->samples)
 
505
        s->one = s->zero = s->zeroes = 0;
 
506
    do{
 
507
        L = wv_get_value(s, gb, 0, &last);
 
508
        if(last) break;
 
509
        R = wv_get_value(s, gb, 1, &last);
 
510
        if(last) break;
 
511
        for(i = 0; i < s->terms; i++){
 
512
            t = s->decorr[i].value;
 
513
            if(t > 0){
 
514
                if(t > 8){
 
515
                    if(t & 1){
 
516
                        A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 
517
                        B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
 
518
                    }else{
 
519
                        A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 
520
                        B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
 
521
                    }
 
522
                    s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 
523
                    s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
 
524
                    j = 0;
 
525
                }else{
 
526
                    A = s->decorr[i].samplesA[pos];
 
527
                    B = s->decorr[i].samplesB[pos];
 
528
                    j = (pos + t) & 7;
 
529
                }
 
530
                if(type != AV_SAMPLE_FMT_S16){
 
531
                    L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 
532
                    R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
 
533
                }else{
 
534
                    L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
 
535
                    R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
 
536
                }
 
537
                if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 
538
                if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
 
539
                s->decorr[i].samplesA[j] = L = L2;
 
540
                s->decorr[i].samplesB[j] = R = R2;
 
541
            }else if(t == -1){
 
542
                if(type != AV_SAMPLE_FMT_S16)
 
543
                    L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
 
544
                else
 
545
                    L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
 
546
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
 
547
                L = L2;
 
548
                if(type != AV_SAMPLE_FMT_S16)
 
549
                    R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
 
550
                else
 
551
                    R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
 
552
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
 
553
                R = R2;
 
554
                s->decorr[i].samplesA[0] = R;
 
555
            }else{
 
556
                if(type != AV_SAMPLE_FMT_S16)
 
557
                    R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
 
558
                else
 
559
                    R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
 
560
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
 
561
                R = R2;
 
562
 
 
563
                if(t == -3){
 
564
                    R2 = s->decorr[i].samplesA[0];
 
565
                    s->decorr[i].samplesA[0] = R;
 
566
                }
 
567
 
 
568
                if(type != AV_SAMPLE_FMT_S16)
 
569
                    L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
 
570
                else
 
571
                    L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
 
572
                UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
 
573
                L = L2;
 
574
                s->decorr[i].samplesB[0] = L;
 
575
            }
 
576
        }
 
577
        pos = (pos + 1) & 7;
 
578
        if(s->joint)
 
579
            L += (R -= (L >> 1));
 
580
        crc = (crc * 3 + L) * 3 + R;
 
581
 
 
582
        if(type == AV_SAMPLE_FMT_FLT){
 
583
            *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
 
584
            *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
 
585
            dstfl += channel_pad;
 
586
        } else if(type == AV_SAMPLE_FMT_S32){
 
587
            *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
 
588
            *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
 
589
            dst32 += channel_pad;
 
590
        } else {
 
591
            *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
 
592
            *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
 
593
            dst16 += channel_pad;
 
594
        }
 
595
        count++;
 
596
    }while(!last && count < s->max_samples);
 
597
 
 
598
    if (last)
 
599
        s->samples_left = 0;
 
600
    else
 
601
        s->samples_left -= count;
 
602
    if(!s->samples_left){
 
603
        if(crc != s->CRC){
 
604
            av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 
605
            return -1;
 
606
        }
 
607
        if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 
608
            av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 
609
            return -1;
 
610
        }
 
611
        wv_reset_saved_context(s);
 
612
    }else{
 
613
        s->pos = pos;
 
614
        s->sc.crc = crc;
 
615
        s->sc.bits_used = get_bits_count(&s->gb);
 
616
        if(s->got_extra_bits){
 
617
            s->extra_sc.crc = crc_extra_bits;
 
618
            s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
 
619
        }
 
620
    }
 
621
    return count * 2;
 
622
}
 
623
 
 
624
static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
 
625
{
 
626
    int i, j, count = 0;
 
627
    int last, t;
 
628
    int A, S, T;
 
629
    int pos = s->pos;
 
630
    uint32_t crc = s->sc.crc;
 
631
    uint32_t crc_extra_bits = s->extra_sc.crc;
 
632
    int16_t *dst16 = dst;
 
633
    int32_t *dst32 = dst;
 
634
    float   *dstfl = dst;
 
635
    const int channel_stride = s->avctx->channels;
 
636
 
 
637
    if(s->samples_left == s->samples)
 
638
        s->one = s->zero = s->zeroes = 0;
 
639
    do{
 
640
        T = wv_get_value(s, gb, 0, &last);
 
641
        S = 0;
 
642
        if(last) break;
 
643
        for(i = 0; i < s->terms; i++){
 
644
            t = s->decorr[i].value;
 
645
            if(t > 8){
 
646
                if(t & 1)
 
647
                    A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
 
648
                else
 
649
                    A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
 
650
                s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
 
651
                j = 0;
 
652
            }else{
 
653
                A = s->decorr[i].samplesA[pos];
 
654
                j = (pos + t) & 7;
 
655
            }
 
656
            if(type != AV_SAMPLE_FMT_S16)
 
657
                S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
 
658
            else
 
659
                S = T + ((s->decorr[i].weightA * A + 512) >> 10);
 
660
            if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
 
661
            s->decorr[i].samplesA[j] = T = S;
 
662
        }
 
663
        pos = (pos + 1) & 7;
 
664
        crc = crc * 3 + S;
 
665
 
 
666
        if(type == AV_SAMPLE_FMT_FLT){
 
667
            *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
 
668
            dstfl += channel_stride;
 
669
        }else if(type == AV_SAMPLE_FMT_S32){
 
670
            *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
 
671
            dst32 += channel_stride;
 
672
        }else{
 
673
            *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
 
674
            dst16 += channel_stride;
 
675
        }
 
676
        count++;
 
677
    }while(!last && count < s->max_samples);
 
678
 
 
679
    if (last)
 
680
        s->samples_left = 0;
 
681
    else
 
682
        s->samples_left -= count;
 
683
    if(!s->samples_left){
 
684
        if(crc != s->CRC){
 
685
            av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
 
686
            return -1;
 
687
        }
 
688
        if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
 
689
            av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
 
690
            return -1;
 
691
        }
 
692
        wv_reset_saved_context(s);
 
693
    }else{
 
694
        s->pos = pos;
 
695
        s->sc.crc = crc;
 
696
        s->sc.bits_used = get_bits_count(&s->gb);
 
697
        if(s->got_extra_bits){
 
698
            s->extra_sc.crc = crc_extra_bits;
 
699
            s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
 
700
        }
 
701
    }
 
702
    return count;
 
703
}
 
704
 
 
705
static av_cold int wv_alloc_frame_context(WavpackContext *c)
 
706
{
 
707
 
 
708
    if(c->fdec_num == WV_MAX_FRAME_DECODERS)
 
709
        return -1;
 
710
 
 
711
    c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
 
712
    if(!c->fdec[c->fdec_num])
 
713
        return -1;
 
714
    c->fdec_num++;
 
715
    c->fdec[c->fdec_num - 1]->avctx = c->avctx;
 
716
    wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
 
717
 
 
718
    return 0;
 
719
}
 
720
 
 
721
static av_cold int wavpack_decode_init(AVCodecContext *avctx)
 
722
{
 
723
    WavpackContext *s = avctx->priv_data;
 
724
 
 
725
    s->avctx = avctx;
 
726
    if(avctx->bits_per_coded_sample <= 16)
 
727
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 
728
    else
 
729
        avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 
730
    if(avctx->channels <= 2 && !avctx->channel_layout)
 
731
        avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
 
732
 
 
733
    s->multichannel = avctx->channels > 2;
 
734
    /* lavf demuxer does not provide extradata, Matroska stores 0x403
 
735
       there, use this to detect decoding mode for multichannel */
 
736
    s->mkv_mode = 0;
 
737
    if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
 
738
        int ver = AV_RL16(avctx->extradata);
 
739
        if(ver >= 0x402 && ver <= 0x410)
 
740
            s->mkv_mode = 1;
 
741
    }
 
742
 
 
743
    s->fdec_num = 0;
 
744
 
 
745
    return 0;
 
746
}
 
747
 
 
748
static av_cold int wavpack_decode_end(AVCodecContext *avctx)
 
749
{
 
750
    WavpackContext *s = avctx->priv_data;
 
751
    int i;
 
752
 
 
753
    for(i = 0; i < s->fdec_num; i++)
 
754
        av_freep(&s->fdec[i]);
 
755
    s->fdec_num = 0;
 
756
 
 
757
    return 0;
 
758
}
 
759
 
 
760
static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
 
761
                                void *data, int *data_size,
 
762
                                const uint8_t *buf, int buf_size)
 
763
{
 
764
    WavpackContext *wc = avctx->priv_data;
 
765
    WavpackFrameContext *s;
 
766
    void *samples = data;
 
767
    int samplecount;
 
768
    int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
 
769
    int got_hybrid = 0;
 
770
    const uint8_t* orig_buf = buf;
 
771
    const uint8_t* buf_end = buf + buf_size;
 
772
    int i, j, id, size, ssize, weights, t;
 
773
    int bpp, chan, chmask;
 
774
 
 
775
    if (buf_size == 0){
 
776
        *data_size = 0;
 
777
        return 0;
 
778
    }
 
779
 
 
780
    if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
 
781
        av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
 
782
        return -1;
 
783
    }
 
784
 
 
785
    s = wc->fdec[block_no];
 
786
    if(!s){
 
787
        av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
 
788
        return -1;
 
789
    }
 
790
 
 
791
    if(!s->samples_left){
 
792
        memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
 
793
        memset(s->ch, 0, sizeof(s->ch));
 
794
        s->extra_bits = 0;
 
795
        s->and = s->or = s->shift = 0;
 
796
        s->got_extra_bits = 0;
 
797
    }
 
798
 
 
799
    if(!wc->mkv_mode){
 
800
        s->samples = AV_RL32(buf); buf += 4;
 
801
        if(!s->samples){
 
802
            *data_size = 0;
 
803
            return buf_size;
 
804
        }
 
805
    }else{
 
806
        s->samples = wc->samples;
 
807
    }
 
808
    s->frame_flags = AV_RL32(buf); buf += 4;
 
809
    if(s->frame_flags&0x80){
 
810
        bpp = sizeof(float);
 
811
        avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
 
812
    } else if((s->frame_flags&0x03) <= 1){
 
813
        bpp = 2;
 
814
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 
815
    } else {
 
816
        bpp = 4;
 
817
        avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 
818
    }
 
819
    samples = (uint8_t*)samples + bpp * wc->ch_offset;
 
820
 
 
821
    s->stereo = !(s->frame_flags & WV_MONO);
 
822
    s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
 
823
    s->joint = s->frame_flags & WV_JOINT_STEREO;
 
824
    s->hybrid = s->frame_flags & WV_HYBRID_MODE;
 
825
    s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
 
826
    s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
 
827
    s->CRC = AV_RL32(buf); buf += 4;
 
828
    if(wc->mkv_mode)
 
829
        buf += 4; //skip block size;
 
830
 
 
831
    wc->ch_offset += 1 + s->stereo;
 
832
 
 
833
    s->max_samples = *data_size / (bpp * avctx->channels);
 
834
    s->max_samples = FFMIN(s->max_samples, s->samples);
 
835
    if(s->samples_left > 0){
 
836
        s->max_samples = FFMIN(s->max_samples, s->samples_left);
 
837
        buf = buf_end;
 
838
    }
 
839
 
 
840
    // parse metadata blocks
 
841
    while(buf < buf_end){
 
842
        id = *buf++;
 
843
        size = *buf++;
 
844
        if(id & WP_IDF_LONG) {
 
845
            size |= (*buf++) << 8;
 
846
            size |= (*buf++) << 16;
 
847
        }
 
848
        size <<= 1; // size is specified in words
 
849
        ssize = size;
 
850
        if(id & WP_IDF_ODD) size--;
 
851
        if(size < 0){
 
852
            av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
 
853
            break;
 
854
        }
 
855
        if(buf + ssize > buf_end){
 
856
            av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
 
857
            break;
 
858
        }
 
859
        if(id & WP_IDF_IGNORE){
 
860
            buf += ssize;
 
861
            continue;
 
862
        }
 
863
        switch(id & WP_IDF_MASK){
 
864
        case WP_ID_DECTERMS:
 
865
            s->terms = size;
 
866
            if(s->terms > MAX_TERMS){
 
867
                av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
 
868
                buf += ssize;
 
869
                continue;
 
870
            }
 
871
            for(i = 0; i < s->terms; i++) {
 
872
                s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
 
873
                s->decorr[s->terms - i - 1].delta = *buf >> 5;
 
874
                buf++;
 
875
            }
 
876
            got_terms = 1;
 
877
            break;
 
878
        case WP_ID_DECWEIGHTS:
 
879
            if(!got_terms){
 
880
                av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 
881
                continue;
 
882
            }
 
883
            weights = size >> s->stereo_in;
 
884
            if(weights > MAX_TERMS || weights > s->terms){
 
885
                av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
 
886
                buf += ssize;
 
887
                continue;
 
888
            }
 
889
            for(i = 0; i < weights; i++) {
 
890
                t = (int8_t)(*buf++);
 
891
                s->decorr[s->terms - i - 1].weightA = t << 3;
 
892
                if(s->decorr[s->terms - i - 1].weightA > 0)
 
893
                    s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
 
894
                if(s->stereo_in){
 
895
                    t = (int8_t)(*buf++);
 
896
                    s->decorr[s->terms - i - 1].weightB = t << 3;
 
897
                    if(s->decorr[s->terms - i - 1].weightB > 0)
 
898
                        s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
 
899
                }
 
900
            }
 
901
            got_weights = 1;
 
902
            break;
 
903
        case WP_ID_DECSAMPLES:
 
904
            if(!got_terms){
 
905
                av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
 
906
                continue;
 
907
            }
 
908
            t = 0;
 
909
            for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
 
910
                if(s->decorr[i].value > 8){
 
911
                    s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 
912
                    s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 
913
                    if(s->stereo_in){
 
914
                        s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 
915
                        s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
 
916
                        t += 4;
 
917
                    }
 
918
                    t += 4;
 
919
                }else if(s->decorr[i].value < 0){
 
920
                    s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 
921
                    s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
 
922
                    t += 4;
 
923
                }else{
 
924
                    for(j = 0; j < s->decorr[i].value; j++){
 
925
                        s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 
926
                        if(s->stereo_in){
 
927
                            s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
 
928
                        }
 
929
                    }
 
930
                    t += s->decorr[i].value * 2 * (s->stereo_in + 1);
 
931
                }
 
932
            }
 
933
            got_samples = 1;
 
934
            break;
 
935
        case WP_ID_ENTROPY:
 
936
            if(size != 6 * (s->stereo_in + 1)){
 
937
                av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
 
938
                buf += ssize;
 
939
                continue;
 
940
            }
 
941
            for(j = 0; j <= s->stereo_in; j++){
 
942
                for(i = 0; i < 3; i++){
 
943
                    s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
 
944
                    buf += 2;
 
945
                }
 
946
            }
 
947
            got_entropy = 1;
 
948
            break;
 
949
        case WP_ID_HYBRID:
 
950
            if(s->hybrid_bitrate){
 
951
                for(i = 0; i <= s->stereo_in; i++){
 
952
                    s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
 
953
                    buf += 2;
 
954
                    size -= 2;
 
955
                }
 
956
            }
 
957
            for(i = 0; i < (s->stereo_in + 1); i++){
 
958
                s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
 
959
                buf += 2;
 
960
                size -= 2;
 
961
            }
 
962
            if(size > 0){
 
963
                for(i = 0; i < (s->stereo_in + 1); i++){
 
964
                    s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
 
965
                    buf += 2;
 
966
                }
 
967
            }else{
 
968
                for(i = 0; i < (s->stereo_in + 1); i++)
 
969
                    s->ch[i].bitrate_delta = 0;
 
970
            }
 
971
            got_hybrid = 1;
 
972
            break;
 
973
        case WP_ID_INT32INFO:
 
974
            if(size != 4){
 
975
                av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
 
976
                buf += ssize;
 
977
                continue;
 
978
            }
 
979
            if(buf[0])
 
980
                s->extra_bits = buf[0];
 
981
            else if(buf[1])
 
982
                s->shift = buf[1];
 
983
            else if(buf[2]){
 
984
                s->and = s->or = 1;
 
985
                s->shift = buf[2];
 
986
            }else if(buf[3]){
 
987
                s->and = 1;
 
988
                s->shift = buf[3];
 
989
            }
 
990
            buf += 4;
 
991
            break;
 
992
        case WP_ID_FLOATINFO:
 
993
            if(size != 4){
 
994
                av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
 
995
                buf += ssize;
 
996
                continue;
 
997
            }
 
998
            s->float_flag = buf[0];
 
999
            s->float_shift = buf[1];
 
1000
            s->float_max_exp = buf[2];
 
1001
            buf += 4;
 
1002
            got_float = 1;
 
1003
            break;
 
1004
        case WP_ID_DATA:
 
1005
            s->sc.offset = buf - orig_buf;
 
1006
            s->sc.size   = size * 8;
 
1007
            init_get_bits(&s->gb, buf, size * 8);
 
1008
            s->data_size = size * 8;
 
1009
            buf += size;
 
1010
            got_bs = 1;
 
1011
            break;
 
1012
        case WP_ID_EXTRABITS:
 
1013
            if(size <= 4){
 
1014
                av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
 
1015
                buf += size;
 
1016
                continue;
 
1017
            }
 
1018
            s->extra_sc.offset = buf - orig_buf;
 
1019
            s->extra_sc.size   = size * 8;
 
1020
            init_get_bits(&s->gb_extra_bits, buf, size * 8);
 
1021
            s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
 
1022
            buf += size;
 
1023
            s->got_extra_bits = 1;
 
1024
            break;
 
1025
        case WP_ID_CHANINFO:
 
1026
            if(size <= 1){
 
1027
                av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
 
1028
                return -1;
 
1029
            }
 
1030
            chan = *buf++;
 
1031
            switch(size - 2){
 
1032
            case 0:
 
1033
                chmask = *buf;
 
1034
                break;
 
1035
            case 1:
 
1036
                chmask = AV_RL16(buf);
 
1037
                break;
 
1038
            case 2:
 
1039
                chmask = AV_RL24(buf);
 
1040
                break;
 
1041
            case 3:
 
1042
                chmask = AV_RL32(buf);
 
1043
                break;
 
1044
            case 5:
 
1045
                chan |= (buf[1] & 0xF) << 8;
 
1046
                chmask = AV_RL24(buf + 2);
 
1047
                break;
 
1048
            default:
 
1049
                av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
 
1050
                chan = avctx->channels;
 
1051
                chmask = avctx->channel_layout;
 
1052
            }
 
1053
            if(chan != avctx->channels){
 
1054
                av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
 
1055
                       chan, avctx->channels);
 
1056
                return -1;
 
1057
            }
 
1058
            if(!avctx->channel_layout)
 
1059
                avctx->channel_layout = chmask;
 
1060
            buf += size - 1;
 
1061
            break;
 
1062
        default:
 
1063
            buf += size;
 
1064
        }
 
1065
        if(id & WP_IDF_ODD) buf++;
 
1066
    }
 
1067
    if(!s->samples_left){
 
1068
        if(!got_terms){
 
1069
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
 
1070
            return -1;
 
1071
        }
 
1072
        if(!got_weights){
 
1073
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
 
1074
            return -1;
 
1075
        }
 
1076
        if(!got_samples){
 
1077
            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
 
1078
            return -1;
 
1079
        }
 
1080
        if(!got_entropy){
 
1081
            av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
 
1082
            return -1;
 
1083
        }
 
1084
        if(s->hybrid && !got_hybrid){
 
1085
            av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
 
1086
            return -1;
 
1087
        }
 
1088
        if(!got_bs){
 
1089
            av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
 
1090
            return -1;
 
1091
        }
 
1092
        if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
 
1093
            av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
 
1094
            return -1;
 
1095
        }
 
1096
        if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
 
1097
            const int size = get_bits_left(&s->gb_extra_bits);
 
1098
            const int wanted = s->samples * s->extra_bits << s->stereo_in;
 
1099
            if(size < wanted){
 
1100
                av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
 
1101
                s->got_extra_bits = 0;
 
1102
            }
 
1103
        }
 
1104
        s->samples_left = s->samples;
 
1105
    }else{
 
1106
        init_get_bits(&s->gb, orig_buf + s->sc.offset, s->sc.size);
 
1107
        skip_bits_long(&s->gb, s->sc.bits_used);
 
1108
        if(s->got_extra_bits){
 
1109
            init_get_bits(&s->gb_extra_bits, orig_buf + s->extra_sc.offset,
 
1110
                          s->extra_sc.size);
 
1111
            skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
 
1112
        }
 
1113
    }
 
1114
 
 
1115
    if(s->stereo_in){
 
1116
        if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
 
1117
            samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
 
1118
        else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
 
1119
            samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
 
1120
        else
 
1121
            samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
 
1122
        samplecount >>= 1;
 
1123
    }else{
 
1124
        const int channel_stride = avctx->channels;
 
1125
 
 
1126
        if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
 
1127
            samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
 
1128
        else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
 
1129
            samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
 
1130
        else
 
1131
            samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
 
1132
 
 
1133
        if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
 
1134
            int16_t *dst = (int16_t*)samples + 1;
 
1135
            int16_t *src = (int16_t*)samples;
 
1136
            int cnt = samplecount;
 
1137
            while(cnt-- > 0){
 
1138
                *dst = *src;
 
1139
                src += channel_stride;
 
1140
                dst += channel_stride;
 
1141
            }
 
1142
        }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
 
1143
            int32_t *dst = (int32_t*)samples + 1;
 
1144
            int32_t *src = (int32_t*)samples;
 
1145
            int cnt = samplecount;
 
1146
            while(cnt-- > 0){
 
1147
                *dst = *src;
 
1148
                src += channel_stride;
 
1149
                dst += channel_stride;
 
1150
            }
 
1151
        }else if(s->stereo){
 
1152
            float *dst = (float*)samples + 1;
 
1153
            float *src = (float*)samples;
 
1154
            int cnt = samplecount;
 
1155
            while(cnt-- > 0){
 
1156
                *dst = *src;
 
1157
                src += channel_stride;
 
1158
                dst += channel_stride;
 
1159
            }
 
1160
        }
 
1161
    }
 
1162
 
 
1163
    wc->samples_left = s->samples_left;
 
1164
 
 
1165
    return samplecount * bpp;
 
1166
}
 
1167
 
 
1168
static int wavpack_decode_frame(AVCodecContext *avctx,
 
1169
                            void *data, int *data_size,
 
1170
                            AVPacket *avpkt)
 
1171
{
 
1172
    WavpackContext *s = avctx->priv_data;
 
1173
    const uint8_t *buf = avpkt->data;
 
1174
    int buf_size = avpkt->size;
 
1175
    int frame_size;
 
1176
    int samplecount = 0;
 
1177
 
 
1178
    s->block = 0;
 
1179
    s->samples_left = 0;
 
1180
    s->ch_offset = 0;
 
1181
 
 
1182
    if(s->mkv_mode){
 
1183
        s->samples = AV_RL32(buf); buf += 4;
 
1184
    }
 
1185
    while(buf_size > 0){
 
1186
        if(!s->multichannel){
 
1187
            frame_size = buf_size;
 
1188
        }else{
 
1189
            if(!s->mkv_mode){
 
1190
                frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
 
1191
            }else{
 
1192
                if(buf_size < 12) //MKV files can have zero flags after last block
 
1193
                    break;
 
1194
                frame_size = AV_RL32(buf + 8) + 12;
 
1195
            }
 
1196
        }
 
1197
        if(frame_size < 0 || frame_size > buf_size){
 
1198
            av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
 
1199
                   s->block, frame_size, buf_size);
 
1200
            return -1;
 
1201
        }
 
1202
        if((samplecount = wavpack_decode_block(avctx, s->block, data,
 
1203
                                               data_size, buf, frame_size)) < 0)
 
1204
            return -1;
 
1205
        s->block++;
 
1206
        buf += frame_size; buf_size -= frame_size;
 
1207
    }
 
1208
    *data_size = samplecount * avctx->channels;
 
1209
 
 
1210
    return s->samples_left > 0 ? 0 : avpkt->size;
 
1211
}
 
1212
 
 
1213
AVCodec ff_wavpack_decoder = {
 
1214
    "wavpack",
 
1215
    AVMEDIA_TYPE_AUDIO,
 
1216
    CODEC_ID_WAVPACK,
 
1217
    sizeof(WavpackContext),
 
1218
    wavpack_decode_init,
 
1219
    NULL,
 
1220
    wavpack_decode_end,
 
1221
    wavpack_decode_frame,
 
1222
    .capabilities = CODEC_CAP_SUBFRAMES,
 
1223
    .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
 
1224
};