blob: 2bda3599a8448e05e6c733bf69d7192f1eaa1a4f
1 | /* |
2 | * WavPack lossless audio decoder |
3 | * Copyright (c) 2006,2011 Konstantin Shishkov |
4 | * |
5 | * This file is part of FFmpeg. |
6 | * |
7 | * FFmpeg 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 | * FFmpeg 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 FFmpeg; if not, write to the Free Software |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
20 | */ |
21 | |
22 | #include "libavutil/channel_layout.h" |
23 | |
24 | #define BITSTREAM_READER_LE |
25 | #include "avcodec.h" |
26 | #include "bytestream.h" |
27 | #include "get_bits.h" |
28 | #include "internal.h" |
29 | #include "thread.h" |
30 | #include "unary.h" |
31 | #include "wavpack.h" |
32 | |
33 | /** |
34 | * @file |
35 | * WavPack lossless audio decoder |
36 | */ |
37 | |
38 | typedef struct SavedContext { |
39 | int offset; |
40 | int size; |
41 | int bits_used; |
42 | uint32_t crc; |
43 | } SavedContext; |
44 | |
45 | typedef struct WavpackFrameContext { |
46 | AVCodecContext *avctx; |
47 | int frame_flags; |
48 | int stereo, stereo_in; |
49 | int joint; |
50 | uint32_t CRC; |
51 | GetBitContext gb; |
52 | int got_extra_bits; |
53 | uint32_t crc_extra_bits; |
54 | GetBitContext gb_extra_bits; |
55 | int data_size; // in bits |
56 | int samples; |
57 | int terms; |
58 | Decorr decorr[MAX_TERMS]; |
59 | int zero, one, zeroes; |
60 | int extra_bits; |
61 | int and, or, shift; |
62 | int post_shift; |
63 | int hybrid, hybrid_bitrate; |
64 | int hybrid_maxclip, hybrid_minclip; |
65 | int float_flag; |
66 | int float_shift; |
67 | int float_max_exp; |
68 | WvChannel ch[2]; |
69 | int pos; |
70 | SavedContext sc, extra_sc; |
71 | } WavpackFrameContext; |
72 | |
73 | #define WV_MAX_FRAME_DECODERS 14 |
74 | |
75 | typedef struct WavpackContext { |
76 | AVCodecContext *avctx; |
77 | |
78 | WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS]; |
79 | int fdec_num; |
80 | |
81 | int block; |
82 | int samples; |
83 | int ch_offset; |
84 | } WavpackContext; |
85 | |
86 | #define LEVEL_DECAY(a) (((a) + 0x80) >> 8) |
87 | |
88 | static av_always_inline int get_tail(GetBitContext *gb, int k) |
89 | { |
90 | int p, e, res; |
91 | |
92 | if (k < 1) |
93 | return 0; |
94 | p = av_log2(k); |
95 | e = (1 << (p + 1)) - k - 1; |
96 | res = get_bitsz(gb, p); |
97 | if (res >= e) |
98 | res = (res << 1) - e + get_bits1(gb); |
99 | return res; |
100 | } |
101 | |
102 | static int update_error_limit(WavpackFrameContext *ctx) |
103 | { |
104 | int i, br[2], sl[2]; |
105 | |
106 | for (i = 0; i <= ctx->stereo_in; i++) { |
107 | if (ctx->ch[i].bitrate_acc > UINT_MAX - ctx->ch[i].bitrate_delta) |
108 | return AVERROR_INVALIDDATA; |
109 | ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta; |
110 | br[i] = ctx->ch[i].bitrate_acc >> 16; |
111 | sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level); |
112 | } |
113 | if (ctx->stereo_in && ctx->hybrid_bitrate) { |
114 | int balance = (sl[1] - sl[0] + br[1] + 1) >> 1; |
115 | if (balance > br[0]) { |
116 | br[1] = br[0] << 1; |
117 | br[0] = 0; |
118 | } else if (-balance > br[0]) { |
119 | br[0] <<= 1; |
120 | br[1] = 0; |
121 | } else { |
122 | br[1] = br[0] + balance; |
123 | br[0] = br[0] - balance; |
124 | } |
125 | } |
126 | for (i = 0; i <= ctx->stereo_in; i++) { |
127 | if (ctx->hybrid_bitrate) { |
128 | if (sl[i] - br[i] > -0x100) |
129 | ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100); |
130 | else |
131 | ctx->ch[i].error_limit = 0; |
132 | } else { |
133 | ctx->ch[i].error_limit = wp_exp2(br[i]); |
134 | } |
135 | } |
136 | |
137 | return 0; |
138 | } |
139 | |
140 | static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, |
141 | int channel, int *last) |
142 | { |
143 | int t, t2; |
144 | int sign, base, add, ret; |
145 | WvChannel *c = &ctx->ch[channel]; |
146 | |
147 | *last = 0; |
148 | |
149 | if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && |
150 | !ctx->zero && !ctx->one) { |
151 | if (ctx->zeroes) { |
152 | ctx->zeroes--; |
153 | if (ctx->zeroes) { |
154 | c->slow_level -= LEVEL_DECAY(c->slow_level); |
155 | return 0; |
156 | } |
157 | } else { |
158 | t = get_unary_0_33(gb); |
159 | if (t >= 2) { |
160 | if (get_bits_left(gb) < t - 1) |
161 | goto error; |
162 | t = get_bits_long(gb, t - 1) | (1 << (t - 1)); |
163 | } else { |
164 | if (get_bits_left(gb) < 0) |
165 | goto error; |
166 | } |
167 | ctx->zeroes = t; |
168 | if (ctx->zeroes) { |
169 | memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median)); |
170 | memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median)); |
171 | c->slow_level -= LEVEL_DECAY(c->slow_level); |
172 | return 0; |
173 | } |
174 | } |
175 | } |
176 | |
177 | if (ctx->zero) { |
178 | t = 0; |
179 | ctx->zero = 0; |
180 | } else { |
181 | t = get_unary_0_33(gb); |
182 | if (get_bits_left(gb) < 0) |
183 | goto error; |
184 | if (t == 16) { |
185 | t2 = get_unary_0_33(gb); |
186 | if (t2 < 2) { |
187 | if (get_bits_left(gb) < 0) |
188 | goto error; |
189 | t += t2; |
190 | } else { |
191 | if (get_bits_left(gb) < t2 - 1) |
192 | goto error; |
193 | t += get_bits_long(gb, t2 - 1) | (1 << (t2 - 1)); |
194 | } |
195 | } |
196 | |
197 | if (ctx->one) { |
198 | ctx->one = t & 1; |
199 | t = (t >> 1) + 1; |
200 | } else { |
201 | ctx->one = t & 1; |
202 | t >>= 1; |
203 | } |
204 | ctx->zero = !ctx->one; |
205 | } |
206 | |
207 | if (ctx->hybrid && !channel) { |
208 | if (update_error_limit(ctx) < 0) |
209 | goto error; |
210 | } |
211 | |
212 | if (!t) { |
213 | base = 0; |
214 | add = GET_MED(0) - 1; |
215 | DEC_MED(0); |
216 | } else if (t == 1) { |
217 | base = GET_MED(0); |
218 | add = GET_MED(1) - 1; |
219 | INC_MED(0); |
220 | DEC_MED(1); |
221 | } else if (t == 2) { |
222 | base = GET_MED(0) + GET_MED(1); |
223 | add = GET_MED(2) - 1; |
224 | INC_MED(0); |
225 | INC_MED(1); |
226 | DEC_MED(2); |
227 | } else { |
228 | base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2); |
229 | add = GET_MED(2) - 1; |
230 | INC_MED(0); |
231 | INC_MED(1); |
232 | INC_MED(2); |
233 | } |
234 | if (!c->error_limit) { |
235 | if (add >= 0x2000000U) { |
236 | av_log(ctx->avctx, AV_LOG_ERROR, "k %d is too large\n", add); |
237 | goto error; |
238 | } |
239 | ret = base + get_tail(gb, add); |
240 | if (get_bits_left(gb) <= 0) |
241 | goto error; |
242 | } else { |
243 | int mid = (base * 2 + add + 1) >> 1; |
244 | while (add > c->error_limit) { |
245 | if (get_bits_left(gb) <= 0) |
246 | goto error; |
247 | if (get_bits1(gb)) { |
248 | add -= (mid - base); |
249 | base = mid; |
250 | } else |
251 | add = mid - base - 1; |
252 | mid = (base * 2 + add + 1) >> 1; |
253 | } |
254 | ret = mid; |
255 | } |
256 | sign = get_bits1(gb); |
257 | if (ctx->hybrid_bitrate) |
258 | c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level); |
259 | return sign ? ~ret : ret; |
260 | |
261 | error: |
262 | ret = get_bits_left(gb); |
263 | if (ret <= 0) { |
264 | av_log(ctx->avctx, AV_LOG_ERROR, "Too few bits (%d) left\n", ret); |
265 | } |
266 | *last = 1; |
267 | return 0; |
268 | } |
269 | |
270 | static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, |
271 | unsigned S) |
272 | { |
273 | unsigned bit; |
274 | |
275 | if (s->extra_bits) { |
276 | S *= 1 << s->extra_bits; |
277 | |
278 | if (s->got_extra_bits && |
279 | get_bits_left(&s->gb_extra_bits) >= s->extra_bits) { |
280 | S |= get_bits_long(&s->gb_extra_bits, s->extra_bits); |
281 | *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16); |
282 | } |
283 | } |
284 | |
285 | bit = (S & s->and) | s->or; |
286 | bit = ((S + bit) << s->shift) - bit; |
287 | |
288 | if (s->hybrid) |
289 | bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip); |
290 | |
291 | return bit << s->post_shift; |
292 | } |
293 | |
294 | static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S) |
295 | { |
296 | union { |
297 | float f; |
298 | uint32_t u; |
299 | } value; |
300 | |
301 | unsigned int sign; |
302 | int exp = s->float_max_exp; |
303 | |
304 | if (s->got_extra_bits) { |
305 | const int max_bits = 1 + 23 + 8 + 1; |
306 | const int left_bits = get_bits_left(&s->gb_extra_bits); |
307 | |
308 | if (left_bits + 8 * AV_INPUT_BUFFER_PADDING_SIZE < max_bits) |
309 | return 0.0; |
310 | } |
311 | |
312 | if (S) { |
313 | S <<= s->float_shift; |
314 | sign = S < 0; |
315 | if (sign) |
316 | S = -S; |
317 | if (S >= 0x1000000) { |
318 | if (s->got_extra_bits && get_bits1(&s->gb_extra_bits)) |
319 | S = get_bits(&s->gb_extra_bits, 23); |
320 | else |
321 | S = 0; |
322 | exp = 255; |
323 | } else if (exp) { |
324 | int shift = 23 - av_log2(S); |
325 | exp = s->float_max_exp; |
326 | if (exp <= shift) |
327 | shift = --exp; |
328 | exp -= shift; |
329 | |
330 | if (shift) { |
331 | S <<= shift; |
332 | if ((s->float_flag & WV_FLT_SHIFT_ONES) || |
333 | (s->got_extra_bits && |
334 | (s->float_flag & WV_FLT_SHIFT_SAME) && |
335 | get_bits1(&s->gb_extra_bits))) { |
336 | S |= (1 << shift) - 1; |
337 | } else if (s->got_extra_bits && |
338 | (s->float_flag & WV_FLT_SHIFT_SENT)) { |
339 | S |= get_bits(&s->gb_extra_bits, shift); |
340 | } |
341 | } |
342 | } else { |
343 | exp = s->float_max_exp; |
344 | } |
345 | S &= 0x7fffff; |
346 | } else { |
347 | sign = 0; |
348 | exp = 0; |
349 | if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) { |
350 | if (get_bits1(&s->gb_extra_bits)) { |
351 | S = get_bits(&s->gb_extra_bits, 23); |
352 | if (s->float_max_exp >= 25) |
353 | exp = get_bits(&s->gb_extra_bits, 8); |
354 | sign = get_bits1(&s->gb_extra_bits); |
355 | } else { |
356 | if (s->float_flag & WV_FLT_ZERO_SIGN) |
357 | sign = get_bits1(&s->gb_extra_bits); |
358 | } |
359 | } |
360 | } |
361 | |
362 | *crc = *crc * 27 + S * 9 + exp * 3 + sign; |
363 | |
364 | value.u = (sign << 31) | (exp << 23) | S; |
365 | return value.f; |
366 | } |
367 | |
368 | static void wv_reset_saved_context(WavpackFrameContext *s) |
369 | { |
370 | s->pos = 0; |
371 | s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF; |
372 | } |
373 | |
374 | static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc, |
375 | uint32_t crc_extra_bits) |
376 | { |
377 | if (crc != s->CRC) { |
378 | av_log(s->avctx, AV_LOG_ERROR, "CRC error\n"); |
379 | return AVERROR_INVALIDDATA; |
380 | } |
381 | if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) { |
382 | av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n"); |
383 | return AVERROR_INVALIDDATA; |
384 | } |
385 | |
386 | return 0; |
387 | } |
388 | |
389 | static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, |
390 | void *dst_l, void *dst_r, const int type) |
391 | { |
392 | int i, j, count = 0; |
393 | int last, t; |
394 | int A, B, L, L2, R, R2; |
395 | int pos = s->pos; |
396 | uint32_t crc = s->sc.crc; |
397 | uint32_t crc_extra_bits = s->extra_sc.crc; |
398 | int16_t *dst16_l = dst_l; |
399 | int16_t *dst16_r = dst_r; |
400 | int32_t *dst32_l = dst_l; |
401 | int32_t *dst32_r = dst_r; |
402 | float *dstfl_l = dst_l; |
403 | float *dstfl_r = dst_r; |
404 | |
405 | s->one = s->zero = s->zeroes = 0; |
406 | do { |
407 | L = wv_get_value(s, gb, 0, &last); |
408 | if (last) |
409 | break; |
410 | R = wv_get_value(s, gb, 1, &last); |
411 | if (last) |
412 | break; |
413 | for (i = 0; i < s->terms; i++) { |
414 | t = s->decorr[i].value; |
415 | if (t > 0) { |
416 | if (t > 8) { |
417 | if (t & 1) { |
418 | A = 2U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]; |
419 | B = 2U * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]; |
420 | } else { |
421 | A = (int)(3U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1; |
422 | B = (int)(3U * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1; |
423 | } |
424 | s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0]; |
425 | s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0]; |
426 | j = 0; |
427 | } else { |
428 | A = s->decorr[i].samplesA[pos]; |
429 | B = s->decorr[i].samplesB[pos]; |
430 | j = (pos + t) & 7; |
431 | } |
432 | if (type != AV_SAMPLE_FMT_S16P) { |
433 | L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10); |
434 | R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10); |
435 | } else { |
436 | L2 = L + ((s->decorr[i].weightA * A + 512) >> 10); |
437 | R2 = R + ((s->decorr[i].weightB * B + 512) >> 10); |
438 | } |
439 | if (A && L) |
440 | s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta; |
441 | if (B && R) |
442 | s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta; |
443 | s->decorr[i].samplesA[j] = L = L2; |
444 | s->decorr[i].samplesB[j] = R = R2; |
445 | } else if (t == -1) { |
446 | if (type != AV_SAMPLE_FMT_S16P) |
447 | L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10); |
448 | else |
449 | L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10); |
450 | UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L); |
451 | L = L2; |
452 | if (type != AV_SAMPLE_FMT_S16P) |
453 | R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10); |
454 | else |
455 | R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10); |
456 | UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R); |
457 | R = R2; |
458 | s->decorr[i].samplesA[0] = R; |
459 | } else { |
460 | if (type != AV_SAMPLE_FMT_S16P) |
461 | R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10); |
462 | else |
463 | R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10); |
464 | UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R); |
465 | R = R2; |
466 | |
467 | if (t == -3) { |
468 | R2 = s->decorr[i].samplesA[0]; |
469 | s->decorr[i].samplesA[0] = R; |
470 | } |
471 | |
472 | if (type != AV_SAMPLE_FMT_S16P) |
473 | L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10); |
474 | else |
475 | L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10); |
476 | UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L); |
477 | L = L2; |
478 | s->decorr[i].samplesB[0] = L; |
479 | } |
480 | } |
481 | |
482 | if (type == AV_SAMPLE_FMT_S16P) { |
483 | if (FFABS(L) + FFABS(R) > (1<<19)) { |
484 | av_log(s->avctx, AV_LOG_ERROR, "sample %d %d too large\n", L, R); |
485 | return AVERROR_INVALIDDATA; |
486 | } |
487 | } |
488 | |
489 | pos = (pos + 1) & 7; |
490 | if (s->joint) |
491 | L += (unsigned)(R -= (unsigned)(L >> 1)); |
492 | crc = (crc * 3 + L) * 3 + R; |
493 | |
494 | if (type == AV_SAMPLE_FMT_FLTP) { |
495 | *dstfl_l++ = wv_get_value_float(s, &crc_extra_bits, L); |
496 | *dstfl_r++ = wv_get_value_float(s, &crc_extra_bits, R); |
497 | } else if (type == AV_SAMPLE_FMT_S32P) { |
498 | *dst32_l++ = wv_get_value_integer(s, &crc_extra_bits, L); |
499 | *dst32_r++ = wv_get_value_integer(s, &crc_extra_bits, R); |
500 | } else { |
501 | *dst16_l++ = wv_get_value_integer(s, &crc_extra_bits, L); |
502 | *dst16_r++ = wv_get_value_integer(s, &crc_extra_bits, R); |
503 | } |
504 | count++; |
505 | } while (!last && count < s->samples); |
506 | |
507 | wv_reset_saved_context(s); |
508 | |
509 | if (last && count < s->samples) { |
510 | int size = av_get_bytes_per_sample(type); |
511 | memset((uint8_t*)dst_l + count*size, 0, (s->samples-count)*size); |
512 | memset((uint8_t*)dst_r + count*size, 0, (s->samples-count)*size); |
513 | } |
514 | |
515 | if ((s->avctx->err_recognition & AV_EF_CRCCHECK) && |
516 | wv_check_crc(s, crc, crc_extra_bits)) |
517 | return AVERROR_INVALIDDATA; |
518 | |
519 | return 0; |
520 | } |
521 | |
522 | static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, |
523 | void *dst, const int type) |
524 | { |
525 | int i, j, count = 0; |
526 | int last, t; |
527 | int A, S, T; |
528 | int pos = s->pos; |
529 | uint32_t crc = s->sc.crc; |
530 | uint32_t crc_extra_bits = s->extra_sc.crc; |
531 | int16_t *dst16 = dst; |
532 | int32_t *dst32 = dst; |
533 | float *dstfl = dst; |
534 | |
535 | s->one = s->zero = s->zeroes = 0; |
536 | do { |
537 | T = wv_get_value(s, gb, 0, &last); |
538 | S = 0; |
539 | if (last) |
540 | break; |
541 | for (i = 0; i < s->terms; i++) { |
542 | t = s->decorr[i].value; |
543 | if (t > 8) { |
544 | if (t & 1) |
545 | A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]; |
546 | else |
547 | A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1; |
548 | s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0]; |
549 | j = 0; |
550 | } else { |
551 | A = s->decorr[i].samplesA[pos]; |
552 | j = (pos + t) & 7; |
553 | } |
554 | if (type != AV_SAMPLE_FMT_S16P) |
555 | S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10); |
556 | else |
557 | S = T + ((s->decorr[i].weightA * A + 512) >> 10); |
558 | if (A && T) |
559 | s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta; |
560 | s->decorr[i].samplesA[j] = T = S; |
561 | } |
562 | pos = (pos + 1) & 7; |
563 | crc = crc * 3 + S; |
564 | |
565 | if (type == AV_SAMPLE_FMT_FLTP) { |
566 | *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S); |
567 | } else if (type == AV_SAMPLE_FMT_S32P) { |
568 | *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S); |
569 | } else { |
570 | *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S); |
571 | } |
572 | count++; |
573 | } while (!last && count < s->samples); |
574 | |
575 | wv_reset_saved_context(s); |
576 | |
577 | if (last && count < s->samples) { |
578 | int size = av_get_bytes_per_sample(type); |
579 | memset((uint8_t*)dst + count*size, 0, (s->samples-count)*size); |
580 | } |
581 | |
582 | if (s->avctx->err_recognition & AV_EF_CRCCHECK) { |
583 | int ret = wv_check_crc(s, crc, crc_extra_bits); |
584 | if (ret < 0 && s->avctx->err_recognition & AV_EF_EXPLODE) |
585 | return ret; |
586 | } |
587 | |
588 | return 0; |
589 | } |
590 | |
591 | static av_cold int wv_alloc_frame_context(WavpackContext *c) |
592 | { |
593 | if (c->fdec_num == WV_MAX_FRAME_DECODERS) |
594 | return -1; |
595 | |
596 | c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec)); |
597 | if (!c->fdec[c->fdec_num]) |
598 | return -1; |
599 | c->fdec_num++; |
600 | c->fdec[c->fdec_num - 1]->avctx = c->avctx; |
601 | wv_reset_saved_context(c->fdec[c->fdec_num - 1]); |
602 | |
603 | return 0; |
604 | } |
605 | |
606 | #if HAVE_THREADS |
607 | static int init_thread_copy(AVCodecContext *avctx) |
608 | { |
609 | WavpackContext *s = avctx->priv_data; |
610 | s->avctx = avctx; |
611 | return 0; |
612 | } |
613 | #endif |
614 | |
615 | static av_cold int wavpack_decode_init(AVCodecContext *avctx) |
616 | { |
617 | WavpackContext *s = avctx->priv_data; |
618 | |
619 | s->avctx = avctx; |
620 | |
621 | s->fdec_num = 0; |
622 | |
623 | return 0; |
624 | } |
625 | |
626 | static av_cold int wavpack_decode_end(AVCodecContext *avctx) |
627 | { |
628 | WavpackContext *s = avctx->priv_data; |
629 | int i; |
630 | |
631 | for (i = 0; i < s->fdec_num; i++) |
632 | av_freep(&s->fdec[i]); |
633 | s->fdec_num = 0; |
634 | |
635 | return 0; |
636 | } |
637 | |
638 | static int wavpack_decode_block(AVCodecContext *avctx, int block_no, |
639 | AVFrame *frame, const uint8_t *buf, int buf_size) |
640 | { |
641 | WavpackContext *wc = avctx->priv_data; |
642 | ThreadFrame tframe = { .f = frame }; |
643 | WavpackFrameContext *s; |
644 | GetByteContext gb; |
645 | void *samples_l = NULL, *samples_r = NULL; |
646 | int ret; |
647 | int got_terms = 0, got_weights = 0, got_samples = 0, |
648 | got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0; |
649 | int i, j, id, size, ssize, weights, t; |
650 | int bpp, chan = 0, chmask = 0, orig_bpp, sample_rate = 0; |
651 | int multiblock; |
652 | |
653 | if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) { |
654 | av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n"); |
655 | return AVERROR_INVALIDDATA; |
656 | } |
657 | |
658 | s = wc->fdec[block_no]; |
659 | if (!s) { |
660 | av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", |
661 | block_no); |
662 | return AVERROR_INVALIDDATA; |
663 | } |
664 | |
665 | memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr)); |
666 | memset(s->ch, 0, sizeof(s->ch)); |
667 | s->extra_bits = 0; |
668 | s->and = s->or = s->shift = 0; |
669 | s->got_extra_bits = 0; |
670 | |
671 | bytestream2_init(&gb, buf, buf_size); |
672 | |
673 | s->samples = bytestream2_get_le32(&gb); |
674 | if (s->samples != wc->samples) { |
675 | av_log(avctx, AV_LOG_ERROR, "Mismatching number of samples in " |
676 | "a sequence: %d and %d\n", wc->samples, s->samples); |
677 | return AVERROR_INVALIDDATA; |
678 | } |
679 | s->frame_flags = bytestream2_get_le32(&gb); |
680 | bpp = av_get_bytes_per_sample(avctx->sample_fmt); |
681 | orig_bpp = ((s->frame_flags & 0x03) + 1) << 3; |
682 | multiblock = (s->frame_flags & WV_SINGLE_BLOCK) != WV_SINGLE_BLOCK; |
683 | |
684 | s->stereo = !(s->frame_flags & WV_MONO); |
685 | s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo; |
686 | s->joint = s->frame_flags & WV_JOINT_STEREO; |
687 | s->hybrid = s->frame_flags & WV_HYBRID_MODE; |
688 | s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE; |
689 | s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f); |
690 | if (s->post_shift < 0 || s->post_shift > 31) { |
691 | return AVERROR_INVALIDDATA; |
692 | } |
693 | s->hybrid_maxclip = ((1LL << (orig_bpp - 1)) - 1); |
694 | s->hybrid_minclip = ((-1UL << (orig_bpp - 1))); |
695 | s->CRC = bytestream2_get_le32(&gb); |
696 | |
697 | // parse metadata blocks |
698 | while (bytestream2_get_bytes_left(&gb)) { |
699 | id = bytestream2_get_byte(&gb); |
700 | size = bytestream2_get_byte(&gb); |
701 | if (id & WP_IDF_LONG) { |
702 | size |= (bytestream2_get_byte(&gb)) << 8; |
703 | size |= (bytestream2_get_byte(&gb)) << 16; |
704 | } |
705 | size <<= 1; // size is specified in words |
706 | ssize = size; |
707 | if (id & WP_IDF_ODD) |
708 | size--; |
709 | if (size < 0) { |
710 | av_log(avctx, AV_LOG_ERROR, |
711 | "Got incorrect block %02X with size %i\n", id, size); |
712 | break; |
713 | } |
714 | if (bytestream2_get_bytes_left(&gb) < ssize) { |
715 | av_log(avctx, AV_LOG_ERROR, |
716 | "Block size %i is out of bounds\n", size); |
717 | break; |
718 | } |
719 | switch (id & WP_IDF_MASK) { |
720 | case WP_ID_DECTERMS: |
721 | if (size > MAX_TERMS) { |
722 | av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n"); |
723 | s->terms = 0; |
724 | bytestream2_skip(&gb, ssize); |
725 | continue; |
726 | } |
727 | s->terms = size; |
728 | for (i = 0; i < s->terms; i++) { |
729 | uint8_t val = bytestream2_get_byte(&gb); |
730 | s->decorr[s->terms - i - 1].value = (val & 0x1F) - 5; |
731 | s->decorr[s->terms - i - 1].delta = val >> 5; |
732 | } |
733 | got_terms = 1; |
734 | break; |
735 | case WP_ID_DECWEIGHTS: |
736 | if (!got_terms) { |
737 | av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n"); |
738 | continue; |
739 | } |
740 | weights = size >> s->stereo_in; |
741 | if (weights > MAX_TERMS || weights > s->terms) { |
742 | av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n"); |
743 | bytestream2_skip(&gb, ssize); |
744 | continue; |
745 | } |
746 | for (i = 0; i < weights; i++) { |
747 | t = (int8_t)bytestream2_get_byte(&gb); |
748 | s->decorr[s->terms - i - 1].weightA = t * (1 << 3); |
749 | if (s->decorr[s->terms - i - 1].weightA > 0) |
750 | s->decorr[s->terms - i - 1].weightA += |
751 | (s->decorr[s->terms - i - 1].weightA + 64) >> 7; |
752 | if (s->stereo_in) { |
753 | t = (int8_t)bytestream2_get_byte(&gb); |
754 | s->decorr[s->terms - i - 1].weightB = t * (1 << 3); |
755 | if (s->decorr[s->terms - i - 1].weightB > 0) |
756 | s->decorr[s->terms - i - 1].weightB += |
757 | (s->decorr[s->terms - i - 1].weightB + 64) >> 7; |
758 | } |
759 | } |
760 | got_weights = 1; |
761 | break; |
762 | case WP_ID_DECSAMPLES: |
763 | if (!got_terms) { |
764 | av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n"); |
765 | continue; |
766 | } |
767 | t = 0; |
768 | for (i = s->terms - 1; (i >= 0) && (t < size); i--) { |
769 | if (s->decorr[i].value > 8) { |
770 | s->decorr[i].samplesA[0] = |
771 | wp_exp2(bytestream2_get_le16(&gb)); |
772 | s->decorr[i].samplesA[1] = |
773 | wp_exp2(bytestream2_get_le16(&gb)); |
774 | |
775 | if (s->stereo_in) { |
776 | s->decorr[i].samplesB[0] = |
777 | wp_exp2(bytestream2_get_le16(&gb)); |
778 | s->decorr[i].samplesB[1] = |
779 | wp_exp2(bytestream2_get_le16(&gb)); |
780 | t += 4; |
781 | } |
782 | t += 4; |
783 | } else if (s->decorr[i].value < 0) { |
784 | s->decorr[i].samplesA[0] = |
785 | wp_exp2(bytestream2_get_le16(&gb)); |
786 | s->decorr[i].samplesB[0] = |
787 | wp_exp2(bytestream2_get_le16(&gb)); |
788 | t += 4; |
789 | } else { |
790 | for (j = 0; j < s->decorr[i].value; j++) { |
791 | s->decorr[i].samplesA[j] = |
792 | wp_exp2(bytestream2_get_le16(&gb)); |
793 | if (s->stereo_in) { |
794 | s->decorr[i].samplesB[j] = |
795 | wp_exp2(bytestream2_get_le16(&gb)); |
796 | } |
797 | } |
798 | t += s->decorr[i].value * 2 * (s->stereo_in + 1); |
799 | } |
800 | } |
801 | got_samples = 1; |
802 | break; |
803 | case WP_ID_ENTROPY: |
804 | if (size != 6 * (s->stereo_in + 1)) { |
805 | av_log(avctx, AV_LOG_ERROR, |
806 | "Entropy vars size should be %i, got %i.\n", |
807 | 6 * (s->stereo_in + 1), size); |
808 | bytestream2_skip(&gb, ssize); |
809 | continue; |
810 | } |
811 | for (j = 0; j <= s->stereo_in; j++) |
812 | for (i = 0; i < 3; i++) { |
813 | s->ch[j].median[i] = wp_exp2(bytestream2_get_le16(&gb)); |
814 | } |
815 | got_entropy = 1; |
816 | break; |
817 | case WP_ID_HYBRID: |
818 | if (s->hybrid_bitrate) { |
819 | for (i = 0; i <= s->stereo_in; i++) { |
820 | s->ch[i].slow_level = wp_exp2(bytestream2_get_le16(&gb)); |
821 | size -= 2; |
822 | } |
823 | } |
824 | for (i = 0; i < (s->stereo_in + 1); i++) { |
825 | s->ch[i].bitrate_acc = bytestream2_get_le16(&gb) << 16; |
826 | size -= 2; |
827 | } |
828 | if (size > 0) { |
829 | for (i = 0; i < (s->stereo_in + 1); i++) { |
830 | s->ch[i].bitrate_delta = |
831 | wp_exp2((int16_t)bytestream2_get_le16(&gb)); |
832 | } |
833 | } else { |
834 | for (i = 0; i < (s->stereo_in + 1); i++) |
835 | s->ch[i].bitrate_delta = 0; |
836 | } |
837 | got_hybrid = 1; |
838 | break; |
839 | case WP_ID_INT32INFO: { |
840 | uint8_t val[4]; |
841 | if (size != 4) { |
842 | av_log(avctx, AV_LOG_ERROR, |
843 | "Invalid INT32INFO, size = %i\n", |
844 | size); |
845 | bytestream2_skip(&gb, ssize - 4); |
846 | continue; |
847 | } |
848 | bytestream2_get_buffer(&gb, val, 4); |
849 | if (val[0] > 31) { |
850 | av_log(avctx, AV_LOG_ERROR, |
851 | "Invalid INT32INFO, extra_bits = %d (> 32)\n", val[0]); |
852 | continue; |
853 | } else if (val[0]) { |
854 | s->extra_bits = val[0]; |
855 | } else if (val[1]) { |
856 | s->shift = val[1]; |
857 | } else if (val[2]) { |
858 | s->and = s->or = 1; |
859 | s->shift = val[2]; |
860 | } else if (val[3]) { |
861 | s->and = 1; |
862 | s->shift = val[3]; |
863 | } |
864 | if (s->shift > 31) { |
865 | av_log(avctx, AV_LOG_ERROR, |
866 | "Invalid INT32INFO, shift = %d (> 31)\n", s->shift); |
867 | s->and = s->or = s->shift = 0; |
868 | continue; |
869 | } |
870 | /* original WavPack decoder forces 32-bit lossy sound to be treated |
871 | * as 24-bit one in order to have proper clipping */ |
872 | if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) { |
873 | s->post_shift += 8; |
874 | s->shift -= 8; |
875 | s->hybrid_maxclip >>= 8; |
876 | s->hybrid_minclip >>= 8; |
877 | } |
878 | break; |
879 | } |
880 | case WP_ID_FLOATINFO: |
881 | if (size != 4) { |
882 | av_log(avctx, AV_LOG_ERROR, |
883 | "Invalid FLOATINFO, size = %i\n", size); |
884 | bytestream2_skip(&gb, ssize); |
885 | continue; |
886 | } |
887 | s->float_flag = bytestream2_get_byte(&gb); |
888 | s->float_shift = bytestream2_get_byte(&gb); |
889 | s->float_max_exp = bytestream2_get_byte(&gb); |
890 | got_float = 1; |
891 | bytestream2_skip(&gb, 1); |
892 | break; |
893 | case WP_ID_DATA: |
894 | s->sc.offset = bytestream2_tell(&gb); |
895 | s->sc.size = size * 8; |
896 | if ((ret = init_get_bits8(&s->gb, gb.buffer, size)) < 0) |
897 | return ret; |
898 | s->data_size = size * 8; |
899 | bytestream2_skip(&gb, size); |
900 | got_bs = 1; |
901 | break; |
902 | case WP_ID_EXTRABITS: |
903 | if (size <= 4) { |
904 | av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", |
905 | size); |
906 | bytestream2_skip(&gb, size); |
907 | continue; |
908 | } |
909 | s->extra_sc.offset = bytestream2_tell(&gb); |
910 | s->extra_sc.size = size * 8; |
911 | if ((ret = init_get_bits8(&s->gb_extra_bits, gb.buffer, size)) < 0) |
912 | return ret; |
913 | s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32); |
914 | bytestream2_skip(&gb, size); |
915 | s->got_extra_bits = 1; |
916 | break; |
917 | case WP_ID_CHANINFO: |
918 | if (size <= 1) { |
919 | av_log(avctx, AV_LOG_ERROR, |
920 | "Insufficient channel information\n"); |
921 | return AVERROR_INVALIDDATA; |
922 | } |
923 | chan = bytestream2_get_byte(&gb); |
924 | switch (size - 2) { |
925 | case 0: |
926 | chmask = bytestream2_get_byte(&gb); |
927 | break; |
928 | case 1: |
929 | chmask = bytestream2_get_le16(&gb); |
930 | break; |
931 | case 2: |
932 | chmask = bytestream2_get_le24(&gb); |
933 | break; |
934 | case 3: |
935 | chmask = bytestream2_get_le32(&gb); |
936 | break; |
937 | case 5: |
938 | size = bytestream2_get_byte(&gb); |
939 | if (avctx->channels != size) |
940 | av_log(avctx, AV_LOG_WARNING, "%i channels signalled" |
941 | " instead of %i.\n", size, avctx->channels); |
942 | chan |= (bytestream2_get_byte(&gb) & 0xF) << 8; |
943 | chmask = bytestream2_get_le16(&gb); |
944 | break; |
945 | default: |
946 | av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", |
947 | size); |
948 | chan = avctx->channels; |
949 | chmask = avctx->channel_layout; |
950 | } |
951 | break; |
952 | case WP_ID_SAMPLE_RATE: |
953 | if (size != 3) { |
954 | av_log(avctx, AV_LOG_ERROR, "Invalid custom sample rate.\n"); |
955 | return AVERROR_INVALIDDATA; |
956 | } |
957 | sample_rate = bytestream2_get_le24(&gb); |
958 | break; |
959 | default: |
960 | bytestream2_skip(&gb, size); |
961 | } |
962 | if (id & WP_IDF_ODD) |
963 | bytestream2_skip(&gb, 1); |
964 | } |
965 | |
966 | if (!got_terms) { |
967 | av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n"); |
968 | return AVERROR_INVALIDDATA; |
969 | } |
970 | if (!got_weights) { |
971 | av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n"); |
972 | return AVERROR_INVALIDDATA; |
973 | } |
974 | if (!got_samples) { |
975 | av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n"); |
976 | return AVERROR_INVALIDDATA; |
977 | } |
978 | if (!got_entropy) { |
979 | av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n"); |
980 | return AVERROR_INVALIDDATA; |
981 | } |
982 | if (s->hybrid && !got_hybrid) { |
983 | av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n"); |
984 | return AVERROR_INVALIDDATA; |
985 | } |
986 | if (!got_bs) { |
987 | av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n"); |
988 | return AVERROR_INVALIDDATA; |
989 | } |
990 | if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) { |
991 | av_log(avctx, AV_LOG_ERROR, "Float information not found\n"); |
992 | return AVERROR_INVALIDDATA; |
993 | } |
994 | if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) { |
995 | const int size = get_bits_left(&s->gb_extra_bits); |
996 | const int wanted = s->samples * s->extra_bits << s->stereo_in; |
997 | if (size < wanted) { |
998 | av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n"); |
999 | s->got_extra_bits = 0; |
1000 | } |
1001 | } |
1002 | |
1003 | if (!wc->ch_offset) { |
1004 | int sr = (s->frame_flags >> 23) & 0xf; |
1005 | if (sr == 0xf) { |
1006 | if (!sample_rate) { |
1007 | av_log(avctx, AV_LOG_ERROR, "Custom sample rate missing.\n"); |
1008 | return AVERROR_INVALIDDATA; |
1009 | } |
1010 | avctx->sample_rate = sample_rate; |
1011 | } else |
1012 | avctx->sample_rate = wv_rates[sr]; |
1013 | |
1014 | if (multiblock) { |
1015 | if (chan) |
1016 | avctx->channels = chan; |
1017 | if (chmask) |
1018 | avctx->channel_layout = chmask; |
1019 | } else { |
1020 | avctx->channels = s->stereo ? 2 : 1; |
1021 | avctx->channel_layout = s->stereo ? AV_CH_LAYOUT_STEREO : |
1022 | AV_CH_LAYOUT_MONO; |
1023 | } |
1024 | |
1025 | /* get output buffer */ |
1026 | frame->nb_samples = s->samples + 1; |
1027 | if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0) |
1028 | return ret; |
1029 | frame->nb_samples = s->samples; |
1030 | } |
1031 | |
1032 | if (wc->ch_offset + s->stereo >= avctx->channels) { |
1033 | av_log(avctx, AV_LOG_WARNING, "Too many channels coded in a packet.\n"); |
1034 | return ((avctx->err_recognition & AV_EF_EXPLODE) || !wc->ch_offset) ? AVERROR_INVALIDDATA : 0; |
1035 | } |
1036 | |
1037 | samples_l = frame->extended_data[wc->ch_offset]; |
1038 | if (s->stereo) |
1039 | samples_r = frame->extended_data[wc->ch_offset + 1]; |
1040 | |
1041 | wc->ch_offset += 1 + s->stereo; |
1042 | |
1043 | if (s->stereo_in) { |
1044 | ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt); |
1045 | if (ret < 0) |
1046 | return ret; |
1047 | } else { |
1048 | ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt); |
1049 | if (ret < 0) |
1050 | return ret; |
1051 | |
1052 | if (s->stereo) |
1053 | memcpy(samples_r, samples_l, bpp * s->samples); |
1054 | } |
1055 | |
1056 | return 0; |
1057 | } |
1058 | |
1059 | static void wavpack_decode_flush(AVCodecContext *avctx) |
1060 | { |
1061 | WavpackContext *s = avctx->priv_data; |
1062 | int i; |
1063 | |
1064 | for (i = 0; i < s->fdec_num; i++) |
1065 | wv_reset_saved_context(s->fdec[i]); |
1066 | } |
1067 | |
1068 | static int wavpack_decode_frame(AVCodecContext *avctx, void *data, |
1069 | int *got_frame_ptr, AVPacket *avpkt) |
1070 | { |
1071 | WavpackContext *s = avctx->priv_data; |
1072 | const uint8_t *buf = avpkt->data; |
1073 | int buf_size = avpkt->size; |
1074 | AVFrame *frame = data; |
1075 | int frame_size, ret, frame_flags; |
1076 | |
1077 | if (avpkt->size <= WV_HEADER_SIZE) |
1078 | return AVERROR_INVALIDDATA; |
1079 | |
1080 | s->block = 0; |
1081 | s->ch_offset = 0; |
1082 | |
1083 | /* determine number of samples */ |
1084 | s->samples = AV_RL32(buf + 20); |
1085 | frame_flags = AV_RL32(buf + 24); |
1086 | if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) { |
1087 | av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n", |
1088 | s->samples); |
1089 | return AVERROR_INVALIDDATA; |
1090 | } |
1091 | |
1092 | if (frame_flags & 0x80) { |
1093 | avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; |
1094 | } else if ((frame_flags & 0x03) <= 1) { |
1095 | avctx->sample_fmt = AV_SAMPLE_FMT_S16P; |
1096 | } else { |
1097 | avctx->sample_fmt = AV_SAMPLE_FMT_S32P; |
1098 | avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3; |
1099 | } |
1100 | |
1101 | while (buf_size > 0) { |
1102 | if (buf_size <= WV_HEADER_SIZE) |
1103 | break; |
1104 | frame_size = AV_RL32(buf + 4) - 12; |
1105 | buf += 20; |
1106 | buf_size -= 20; |
1107 | if (frame_size <= 0 || frame_size > buf_size) { |
1108 | av_log(avctx, AV_LOG_ERROR, |
1109 | "Block %d has invalid size (size %d vs. %d bytes left)\n", |
1110 | s->block, frame_size, buf_size); |
1111 | wavpack_decode_flush(avctx); |
1112 | return AVERROR_INVALIDDATA; |
1113 | } |
1114 | if ((ret = wavpack_decode_block(avctx, s->block, |
1115 | frame, buf, frame_size)) < 0) { |
1116 | wavpack_decode_flush(avctx); |
1117 | return ret; |
1118 | } |
1119 | s->block++; |
1120 | buf += frame_size; |
1121 | buf_size -= frame_size; |
1122 | } |
1123 | |
1124 | if (s->ch_offset != avctx->channels) { |
1125 | av_log(avctx, AV_LOG_ERROR, "Not enough channels coded in a packet.\n"); |
1126 | return AVERROR_INVALIDDATA; |
1127 | } |
1128 | |
1129 | *got_frame_ptr = 1; |
1130 | |
1131 | return avpkt->size; |
1132 | } |
1133 | |
1134 | AVCodec ff_wavpack_decoder = { |
1135 | .name = "wavpack", |
1136 | .long_name = NULL_IF_CONFIG_SMALL("WavPack"), |
1137 | .type = AVMEDIA_TYPE_AUDIO, |
1138 | .id = AV_CODEC_ID_WAVPACK, |
1139 | .priv_data_size = sizeof(WavpackContext), |
1140 | .init = wavpack_decode_init, |
1141 | .close = wavpack_decode_end, |
1142 | .decode = wavpack_decode_frame, |
1143 | .flush = wavpack_decode_flush, |
1144 | .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy), |
1145 | .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, |
1146 | }; |
1147 |