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