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