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