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 -1;
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 -1;
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) {
794  *got_frame_ptr = 0;
795  return 0;
796  }
797  } else {
798  s->samples = wc->samples;
799  }
800  s->frame_flags = AV_RL32(buf); buf += 4;
801  bpp = av_get_bytes_per_sample(avctx->sample_fmt);
802  samples = (uint8_t*)samples + bpp * wc->ch_offset;
803  orig_bpp = ((s->frame_flags & 0x03) + 1) << 3;
804 
805  s->stereo = !(s->frame_flags & WV_MONO);
806  s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
810  s->post_shift = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
811  s->hybrid_maxclip = (( 1LL << (orig_bpp - 1)) - 1) >> s->post_shift;
812  s->hybrid_minclip = ((-1LL << (orig_bpp - 1))) >> s->post_shift;
813  s->CRC = AV_RL32(buf); buf += 4;
814  if (wc->mkv_mode)
815  buf += 4; //skip block size;
816 
817  wc->ch_offset += 1 + s->stereo;
818 
819  // parse metadata blocks
820  while (buf < buf_end) {
821  id = *buf++;
822  size = *buf++;
823  if (id & WP_IDF_LONG) {
824  size |= (*buf++) << 8;
825  size |= (*buf++) << 16;
826  }
827  size <<= 1; // size is specified in words
828  ssize = size;
829  if (id & WP_IDF_ODD)
830  size--;
831  if (size < 0) {
832  av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
833  break;
834  }
835  if (buf + ssize > buf_end) {
836  av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
837  break;
838  }
839  if (id & WP_IDF_IGNORE) {
840  buf += ssize;
841  continue;
842  }
843  switch (id & WP_IDF_MASK) {
844  case WP_ID_DECTERMS:
845  if (size > MAX_TERMS) {
846  av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
847  s->terms = 0;
848  buf += ssize;
849  continue;
850  }
851  s->terms = size;
852  for (i = 0; i < s->terms; i++) {
853  s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
854  s->decorr[s->terms - i - 1].delta = *buf >> 5;
855  buf++;
856  }
857  got_terms = 1;
858  break;
859  case WP_ID_DECWEIGHTS:
860  if (!got_terms) {
861  av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
862  continue;
863  }
864  weights = size >> s->stereo_in;
865  if (weights > MAX_TERMS || weights > s->terms) {
866  av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
867  buf += ssize;
868  continue;
869  }
870  for (i = 0; i < weights; i++) {
871  t = (int8_t)(*buf++);
872  s->decorr[s->terms - i - 1].weightA = t << 3;
873  if (s->decorr[s->terms - i - 1].weightA > 0)
874  s->decorr[s->terms - i - 1].weightA +=
875  (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
876  if (s->stereo_in) {
877  t = (int8_t)(*buf++);
878  s->decorr[s->terms - i - 1].weightB = t << 3;
879  if (s->decorr[s->terms - i - 1].weightB > 0)
880  s->decorr[s->terms - i - 1].weightB +=
881  (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
882  }
883  }
884  got_weights = 1;
885  break;
886  case WP_ID_DECSAMPLES:
887  if (!got_terms) {
888  av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
889  continue;
890  }
891  t = 0;
892  for (i = s->terms - 1; (i >= 0) && (t < size); i--) {
893  if (s->decorr[i].value > 8) {
894  s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
895  s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
896  if (s->stereo_in) {
897  s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
898  s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
899  t += 4;
900  }
901  t += 4;
902  } else if (s->decorr[i].value < 0) {
903  s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
904  s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
905  t += 4;
906  } else {
907  for (j = 0; j < s->decorr[i].value; j++) {
908  s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
909  if (s->stereo_in)
910  s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
911  }
912  t += s->decorr[i].value * 2 * (s->stereo_in + 1);
913  }
914  }
915  got_samples = 1;
916  break;
917  case WP_ID_ENTROPY:
918  if (size != 6 * (s->stereo_in + 1)) {
919  av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, "
920  "got %i", 6 * (s->stereo_in + 1), size);
921  buf += ssize;
922  continue;
923  }
924  for (j = 0; j <= s->stereo_in; j++) {
925  for (i = 0; i < 3; i++) {
926  s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
927  buf += 2;
928  }
929  }
930  got_entropy = 1;
931  break;
932  case WP_ID_HYBRID:
933  if (s->hybrid_bitrate) {
934  for (i = 0; i <= s->stereo_in; i++) {
935  s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
936  buf += 2;
937  size -= 2;
938  }
939  }
940  for (i = 0; i < (s->stereo_in + 1); i++) {
941  s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
942  buf += 2;
943  size -= 2;
944  }
945  if (size > 0) {
946  for (i = 0; i < (s->stereo_in + 1); i++) {
947  s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
948  buf += 2;
949  }
950  } else {
951  for (i = 0; i < (s->stereo_in + 1); i++)
952  s->ch[i].bitrate_delta = 0;
953  }
954  got_hybrid = 1;
955  break;
956  case WP_ID_INT32INFO:
957  if (size != 4) {
958  av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
959  buf += ssize;
960  continue;
961  }
962  if (buf[0])
963  s->extra_bits = buf[0];
964  else if (buf[1])
965  s->shift = buf[1];
966  else if (buf[2]){
967  s->and = s->or = 1;
968  s->shift = buf[2];
969  } else if(buf[3]) {
970  s->and = 1;
971  s->shift = buf[3];
972  }
973  /* original WavPack decoder forces 32-bit lossy sound to be treated
974  * as 24-bit one in order to have proper clipping
975  */
976  if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
977  s->post_shift += 8;
978  s->shift -= 8;
979  s->hybrid_maxclip >>= 8;
980  s->hybrid_minclip >>= 8;
981  }
982  buf += 4;
983  break;
984  case WP_ID_FLOATINFO:
985  if (size != 4) {
986  av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
987  buf += ssize;
988  continue;
989  }
990  s->float_flag = buf[0];
991  s->float_shift = buf[1];
992  s->float_max_exp = buf[2];
993  buf += 4;
994  got_float = 1;
995  break;
996  case WP_ID_DATA:
997  s->sc.offset = buf - orig_buf;
998  s->sc.size = size * 8;
999  init_get_bits(&s->gb, buf, size * 8);
1000  s->data_size = size * 8;
1001  buf += size;
1002  got_bs = 1;
1003  break;
1004  case WP_ID_EXTRABITS:
1005  if (size <= 4) {
1006  av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n",
1007  size);
1008  buf += size;
1009  continue;
1010  }
1011  s->extra_sc.offset = buf - orig_buf;
1012  s->extra_sc.size = size * 8;
1013  init_get_bits(&s->gb_extra_bits, buf, size * 8);
1015  buf += size;
1016  s->got_extra_bits = 1;
1017  break;
1018  case WP_ID_CHANINFO:
1019  if (size <= 1) {
1020  av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
1021  return -1;
1022  }
1023  chan = *buf++;
1024  switch (size - 2) {
1025  case 0: chmask = *buf; break;
1026  case 1: chmask = AV_RL16(buf); break;
1027  case 2: chmask = AV_RL24(buf); break;
1028  case 3: chmask = AV_RL32(buf); break;
1029  case 5:
1030  chan |= (buf[1] & 0xF) << 8;
1031  chmask = AV_RL24(buf + 2);
1032  break;
1033  default:
1034  av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n",
1035  size);
1036  chan = avctx->channels;
1037  chmask = avctx->channel_layout;
1038  }
1039  if (chan != avctx->channels) {
1040  av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, "
1041  "decoder believes it's %d channels\n", chan,
1042  avctx->channels);
1043  return -1;
1044  }
1045  if (!avctx->channel_layout)
1046  avctx->channel_layout = chmask;
1047  buf += size - 1;
1048  break;
1049  default:
1050  buf += size;
1051  }
1052  if (id & WP_IDF_ODD)
1053  buf++;
1054  }
1055 
1056  if (!got_terms) {
1057  av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1058  return -1;
1059  }
1060  if (!got_weights) {
1061  av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
1062  return -1;
1063  }
1064  if (!got_samples) {
1065  av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
1066  return -1;
1067  }
1068  if (!got_entropy) {
1069  av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
1070  return -1;
1071  }
1072  if (s->hybrid && !got_hybrid) {
1073  av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
1074  return -1;
1075  }
1076  if (!got_bs) {
1077  av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
1078  return -1;
1079  }
1080  if (!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1081  av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
1082  return -1;
1083  }
1084  if (s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT) {
1085  const int size = get_bits_left(&s->gb_extra_bits);
1086  const int wanted = s->samples * s->extra_bits << s->stereo_in;
1087  if (size < wanted) {
1088  av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
1089  s->got_extra_bits = 0;
1090  }
1091  }
1092 
1093  if (s->stereo_in) {
1094  if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1095  samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1096  else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1097  samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1098  else
1099  samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1100 
1101  if (samplecount < 0)
1102  return -1;
1103 
1104  samplecount >>= 1;
1105  } else {
1106  const int channel_stride = avctx->channels;
1107 
1108  if (avctx->sample_fmt == AV_SAMPLE_FMT_S16)
1109  samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
1110  else if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1111  samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
1112  else
1113  samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
1114 
1115  if (samplecount < 0)
1116  return -1;
1117 
1118  if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
1119  int16_t *dst = (int16_t*)samples + 1;
1120  int16_t *src = (int16_t*)samples;
1121  int cnt = samplecount;
1122  while (cnt--) {
1123  *dst = *src;
1124  src += channel_stride;
1125  dst += channel_stride;
1126  }
1127  } else if (s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32) {
1128  int32_t *dst = (int32_t*)samples + 1;
1129  int32_t *src = (int32_t*)samples;
1130  int cnt = samplecount;
1131  while (cnt--) {
1132  *dst = *src;
1133  src += channel_stride;
1134  dst += channel_stride;
1135  }
1136  } else if (s->stereo) {
1137  float *dst = (float*)samples + 1;
1138  float *src = (float*)samples;
1139  int cnt = samplecount;
1140  while (cnt--) {
1141  *dst = *src;
1142  src += channel_stride;
1143  dst += channel_stride;
1144  }
1145  }
1146  }
1147 
1148  *got_frame_ptr = 1;
1149 
1150  return samplecount * bpp;
1151 }
1152 
1154 {
1155  WavpackContext *s = avctx->priv_data;
1156  int i;
1157 
1158  for (i = 0; i < s->fdec_num; i++)
1160 }
1161 
1162 static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
1163  int *got_frame_ptr, AVPacket *avpkt)
1164 {
1165  WavpackContext *s = avctx->priv_data;
1166  const uint8_t *buf = avpkt->data;
1167  int buf_size = avpkt->size;
1168  int frame_size, ret, frame_flags;
1169  int samplecount = 0;
1170 
1171  s->block = 0;
1172  s->ch_offset = 0;
1173 
1174  /* determine number of samples */
1175  if (s->mkv_mode) {
1176  s->samples = AV_RL32(buf); buf += 4;
1177  frame_flags = AV_RL32(buf);
1178  } else {
1179  if (s->multichannel) {
1180  s->samples = AV_RL32(buf + 4);
1181  frame_flags = AV_RL32(buf + 8);
1182  } else {
1183  s->samples = AV_RL32(buf);
1184  frame_flags = AV_RL32(buf + 4);
1185  }
1186  }
1187  if (s->samples <= 0) {
1188  av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
1189  s->samples);
1190  return AVERROR(EINVAL);
1191  }
1192 
1193  if (frame_flags & 0x80) {
1194  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1195  } else if ((frame_flags & 0x03) <= 1) {
1196  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1197  } else {
1198  avctx->sample_fmt = AV_SAMPLE_FMT_S32;
1199  }
1200 
1201  /* get output buffer */
1202  s->frame.nb_samples = s->samples;
1203  if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1204  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1205  return ret;
1206  }
1207 
1208  while (buf_size > 0) {
1209  if (!s->multichannel) {
1210  frame_size = buf_size;
1211  } else {
1212  if (!s->mkv_mode) {
1213  frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1214  } else {
1215  if (buf_size < 12) //MKV files can have zero flags after last block
1216  break;
1217  frame_size = AV_RL32(buf + 8) + 12;
1218  }
1219  }
1220  if (frame_size < 0 || frame_size > buf_size) {
1221  av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d "
1222  "vs. %d bytes left)\n", s->block, frame_size, buf_size);
1223  wavpack_decode_flush(avctx);
1224  return -1;
1225  }
1226  if ((samplecount = wavpack_decode_block(avctx, s->block,
1227  s->frame.data[0], got_frame_ptr,
1228  buf, frame_size)) < 0) {
1229  wavpack_decode_flush(avctx);
1230  return -1;
1231  }
1232  s->block++;
1233  buf += frame_size; buf_size -= frame_size;
1234  }
1235 
1236  if (*got_frame_ptr)
1237  *(AVFrame *)data = s->frame;
1238 
1239  return avpkt->size;
1240 }
1241 
1243  .name = "wavpack",
1244  .type = AVMEDIA_TYPE_AUDIO,
1245  .id = CODEC_ID_WAVPACK,
1246  .priv_data_size = sizeof(WavpackContext),
1251  .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
1252  .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1253 };