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