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