FFmpeg
wavpack.c
Go to the documentation of this file.
1 /*
2  * WavPack lossless audio decoder
3  * Copyright (c) 2006,2011 Konstantin Shishkov
4  * Copyright (c) 2020 David Bryant
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
24 
25 #define BITSTREAM_READER_LE
26 #include "avcodec.h"
27 #include "bytestream.h"
28 #include "get_bits.h"
29 #include "internal.h"
30 #include "thread.h"
31 #include "unary.h"
32 #include "wavpack.h"
33 #include "dsd.h"
34 
35 /**
36  * @file
37  * WavPack lossless audio decoder
38  */
39 
40 #define DSD_BYTE_READY(low,high) (!(((low) ^ (high)) & 0xff000000))
41 
42 #define PTABLE_BITS 8
43 #define PTABLE_BINS (1<<PTABLE_BITS)
44 #define PTABLE_MASK (PTABLE_BINS-1)
45 
46 #define UP 0x010000fe
47 #define DOWN 0x00010000
48 #define DECAY 8
49 
50 #define PRECISION 20
51 #define VALUE_ONE (1 << PRECISION)
52 #define PRECISION_USE 12
53 
54 #define RATE_S 20
55 
56 #define MAX_HISTORY_BITS 5
57 #define MAX_HISTORY_BINS (1 << MAX_HISTORY_BITS)
58 #define MAX_BIN_BYTES 1280 // for value_lookup, per bin (2k - 512 - 256)
59 
60 typedef enum {
61  MODULATION_PCM, // pulse code modulation
62  MODULATION_DSD // pulse density modulation (aka DSD)
63 } Modulation;
64 
65 typedef struct WavpackFrameContext {
69  int joint;
70  uint32_t CRC;
73  uint32_t crc_extra_bits;
75  int samples;
76  int terms;
78  int zero, one, zeroes;
80  int and, or, shift;
88 
96 
97 #define WV_MAX_FRAME_DECODERS 14
98 
99 typedef struct WavpackContext {
101 
103  int fdec_num;
104 
105  int block;
106  int samples;
108 
110  ThreadFrame curr_frame, prev_frame;
114 
115 #define LEVEL_DECAY(a) (((a) + 0x80) >> 8)
116 
117 static av_always_inline unsigned get_tail(GetBitContext *gb, int k)
118 {
119  int p, e, res;
120 
121  if (k < 1)
122  return 0;
123  p = av_log2(k);
124  e = (1 << (p + 1)) - k - 1;
125  res = get_bitsz(gb, p);
126  if (res >= e)
127  res = (res << 1) - e + get_bits1(gb);
128  return res;
129 }
130 
132 {
133  int i, br[2], sl[2];
134 
135  for (i = 0; i <= ctx->stereo_in; i++) {
136  if (ctx->ch[i].bitrate_acc > UINT_MAX - ctx->ch[i].bitrate_delta)
137  return AVERROR_INVALIDDATA;
138  ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
139  br[i] = ctx->ch[i].bitrate_acc >> 16;
140  sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
141  }
142  if (ctx->stereo_in && ctx->hybrid_bitrate) {
143  int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
144  if (balance > br[0]) {
145  br[1] = br[0] * 2;
146  br[0] = 0;
147  } else if (-balance > br[0]) {
148  br[0] *= 2;
149  br[1] = 0;
150  } else {
151  br[1] = br[0] + balance;
152  br[0] = br[0] - balance;
153  }
154  }
155  for (i = 0; i <= ctx->stereo_in; i++) {
156  if (ctx->hybrid_bitrate) {
157  if (sl[i] - br[i] > -0x100)
158  ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
159  else
160  ctx->ch[i].error_limit = 0;
161  } else {
162  ctx->ch[i].error_limit = wp_exp2(br[i]);
163  }
164  }
165 
166  return 0;
167 }
168 
170  int channel, int *last)
171 {
172  int t, t2;
173  int sign, base, add, ret;
174  WvChannel *c = &ctx->ch[channel];
175 
176  *last = 0;
177 
178  if ((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) &&
179  !ctx->zero && !ctx->one) {
180  if (ctx->zeroes) {
181  ctx->zeroes--;
182  if (ctx->zeroes) {
184  return 0;
185  }
186  } else {
187  t = get_unary_0_33(gb);
188  if (t >= 2) {
189  if (t >= 32 || get_bits_left(gb) < t - 1)
190  goto error;
191  t = get_bits_long(gb, t - 1) | (1 << (t - 1));
192  } else {
193  if (get_bits_left(gb) < 0)
194  goto error;
195  }
196  ctx->zeroes = t;
197  if (ctx->zeroes) {
198  memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
199  memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
201  return 0;
202  }
203  }
204  }
205 
206  if (ctx->zero) {
207  t = 0;
208  ctx->zero = 0;
209  } else {
210  t = get_unary_0_33(gb);
211  if (get_bits_left(gb) < 0)
212  goto error;
213  if (t == 16) {
214  t2 = get_unary_0_33(gb);
215  if (t2 < 2) {
216  if (get_bits_left(gb) < 0)
217  goto error;
218  t += t2;
219  } else {
220  if (t2 >= 32 || get_bits_left(gb) < t2 - 1)
221  goto error;
222  t += get_bits_long(gb, t2 - 1) | (1 << (t2 - 1));
223  }
224  }
225 
226  if (ctx->one) {
227  ctx->one = t & 1;
228  t = (t >> 1) + 1;
229  } else {
230  ctx->one = t & 1;
231  t >>= 1;
232  }
233  ctx->zero = !ctx->one;
234  }
235 
236  if (ctx->hybrid && !channel) {
237  if (update_error_limit(ctx) < 0)
238  goto error;
239  }
240 
241  if (!t) {
242  base = 0;
243  add = GET_MED(0) - 1;
244  DEC_MED(0);
245  } else if (t == 1) {
246  base = GET_MED(0);
247  add = GET_MED(1) - 1;
248  INC_MED(0);
249  DEC_MED(1);
250  } else if (t == 2) {
251  base = GET_MED(0) + GET_MED(1);
252  add = GET_MED(2) - 1;
253  INC_MED(0);
254  INC_MED(1);
255  DEC_MED(2);
256  } else {
257  base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2U);
258  add = GET_MED(2) - 1;
259  INC_MED(0);
260  INC_MED(1);
261  INC_MED(2);
262  }
263  if (!c->error_limit) {
264  if (add >= 0x2000000U) {
265  av_log(ctx->avctx, AV_LOG_ERROR, "k %d is too large\n", add);
266  goto error;
267  }
268  ret = base + get_tail(gb, add);
269  if (get_bits_left(gb) <= 0)
270  goto error;
271  } else {
272  int mid = (base * 2U + add + 1) >> 1;
273  while (add > c->error_limit) {
274  if (get_bits_left(gb) <= 0)
275  goto error;
276  if (get_bits1(gb)) {
277  add -= (mid - (unsigned)base);
278  base = mid;
279  } else
280  add = mid - (unsigned)base - 1;
281  mid = (base * 2U + add + 1) >> 1;
282  }
283  ret = mid;
284  }
285  sign = get_bits1(gb);
286  if (ctx->hybrid_bitrate)
287  c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
288  return sign ? ~ret : ret;
289 
290 error:
291  ret = get_bits_left(gb);
292  if (ret <= 0) {
293  av_log(ctx->avctx, AV_LOG_ERROR, "Too few bits (%d) left\n", ret);
294  }
295  *last = 1;
296  return 0;
297 }
298 
299 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
300  unsigned S)
301 {
302  unsigned bit;
303 
304  if (s->extra_bits) {
305  S *= 1 << s->extra_bits;
306 
307  if (s->got_extra_bits &&
309  S |= get_bits_long(&s->gb_extra_bits, s->extra_bits);
310  *crc = *crc * 9 + (S & 0xffff) * 3 + ((unsigned)S >> 16);
311  }
312  }
313 
314  bit = (S & s->and) | s->or;
315  bit = ((S + bit) << s->shift) - bit;
316 
317  if (s->hybrid)
318  bit = av_clip(bit, s->hybrid_minclip, s->hybrid_maxclip);
319 
320  return bit << s->post_shift;
321 }
322 
323 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
324 {
325  union {
326  float f;
327  uint32_t u;
328  } value;
329 
330  unsigned int sign;
331  int exp = s->float_max_exp;
332 
333  if (s->got_extra_bits) {
334  const int max_bits = 1 + 23 + 8 + 1;
335  const int left_bits = get_bits_left(&s->gb_extra_bits);
336 
337  if (left_bits + 8 * AV_INPUT_BUFFER_PADDING_SIZE < max_bits)
338  return 0.0;
339  }
340 
341  if (S) {
342  S *= 1U << s->float_shift;
343  sign = S < 0;
344  if (sign)
345  S = -(unsigned)S;
346  if (S >= 0x1000000U) {
347  if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
348  S = get_bits(&s->gb_extra_bits, 23);
349  else
350  S = 0;
351  exp = 255;
352  } else if (exp) {
353  int shift = 23 - av_log2(S);
354  exp = s->float_max_exp;
355  if (exp <= shift)
356  shift = --exp;
357  exp -= shift;
358 
359  if (shift) {
360  S <<= shift;
361  if ((s->float_flag & WV_FLT_SHIFT_ONES) ||
362  (s->got_extra_bits &&
363  (s->float_flag & WV_FLT_SHIFT_SAME) &&
364  get_bits1(&s->gb_extra_bits))) {
365  S |= (1 << shift) - 1;
366  } else if (s->got_extra_bits &&
367  (s->float_flag & WV_FLT_SHIFT_SENT)) {
368  S |= get_bits(&s->gb_extra_bits, shift);
369  }
370  }
371  } else {
372  exp = s->float_max_exp;
373  }
374  S &= 0x7fffff;
375  } else {
376  sign = 0;
377  exp = 0;
378  if (s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)) {
379  if (get_bits1(&s->gb_extra_bits)) {
380  S = get_bits(&s->gb_extra_bits, 23);
381  if (s->float_max_exp >= 25)
382  exp = get_bits(&s->gb_extra_bits, 8);
383  sign = get_bits1(&s->gb_extra_bits);
384  } else {
385  if (s->float_flag & WV_FLT_ZERO_SIGN)
386  sign = get_bits1(&s->gb_extra_bits);
387  }
388  }
389  }
390 
391  *crc = *crc * 27 + S * 9 + exp * 3 + sign;
392 
393  value.u = (sign << 31) | (exp << 23) | S;
394  return value.f;
395 }
396 
397 static inline int wv_check_crc(WavpackFrameContext *s, uint32_t crc,
398  uint32_t crc_extra_bits)
399 {
400  if (crc != s->CRC) {
401  av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
402  return AVERROR_INVALIDDATA;
403  }
404  if (s->got_extra_bits && crc_extra_bits != s->crc_extra_bits) {
405  av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
406  return AVERROR_INVALIDDATA;
407  }
408 
409  return 0;
410 }
411 
412 static void init_ptable(int *table, int rate_i, int rate_s)
413 {
414  int value = 0x808000, rate = rate_i << 8;
415 
416  for (int c = (rate + 128) >> 8; c--;)
417  value += (DOWN - value) >> DECAY;
418 
419  for (int i = 0; i < PTABLE_BINS/2; i++) {
420  table[i] = value;
421  table[PTABLE_BINS-1-i] = 0x100ffff - value;
422 
423  if (value > 0x010000) {
424  rate += (rate * rate_s + 128) >> 8;
425 
426  for (int c = (rate + 64) >> 7; c--;)
427  value += (DOWN - value) >> DECAY;
428  }
429  }
430 }
431 
432 typedef struct {
433  int32_t value, fltr0, fltr1, fltr2, fltr3, fltr4, fltr5, fltr6, factor;
434  unsigned int byte;
435 } DSDfilters;
436 
437 static int wv_unpack_dsd_high(WavpackFrameContext *s, uint8_t *dst_left, uint8_t *dst_right)
438 {
439  uint32_t checksum = 0xFFFFFFFF;
440  uint8_t *dst_l = dst_left, *dst_r = dst_right;
441  int total_samples = s->samples, stereo = dst_r ? 1 : 0;
442  DSDfilters filters[2], *sp = filters;
443  int rate_i, rate_s;
444  uint32_t low, high, value;
445 
446  if (bytestream2_get_bytes_left(&s->gbyte) < (stereo ? 20 : 13))
447  return AVERROR_INVALIDDATA;
448 
449  rate_i = bytestream2_get_byte(&s->gbyte);
450  rate_s = bytestream2_get_byte(&s->gbyte);
451 
452  if (rate_s != RATE_S)
453  return AVERROR_INVALIDDATA;
454 
455  init_ptable(s->ptable, rate_i, rate_s);
456 
457  for (int channel = 0; channel < stereo + 1; channel++) {
458  DSDfilters *sp = filters + channel;
459 
460  sp->fltr1 = bytestream2_get_byte(&s->gbyte) << (PRECISION - 8);
461  sp->fltr2 = bytestream2_get_byte(&s->gbyte) << (PRECISION - 8);
462  sp->fltr3 = bytestream2_get_byte(&s->gbyte) << (PRECISION - 8);
463  sp->fltr4 = bytestream2_get_byte(&s->gbyte) << (PRECISION - 8);
464  sp->fltr5 = bytestream2_get_byte(&s->gbyte) << (PRECISION - 8);
465  sp->fltr6 = 0;
466  sp->factor = bytestream2_get_byte(&s->gbyte) & 0xff;
467  sp->factor |= (bytestream2_get_byte(&s->gbyte) << 8) & 0xff00;
468  sp->factor = (int32_t)((uint32_t)sp->factor << 16) >> 16;
469  }
470 
471  value = bytestream2_get_be32(&s->gbyte);
472  high = 0xffffffff;
473  low = 0x0;
474 
475  while (total_samples--) {
476  int bitcount = 8;
477 
478  sp[0].value = sp[0].fltr1 - sp[0].fltr5 + ((sp[0].fltr6 * sp[0].factor) >> 2);
479 
480  if (stereo)
481  sp[1].value = sp[1].fltr1 - sp[1].fltr5 + ((sp[1].fltr6 * sp[1].factor) >> 2);
482 
483  while (bitcount--) {
484  int32_t *pp = s->ptable + ((sp[0].value >> (PRECISION - PRECISION_USE)) & PTABLE_MASK);
485  uint32_t split = low + ((high - low) >> 8) * (*pp >> 16);
486 
487  if (value <= split) {
488  high = split;
489  *pp += (UP - *pp) >> DECAY;
490  sp[0].fltr0 = -1;
491  } else {
492  low = split + 1;
493  *pp += (DOWN - *pp) >> DECAY;
494  sp[0].fltr0 = 0;
495  }
496 
497  while (DSD_BYTE_READY(high, low) && bytestream2_get_bytes_left(&s->gbyte)) {
498  value = (value << 8) | bytestream2_get_byte(&s->gbyte);
499  high = (high << 8) | 0xff;
500  low <<= 8;
501  }
502 
503  sp[0].value += sp[0].fltr6 * 8;
504  sp[0].byte = (sp[0].byte << 1) | (sp[0].fltr0 & 1);
505  sp[0].factor += (((sp[0].value ^ sp[0].fltr0) >> 31) | 1) &
506  ((sp[0].value ^ (sp[0].value - (sp[0].fltr6 * 16))) >> 31);
507  sp[0].fltr1 += ((sp[0].fltr0 & VALUE_ONE) - sp[0].fltr1) >> 6;
508  sp[0].fltr2 += ((sp[0].fltr0 & VALUE_ONE) - sp[0].fltr2) >> 4;
509  sp[0].fltr3 += (sp[0].fltr2 - sp[0].fltr3) >> 4;
510  sp[0].fltr4 += (sp[0].fltr3 - sp[0].fltr4) >> 4;
511  sp[0].value = (sp[0].fltr4 - sp[0].fltr5) >> 4;
512  sp[0].fltr5 += sp[0].value;
513  sp[0].fltr6 += (sp[0].value - sp[0].fltr6) >> 3;
514  sp[0].value = sp[0].fltr1 - sp[0].fltr5 + ((sp[0].fltr6 * sp[0].factor) >> 2);
515 
516  if (!stereo)
517  continue;
518 
519  pp = s->ptable + ((sp[1].value >> (PRECISION - PRECISION_USE)) & PTABLE_MASK);
520  split = low + ((high - low) >> 8) * (*pp >> 16);
521 
522  if (value <= split) {
523  high = split;
524  *pp += (UP - *pp) >> DECAY;
525  sp[1].fltr0 = -1;
526  } else {
527  low = split + 1;
528  *pp += (DOWN - *pp) >> DECAY;
529  sp[1].fltr0 = 0;
530  }
531 
532  while (DSD_BYTE_READY(high, low) && bytestream2_get_bytes_left(&s->gbyte)) {
533  value = (value << 8) | bytestream2_get_byte(&s->gbyte);
534  high = (high << 8) | 0xff;
535  low <<= 8;
536  }
537 
538  sp[1].value += sp[1].fltr6 * 8;
539  sp[1].byte = (sp[1].byte << 1) | (sp[1].fltr0 & 1);
540  sp[1].factor += (((sp[1].value ^ sp[1].fltr0) >> 31) | 1) &
541  ((sp[1].value ^ (sp[1].value - (sp[1].fltr6 * 16))) >> 31);
542  sp[1].fltr1 += ((sp[1].fltr0 & VALUE_ONE) - sp[1].fltr1) >> 6;
543  sp[1].fltr2 += ((sp[1].fltr0 & VALUE_ONE) - sp[1].fltr2) >> 4;
544  sp[1].fltr3 += (sp[1].fltr2 - sp[1].fltr3) >> 4;
545  sp[1].fltr4 += (sp[1].fltr3 - sp[1].fltr4) >> 4;
546  sp[1].value = (sp[1].fltr4 - sp[1].fltr5) >> 4;
547  sp[1].fltr5 += sp[1].value;
548  sp[1].fltr6 += (sp[1].value - sp[1].fltr6) >> 3;
549  sp[1].value = sp[1].fltr1 - sp[1].fltr5 + ((sp[1].fltr6 * sp[1].factor) >> 2);
550  }
551 
552  checksum += (checksum << 1) + (*dst_l = sp[0].byte & 0xff);
553  sp[0].factor -= (sp[0].factor + 512) >> 10;
554  dst_l += 4;
555 
556  if (stereo) {
557  checksum += (checksum << 1) + (*dst_r = filters[1].byte & 0xff);
558  filters[1].factor -= (filters[1].factor + 512) >> 10;
559  dst_r += 4;
560  }
561  }
562 
563  if (wv_check_crc(s, checksum, 0)) {
565  return AVERROR_INVALIDDATA;
566 
567  memset(dst_left, 0x69, s->samples * 4);
568 
569  if (dst_r)
570  memset(dst_right, 0x69, s->samples * 4);
571  }
572 
573  return 0;
574 }
575 
576 static int wv_unpack_dsd_fast(WavpackFrameContext *s, uint8_t *dst_left, uint8_t *dst_right)
577 {
578  uint8_t *dst_l = dst_left, *dst_r = dst_right;
579  uint8_t history_bits, max_probability;
580  int total_summed_probabilities = 0;
581  int total_samples = s->samples;
582  uint8_t *vlb = s->value_lookup_buffer;
583  int history_bins, p0, p1, chan;
584  uint32_t checksum = 0xFFFFFFFF;
585  uint32_t low, high, value;
586 
588  return AVERROR_INVALIDDATA;
589 
590  history_bits = bytestream2_get_byte(&s->gbyte);
591 
592  if (!bytestream2_get_bytes_left(&s->gbyte) || history_bits > MAX_HISTORY_BITS)
593  return AVERROR_INVALIDDATA;
594 
595  history_bins = 1 << history_bits;
596  max_probability = bytestream2_get_byte(&s->gbyte);
597 
598  if (max_probability < 0xff) {
599  uint8_t *outptr = (uint8_t *)s->probabilities;
600  uint8_t *outend = outptr + sizeof(*s->probabilities) * history_bins;
601 
602  while (outptr < outend && bytestream2_get_bytes_left(&s->gbyte)) {
603  int code = bytestream2_get_byte(&s->gbyte);
604 
605  if (code > max_probability) {
606  int zcount = code - max_probability;
607 
608  while (outptr < outend && zcount--)
609  *outptr++ = 0;
610  } else if (code) {
611  *outptr++ = code;
612  }
613  else {
614  break;
615  }
616  }
617 
618  if (outptr < outend ||
619  (bytestream2_get_bytes_left(&s->gbyte) && bytestream2_get_byte(&s->gbyte)))
620  return AVERROR_INVALIDDATA;
621  } else if (bytestream2_get_bytes_left(&s->gbyte) > (int)sizeof(*s->probabilities) * history_bins) {
623  sizeof(*s->probabilities) * history_bins);
624  } else {
625  return AVERROR_INVALIDDATA;
626  }
627 
628  for (p0 = 0; p0 < history_bins; p0++) {
629  int32_t sum_values = 0;
630 
631  for (int i = 0; i < 256; i++)
632  s->summed_probabilities[p0][i] = sum_values += s->probabilities[p0][i];
633 
634  if (sum_values) {
635  total_summed_probabilities += sum_values;
636 
637  if (total_summed_probabilities > history_bins * MAX_BIN_BYTES)
638  return AVERROR_INVALIDDATA;
639 
640  s->value_lookup[p0] = vlb;
641 
642  for (int i = 0; i < 256; i++) {
643  int c = s->probabilities[p0][i];
644 
645  while (c--)
646  *vlb++ = i;
647  }
648  }
649  }
650 
651  if (bytestream2_get_bytes_left(&s->gbyte) < 4)
652  return AVERROR_INVALIDDATA;
653 
654  chan = p0 = p1 = 0;
655  low = 0; high = 0xffffffff;
656  value = bytestream2_get_be32(&s->gbyte);
657 
658  if (dst_r)
659  total_samples *= 2;
660 
661  while (total_samples--) {
662  unsigned int mult, index, code;
663 
664  if (!s->summed_probabilities[p0][255])
665  return AVERROR_INVALIDDATA;
666 
667  mult = (high - low) / s->summed_probabilities[p0][255];
668 
669  if (!mult) {
670  if (bytestream2_get_bytes_left(&s->gbyte) >= 4)
671  value = bytestream2_get_be32(&s->gbyte);
672 
673  low = 0;
674  high = 0xffffffff;
675  mult = high / s->summed_probabilities[p0][255];
676 
677  if (!mult)
678  return AVERROR_INVALIDDATA;
679  }
680 
681  index = (value - low) / mult;
682 
683  if (index >= s->summed_probabilities[p0][255])
684  return AVERROR_INVALIDDATA;
685 
686  if (!dst_r) {
687  if ((*dst_l = code = s->value_lookup[p0][index]))
688  low += s->summed_probabilities[p0][code-1] * mult;
689 
690  dst_l += 4;
691  } else {
692  if ((code = s->value_lookup[p0][index]))
693  low += s->summed_probabilities[p0][code-1] * mult;
694 
695  if (chan) {
696  *dst_r = code;
697  dst_r += 4;
698  }
699  else {
700  *dst_l = code;
701  dst_l += 4;
702  }
703 
704  chan ^= 1;
705  }
706 
707  high = low + s->probabilities[p0][code] * mult - 1;
708  checksum += (checksum << 1) + code;
709 
710  if (!dst_r) {
711  p0 = code & (history_bins-1);
712  } else {
713  p0 = p1;
714  p1 = code & (history_bins-1);
715  }
716 
717  while (DSD_BYTE_READY(high, low) && bytestream2_get_bytes_left(&s->gbyte)) {
718  value = (value << 8) | bytestream2_get_byte(&s->gbyte);
719  high = (high << 8) | 0xff;
720  low <<= 8;
721  }
722  }
723 
724  if (wv_check_crc(s, checksum, 0)) {
726  return AVERROR_INVALIDDATA;
727 
728  memset(dst_left, 0x69, s->samples * 4);
729 
730  if (dst_r)
731  memset(dst_right, 0x69, s->samples * 4);
732  }
733 
734  return 0;
735 }
736 
737 static int wv_unpack_dsd_copy(WavpackFrameContext *s, uint8_t *dst_left, uint8_t *dst_right)
738 {
739  uint8_t *dst_l = dst_left, *dst_r = dst_right;
740  int total_samples = s->samples;
741  uint32_t checksum = 0xFFFFFFFF;
742 
743  if (bytestream2_get_bytes_left(&s->gbyte) != total_samples * (dst_r ? 2 : 1))
744  return AVERROR_INVALIDDATA;
745 
746  while (total_samples--) {
747  checksum += (checksum << 1) + (*dst_l = bytestream2_get_byte(&s->gbyte));
748  dst_l += 4;
749 
750  if (dst_r) {
751  checksum += (checksum << 1) + (*dst_r = bytestream2_get_byte(&s->gbyte));
752  dst_r += 4;
753  }
754  }
755 
756  if (wv_check_crc(s, checksum, 0)) {
758  return AVERROR_INVALIDDATA;
759 
760  memset(dst_left, 0x69, s->samples * 4);
761 
762  if (dst_r)
763  memset(dst_right, 0x69, s->samples * 4);
764  }
765 
766  return 0;
767 }
768 
770  void *dst_l, void *dst_r, const int type)
771 {
772  int i, j, count = 0;
773  int last, t;
774  int A, B, L, L2, R, R2;
775  int pos = 0;
776  uint32_t crc = 0xFFFFFFFF;
777  uint32_t crc_extra_bits = 0xFFFFFFFF;
778  int16_t *dst16_l = dst_l;
779  int16_t *dst16_r = dst_r;
780  int32_t *dst32_l = dst_l;
781  int32_t *dst32_r = dst_r;
782  float *dstfl_l = dst_l;
783  float *dstfl_r = dst_r;
784 
785  s->one = s->zero = s->zeroes = 0;
786  do {
787  L = wv_get_value(s, gb, 0, &last);
788  if (last)
789  break;
790  R = wv_get_value(s, gb, 1, &last);
791  if (last)
792  break;
793  for (i = 0; i < s->terms; i++) {
794  t = s->decorr[i].value;
795  if (t > 0) {
796  if (t > 8) {
797  if (t & 1) {
798  A = 2U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
799  B = 2U * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
800  } else {
801  A = (int)(3U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
802  B = (int)(3U * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
803  }
804  s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
805  s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
806  j = 0;
807  } else {
808  A = s->decorr[i].samplesA[pos];
809  B = s->decorr[i].samplesB[pos];
810  j = (pos + t) & 7;
811  }
812  if (type != AV_SAMPLE_FMT_S16P) {
813  L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
814  R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
815  } else {
816  L2 = L + (unsigned)((int)(s->decorr[i].weightA * (unsigned)A + 512) >> 10);
817  R2 = R + (unsigned)((int)(s->decorr[i].weightB * (unsigned)B + 512) >> 10);
818  }
819  if (A && L)
820  s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
821  if (B && R)
822  s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
823  s->decorr[i].samplesA[j] = L = L2;
824  s->decorr[i].samplesB[j] = R = R2;
825  } else if (t == -1) {
826  if (type != AV_SAMPLE_FMT_S16P)
827  L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
828  else
829  L2 = L + (unsigned)((int)(s->decorr[i].weightA * (unsigned)s->decorr[i].samplesA[0] + 512) >> 10);
830  UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
831  L = L2;
832  if (type != AV_SAMPLE_FMT_S16P)
833  R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
834  else
835  R2 = R + (unsigned)((int)(s->decorr[i].weightB * (unsigned)L2 + 512) >> 10);
836  UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
837  R = R2;
838  s->decorr[i].samplesA[0] = R;
839  } else {
840  if (type != AV_SAMPLE_FMT_S16P)
841  R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
842  else
843  R2 = R + (unsigned)((int)(s->decorr[i].weightB * (unsigned)s->decorr[i].samplesB[0] + 512) >> 10);
844  UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
845  R = R2;
846 
847  if (t == -3) {
848  R2 = s->decorr[i].samplesA[0];
849  s->decorr[i].samplesA[0] = R;
850  }
851 
852  if (type != AV_SAMPLE_FMT_S16P)
853  L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
854  else
855  L2 = L + (unsigned)((int)(s->decorr[i].weightA * (unsigned)R2 + 512) >> 10);
856  UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
857  L = L2;
858  s->decorr[i].samplesB[0] = L;
859  }
860  }
861 
862  if (type == AV_SAMPLE_FMT_S16P) {
863  if (FFABS((int64_t)L) + FFABS((int64_t)R) > (1<<19)) {
864  av_log(s->avctx, AV_LOG_ERROR, "sample %d %d too large\n", L, R);
865  return AVERROR_INVALIDDATA;
866  }
867  }
868 
869  pos = (pos + 1) & 7;
870  if (s->joint)
871  L += (unsigned)(R -= (unsigned)(L >> 1));
872  crc = (crc * 3 + L) * 3 + R;
873 
874  if (type == AV_SAMPLE_FMT_FLTP) {
875  *dstfl_l++ = wv_get_value_float(s, &crc_extra_bits, L);
876  *dstfl_r++ = wv_get_value_float(s, &crc_extra_bits, R);
877  } else if (type == AV_SAMPLE_FMT_S32P) {
878  *dst32_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
879  *dst32_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
880  } else {
881  *dst16_l++ = wv_get_value_integer(s, &crc_extra_bits, L);
882  *dst16_r++ = wv_get_value_integer(s, &crc_extra_bits, R);
883  }
884  count++;
885  } while (!last && count < s->samples);
886 
887  if (last && count < s->samples) {
888  int size = av_get_bytes_per_sample(type);
889  memset((uint8_t*)dst_l + count*size, 0, (s->samples-count)*size);
890  memset((uint8_t*)dst_r + count*size, 0, (s->samples-count)*size);
891  }
892 
893  if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
894  wv_check_crc(s, crc, crc_extra_bits))
895  return AVERROR_INVALIDDATA;
896 
897  return 0;
898 }
899 
901  void *dst, const int type)
902 {
903  int i, j, count = 0;
904  int last, t;
905  int A, S, T;
906  int pos = 0;
907  uint32_t crc = 0xFFFFFFFF;
908  uint32_t crc_extra_bits = 0xFFFFFFFF;
909  int16_t *dst16 = dst;
910  int32_t *dst32 = dst;
911  float *dstfl = dst;
912 
913  s->one = s->zero = s->zeroes = 0;
914  do {
915  T = wv_get_value(s, gb, 0, &last);
916  S = 0;
917  if (last)
918  break;
919  for (i = 0; i < s->terms; i++) {
920  t = s->decorr[i].value;
921  if (t > 8) {
922  if (t & 1)
923  A = 2U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
924  else
925  A = (int)(3U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
926  s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
927  j = 0;
928  } else {
929  A = s->decorr[i].samplesA[pos];
930  j = (pos + t) & 7;
931  }
932  if (type != AV_SAMPLE_FMT_S16P)
933  S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
934  else
935  S = T + (unsigned)((int)(s->decorr[i].weightA * (unsigned)A + 512) >> 10);
936  if (A && T)
937  s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
938  s->decorr[i].samplesA[j] = T = S;
939  }
940  pos = (pos + 1) & 7;
941  crc = crc * 3 + S;
942 
943  if (type == AV_SAMPLE_FMT_FLTP) {
944  *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
945  } else if (type == AV_SAMPLE_FMT_S32P) {
946  *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
947  } else {
948  *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
949  }
950  count++;
951  } while (!last && count < s->samples);
952 
953  if (last && count < s->samples) {
954  int size = av_get_bytes_per_sample(type);
955  memset((uint8_t*)dst + count*size, 0, (s->samples-count)*size);
956  }
957 
959  int ret = wv_check_crc(s, crc, crc_extra_bits);
960  if (ret < 0 && s->avctx->err_recognition & AV_EF_EXPLODE)
961  return ret;
962  }
963 
964  return 0;
965 }
966 
968 {
970  return -1;
971 
972  c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
973  if (!c->fdec[c->fdec_num])
974  return -1;
975  c->fdec_num++;
976  c->fdec[c->fdec_num - 1]->avctx = c->avctx;
977 
978  return 0;
979 }
980 
981 #if HAVE_THREADS
983 {
984  WavpackContext *s = avctx->priv_data;
985  s->avctx = avctx;
986 
987  s->curr_frame.f = av_frame_alloc();
988  s->prev_frame.f = av_frame_alloc();
989 
990  if (!s->curr_frame.f || !s->prev_frame.f)
991  return AVERROR(ENOMEM);
992 
993  return 0;
994 }
995 
997 {
998  WavpackContext *fsrc = src->priv_data;
999  WavpackContext *fdst = dst->priv_data;
1000  int ret;
1001 
1002  if (dst == src)
1003  return 0;
1004 
1005  ff_thread_release_buffer(dst, &fdst->curr_frame);
1006  if (fsrc->curr_frame.f->data[0]) {
1007  if ((ret = ff_thread_ref_frame(&fdst->curr_frame, &fsrc->curr_frame)) < 0)
1008  return ret;
1009  }
1010 
1011  return 0;
1012 }
1013 #endif
1014 
1016 {
1017  WavpackContext *s = avctx->priv_data;
1018 
1019  s->avctx = avctx;
1020 
1021  s->fdec_num = 0;
1022 
1023  avctx->internal->allocate_progress = 1;
1024 
1025  s->curr_frame.f = av_frame_alloc();
1026  s->prev_frame.f = av_frame_alloc();
1027 
1028  // the DSD to PCM context is shared (and used serially) between all decoding threads
1029  s->dsdctx = av_calloc(avctx->channels, sizeof(DSDContext));
1030 
1031  if (!s->curr_frame.f || !s->prev_frame.f || !s->dsdctx)
1032  return AVERROR(ENOMEM);
1033 
1034  for (int i = 0; i < avctx->channels; i++)
1035  memset(s->dsdctx[i].buf, 0x69, sizeof(s->dsdctx[i].buf));
1036 
1037  ff_init_dsd_data();
1038 
1039  return 0;
1040 }
1041 
1043 {
1044  WavpackContext *s = avctx->priv_data;
1045 
1046  for (int i = 0; i < s->fdec_num; i++)
1047  av_freep(&s->fdec[i]);
1048  s->fdec_num = 0;
1049 
1051  av_frame_free(&s->curr_frame.f);
1052 
1054  av_frame_free(&s->prev_frame.f);
1055 
1056  if (!avctx->internal->is_copy)
1057  av_freep(&s->dsdctx);
1058 
1059  return 0;
1060 }
1061 
1062 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
1063  const uint8_t *buf, int buf_size)
1064 {
1065  WavpackContext *wc = avctx->priv_data;
1068  void *samples_l = NULL, *samples_r = NULL;
1069  int ret;
1070  int got_terms = 0, got_weights = 0, got_samples = 0,
1071  got_entropy = 0, got_pcm = 0, got_float = 0, got_hybrid = 0;
1072  int got_dsd = 0;
1073  int i, j, id, size, ssize, weights, t;
1074  int bpp, chan = 0, orig_bpp, sample_rate = 0, rate_x = 1, dsd_mode = 0;
1075  int multiblock;
1076  uint64_t chmask = 0;
1077 
1078  if (block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0) {
1079  av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
1080  return AVERROR_INVALIDDATA;
1081  }
1082 
1083  s = wc->fdec[block_no];
1084  if (!s) {
1085  av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n",
1086  block_no);
1087  return AVERROR_INVALIDDATA;
1088  }
1089 
1090  memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
1091  memset(s->ch, 0, sizeof(s->ch));
1092  s->extra_bits = 0;
1093  s->and = s->or = s->shift = 0;
1094  s->got_extra_bits = 0;
1095 
1096  bytestream2_init(&gb, buf, buf_size);
1097 
1098  s->samples = bytestream2_get_le32(&gb);
1099  if (s->samples != wc->samples) {
1100  av_log(avctx, AV_LOG_ERROR, "Mismatching number of samples in "
1101  "a sequence: %d and %d\n", wc->samples, s->samples);
1102  return AVERROR_INVALIDDATA;
1103  }
1104  s->frame_flags = bytestream2_get_le32(&gb);
1105  bpp = av_get_bytes_per_sample(avctx->sample_fmt);
1106  orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
1107  multiblock = (s->frame_flags & WV_SINGLE_BLOCK) != WV_SINGLE_BLOCK;
1108 
1109  s->stereo = !(s->frame_flags & WV_MONO);
1110  s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
1111  s->joint = s->frame_flags & WV_JOINT_STEREO;
1112  s->hybrid = s->frame_flags & WV_HYBRID_MODE;
1114  s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
1115  if (s->post_shift < 0 || s->post_shift > 31) {
1116  return AVERROR_INVALIDDATA;
1117  }
1118  s->hybrid_maxclip = ((1LL << (orig_bpp - 1)) - 1);
1119  s->hybrid_minclip = ((-1UL << (orig_bpp - 1)));
1120  s->CRC = bytestream2_get_le32(&gb);
1121 
1122  // parse metadata blocks
1123  while (bytestream2_get_bytes_left(&gb)) {
1124  id = bytestream2_get_byte(&gb);
1125  size = bytestream2_get_byte(&gb);
1126  if (id & WP_IDF_LONG)
1127  size |= (bytestream2_get_le16u(&gb)) << 8;
1128  size <<= 1; // size is specified in words
1129  ssize = size;
1130  if (id & WP_IDF_ODD)
1131  size--;
1132  if (size < 0) {
1133  av_log(avctx, AV_LOG_ERROR,
1134  "Got incorrect block %02X with size %i\n", id, size);
1135  break;
1136  }
1137  if (bytestream2_get_bytes_left(&gb) < ssize) {
1138  av_log(avctx, AV_LOG_ERROR,
1139  "Block size %i is out of bounds\n", size);
1140  break;
1141  }
1142  switch (id & WP_IDF_MASK) {
1143  case WP_ID_DECTERMS:
1144  if (size > MAX_TERMS) {
1145  av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
1146  s->terms = 0;
1147  bytestream2_skip(&gb, ssize);
1148  continue;
1149  }
1150  s->terms = size;
1151  for (i = 0; i < s->terms; i++) {
1152  uint8_t val = bytestream2_get_byte(&gb);
1153  s->decorr[s->terms - i - 1].value = (val & 0x1F) - 5;
1154  s->decorr[s->terms - i - 1].delta = val >> 5;
1155  }
1156  got_terms = 1;
1157  break;
1158  case WP_ID_DECWEIGHTS:
1159  if (!got_terms) {
1160  av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
1161  continue;
1162  }
1163  weights = size >> s->stereo_in;
1164  if (weights > MAX_TERMS || weights > s->terms) {
1165  av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
1166  bytestream2_skip(&gb, ssize);
1167  continue;
1168  }
1169  for (i = 0; i < weights; i++) {
1170  t = (int8_t)bytestream2_get_byte(&gb);
1171  s->decorr[s->terms - i - 1].weightA = t * (1 << 3);
1172  if (s->decorr[s->terms - i - 1].weightA > 0)
1173  s->decorr[s->terms - i - 1].weightA +=
1174  (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
1175  if (s->stereo_in) {
1176  t = (int8_t)bytestream2_get_byte(&gb);
1177  s->decorr[s->terms - i - 1].weightB = t * (1 << 3);
1178  if (s->decorr[s->terms - i - 1].weightB > 0)
1179  s->decorr[s->terms - i - 1].weightB +=
1180  (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
1181  }
1182  }
1183  got_weights = 1;
1184  break;
1185  case WP_ID_DECSAMPLES:
1186  if (!got_terms) {
1187  av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
1188  continue;
1189  }
1190  t = 0;
1191  for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
1192  if (s->decorr[i].value > 8) {
1193  s->decorr[i].samplesA[0] =
1194  wp_exp2(bytestream2_get_le16(&gb));
1195  s->decorr[i].samplesA[1] =
1196  wp_exp2(bytestream2_get_le16(&gb));
1197 
1198  if (s->stereo_in) {
1199  s->decorr[i].samplesB[0] =
1200  wp_exp2(bytestream2_get_le16(&gb));
1201  s->decorr[i].samplesB[1] =
1202  wp_exp2(bytestream2_get_le16(&gb));
1203  t += 4;
1204  }
1205  t += 4;
1206  } else if (s->decorr[i].value < 0) {
1207  s->decorr[i].samplesA[0] =
1208  wp_exp2(bytestream2_get_le16(&gb));
1209  s->decorr[i].samplesB[0] =
1210  wp_exp2(bytestream2_get_le16(&gb));
1211  t += 4;
1212  } else {
1213  for (j = 0; j < s->decorr[i].value; j++) {
1214  s->decorr[i].samplesA[j] =
1215  wp_exp2(bytestream2_get_le16(&gb));
1216  if (s->stereo_in) {
1217  s->decorr[i].samplesB[j] =
1218  wp_exp2(bytestream2_get_le16(&gb));
1219  }
1220  }
1221  t += s->decorr[i].value * 2 * (s->stereo_in + 1);
1222  }
1223  }
1224  got_samples = 1;
1225  break;
1226  case WP_ID_ENTROPY:
1227  if (size != 6 * (s->stereo_in + 1)) {
1228  av_log(avctx, AV_LOG_ERROR,
1229  "Entropy vars size should be %i, got %i.\n",
1230  6 * (s->stereo_in + 1), size);
1231  bytestream2_skip(&gb, ssize);
1232  continue;
1233  }
1234  for (j = 0; j <= s->stereo_in; j++)
1235  for (i = 0; i < 3; i++) {
1236  s->ch[j].median[i] = wp_exp2(bytestream2_get_le16(&gb));
1237  }
1238  got_entropy = 1;
1239  break;
1240  case WP_ID_HYBRID:
1241  if (s->hybrid_bitrate) {
1242  for (i = 0; i <= s->stereo_in; i++) {
1243  s->ch[i].slow_level = wp_exp2(bytestream2_get_le16(&gb));
1244  size -= 2;
1245  }
1246  }
1247  for (i = 0; i < (s->stereo_in + 1); i++) {
1248  s->ch[i].bitrate_acc = bytestream2_get_le16(&gb) << 16;
1249  size -= 2;
1250  }
1251  if (size > 0) {
1252  for (i = 0; i < (s->stereo_in + 1); i++) {
1253  s->ch[i].bitrate_delta =
1254  wp_exp2((int16_t)bytestream2_get_le16(&gb));
1255  }
1256  } else {
1257  for (i = 0; i < (s->stereo_in + 1); i++)
1258  s->ch[i].bitrate_delta = 0;
1259  }
1260  got_hybrid = 1;
1261  break;
1262  case WP_ID_INT32INFO: {
1263  uint8_t val[4];
1264  if (size != 4) {
1265  av_log(avctx, AV_LOG_ERROR,
1266  "Invalid INT32INFO, size = %i\n",
1267  size);
1268  bytestream2_skip(&gb, ssize - 4);
1269  continue;
1270  }
1271  bytestream2_get_buffer(&gb, val, 4);
1272  if (val[0] > 30) {
1273  av_log(avctx, AV_LOG_ERROR,
1274  "Invalid INT32INFO, extra_bits = %d (> 30)\n", val[0]);
1275  continue;
1276  } else if (val[0]) {
1277  s->extra_bits = val[0];
1278  } else if (val[1]) {
1279  s->shift = val[1];
1280  } else if (val[2]) {
1281  s->and = s->or = 1;
1282  s->shift = val[2];
1283  } else if (val[3]) {
1284  s->and = 1;
1285  s->shift = val[3];
1286  }
1287  if (s->shift > 31) {
1288  av_log(avctx, AV_LOG_ERROR,
1289  "Invalid INT32INFO, shift = %d (> 31)\n", s->shift);
1290  s->and = s->or = s->shift = 0;
1291  continue;
1292  }
1293  /* original WavPack decoder forces 32-bit lossy sound to be treated
1294  * as 24-bit one in order to have proper clipping */
1295  if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
1296  s->post_shift += 8;
1297  s->shift -= 8;
1298  s->hybrid_maxclip >>= 8;
1299  s->hybrid_minclip >>= 8;
1300  }
1301  break;
1302  }
1303  case WP_ID_FLOATINFO:
1304  if (size != 4) {
1305  av_log(avctx, AV_LOG_ERROR,
1306  "Invalid FLOATINFO, size = %i\n", size);
1307  bytestream2_skip(&gb, ssize);
1308  continue;
1309  }
1310  s->float_flag = bytestream2_get_byte(&gb);
1311  s->float_shift = bytestream2_get_byte(&gb);
1312  s->float_max_exp = bytestream2_get_byte(&gb);
1313  if (s->float_shift > 31) {
1314  av_log(avctx, AV_LOG_ERROR,
1315  "Invalid FLOATINFO, shift = %d (> 31)\n", s->float_shift);
1316  s->float_shift = 0;
1317  continue;
1318  }
1319  got_float = 1;
1320  bytestream2_skip(&gb, 1);
1321  break;
1322  case WP_ID_DATA:
1323  if ((ret = init_get_bits8(&s->gb, gb.buffer, size)) < 0)
1324  return ret;
1325  bytestream2_skip(&gb, size);
1326  got_pcm = 1;
1327  break;
1328  case WP_ID_DSD_DATA:
1329  if (size < 2) {
1330  av_log(avctx, AV_LOG_ERROR, "Invalid DSD_DATA, size = %i\n",
1331  size);
1332  bytestream2_skip(&gb, ssize);
1333  continue;
1334  }
1335  rate_x = 1 << bytestream2_get_byte(&gb);
1336  dsd_mode = bytestream2_get_byte(&gb);
1337  if (dsd_mode && dsd_mode != 1 && dsd_mode != 3) {
1338  av_log(avctx, AV_LOG_ERROR, "Invalid DSD encoding mode: %d\n",
1339  dsd_mode);
1340  return AVERROR_INVALIDDATA;
1341  }
1342  bytestream2_init(&s->gbyte, gb.buffer, size-2);
1343  bytestream2_skip(&gb, size-2);
1344  got_dsd = 1;
1345  break;
1346  case WP_ID_EXTRABITS:
1347  if (size <= 4) {
1348  av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1349  size);
1350  bytestream2_skip(&gb, size);
1351  continue;
1352  }
1353  if ((ret = init_get_bits8(&s->gb_extra_bits, gb.buffer, size)) < 0)
1354  return ret;
1356  bytestream2_skip(&gb, size);
1357  s->got_extra_bits = 1;
1358  break;
1359  case WP_ID_CHANINFO:
1360  if (size <= 1) {
1361  av_log(avctx, AV_LOG_ERROR,
1362  "Insufficient channel information\n");
1363  return AVERROR_INVALIDDATA;
1364  }
1365  chan = bytestream2_get_byte(&gb);
1366  switch (size - 2) {
1367  case 0:
1368  chmask = bytestream2_get_byte(&gb);
1369  break;
1370  case 1:
1371  chmask = bytestream2_get_le16(&gb);
1372  break;
1373  case 2:
1374  chmask = bytestream2_get_le24(&gb);
1375  break;
1376  case 3:
1377  chmask = bytestream2_get_le32(&gb);
1378  break;
1379  case 4:
1380  size = bytestream2_get_byte(&gb);
1381  chan |= (bytestream2_get_byte(&gb) & 0xF) << 8;
1382  chan += 1;
1383  if (avctx->channels != chan)
1384  av_log(avctx, AV_LOG_WARNING, "%i channels signalled"
1385  " instead of %i.\n", chan, avctx->channels);
1386  chmask = bytestream2_get_le24(&gb);
1387  break;
1388  case 5:
1389  size = bytestream2_get_byte(&gb);
1390  chan |= (bytestream2_get_byte(&gb) & 0xF) << 8;
1391  chan += 1;
1392  if (avctx->channels != chan)
1393  av_log(avctx, AV_LOG_WARNING, "%i channels signalled"
1394  " instead of %i.\n", chan, avctx->channels);
1395  chmask = bytestream2_get_le32(&gb);
1396  break;
1397  default:
1398  av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1399  size);
1400  chan = avctx->channels;
1401  chmask = avctx->channel_layout;
1402  }
1403  break;
1404  case WP_ID_SAMPLE_RATE:
1405  if (size != 3) {
1406  av_log(avctx, AV_LOG_ERROR, "Invalid custom sample rate.\n");
1407  return AVERROR_INVALIDDATA;
1408  }
1409  sample_rate = bytestream2_get_le24(&gb);
1410  break;
1411  default:
1412  bytestream2_skip(&gb, size);
1413  }
1414  if (id & WP_IDF_ODD)
1415  bytestream2_skip(&gb, 1);
1416  }
1417 
1418  if (got_pcm) {
1419  if (!got_terms) {
1420  av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1421  return AVERROR_INVALIDDATA;
1422  }
1423  if (!got_weights) {
1424  av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1425  return AVERROR_INVALIDDATA;
1426  }
1427  if (!got_samples) {
1428  av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1429  return AVERROR_INVALIDDATA;
1430  }
1431  if (!got_entropy) {
1432  av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1433  return AVERROR_INVALIDDATA;
1434  }
1435  if (s->hybrid && !got_hybrid) {
1436  av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1437  return AVERROR_INVALIDDATA;
1438  }
1439  if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLTP) {
1440  av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1441  return AVERROR_INVALIDDATA;
1442  }
1443  if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLTP) {
1444  const int size = get_bits_left(&s->gb_extra_bits);
1445  const int wanted = s->samples * s->extra_bits << s->stereo_in;
1446  if (size < wanted) {
1447  av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1448  s->got_extra_bits = 0;
1449  }
1450  }
1451  }
1452 
1453  if (!got_pcm && !got_dsd) {
1454  av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1455  return AVERROR_INVALIDDATA;
1456  }
1457 
1458  if ((got_pcm && wc->modulation != MODULATION_PCM) ||
1459  (got_dsd && wc->modulation != MODULATION_DSD)) {
1460  av_log(avctx, AV_LOG_ERROR, "Invalid PCM/DSD mix encountered\n");
1461  return AVERROR_INVALIDDATA;
1462  }
1463 
1464  if (!wc->ch_offset) {
1465  int sr = (s->frame_flags >> 23) & 0xf;
1466  if (sr == 0xf) {
1467  if (!sample_rate) {
1468  av_log(avctx, AV_LOG_ERROR, "Custom sample rate missing.\n");
1469  return AVERROR_INVALIDDATA;
1470  }
1471  avctx->sample_rate = sample_rate * rate_x;
1472  } else
1473  avctx->sample_rate = wv_rates[sr] * rate_x;
1474 
1475  if (multiblock) {
1476  if (chan)
1477  avctx->channels = chan;
1478  if (chmask)
1479  avctx->channel_layout = chmask;
1480  } else {
1481  avctx->channels = s->stereo ? 2 : 1;
1482  avctx->channel_layout = s->stereo ? AV_CH_LAYOUT_STEREO :
1484  }
1485 
1486  ff_thread_release_buffer(avctx, &wc->prev_frame);
1488 
1489  /* get output buffer */
1490  wc->curr_frame.f->nb_samples = s->samples;
1491  if ((ret = ff_thread_get_buffer(avctx, &wc->curr_frame, AV_GET_BUFFER_FLAG_REF)) < 0)
1492  return ret;
1493 
1494  wc->frame = wc->curr_frame.f;
1495  ff_thread_finish_setup(avctx);
1496  }
1497 
1498  if (wc->ch_offset + s->stereo >= avctx->channels) {
1499  av_log(avctx, AV_LOG_WARNING, "Too many channels coded in a packet.\n");
1500  return ((avctx->err_recognition & AV_EF_EXPLODE) || !wc->ch_offset) ? AVERROR_INVALIDDATA : 0;
1501  }
1502 
1503  samples_l = wc->frame->extended_data[wc->ch_offset];
1504  if (s->stereo)
1505  samples_r = wc->frame->extended_data[wc->ch_offset + 1];
1506 
1507  wc->ch_offset += 1 + s->stereo;
1508 
1509  if (s->stereo_in) {
1510  if (got_dsd) {
1511  if (dsd_mode == 3) {
1512  ret = wv_unpack_dsd_high(s, samples_l, samples_r);
1513  } else if (dsd_mode == 1) {
1514  ret = wv_unpack_dsd_fast(s, samples_l, samples_r);
1515  } else {
1516  ret = wv_unpack_dsd_copy(s, samples_l, samples_r);
1517  }
1518  } else {
1519  ret = wv_unpack_stereo(s, &s->gb, samples_l, samples_r, avctx->sample_fmt);
1520  }
1521  if (ret < 0)
1522  return ret;
1523  } else {
1524  if (got_dsd) {
1525  if (dsd_mode == 3) {
1526  ret = wv_unpack_dsd_high(s, samples_l, NULL);
1527  } else if (dsd_mode == 1) {
1528  ret = wv_unpack_dsd_fast(s, samples_l, NULL);
1529  } else {
1530  ret = wv_unpack_dsd_copy(s, samples_l, NULL);
1531  }
1532  } else {
1533  ret = wv_unpack_mono(s, &s->gb, samples_l, avctx->sample_fmt);
1534  }
1535  if (ret < 0)
1536  return ret;
1537 
1538  if (s->stereo)
1539  memcpy(samples_r, samples_l, bpp * s->samples);
1540  }
1541 
1542  return 0;
1543 }
1544 
1546 {
1547  WavpackContext *s = avctx->priv_data;
1548 
1549  if (!avctx->internal->is_copy) {
1550  for (int i = 0; i < avctx->channels; i++)
1551  memset(s->dsdctx[i].buf, 0x69, sizeof(s->dsdctx[i].buf));
1552  }
1553 }
1554 
1555 static int dsd_channel(AVCodecContext *avctx, void *frmptr, int jobnr, int threadnr)
1556 {
1557  WavpackContext *s = avctx->priv_data;
1558  AVFrame *frame = frmptr;
1559 
1560  ff_dsd2pcm_translate (&s->dsdctx [jobnr], s->samples, 0,
1561  (uint8_t *)frame->extended_data[jobnr], 4,
1562  (float *)frame->extended_data[jobnr], 1);
1563 
1564  return 0;
1565 }
1566 
1567 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1568  int *got_frame_ptr, AVPacket *avpkt)
1569 {
1570  WavpackContext *s = avctx->priv_data;
1571  const uint8_t *buf = avpkt->data;
1572  int buf_size = avpkt->size;
1573  int frame_size, ret, frame_flags;
1574 
1575  if (avpkt->size <= WV_HEADER_SIZE)
1576  return AVERROR_INVALIDDATA;
1577 
1578  s->frame = NULL;
1579  s->block = 0;
1580  s->ch_offset = 0;
1581 
1582  /* determine number of samples */
1583  s->samples = AV_RL32(buf + 20);
1584  frame_flags = AV_RL32(buf + 24);
1585  if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
1586  av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1587  s->samples);
1588  return AVERROR_INVALIDDATA;
1589  }
1590 
1591  s->modulation = (frame_flags & WV_DSD_DATA) ? MODULATION_DSD : MODULATION_PCM;
1592 
1593  if (frame_flags & (WV_FLOAT_DATA | WV_DSD_DATA)) {
1594  avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1595  } else if ((frame_flags & 0x03) <= 1) {
1596  avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
1597  } else {
1598  avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
1599  avctx->bits_per_raw_sample = ((frame_flags & 0x03) + 1) << 3;
1600  }
1601 
1602  while (buf_size > WV_HEADER_SIZE) {
1603  frame_size = AV_RL32(buf + 4) - 12;
1604  buf += 20;
1605  buf_size -= 20;
1606  if (frame_size <= 0 || frame_size > buf_size) {
1607  av_log(avctx, AV_LOG_ERROR,
1608  "Block %d has invalid size (size %d vs. %d bytes left)\n",
1609  s->block, frame_size, buf_size);
1610  ret = AVERROR_INVALIDDATA;
1611  goto error;
1612  }
1613  if ((ret = wavpack_decode_block(avctx, s->block, buf, frame_size)) < 0)
1614  goto error;
1615  s->block++;
1616  buf += frame_size;
1617  buf_size -= frame_size;
1618  }
1619 
1620  if (s->ch_offset != avctx->channels) {
1621  av_log(avctx, AV_LOG_ERROR, "Not enough channels coded in a packet.\n");
1622  ret = AVERROR_INVALIDDATA;
1623  goto error;
1624  }
1625 
1626  ff_thread_await_progress(&s->prev_frame, INT_MAX, 0);
1628 
1629  if (s->modulation == MODULATION_DSD)
1630  avctx->execute2(avctx, dsd_channel, s->frame, NULL, avctx->channels);
1631 
1632  ff_thread_report_progress(&s->curr_frame, INT_MAX, 0);
1633 
1634  if ((ret = av_frame_ref(data, s->frame)) < 0)
1635  return ret;
1636 
1637  *got_frame_ptr = 1;
1638 
1639  return avpkt->size;
1640 
1641 error:
1642  if (s->frame) {
1643  ff_thread_await_progress(&s->prev_frame, INT_MAX, 0);
1645  ff_thread_report_progress(&s->curr_frame, INT_MAX, 0);
1646  }
1647 
1648  return ret;
1649 }
1650 
1652  .name = "wavpack",
1653  .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1654  .type = AVMEDIA_TYPE_AUDIO,
1655  .id = AV_CODEC_ID_WAVPACK,
1656  .priv_data_size = sizeof(WavpackContext),
1658  .close = wavpack_decode_end,
1662  .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
1663  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
1665 };
int delta
Definition: wavpack.h:86
float, planar
Definition: samplefmt.h:69
#define NULL
Definition: coverity.c:32
#define WV_HYBRID_MODE
Definition: wavpack.h:40
const char const char void * val
Definition: avisynth_c.h:863
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int median[3]
Definition: wavpack.h:97
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
unsigned bitrate_delta
Definition: wavpack.h:99
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
static void wavpack_decode_flush(AVCodecContext *avctx)
Definition: wavpack.c:1545
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVFrame * f
Definition: thread.h:35
int slow_level
Definition: wavpack.h:98
Definition: wvdec.c:32
#define MAX_HISTORY_BINS
Definition: wavpack.c:57
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have add an init_thread_copy() which re-allocates them for other threads.Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities.There will be very little speed gain at this point but it should work.If there are inter-frame dependencies
int32_t fltr5
Definition: wavpack.c:433
int samplesA[MAX_TERM]
Definition: wavpack.h:90
int size
Definition: avcodec.h:1534
int32_t factor
Definition: wavpack.c:433
#define DECAY
Definition: wavpack.c:48
static int wavpack_decode_block(AVCodecContext *avctx, int block_no, const uint8_t *buf, int buf_size)
Definition: wavpack.c:1062
int av_log2(unsigned v)
Definition: intmath.c:26
#define R2
Definition: simple_idct.c:173
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
#define WV_FLT_SHIFT_ONES
Definition: wavpack.h:51
#define WV_FLOAT_DATA
Definition: wavpack.h:35
GLint GLenum type
Definition: opengl_enc.c:104
#define MAX_TERMS
Definition: wavpack.h:27
static int dsd_channel(AVCodecContext *avctx, void *frmptr, int jobnr, int threadnr)
Definition: wavpack.c:1555
int weightB
Definition: wavpack.h:89
GetByteContext gbyte
Definition: wavpack.c:89
#define WV_HYBRID_BITRATE
Definition: wavpack.h:42
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2852
#define AV_CH_LAYOUT_STEREO
static void error(const char *err)
uint32_t CRC
Definition: wavpack.c:70
av_cold void ff_init_dsd_data(void)
Definition: dsd.c:46
ThreadFrame curr_frame
Definition: wavpack.c:110
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them.reget_buffer() and buffer age optimizations no longer work.*The contents of buffers must not be written to after ff_thread_report_progress() has been called on them.This includes draw_edges().Porting codecs to frame threading
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3555
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
Decorr decorr[MAX_TERMS]
Definition: wavpack.c:77
int32_t fltr2
Definition: wavpack.c:433
uint8_t base
Definition: vp3data.h:202
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
Modulation
Definition: wavpack.c:60
#define PRECISION
Definition: wavpack.c:50
static int get_unary_0_33(GetBitContext *gb)
Get unary code terminated by a 0 with a maximum length of 33.
Definition: unary.h:59
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2289
uint8_t
#define av_cold
Definition: attributes.h:82
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread.If the codec allocates writable tables in its init()
static int wv_unpack_dsd_high(WavpackFrameContext *s, uint8_t *dst_left, uint8_t *dst_right)
Definition: wavpack.c:437
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
AVCodec ff_wavpack_decoder
Definition: wavpack.c:1651
void ff_dsd2pcm_translate(DSDContext *s, size_t samples, int lsbf, const uint8_t *src, ptrdiff_t src_stride, float *dst, ptrdiff_t dst_stride)
Definition: dsd.c:55
#define f(width, name)
Definition: cbs_vp9.c:255
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
Multithreading support functions.
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int value
Definition: wavpack.h:87
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:444
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
uint8_t * data
Definition: avcodec.h:1533
const uint8_t * buffer
Definition: bytestream.h:34
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:1827
#define sp
Definition: regdef.h:63
bitstream reader API header.
#define WV_HEADER_SIZE
Definition: wavpack.h:30
#define WV_FLT_ZERO_SIGN
Definition: wavpack.h:55
#define MAX_BIN_BYTES
Definition: wavpack.c:58
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int wp_log2(uint32_t val)
Definition: wavpack.h:182
#define A(x)
Definition: vp56_arith.h:28
DSDContext * dsdctx
Definition: wavpack.c:112
#define av_log(a,...)
#define MAX_HISTORY_BITS
Definition: wavpack.c:56
static const uint16_t table[]
Definition: prosumer.c:206
WavpackFrameContext * fdec[WV_MAX_FRAME_DECODERS]
Definition: wavpack.c:102
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
uint8_t probabilities[MAX_HISTORY_BINS][256]
Definition: wavpack.c:93
#define U(x)
Definition: vp56_arith.h:37
static int wv_unpack_dsd_copy(WavpackFrameContext *s, uint8_t *dst_left, uint8_t *dst_right)
Definition: wavpack.c:737
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static int update_error_limit(WavpackFrameContext *ctx)
Definition: wavpack.c:131
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define R
Definition: huffyuvdsp.h:34
#define S(s, c, i)
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
Definition: internal.h:142
#define DSD_BYTE_READY(low, high)
Definition: wavpack.c:40
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#define B
Definition: huffyuvdsp.h:32
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static av_always_inline int wp_exp2(int16_t val)
Definition: wavpack.h:165
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:263
unsigned int pos
Definition: spdifenc.c:410
AVCodecContext * avctx
Definition: wavpack.c:66
uint8_t * value_lookup[MAX_HISTORY_BINS]
Definition: wavpack.c:94
#define WV_SINGLE_BLOCK
Definition: wavpack.h:49
const char * name
Name of the codec implementation.
Definition: avcodec.h:3562
GLsizei count
Definition: opengl_enc.c:108
int ptable[PTABLE_BINS]
Definition: wavpack.c:90
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1055
int8_t exp
Definition: eval.c:72
#define WV_DSD_DATA
Definition: wavpack.h:38
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2332
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:225
int weightA
Definition: wavpack.h:88
int32_t fltr4
Definition: wavpack.c:433
#define T(x)
Definition: vp56_arith.h:29
audio channel layout utility functions
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:55
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2750
signed 32 bits, planar
Definition: samplefmt.h:68
static int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst_l, void *dst_r, const int type)
Definition: wavpack.c:769
static const int wv_rates[16]
Definition: wavpack.h:121
#define WV_FALSE_STEREO
Definition: wavpack.h:37
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards.If some code can't be moved
static int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
Definition: wavpack.c:900
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
#define WV_FLT_SHIFT_SAME
Definition: wavpack.h:52
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Per-channel buffer.
Definition: dsd.h:42
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
#define PTABLE_BINS
Definition: wavpack.c:43
#define UP
Definition: wavpack.c:46
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2761
#define WV_FLT_SHIFT_SENT
Definition: wavpack.h:53
static volatile int checksum
Definition: adler32.c:30
#define L(x)
Definition: vp56_arith.h:36
#define RATE_S
Definition: wavpack.c:54
int error_limit
Definition: wavpack.h:98
if(ret)
int32_t value
Definition: wavpack.c:433
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1059
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:2940
#define VALUE_ONE
Definition: wavpack.c:51
static av_cold int wavpack_decode_end(AVCodecContext *avctx)
Definition: wavpack.c:1042
#define GET_MED(n)
Definition: wavpack.h:103
sample_rate
int frame_size
Definition: mxfenc.c:2140
uint32_t crc_extra_bits
Definition: wavpack.c:73
Libavcodec external API header.
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have add an so the codec calls ff_thread_report set AVCodecInternal allocate_progress The frames must then be freed with ff_thread_release_buffer().Otherwise leave it at zero and decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
unsigned int byte
Definition: wavpack.c:434
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:87
int sample_rate
samples per second
Definition: avcodec.h:2281
unsigned bitrate_acc
Definition: wavpack.h:99
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
Definition: avcodec.h:1621
int32_t fltr1
Definition: wavpack.c:433
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2^^^F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v\/v\/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O^/\^/\^h2--> O q O<--h3-> O q O<--h2 v\/v\/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O^/\^/\^F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0.To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){for(x=0;x< width;x++){sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][*]=sample[*][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform)--------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one.------------------------------------------------------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 L2
Definition: snow.txt:554
static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
Definition: wavpack.c:323
int samplesB[MAX_TERM]
Definition: wavpack.h:91
static int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, unsigned S)
Definition: wavpack.c:299
int32_t fltr6
Definition: wavpack.c:433
void * buf
Definition: avisynth_c.h:766
#define LEVEL_DECAY(a)
Definition: wavpack.c:115
Modulation modulation
Definition: wavpack.c:111
int32_t fltr0
Definition: wavpack.c:433
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void init_ptable(int *table, int rate_i, int rate_s)
Definition: wavpack.c:412
int index
Definition: gxfenc.c:89
#define WV_JOINT_STEREO
Definition: wavpack.h:33
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:2758
static const int factor[16]
Definition: vf_pp7.c:75
static int wavpack_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: wavpack.c:1567
static int wv_check_crc(WavpackFrameContext *s, uint32_t crc, uint32_t crc_extra_bits)
Definition: wavpack.c:397
int allocate_progress
Whether to allocate progress for frame threading.
Definition: internal.h:157
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, int channel, int *last)
Definition: wavpack.c:169
WvChannel ch[2]
Definition: wavpack.c:87
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in)
Definition: wavpack.h:108
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
static av_always_inline unsigned get_tail(GetBitContext *gb, int k)
Definition: wavpack.c:117
static int wv_unpack_dsd_fast(WavpackFrameContext *s, uint8_t *dst_left, uint8_t *dst_right)
Definition: wavpack.c:576
int
ThreadFrame prev_frame
Definition: wavpack.c:110
uint8_t buf[FIFOSIZE]
Definition: dsd.h:43
common internal api header.
#define DOWN
Definition: wavpack.c:47
#define bit(string, value)
Definition: cbs_mpeg2.c:58
#define WV_FLT_ZERO_SENT
Definition: wavpack.h:54
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
int32_t fltr3
Definition: wavpack.c:433
#define INC_MED(n)
Definition: wavpack.h:105
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:808
GetBitContext gb_extra_bits
Definition: wavpack.c:74
void * priv_data
Definition: avcodec.h:1648
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:667
int channels
number of audio channels
Definition: avcodec.h:2282
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1656
static const struct PPFilter filters[]
Definition: postprocess.c:134
AVFrame * frame
Definition: wavpack.c:109
AVCodecContext * avctx
Definition: wavpack.c:100
#define WV_MAX_SAMPLES
Definition: wavpack.h:57
#define DEC_MED(n)
Definition: wavpack.h:104
uint16_t summed_probabilities[MAX_HISTORY_BINS][256]
Definition: wavpack.c:92
#define PTABLE_MASK
Definition: wavpack.c:44
Definition: wavpack.h:85
GetBitContext gb
Definition: wavpack.c:71
#define av_freep(p)
signed 16 bits, planar
Definition: samplefmt.h:67
#define av_always_inline
Definition: attributes.h:39
static av_cold int wv_alloc_frame_context(WavpackContext *c)
Definition: wavpack.c:967
uint8_t value_lookup_buffer[MAX_HISTORY_BINS *MAX_BIN_BYTES]
Definition: wavpack.c:91
static av_cold int wavpack_decode_init(AVCodecContext *avctx)
Definition: wavpack.c:1015
#define FFSWAP(type, a, b)
Definition: common.h:99
#define WV_MAX_FRAME_DECODERS
Definition: wavpack.c:97
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
#define AV_CH_LAYOUT_MONO
enum AVCodecID id
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1510
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1219
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:999
#define t2
Definition: regdef.h:30
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
#define PRECISION_USE
Definition: wavpack.c:52