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