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