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