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