FFmpeg
takdec.c
Go to the documentation of this file.
1 /*
2  * TAK decoder
3  * Copyright (c) 2012 Paul B Mahol
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 /**
23  * @file
24  * TAK (Tom's lossless Audio Kompressor) decoder
25  * @author Paul B Mahol
26  */
27 
28 #include "libavutil/attributes.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mem.h"
31 #include "libavutil/mem_internal.h"
32 #include "libavutil/samplefmt.h"
33 
34 #define CACHED_BITSTREAM_READER !ARCH_X86_32
35 #define BITSTREAM_READER_LE
36 #include "audiodsp.h"
37 #include "thread.h"
38 #include "avcodec.h"
39 #include "codec_internal.h"
40 #include "unary.h"
41 #include "tak.h"
42 #include "takdsp.h"
43 
44 #define MAX_SUBFRAMES 8 ///< max number of subframes per channel
45 #define MAX_PREDICTORS 256
46 
47 typedef struct MCDParam {
48  int8_t present; ///< decorrelation parameter availability for this channel
49  int8_t index; ///< index into array of decorrelation types
50  int8_t chan1;
51  int8_t chan2;
52 } MCDParam;
53 
54 typedef struct TAKDecContext {
55  AVCodecContext *avctx; ///< parent AVCodecContext
59  GetBitContext gb; ///< bitstream reader initialized to start at the current frame
60 
61  int uval;
62  int nb_samples; ///< number of samples in the current frame
63  uint8_t *decode_buffer;
64  unsigned int decode_buffer_size;
65  int32_t *decoded[TAK_MAX_CHANNELS]; ///< decoded samples for each channel
66 
68  int8_t sample_shift[TAK_MAX_CHANNELS]; ///< shift applied to every sample in the channel
70  int nb_subframes; ///< number of subframes in the current frame
71  int16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
73 
74  int8_t dmode; ///< channel decorrelation type in the current frame
75 
76  MCDParam mcdparams[TAK_MAX_CHANNELS]; ///< multichannel decorrelation parameters
77 
78  int8_t coding_mode[128];
80  DECLARE_ALIGNED(16, int16_t, residues)[544];
82 
83 static const int8_t mc_dmodes[] = { 1, 3, 4, 6, };
84 
85 static const uint16_t predictor_sizes[] = {
86  4, 8, 12, 16, 24, 32, 48, 64, 80, 96, 128, 160, 192, 224, 256, 0,
87 };
88 
89 static const struct CParam {
90  int init;
91  int escape;
92  int scale;
93  int aescape;
94  int bias;
95 } xcodes[50] = {
96  { 0x01, 0x0000001, 0x0000001, 0x0000003, 0x0000008 },
97  { 0x02, 0x0000003, 0x0000001, 0x0000007, 0x0000006 },
98  { 0x03, 0x0000005, 0x0000002, 0x000000E, 0x000000D },
99  { 0x03, 0x0000003, 0x0000003, 0x000000D, 0x0000018 },
100  { 0x04, 0x000000B, 0x0000004, 0x000001C, 0x0000019 },
101  { 0x04, 0x0000006, 0x0000006, 0x000001A, 0x0000030 },
102  { 0x05, 0x0000016, 0x0000008, 0x0000038, 0x0000032 },
103  { 0x05, 0x000000C, 0x000000C, 0x0000034, 0x0000060 },
104  { 0x06, 0x000002C, 0x0000010, 0x0000070, 0x0000064 },
105  { 0x06, 0x0000018, 0x0000018, 0x0000068, 0x00000C0 },
106  { 0x07, 0x0000058, 0x0000020, 0x00000E0, 0x00000C8 },
107  { 0x07, 0x0000030, 0x0000030, 0x00000D0, 0x0000180 },
108  { 0x08, 0x00000B0, 0x0000040, 0x00001C0, 0x0000190 },
109  { 0x08, 0x0000060, 0x0000060, 0x00001A0, 0x0000300 },
110  { 0x09, 0x0000160, 0x0000080, 0x0000380, 0x0000320 },
111  { 0x09, 0x00000C0, 0x00000C0, 0x0000340, 0x0000600 },
112  { 0x0A, 0x00002C0, 0x0000100, 0x0000700, 0x0000640 },
113  { 0x0A, 0x0000180, 0x0000180, 0x0000680, 0x0000C00 },
114  { 0x0B, 0x0000580, 0x0000200, 0x0000E00, 0x0000C80 },
115  { 0x0B, 0x0000300, 0x0000300, 0x0000D00, 0x0001800 },
116  { 0x0C, 0x0000B00, 0x0000400, 0x0001C00, 0x0001900 },
117  { 0x0C, 0x0000600, 0x0000600, 0x0001A00, 0x0003000 },
118  { 0x0D, 0x0001600, 0x0000800, 0x0003800, 0x0003200 },
119  { 0x0D, 0x0000C00, 0x0000C00, 0x0003400, 0x0006000 },
120  { 0x0E, 0x0002C00, 0x0001000, 0x0007000, 0x0006400 },
121  { 0x0E, 0x0001800, 0x0001800, 0x0006800, 0x000C000 },
122  { 0x0F, 0x0005800, 0x0002000, 0x000E000, 0x000C800 },
123  { 0x0F, 0x0003000, 0x0003000, 0x000D000, 0x0018000 },
124  { 0x10, 0x000B000, 0x0004000, 0x001C000, 0x0019000 },
125  { 0x10, 0x0006000, 0x0006000, 0x001A000, 0x0030000 },
126  { 0x11, 0x0016000, 0x0008000, 0x0038000, 0x0032000 },
127  { 0x11, 0x000C000, 0x000C000, 0x0034000, 0x0060000 },
128  { 0x12, 0x002C000, 0x0010000, 0x0070000, 0x0064000 },
129  { 0x12, 0x0018000, 0x0018000, 0x0068000, 0x00C0000 },
130  { 0x13, 0x0058000, 0x0020000, 0x00E0000, 0x00C8000 },
131  { 0x13, 0x0030000, 0x0030000, 0x00D0000, 0x0180000 },
132  { 0x14, 0x00B0000, 0x0040000, 0x01C0000, 0x0190000 },
133  { 0x14, 0x0060000, 0x0060000, 0x01A0000, 0x0300000 },
134  { 0x15, 0x0160000, 0x0080000, 0x0380000, 0x0320000 },
135  { 0x15, 0x00C0000, 0x00C0000, 0x0340000, 0x0600000 },
136  { 0x16, 0x02C0000, 0x0100000, 0x0700000, 0x0640000 },
137  { 0x16, 0x0180000, 0x0180000, 0x0680000, 0x0C00000 },
138  { 0x17, 0x0580000, 0x0200000, 0x0E00000, 0x0C80000 },
139  { 0x17, 0x0300000, 0x0300000, 0x0D00000, 0x1800000 },
140  { 0x18, 0x0B00000, 0x0400000, 0x1C00000, 0x1900000 },
141  { 0x18, 0x0600000, 0x0600000, 0x1A00000, 0x3000000 },
142  { 0x19, 0x1600000, 0x0800000, 0x3800000, 0x3200000 },
143  { 0x19, 0x0C00000, 0x0C00000, 0x3400000, 0x6000000 },
144  { 0x1A, 0x2C00000, 0x1000000, 0x7000000, 0x6400000 },
145  { 0x1A, 0x1800000, 0x1800000, 0x6800000, 0xC000000 },
146 };
147 
148 static int set_bps_params(AVCodecContext *avctx)
149 {
150  switch (avctx->bits_per_raw_sample) {
151  case 8:
152  avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
153  break;
154  case 16:
156  break;
157  case 24:
159  break;
160  default:
161  av_log(avctx, AV_LOG_ERROR, "invalid/unsupported bits per sample: %d\n",
162  avctx->bits_per_raw_sample);
163  return AVERROR_INVALIDDATA;
164  }
165 
166  return 0;
167 }
168 
170 {
171  TAKDecContext *s = avctx->priv_data;
172  int shift;
173 
174  if (avctx->sample_rate < 11025) {
175  shift = 3;
176  } else if (avctx->sample_rate < 22050) {
177  shift = 2;
178  } else if (avctx->sample_rate < 44100) {
179  shift = 1;
180  } else {
181  shift = 0;
182  }
183  s->uval = FFALIGN(avctx->sample_rate + 511LL >> 9, 4) << shift;
184  s->subframe_scale = FFALIGN(avctx->sample_rate + 511LL >> 9, 4) << 1;
185 }
186 
188 {
189  TAKDecContext *s = avctx->priv_data;
190 
191  ff_audiodsp_init(&s->adsp);
192  ff_takdsp_init(&s->tdsp);
193 
194  s->avctx = avctx;
196 
197  set_sample_rate_params(avctx);
198 
199  return set_bps_params(avctx);
200 }
201 
202 static void decode_lpc(int32_t *coeffs, int mode, int length)
203 {
204  int i;
205 
206  if (length < 2)
207  return;
208 
209  if (mode == 1) {
210  unsigned a1 = *coeffs++;
211  for (i = 0; i < length - 1 >> 1; i++) {
212  *coeffs += a1;
213  coeffs[1] += (unsigned)*coeffs;
214  a1 = coeffs[1];
215  coeffs += 2;
216  }
217  if (length - 1 & 1)
218  *coeffs += a1;
219  } else if (mode == 2) {
220  unsigned a1 = coeffs[1];
221  unsigned a2 = a1 + *coeffs;
222  coeffs[1] = a2;
223  if (length > 2) {
224  coeffs += 2;
225  for (i = 0; i < length - 2 >> 1; i++) {
226  unsigned a3 = *coeffs + a1;
227  unsigned a4 = a3 + a2;
228  *coeffs = a4;
229  a1 = coeffs[1] + a3;
230  a2 = a1 + a4;
231  coeffs[1] = a2;
232  coeffs += 2;
233  }
234  if (length & 1)
235  *coeffs += a1 + a2;
236  }
237  } else if (mode == 3) {
238  unsigned a1 = coeffs[1];
239  unsigned a2 = a1 + *coeffs;
240  coeffs[1] = a2;
241  if (length > 2) {
242  unsigned a3 = coeffs[2];
243  unsigned a4 = a3 + a1;
244  unsigned a5 = a4 + a2;
245  coeffs[2] = a5;
246  coeffs += 3;
247  for (i = 0; i < length - 3; i++) {
248  a3 += *coeffs;
249  a4 += a3;
250  a5 += a4;
251  *coeffs = a5;
252  coeffs++;
253  }
254  }
255  }
256 }
257 
258 static int decode_segment(TAKDecContext *s, int8_t mode, int32_t *decoded, int len)
259 {
260  struct CParam code;
261  GetBitContext *gb = &s->gb;
262  int i;
263 
264  if (!mode) {
265  memset(decoded, 0, len * sizeof(*decoded));
266  return 0;
267  }
268 
269  if (mode > FF_ARRAY_ELEMS(xcodes))
270  return AVERROR_INVALIDDATA;
271  code = xcodes[mode - 1];
272 
273  for (i = 0; i < len; i++) {
274  unsigned x = get_bits_long(gb, code.init);
275  if (x >= code.escape && get_bits1(gb)) {
276  x |= 1 << code.init;
277  if (x >= code.aescape) {
278  unsigned scale = get_unary(gb, 1, 9);
279  if (scale == 9) {
280  int scale_bits = get_bits(gb, 3);
281  if (scale_bits > 0) {
282  if (scale_bits == 7) {
283  scale_bits += get_bits(gb, 5);
284  if (scale_bits > 29)
285  return AVERROR_INVALIDDATA;
286  }
287  scale = get_bits_long(gb, scale_bits) + 1;
288  x += code.scale * scale;
289  }
290  x += code.bias;
291  } else
292  x += code.scale * scale - code.escape;
293  } else
294  x -= code.escape;
295  }
296  decoded[i] = (x >> 1) ^ -(x & 1);
297  }
298 
299  return 0;
300 }
301 
302 static int decode_residues(TAKDecContext *s, int32_t *decoded, int length)
303 {
304  GetBitContext *gb = &s->gb;
305  int i, mode, ret;
306 
307  if (length > s->nb_samples)
308  return AVERROR_INVALIDDATA;
309 
310  if (get_bits1(gb)) {
311  int wlength, rval;
312 
313  wlength = length / s->uval;
314 
315  rval = length - (wlength * s->uval);
316 
317  if (rval < s->uval / 2)
318  rval += s->uval;
319  else
320  wlength++;
321 
322  if (wlength <= 1 || wlength > 128)
323  return AVERROR_INVALIDDATA;
324 
325  s->coding_mode[0] = mode = get_bits(gb, 6);
326 
327  for (i = 1; i < wlength; i++) {
328  int c = get_unary(gb, 1, 6);
329 
330  switch (c) {
331  case 6:
332  mode = get_bits(gb, 6);
333  break;
334  case 5:
335  case 4:
336  case 3: {
337  /* mode += sign ? (1 - c) : (c - 1) */
338  int sign = get_bits1(gb);
339  mode += (-sign ^ (c - 1)) + sign;
340  break;
341  }
342  case 2:
343  mode++;
344  break;
345  case 1:
346  mode--;
347  break;
348  }
349  s->coding_mode[i] = mode;
350  }
351 
352  i = 0;
353  while (i < wlength) {
354  int len = 0;
355 
356  mode = s->coding_mode[i];
357  do {
358  if (i >= wlength - 1)
359  len += rval;
360  else
361  len += s->uval;
362  i++;
363 
364  if (i == wlength)
365  break;
366  } while (s->coding_mode[i] == mode);
367 
368  if ((ret = decode_segment(s, mode, decoded, len)) < 0)
369  return ret;
370  decoded += len;
371  }
372  } else {
373  mode = get_bits(gb, 6);
374  if ((ret = decode_segment(s, mode, decoded, length)) < 0)
375  return ret;
376  }
377 
378  return 0;
379 }
380 
382 {
383  if (get_bits1(gb))
384  return get_bits(gb, 4) + 1;
385  else
386  return 0;
387 }
388 
389 static int decode_subframe(TAKDecContext *s, int32_t *decoded,
390  int subframe_size, int prev_subframe_size)
391 {
392  GetBitContext *gb = &s->gb;
393  int x, y, i, j, ret = 0;
394  int dshift, size, filter_quant, filter_order;
395  int tfilter[MAX_PREDICTORS];
396 
397  if (!get_bits1(gb))
398  return decode_residues(s, decoded, subframe_size);
399 
400  filter_order = predictor_sizes[get_bits(gb, 4)];
401 
402  if (prev_subframe_size > 0 && get_bits1(gb)) {
403  if (filter_order > prev_subframe_size)
404  return AVERROR_INVALIDDATA;
405 
406  decoded -= filter_order;
407  subframe_size += filter_order;
408 
409  if (filter_order > subframe_size)
410  return AVERROR_INVALIDDATA;
411  } else {
412  int lpc_mode;
413 
414  if (filter_order > subframe_size)
415  return AVERROR_INVALIDDATA;
416 
417  lpc_mode = get_bits(gb, 2);
418  if (lpc_mode > 2)
419  return AVERROR_INVALIDDATA;
420 
421  if ((ret = decode_residues(s, decoded, filter_order)) < 0)
422  return ret;
423 
424  if (lpc_mode)
425  decode_lpc(decoded, lpc_mode, filter_order);
426  }
427 
428  dshift = get_bits_esc4(gb);
429  size = get_bits1(gb) + 6;
430 
431  filter_quant = 10;
432  if (get_bits1(gb)) {
433  filter_quant -= get_bits(gb, 3) + 1;
434  if (filter_quant < 3)
435  return AVERROR_INVALIDDATA;
436  }
437 
438  if (get_bits_left(gb) < 2*10 + 2*size)
439  return AVERROR_INVALIDDATA;
440 
441  s->predictors[0] = get_sbits(gb, 10);
442  s->predictors[1] = get_sbits(gb, 10);
443  s->predictors[2] = get_sbits(gb, size) * (1 << (10 - size));
444  s->predictors[3] = get_sbits(gb, size) * (1 << (10 - size));
445  if (filter_order > 4) {
446  int tmp = size - get_bits1(gb);
447 
448  for (i = 4; i < filter_order; i++) {
449  if (!(i & 3))
450  x = tmp - get_bits(gb, 2);
451  s->predictors[i] = get_sbits(gb, x) * (1 << (10 - size));
452  }
453  }
454 
455  tfilter[0] = s->predictors[0] * 64;
456  for (i = 1; i < filter_order; i++) {
457  uint32_t *p1 = &tfilter[0];
458  uint32_t *p2 = &tfilter[i - 1];
459 
460  for (j = 0; j < (i + 1) / 2; j++) {
461  x = *p1 + ((int32_t)(s->predictors[i] * *p2 + 256) >> 9);
462  *p2 += (int32_t)(s->predictors[i] * *p1 + 256) >> 9;
463  *p1++ = x;
464  p2--;
465  }
466 
467  tfilter[i] = s->predictors[i] * 64;
468  }
469 
470  x = 1 << (32 - (15 - filter_quant));
471  y = 1 << ((15 - filter_quant) - 1);
472  for (i = 0, j = filter_order - 1; i < filter_order / 2; i++, j--) {
473  s->filter[j] = x - ((tfilter[i] + y) >> (15 - filter_quant));
474  s->filter[i] = x - ((tfilter[j] + y) >> (15 - filter_quant));
475  }
476 
477  if ((ret = decode_residues(s, &decoded[filter_order],
478  subframe_size - filter_order)) < 0)
479  return ret;
480 
481  for (i = 0; i < filter_order; i++)
482  s->residues[i] = *decoded++ >> dshift;
483 
484  y = FF_ARRAY_ELEMS(s->residues) - filter_order;
485  x = subframe_size - filter_order;
486  while (x > 0) {
487  int tmp = FFMIN(y, x);
488 
489  for (i = 0; i < tmp; i++) {
490  int v = 1 << (filter_quant - 1);
491 
492  if (filter_order & -16)
493  v += (unsigned)s->adsp.scalarproduct_int16(&s->residues[i], s->filter,
494  filter_order & -16);
495  for (j = filter_order & -16; j < filter_order; j += 4) {
496  v += s->residues[i + j + 3] * (unsigned)s->filter[j + 3] +
497  s->residues[i + j + 2] * (unsigned)s->filter[j + 2] +
498  s->residues[i + j + 1] * (unsigned)s->filter[j + 1] +
499  s->residues[i + j ] * (unsigned)s->filter[j ];
500  }
501  v = (av_clip_intp2(v >> filter_quant, 13) * (1 << dshift)) - (unsigned)*decoded;
502  *decoded++ = v;
503  s->residues[filter_order + i] = v >> dshift;
504  }
505 
506  x -= tmp;
507  if (x > 0)
508  memcpy(s->residues, &s->residues[y], 2 * filter_order);
509  }
510 
511  return 0;
512 }
513 
514 static int decode_channel(TAKDecContext *s, int chan)
515 {
516  AVCodecContext *avctx = s->avctx;
517  GetBitContext *gb = &s->gb;
518  int32_t *decoded = s->decoded[chan];
519  int left = s->nb_samples - 1;
520  int i = 0, ret, prev = 0;
521 
522  s->sample_shift[chan] = get_bits_esc4(gb);
523  if (s->sample_shift[chan] >= avctx->bits_per_raw_sample)
524  return AVERROR_INVALIDDATA;
525 
526  *decoded++ = get_sbits(gb, avctx->bits_per_raw_sample - s->sample_shift[chan]);
527  s->lpc_mode[chan] = get_bits(gb, 2);
528  s->nb_subframes = get_bits(gb, 3) + 1;
529 
530  if (s->nb_subframes > 1) {
531  if (get_bits_left(gb) < (s->nb_subframes - 1) * 6)
532  return AVERROR_INVALIDDATA;
533 
534  for (; i < s->nb_subframes - 1; i++) {
535  int v = get_bits(gb, 6);
536 
537  s->subframe_len[i] = (v - prev) * s->subframe_scale;
538  if (s->subframe_len[i] <= 0)
539  return AVERROR_INVALIDDATA;
540 
541  left -= s->subframe_len[i];
542  prev = v;
543  }
544 
545  if (left <= 0)
546  return AVERROR_INVALIDDATA;
547  }
548  s->subframe_len[i] = left;
549 
550  prev = 0;
551  for (i = 0; i < s->nb_subframes; i++) {
552  if ((ret = decode_subframe(s, decoded, s->subframe_len[i], prev)) < 0)
553  return ret;
554  decoded += s->subframe_len[i];
555  prev = s->subframe_len[i];
556  }
557 
558  return 0;
559 }
560 
561 static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
562 {
563  GetBitContext *gb = &s->gb;
564  int32_t *p1 = s->decoded[c1] + (s->dmode > 5);
565  int32_t *p2 = s->decoded[c2] + (s->dmode > 5);
566  int32_t bp1 = p1[0];
567  int32_t bp2 = p2[0];
568  int i;
569  int dshift, dfactor;
570 
571  length += s->dmode < 6;
572 
573  switch (s->dmode) {
574  case 1: /* left/side */
575  s->tdsp.decorrelate_ls(p1, p2, length);
576  break;
577  case 2: /* side/right */
578  s->tdsp.decorrelate_sr(p1, p2, length);
579  break;
580  case 3: /* side/mid */
581  s->tdsp.decorrelate_sm(p1, p2, length);
582  break;
583  case 4: /* side/left with scale factor */
584  FFSWAP(int32_t*, p1, p2);
585  FFSWAP(int32_t, bp1, bp2);
587  case 5: /* side/right with scale factor */
588  dshift = get_bits_esc4(gb);
589  dfactor = get_sbits(gb, 10);
590  s->tdsp.decorrelate_sf(p1, p2, length, dshift, dfactor);
591  break;
592  case 6:
593  FFSWAP(int32_t*, p1, p2);
595  case 7: {
596  int length2, order_half, filter_order, dval1, dval2;
597  int tmp, x, code_size;
598 
599  if (length < 256)
600  return AVERROR_INVALIDDATA;
601 
602  dshift = get_bits_esc4(gb);
603  filter_order = 8 << get_bits1(gb);
604  dval1 = get_bits1(gb);
605  dval2 = get_bits1(gb);
606 
607  for (i = 0; i < filter_order; i++) {
608  if (!(i & 3))
609  code_size = 14 - get_bits(gb, 3);
610  s->filter[i] = get_sbits(gb, code_size);
611  }
612 
613  order_half = filter_order / 2;
614  length2 = length - (filter_order - 1);
615 
616  /* decorrelate beginning samples */
617  if (dval1) {
618  for (i = 0; i < order_half; i++) {
619  int32_t a = p1[i];
620  int32_t b = p2[i];
621  p1[i] = a + b;
622  }
623  }
624 
625  /* decorrelate ending samples */
626  if (dval2) {
627  for (i = length2 + order_half; i < length; i++) {
628  int32_t a = p1[i];
629  int32_t b = p2[i];
630  p1[i] = a + b;
631  }
632  }
633 
634 
635  for (i = 0; i < filter_order; i++)
636  s->residues[i] = *p2++ >> dshift;
637 
638  p1 += order_half;
639  x = FF_ARRAY_ELEMS(s->residues) - filter_order;
640  for (; length2 > 0; length2 -= tmp) {
641  tmp = FFMIN(length2, x);
642 
643  for (i = 0; i < tmp - (tmp == length2); i++)
644  s->residues[filter_order + i] = *p2++ >> dshift;
645 
646  for (i = 0; i < tmp; i++) {
647  int v = 1 << 9;
648 
649  if (filter_order == 16) {
650  v += s->adsp.scalarproduct_int16(&s->residues[i], s->filter,
651  filter_order);
652  } else {
653  v += s->residues[i + 7] * s->filter[7] +
654  s->residues[i + 6] * s->filter[6] +
655  s->residues[i + 5] * s->filter[5] +
656  s->residues[i + 4] * s->filter[4] +
657  s->residues[i + 3] * s->filter[3] +
658  s->residues[i + 2] * s->filter[2] +
659  s->residues[i + 1] * s->filter[1] +
660  s->residues[i ] * s->filter[0];
661  }
662 
663  v = av_clip_intp2(v >> 10, 13) * (1U << dshift) - *p1;
664  *p1++ = v;
665  }
666 
667  memmove(s->residues, &s->residues[tmp], 2 * filter_order);
668  }
669  break;
670  }
671  }
672 
673  if (s->dmode > 0 && s->dmode < 6) {
674  p1[0] = bp1;
675  p2[0] = bp2;
676  }
677 
678  return 0;
679 }
680 
682  int *got_frame_ptr, AVPacket *pkt)
683 {
684  TAKDecContext *s = avctx->priv_data;
685  GetBitContext *gb = &s->gb;
686  int chan, i, ret, hsize;
687 
689  return AVERROR_INVALIDDATA;
690 
691  if ((ret = init_get_bits8(gb, pkt->data, pkt->size)) < 0)
692  return ret;
693 
694  if ((ret = ff_tak_decode_frame_header(avctx, gb, &s->ti, 0)) < 0)
695  return ret;
696 
697  hsize = get_bits_count(gb) / 8;
699  if (ff_tak_check_crc(pkt->data, hsize)) {
700  av_log(avctx, AV_LOG_ERROR, "CRC error\n");
701  if (avctx->err_recognition & AV_EF_EXPLODE)
702  return AVERROR_INVALIDDATA;
703  }
704  }
705 
706  if (s->ti.codec != TAK_CODEC_MONO_STEREO &&
707  s->ti.codec != TAK_CODEC_MULTICHANNEL) {
708  avpriv_report_missing_feature(avctx, "TAK codec type %d", s->ti.codec);
709  return AVERROR_PATCHWELCOME;
710  }
711  if (s->ti.data_type) {
712  av_log(avctx, AV_LOG_ERROR,
713  "unsupported data type: %d\n", s->ti.data_type);
714  return AVERROR_INVALIDDATA;
715  }
716  if (s->ti.codec == TAK_CODEC_MONO_STEREO && s->ti.channels > 2) {
717  av_log(avctx, AV_LOG_ERROR,
718  "invalid number of channels: %d\n", s->ti.channels);
719  return AVERROR_INVALIDDATA;
720  }
721  if (s->ti.channels > 6) {
722  av_log(avctx, AV_LOG_ERROR,
723  "unsupported number of channels: %d\n", s->ti.channels);
724  return AVERROR_INVALIDDATA;
725  }
726 
727  if (s->ti.frame_samples <= 0) {
728  av_log(avctx, AV_LOG_ERROR, "unsupported/invalid number of samples\n");
729  return AVERROR_INVALIDDATA;
730  }
731 
732  avctx->bits_per_raw_sample = s->ti.bps;
733  if ((ret = set_bps_params(avctx)) < 0)
734  return ret;
735  if (s->ti.sample_rate != avctx->sample_rate) {
736  avctx->sample_rate = s->ti.sample_rate;
737  set_sample_rate_params(avctx);
738  }
739 
741  if (s->ti.ch_layout) {
742  av_channel_layout_from_mask(&avctx->ch_layout, s->ti.ch_layout);
743  } else {
745  avctx->ch_layout.nb_channels = s->ti.channels;
746  }
747 
748  s->nb_samples = s->ti.last_frame_samples ? s->ti.last_frame_samples
749  : s->ti.frame_samples;
750 
751  frame->nb_samples = s->nb_samples;
752  if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
753  return ret;
754  ff_thread_finish_setup(avctx);
755 
756  if (avctx->bits_per_raw_sample <= 16) {
757  int buf_size = av_samples_get_buffer_size(NULL, avctx->ch_layout.nb_channels,
758  s->nb_samples,
759  AV_SAMPLE_FMT_S32P, 0);
760  if (buf_size < 0)
761  return buf_size;
762  av_fast_malloc(&s->decode_buffer, &s->decode_buffer_size, buf_size);
763  if (!s->decode_buffer)
764  return AVERROR(ENOMEM);
765  ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
766  s->decode_buffer, avctx->ch_layout.nb_channels,
767  s->nb_samples, AV_SAMPLE_FMT_S32P, 0);
768  if (ret < 0)
769  return ret;
770  } else {
771  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++)
772  s->decoded[chan] = (int32_t *)frame->extended_data[chan];
773  }
774 
775  if (s->nb_samples < 16) {
776  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) {
777  int32_t *decoded = s->decoded[chan];
778  for (i = 0; i < s->nb_samples; i++)
779  decoded[i] = get_sbits(gb, avctx->bits_per_raw_sample);
780  }
781  } else {
782  if (s->ti.codec == TAK_CODEC_MONO_STEREO) {
783  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++)
784  if (ret = decode_channel(s, chan))
785  return ret;
786 
787  if (avctx->ch_layout.nb_channels == 2) {
788  s->nb_subframes = get_bits(gb, 1) + 1;
789  if (s->nb_subframes > 1) {
790  s->subframe_len[1] = get_bits(gb, 6);
791  }
792 
793  s->dmode = get_bits(gb, 3);
794  if (ret = decorrelate(s, 0, 1, s->nb_samples - 1))
795  return ret;
796  }
797  } else if (s->ti.codec == TAK_CODEC_MULTICHANNEL) {
798  if (get_bits1(gb)) {
799  int ch_mask = 0;
800 
801  chan = get_bits(gb, 4) + 1;
802  if (chan > avctx->ch_layout.nb_channels)
803  return AVERROR_INVALIDDATA;
804 
805  for (i = 0; i < chan; i++) {
806  int nbit = get_bits(gb, 4);
807 
808  if (nbit >= avctx->ch_layout.nb_channels)
809  return AVERROR_INVALIDDATA;
810 
811  if (ch_mask & 1 << nbit)
812  return AVERROR_INVALIDDATA;
813 
814  s->mcdparams[i].present = get_bits1(gb);
815  if (s->mcdparams[i].present) {
816  s->mcdparams[i].index = get_bits(gb, 2);
817  s->mcdparams[i].chan2 = get_bits(gb, 4);
818  if (s->mcdparams[i].chan2 >= avctx->ch_layout.nb_channels) {
819  av_log(avctx, AV_LOG_ERROR,
820  "invalid channel 2 (%d) for %d channel(s)\n",
821  s->mcdparams[i].chan2, avctx->ch_layout.nb_channels);
822  return AVERROR_INVALIDDATA;
823  }
824  if (s->mcdparams[i].index == 1) {
825  if ((nbit == s->mcdparams[i].chan2) ||
826  (ch_mask & 1 << s->mcdparams[i].chan2))
827  return AVERROR_INVALIDDATA;
828 
829  ch_mask |= 1 << s->mcdparams[i].chan2;
830  } else if (!(ch_mask & 1 << s->mcdparams[i].chan2)) {
831  return AVERROR_INVALIDDATA;
832  }
833  }
834  s->mcdparams[i].chan1 = nbit;
835 
836  ch_mask |= 1 << nbit;
837  }
838  } else {
839  chan = avctx->ch_layout.nb_channels;
840  for (i = 0; i < chan; i++) {
841  s->mcdparams[i].present = 0;
842  s->mcdparams[i].chan1 = i;
843  }
844  }
845 
846  for (i = 0; i < chan; i++) {
847  if (s->mcdparams[i].present && s->mcdparams[i].index == 1)
848  if (ret = decode_channel(s, s->mcdparams[i].chan2))
849  return ret;
850 
851  if (ret = decode_channel(s, s->mcdparams[i].chan1))
852  return ret;
853 
854  if (s->mcdparams[i].present) {
855  s->dmode = mc_dmodes[s->mcdparams[i].index];
856  if (ret = decorrelate(s,
857  s->mcdparams[i].chan2,
858  s->mcdparams[i].chan1,
859  s->nb_samples - 1))
860  return ret;
861  }
862  }
863  }
864 
865  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) {
866  int32_t *decoded = s->decoded[chan];
867 
868  if (s->lpc_mode[chan])
869  decode_lpc(decoded, s->lpc_mode[chan], s->nb_samples);
870 
871  if (s->sample_shift[chan] > 0)
872  for (i = 0; i < s->nb_samples; i++)
873  decoded[i] *= 1U << s->sample_shift[chan];
874  }
875  }
876 
877  align_get_bits(gb);
878  skip_bits(gb, 24);
879  if (get_bits_left(gb) < 0)
880  av_log(avctx, AV_LOG_DEBUG, "overread\n");
881  else if (get_bits_left(gb) > 0)
882  av_log(avctx, AV_LOG_DEBUG, "underread\n");
883 
885  if (ff_tak_check_crc(pkt->data + hsize,
886  get_bits_count(gb) / 8 - hsize)) {
887  av_log(avctx, AV_LOG_ERROR, "CRC error\n");
888  if (avctx->err_recognition & AV_EF_EXPLODE)
889  return AVERROR_INVALIDDATA;
890  }
891  }
892 
893  /* convert to output buffer */
894  switch (avctx->sample_fmt) {
895  case AV_SAMPLE_FMT_U8P:
896  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) {
897  uint8_t *samples = (uint8_t *)frame->extended_data[chan];
898  int32_t *decoded = s->decoded[chan];
899  for (i = 0; i < s->nb_samples; i++)
900  samples[i] = decoded[i] + 0x80U;
901  }
902  break;
903  case AV_SAMPLE_FMT_S16P:
904  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) {
905  int16_t *samples = (int16_t *)frame->extended_data[chan];
906  int32_t *decoded = s->decoded[chan];
907  for (i = 0; i < s->nb_samples; i++)
908  samples[i] = decoded[i];
909  }
910  break;
911  case AV_SAMPLE_FMT_S32P:
912  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) {
913  int32_t *samples = (int32_t *)frame->extended_data[chan];
914  for (i = 0; i < s->nb_samples; i++)
915  samples[i] *= 1U << 8;
916  }
917  break;
918  }
919 
920  *got_frame_ptr = 1;
921 
922  return pkt->size;
923 }
924 
925 #if HAVE_THREADS
927  const AVCodecContext *src)
928 {
929  TAKDecContext *tsrc = src->priv_data;
930  TAKDecContext *tdst = dst->priv_data;
931 
932  if (dst == src)
933  return 0;
934  memcpy(&tdst->ti, &tsrc->ti, sizeof(TAKStreamInfo));
935  return 0;
936 }
937 #endif
938 
940 {
941  TAKDecContext *s = avctx->priv_data;
942 
943  av_freep(&s->decode_buffer);
944 
945  return 0;
946 }
947 
949  .p.name = "tak",
950  CODEC_LONG_NAME("TAK (Tom's lossless Audio Kompressor)"),
951  .p.type = AVMEDIA_TYPE_AUDIO,
952  .p.id = AV_CODEC_ID_TAK,
953  .priv_data_size = sizeof(TAKDecContext),
959 };
TAK_MAX_CHANNELS
#define TAK_MAX_CHANNELS
Definition: tak.h:62
ff_tak_decode_frame_header
int ff_tak_decode_frame_header(void *logctx, GetBitContext *gb, TAKStreamInfo *ti, int log_level_offset)
Validate and decode a frame header.
Definition: tak.c:147
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
TAKDecContext::avctx
AVCodecContext * avctx
parent AVCodecContext
Definition: takdec.c:55
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:688
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
TAKDecContext::sample_shift
int8_t sample_shift[TAK_MAX_CHANNELS]
shift applied to every sample in the channel
Definition: takdec.c:68
MCDParam::chan1
int8_t chan1
Definition: takdec.c:50
MCDParam::present
int8_t present
decorrelation parameter availability for this channel
Definition: takdec.c:48
mem_internal.h
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: defs.h:55
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1036
TAKDecContext::ti
TAKStreamInfo ti
Definition: takdec.c:58
MAX_PREDICTORS
#define MAX_PREDICTORS
Definition: takdec.c:45
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1410
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:424
av_samples_fill_arrays
int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, const uint8_t *buf, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Fill plane data pointers and linesize for samples with sample format sample_fmt.
Definition: samplefmt.c:153
TAKDecContext::tdsp
TAKDSPContext tdsp
Definition: takdec.c:57
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:254
mode
Definition: swscale.c:60
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:435
TAKDecContext::mcdparams
MCDParam mcdparams[TAK_MAX_CHANNELS]
multichannel decorrelation parameters
Definition: takdec.c:76
CParam::scale
int scale
Definition: takdec.c:92
AVPacket::data
uint8_t * data
Definition: packet.h:595
b
#define b
Definition: input.c:43
TAKDSPContext
Definition: takdsp.h:24
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
FFCodec
Definition: codec_internal.h:127
ff_audiodsp_init
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:65
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:324
c1
static const uint64_t c1
Definition: murmur3.c:52
TAKDecContext::lpc_mode
int8_t lpc_mode[TAK_MAX_CHANNELS]
Definition: takdec.c:67
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
thread.h
TAKDecContext::subframe_len
int16_t subframe_len[MAX_SUBFRAMES]
subframe length in samples
Definition: takdec.c:71
tak_decode_close
static av_cold int tak_decode_close(AVCodecContext *avctx)
Definition: takdec.c:939
predictor_sizes
static const uint16_t predictor_sizes[]
Definition: takdec.c:85
MCDParam::chan2
int8_t chan2
Definition: takdec.c:51
ff_takdsp_init
av_cold void ff_takdsp_init(TAKDSPContext *c)
Definition: takdsp.c:73
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:383
close
static av_cold void close(AVCodecParserContext *s)
Definition: apv_parser.c:197
TAKDecContext::coding_mode
int8_t coding_mode[128]
Definition: takdec.c:78
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:337
MCDParam::index
int8_t index
index into array of decorrelation types
Definition: takdec.c:49
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
TAKDecContext::uval
int uval
Definition: takdec.c:61
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1051
GetBitContext
Definition: get_bits.h:109
samplefmt.h
MAX_SUBFRAMES
#define MAX_SUBFRAMES
max number of subframes per channel
Definition: takdec.c:44
a2
static double a2(void *priv, double x, double y)
Definition: vf_xfade.c:2030
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:119
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:544
tak_decode_init
static av_cold int tak_decode_init(AVCodecContext *avctx)
Definition: takdec.c:187
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:347
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:119
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1044
av_channel_layout_from_mask
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:253
CParam::bias
int bias
Definition: takdec.c:94
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1565
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:322
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
TAK_CODEC_MONO_STEREO
@ TAK_CODEC_MONO_STEREO
Definition: tak.h:98
TAKDecContext::adsp
AudioDSPContext adsp
Definition: takdec.c:56
av_fallthrough
#define av_fallthrough
Definition: attributes.h:67
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
decorrelate
static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
Definition: takdec.c:561
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:95
NULL
#define NULL
Definition: coverity.c:32
av_clip_intp2
#define av_clip_intp2
Definition: common.h:121
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
a3
static double a3(void *priv, double x, double y)
Definition: vf_xfade.c:2031
TAKDecContext::dmode
int8_t dmode
channel decorrelation type in the current frame
Definition: takdec.c:74
ff_tak_decoder
const FFCodec ff_tak_decoder
Definition: takdec.c:948
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:391
TAKDecContext::decode_buffer_size
unsigned int decode_buffer_size
Definition: takdec.c:64
tak.h
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:341
decode_channel
static int decode_channel(TAKDecContext *s, int chan)
Definition: takdec.c:514
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: defs.h:48
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:91
takdsp.h
CParam::aescape
int aescape
Definition: takdec.c:93
TAKDecContext
Definition: takdec.c:54
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:551
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:596
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:63
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
shift
static int shift(int a, int b)
Definition: bonk.c:261
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
TAKDecContext::residues
int16_t residues[544]
Definition: takdec.c:80
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1043
size
int size
Definition: twinvq_data.h:10344
decode_residues
static int decode_residues(TAKDecContext *s, int32_t *decoded, int length)
Definition: takdec.c:302
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
ff_tak_check_crc
int ff_tak_check_crc(const uint8_t *buf, unsigned int buf_size)
Definition: tak.c:79
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
attributes.h
unary.h
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
CParam::init
int init
Definition: takdec.c:90
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1558
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
internal.h
TAKDecContext::decode_buffer
uint8_t * decode_buffer
Definition: takdec.c:63
get_bits_esc4
static int get_bits_esc4(GetBitContext *gb)
Definition: takdec.c:381
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
len
int len
Definition: vorbis_enc_data.h:426
av_samples_get_buffer_size
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:121
avcodec.h
set_sample_rate_params
static void set_sample_rate_params(AVCodecContext *avctx)
Definition: takdec.c:169
ret
ret
Definition: filter_design.txt:187
decode_lpc
static void decode_lpc(int32_t *coeffs, int mode, int length)
Definition: takdec.c:202
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
mc_dmodes
static const int8_t mc_dmodes[]
Definition: takdec.c:83
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:560
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
CParam::escape
int escape
Definition: takdec.c:91
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:439
c2
static const uint64_t c2
Definition: murmur3.c:53
TAKDecContext::predictors
int16_t predictors[MAX_PREDICTORS]
Definition: takdec.c:69
mode
mode
Definition: ebur128.h:83
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:443
update_thread_context
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. Use ff_thread_get_buffer()(or ff_progress_frame_get_buffer() in case you have inter-frame dependencies and use the ProgressFrame API) to allocate frame buffers. Call ff_progress_frame_report() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
TAKDecContext::gb
GetBitContext gb
bitstream reader initialized to start at the current frame
Definition: takdec.c:59
xcodes
static const struct CParam xcodes[50]
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
TAKDecContext::filter
int16_t filter[MAX_PREDICTORS]
Definition: takdec.c:79
set_bps_params
static int set_bps_params(AVCodecContext *avctx)
Definition: takdec.c:148
MCDParam
Definition: takdec.c:47
audiodsp.h
mem.h
TAKStreamInfo
Definition: tak.h:126
AudioDSPContext
Definition: audiodsp.h:24
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:278
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:572
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:466
CParam
Definition: takdec.c:89
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:557
AV_CODEC_ID_TAK
@ AV_CODEC_ID_TAK
Definition: codec_id.h:522
TAKDecContext::nb_samples
int nb_samples
number of samples in the current frame
Definition: takdec.c:62
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
a1
static double a1(void *priv, double x, double y)
Definition: vf_xfade.c:2029
TAKDecContext::decoded
int32_t * decoded[TAK_MAX_CHANNELS]
decoded samples for each channel
Definition: takdec.c:65
tak_decode_frame
static int tak_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *pkt)
Definition: takdec.c:681
pkt
static AVPacket * pkt
Definition: demux_decode.c:55
decode_subframe
static int decode_subframe(TAKDecContext *s, int32_t *decoded, int subframe_size, int prev_subframe_size)
Definition: takdec.c:389
TAK_MIN_FRAME_HEADER_BYTES
#define TAK_MIN_FRAME_HEADER_BYTES
Definition: tak.h:95
TAK_CODEC_MULTICHANNEL
@ TAK_CODEC_MULTICHANNEL
Definition: tak.h:99
TAKDecContext::subframe_scale
int subframe_scale
Definition: takdec.c:72
TAKDecContext::nb_subframes
int nb_subframes
number of subframes in the current frame
Definition: takdec.c:70
src
#define src
Definition: vp8dsp.c:248
decode_segment
static int decode_segment(TAKDecContext *s, int8_t mode, int32_t *decoded, int len)
Definition: takdec.c:258