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