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/internal.h"
29 #include "libavutil/mem_internal.h"
30 #include "libavutil/samplefmt.h"
31 
32 #define BITSTREAM_READER_LE
33 #include "audiodsp.h"
34 #include "thread.h"
35 #include "avcodec.h"
36 #include "codec_internal.h"
37 #include "unary.h"
38 #include "tak.h"
39 #include "takdsp.h"
40 
41 #define MAX_SUBFRAMES 8 ///< max number of subframes per channel
42 #define MAX_PREDICTORS 256
43 
44 typedef struct MCDParam {
45  int8_t present; ///< decorrelation parameter availability for this channel
46  int8_t index; ///< index into array of decorrelation types
47  int8_t chan1;
48  int8_t chan2;
49 } MCDParam;
50 
51 typedef struct TAKDecContext {
52  AVCodecContext *avctx; ///< parent AVCodecContext
56  GetBitContext gb; ///< bitstream reader initialized to start at the current frame
57 
58  int uval;
59  int nb_samples; ///< number of samples in the current frame
60  uint8_t *decode_buffer;
61  unsigned int decode_buffer_size;
62  int32_t *decoded[TAK_MAX_CHANNELS]; ///< decoded samples for each channel
63 
65  int8_t sample_shift[TAK_MAX_CHANNELS]; ///< shift applied to every sample in the channel
67  int nb_subframes; ///< number of subframes in the current frame
68  int16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples
70 
71  int8_t dmode; ///< channel decorrelation type in the current frame
72 
73  MCDParam mcdparams[TAK_MAX_CHANNELS]; ///< multichannel decorrelation parameters
74 
75  int8_t coding_mode[128];
77  DECLARE_ALIGNED(16, int16_t, residues)[544];
79 
80 static const int8_t mc_dmodes[] = { 1, 3, 4, 6, };
81 
82 static const uint16_t predictor_sizes[] = {
83  4, 8, 12, 16, 24, 32, 48, 64, 80, 96, 128, 160, 192, 224, 256, 0,
84 };
85 
86 static const struct CParam {
87  int init;
88  int escape;
89  int scale;
90  int aescape;
91  int bias;
92 } xcodes[50] = {
93  { 0x01, 0x0000001, 0x0000001, 0x0000003, 0x0000008 },
94  { 0x02, 0x0000003, 0x0000001, 0x0000007, 0x0000006 },
95  { 0x03, 0x0000005, 0x0000002, 0x000000E, 0x000000D },
96  { 0x03, 0x0000003, 0x0000003, 0x000000D, 0x0000018 },
97  { 0x04, 0x000000B, 0x0000004, 0x000001C, 0x0000019 },
98  { 0x04, 0x0000006, 0x0000006, 0x000001A, 0x0000030 },
99  { 0x05, 0x0000016, 0x0000008, 0x0000038, 0x0000032 },
100  { 0x05, 0x000000C, 0x000000C, 0x0000034, 0x0000060 },
101  { 0x06, 0x000002C, 0x0000010, 0x0000070, 0x0000064 },
102  { 0x06, 0x0000018, 0x0000018, 0x0000068, 0x00000C0 },
103  { 0x07, 0x0000058, 0x0000020, 0x00000E0, 0x00000C8 },
104  { 0x07, 0x0000030, 0x0000030, 0x00000D0, 0x0000180 },
105  { 0x08, 0x00000B0, 0x0000040, 0x00001C0, 0x0000190 },
106  { 0x08, 0x0000060, 0x0000060, 0x00001A0, 0x0000300 },
107  { 0x09, 0x0000160, 0x0000080, 0x0000380, 0x0000320 },
108  { 0x09, 0x00000C0, 0x00000C0, 0x0000340, 0x0000600 },
109  { 0x0A, 0x00002C0, 0x0000100, 0x0000700, 0x0000640 },
110  { 0x0A, 0x0000180, 0x0000180, 0x0000680, 0x0000C00 },
111  { 0x0B, 0x0000580, 0x0000200, 0x0000E00, 0x0000C80 },
112  { 0x0B, 0x0000300, 0x0000300, 0x0000D00, 0x0001800 },
113  { 0x0C, 0x0000B00, 0x0000400, 0x0001C00, 0x0001900 },
114  { 0x0C, 0x0000600, 0x0000600, 0x0001A00, 0x0003000 },
115  { 0x0D, 0x0001600, 0x0000800, 0x0003800, 0x0003200 },
116  { 0x0D, 0x0000C00, 0x0000C00, 0x0003400, 0x0006000 },
117  { 0x0E, 0x0002C00, 0x0001000, 0x0007000, 0x0006400 },
118  { 0x0E, 0x0001800, 0x0001800, 0x0006800, 0x000C000 },
119  { 0x0F, 0x0005800, 0x0002000, 0x000E000, 0x000C800 },
120  { 0x0F, 0x0003000, 0x0003000, 0x000D000, 0x0018000 },
121  { 0x10, 0x000B000, 0x0004000, 0x001C000, 0x0019000 },
122  { 0x10, 0x0006000, 0x0006000, 0x001A000, 0x0030000 },
123  { 0x11, 0x0016000, 0x0008000, 0x0038000, 0x0032000 },
124  { 0x11, 0x000C000, 0x000C000, 0x0034000, 0x0060000 },
125  { 0x12, 0x002C000, 0x0010000, 0x0070000, 0x0064000 },
126  { 0x12, 0x0018000, 0x0018000, 0x0068000, 0x00C0000 },
127  { 0x13, 0x0058000, 0x0020000, 0x00E0000, 0x00C8000 },
128  { 0x13, 0x0030000, 0x0030000, 0x00D0000, 0x0180000 },
129  { 0x14, 0x00B0000, 0x0040000, 0x01C0000, 0x0190000 },
130  { 0x14, 0x0060000, 0x0060000, 0x01A0000, 0x0300000 },
131  { 0x15, 0x0160000, 0x0080000, 0x0380000, 0x0320000 },
132  { 0x15, 0x00C0000, 0x00C0000, 0x0340000, 0x0600000 },
133  { 0x16, 0x02C0000, 0x0100000, 0x0700000, 0x0640000 },
134  { 0x16, 0x0180000, 0x0180000, 0x0680000, 0x0C00000 },
135  { 0x17, 0x0580000, 0x0200000, 0x0E00000, 0x0C80000 },
136  { 0x17, 0x0300000, 0x0300000, 0x0D00000, 0x1800000 },
137  { 0x18, 0x0B00000, 0x0400000, 0x1C00000, 0x1900000 },
138  { 0x18, 0x0600000, 0x0600000, 0x1A00000, 0x3000000 },
139  { 0x19, 0x1600000, 0x0800000, 0x3800000, 0x3200000 },
140  { 0x19, 0x0C00000, 0x0C00000, 0x3400000, 0x6000000 },
141  { 0x1A, 0x2C00000, 0x1000000, 0x7000000, 0x6400000 },
142  { 0x1A, 0x1800000, 0x1800000, 0x6800000, 0xC000000 },
143 };
144 
145 static int set_bps_params(AVCodecContext *avctx)
146 {
147  switch (avctx->bits_per_raw_sample) {
148  case 8:
149  avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
150  break;
151  case 16:
153  break;
154  case 24:
156  break;
157  default:
158  av_log(avctx, AV_LOG_ERROR, "invalid/unsupported bits per sample: %d\n",
159  avctx->bits_per_raw_sample);
160  return AVERROR_INVALIDDATA;
161  }
162 
163  return 0;
164 }
165 
167 {
168  TAKDecContext *s = avctx->priv_data;
169  int shift;
170 
171  if (avctx->sample_rate < 11025) {
172  shift = 3;
173  } else if (avctx->sample_rate < 22050) {
174  shift = 2;
175  } else if (avctx->sample_rate < 44100) {
176  shift = 1;
177  } else {
178  shift = 0;
179  }
180  s->uval = FFALIGN(avctx->sample_rate + 511LL >> 9, 4) << shift;
181  s->subframe_scale = FFALIGN(avctx->sample_rate + 511LL >> 9, 4) << 1;
182 }
183 
185 {
186  TAKDecContext *s = avctx->priv_data;
187 
188  ff_audiodsp_init(&s->adsp);
189  ff_takdsp_init(&s->tdsp);
190 
191  s->avctx = avctx;
193 
194  set_sample_rate_params(avctx);
195 
196  return set_bps_params(avctx);
197 }
198 
199 static void decode_lpc(int32_t *coeffs, int mode, int length)
200 {
201  int i;
202 
203  if (length < 2)
204  return;
205 
206  if (mode == 1) {
207  unsigned a1 = *coeffs++;
208  for (i = 0; i < length - 1 >> 1; i++) {
209  *coeffs += a1;
210  coeffs[1] += (unsigned)*coeffs;
211  a1 = coeffs[1];
212  coeffs += 2;
213  }
214  if (length - 1 & 1)
215  *coeffs += a1;
216  } else if (mode == 2) {
217  unsigned a1 = coeffs[1];
218  unsigned a2 = a1 + *coeffs;
219  coeffs[1] = a2;
220  if (length > 2) {
221  coeffs += 2;
222  for (i = 0; i < length - 2 >> 1; i++) {
223  unsigned a3 = *coeffs + a1;
224  unsigned a4 = a3 + a2;
225  *coeffs = a4;
226  a1 = coeffs[1] + a3;
227  a2 = a1 + a4;
228  coeffs[1] = a2;
229  coeffs += 2;
230  }
231  if (length & 1)
232  *coeffs += a1 + a2;
233  }
234  } else if (mode == 3) {
235  unsigned a1 = coeffs[1];
236  unsigned a2 = a1 + *coeffs;
237  coeffs[1] = a2;
238  if (length > 2) {
239  unsigned a3 = coeffs[2];
240  unsigned a4 = a3 + a1;
241  unsigned a5 = a4 + a2;
242  coeffs[2] = a5;
243  coeffs += 3;
244  for (i = 0; i < length - 3; i++) {
245  a3 += *coeffs;
246  a4 += a3;
247  a5 += a4;
248  *coeffs = a5;
249  coeffs++;
250  }
251  }
252  }
253 }
254 
255 static int decode_segment(TAKDecContext *s, int8_t mode, int32_t *decoded, int len)
256 {
257  struct CParam code;
258  GetBitContext *gb = &s->gb;
259  int i;
260 
261  if (!mode) {
262  memset(decoded, 0, len * sizeof(*decoded));
263  return 0;
264  }
265 
266  if (mode > FF_ARRAY_ELEMS(xcodes))
267  return AVERROR_INVALIDDATA;
268  code = xcodes[mode - 1];
269 
270  for (i = 0; i < len; i++) {
271  unsigned x = get_bits_long(gb, code.init);
272  if (x >= code.escape && get_bits1(gb)) {
273  x |= 1 << code.init;
274  if (x >= code.aescape) {
275  unsigned scale = get_unary(gb, 1, 9);
276  if (scale == 9) {
277  int scale_bits = get_bits(gb, 3);
278  if (scale_bits > 0) {
279  if (scale_bits == 7) {
280  scale_bits += get_bits(gb, 5);
281  if (scale_bits > 29)
282  return AVERROR_INVALIDDATA;
283  }
284  scale = get_bits_long(gb, scale_bits) + 1;
285  x += code.scale * scale;
286  }
287  x += code.bias;
288  } else
289  x += code.scale * scale - code.escape;
290  } else
291  x -= code.escape;
292  }
293  decoded[i] = (x >> 1) ^ -(x & 1);
294  }
295 
296  return 0;
297 }
298 
299 static int decode_residues(TAKDecContext *s, int32_t *decoded, int length)
300 {
301  GetBitContext *gb = &s->gb;
302  int i, mode, ret;
303 
304  if (length > s->nb_samples)
305  return AVERROR_INVALIDDATA;
306 
307  if (get_bits1(gb)) {
308  int wlength, rval;
309 
310  wlength = length / s->uval;
311 
312  rval = length - (wlength * s->uval);
313 
314  if (rval < s->uval / 2)
315  rval += s->uval;
316  else
317  wlength++;
318 
319  if (wlength <= 1 || wlength > 128)
320  return AVERROR_INVALIDDATA;
321 
322  s->coding_mode[0] = mode = get_bits(gb, 6);
323 
324  for (i = 1; i < wlength; i++) {
325  int c = get_unary(gb, 1, 6);
326 
327  switch (c) {
328  case 6:
329  mode = get_bits(gb, 6);
330  break;
331  case 5:
332  case 4:
333  case 3: {
334  /* mode += sign ? (1 - c) : (c - 1) */
335  int sign = get_bits1(gb);
336  mode += (-sign ^ (c - 1)) + sign;
337  break;
338  }
339  case 2:
340  mode++;
341  break;
342  case 1:
343  mode--;
344  break;
345  }
346  s->coding_mode[i] = mode;
347  }
348 
349  i = 0;
350  while (i < wlength) {
351  int len = 0;
352 
353  mode = s->coding_mode[i];
354  do {
355  if (i >= wlength - 1)
356  len += rval;
357  else
358  len += s->uval;
359  i++;
360 
361  if (i == wlength)
362  break;
363  } while (s->coding_mode[i] == mode);
364 
365  if ((ret = decode_segment(s, mode, decoded, len)) < 0)
366  return ret;
367  decoded += len;
368  }
369  } else {
370  mode = get_bits(gb, 6);
371  if ((ret = decode_segment(s, mode, decoded, length)) < 0)
372  return ret;
373  }
374 
375  return 0;
376 }
377 
379 {
380  if (get_bits1(gb))
381  return get_bits(gb, 4) + 1;
382  else
383  return 0;
384 }
385 
386 static int decode_subframe(TAKDecContext *s, int32_t *decoded,
387  int subframe_size, int prev_subframe_size)
388 {
389  GetBitContext *gb = &s->gb;
390  int x, y, i, j, ret = 0;
391  int dshift, size, filter_quant, filter_order;
392  int tfilter[MAX_PREDICTORS];
393 
394  if (!get_bits1(gb))
395  return decode_residues(s, decoded, subframe_size);
396 
397  filter_order = predictor_sizes[get_bits(gb, 4)];
398 
399  if (prev_subframe_size > 0 && get_bits1(gb)) {
400  if (filter_order > prev_subframe_size)
401  return AVERROR_INVALIDDATA;
402 
403  decoded -= filter_order;
404  subframe_size += filter_order;
405 
406  if (filter_order > subframe_size)
407  return AVERROR_INVALIDDATA;
408  } else {
409  int lpc_mode;
410 
411  if (filter_order > subframe_size)
412  return AVERROR_INVALIDDATA;
413 
414  lpc_mode = get_bits(gb, 2);
415  if (lpc_mode > 2)
416  return AVERROR_INVALIDDATA;
417 
418  if ((ret = decode_residues(s, decoded, filter_order)) < 0)
419  return ret;
420 
421  if (lpc_mode)
422  decode_lpc(decoded, lpc_mode, filter_order);
423  }
424 
425  dshift = get_bits_esc4(gb);
426  size = get_bits1(gb) + 6;
427 
428  filter_quant = 10;
429  if (get_bits1(gb)) {
430  filter_quant -= get_bits(gb, 3) + 1;
431  if (filter_quant < 3)
432  return AVERROR_INVALIDDATA;
433  }
434 
435  s->predictors[0] = get_sbits(gb, 10);
436  s->predictors[1] = get_sbits(gb, 10);
437  s->predictors[2] = get_sbits(gb, size) * (1 << (10 - size));
438  s->predictors[3] = get_sbits(gb, size) * (1 << (10 - size));
439  if (filter_order > 4) {
440  int tmp = size - get_bits1(gb);
441 
442  for (i = 4; i < filter_order; i++) {
443  if (!(i & 3))
444  x = tmp - get_bits(gb, 2);
445  s->predictors[i] = get_sbits(gb, x) * (1 << (10 - size));
446  }
447  }
448 
449  tfilter[0] = s->predictors[0] * 64;
450  for (i = 1; i < filter_order; i++) {
451  uint32_t *p1 = &tfilter[0];
452  uint32_t *p2 = &tfilter[i - 1];
453 
454  for (j = 0; j < (i + 1) / 2; j++) {
455  x = *p1 + ((int32_t)(s->predictors[i] * *p2 + 256) >> 9);
456  *p2 += (int32_t)(s->predictors[i] * *p1 + 256) >> 9;
457  *p1++ = x;
458  p2--;
459  }
460 
461  tfilter[i] = s->predictors[i] * 64;
462  }
463 
464  x = 1 << (32 - (15 - filter_quant));
465  y = 1 << ((15 - filter_quant) - 1);
466  for (i = 0, j = filter_order - 1; i < filter_order / 2; i++, j--) {
467  s->filter[j] = x - ((tfilter[i] + y) >> (15 - filter_quant));
468  s->filter[i] = x - ((tfilter[j] + y) >> (15 - filter_quant));
469  }
470 
471  if ((ret = decode_residues(s, &decoded[filter_order],
472  subframe_size - filter_order)) < 0)
473  return ret;
474 
475  for (i = 0; i < filter_order; i++)
476  s->residues[i] = *decoded++ >> dshift;
477 
478  y = FF_ARRAY_ELEMS(s->residues) - filter_order;
479  x = subframe_size - filter_order;
480  while (x > 0) {
481  int tmp = FFMIN(y, x);
482 
483  for (i = 0; i < tmp; i++) {
484  int v = 1 << (filter_quant - 1);
485 
486  if (filter_order & -16)
487  v += (unsigned)s->adsp.scalarproduct_int16(&s->residues[i], s->filter,
488  filter_order & -16);
489  for (j = filter_order & -16; j < filter_order; j += 4) {
490  v += s->residues[i + j + 3] * (unsigned)s->filter[j + 3] +
491  s->residues[i + j + 2] * (unsigned)s->filter[j + 2] +
492  s->residues[i + j + 1] * (unsigned)s->filter[j + 1] +
493  s->residues[i + j ] * (unsigned)s->filter[j ];
494  }
495  v = (av_clip_intp2(v >> filter_quant, 13) * (1 << dshift)) - (unsigned)*decoded;
496  *decoded++ = v;
497  s->residues[filter_order + i] = v >> dshift;
498  }
499 
500  x -= tmp;
501  if (x > 0)
502  memcpy(s->residues, &s->residues[y], 2 * filter_order);
503  }
504 
505  emms_c();
506 
507  return 0;
508 }
509 
510 static int decode_channel(TAKDecContext *s, int chan)
511 {
512  AVCodecContext *avctx = s->avctx;
513  GetBitContext *gb = &s->gb;
514  int32_t *decoded = s->decoded[chan];
515  int left = s->nb_samples - 1;
516  int i = 0, ret, prev = 0;
517 
518  s->sample_shift[chan] = get_bits_esc4(gb);
519  if (s->sample_shift[chan] >= avctx->bits_per_raw_sample)
520  return AVERROR_INVALIDDATA;
521 
522  *decoded++ = get_sbits(gb, avctx->bits_per_raw_sample - s->sample_shift[chan]);
523  s->lpc_mode[chan] = get_bits(gb, 2);
524  s->nb_subframes = get_bits(gb, 3) + 1;
525 
526  if (s->nb_subframes > 1) {
527  if (get_bits_left(gb) < (s->nb_subframes - 1) * 6)
528  return AVERROR_INVALIDDATA;
529 
530  for (; i < s->nb_subframes - 1; i++) {
531  int v = get_bits(gb, 6);
532 
533  s->subframe_len[i] = (v - prev) * s->subframe_scale;
534  if (s->subframe_len[i] <= 0)
535  return AVERROR_INVALIDDATA;
536 
537  left -= s->subframe_len[i];
538  prev = v;
539  }
540 
541  if (left <= 0)
542  return AVERROR_INVALIDDATA;
543  }
544  s->subframe_len[i] = left;
545 
546  prev = 0;
547  for (i = 0; i < s->nb_subframes; i++) {
548  if ((ret = decode_subframe(s, decoded, s->subframe_len[i], prev)) < 0)
549  return ret;
550  decoded += s->subframe_len[i];
551  prev = s->subframe_len[i];
552  }
553 
554  return 0;
555 }
556 
557 static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
558 {
559  GetBitContext *gb = &s->gb;
560  int32_t *p1 = s->decoded[c1] + (s->dmode > 5);
561  int32_t *p2 = s->decoded[c2] + (s->dmode > 5);
562  int32_t bp1 = p1[0];
563  int32_t bp2 = p2[0];
564  int i;
565  int dshift, dfactor;
566 
567  length += s->dmode < 6;
568 
569  switch (s->dmode) {
570  case 1: /* left/side */
571  s->tdsp.decorrelate_ls(p1, p2, length);
572  break;
573  case 2: /* side/right */
574  s->tdsp.decorrelate_sr(p1, p2, length);
575  break;
576  case 3: /* side/mid */
577  s->tdsp.decorrelate_sm(p1, p2, length);
578  break;
579  case 4: /* side/left with scale factor */
580  FFSWAP(int32_t*, p1, p2);
581  FFSWAP(int32_t, bp1, bp2);
582  case 5: /* side/right with scale factor */
583  dshift = get_bits_esc4(gb);
584  dfactor = get_sbits(gb, 10);
585  s->tdsp.decorrelate_sf(p1, p2, length, dshift, dfactor);
586  break;
587  case 6:
588  FFSWAP(int32_t*, p1, p2);
589  case 7: {
590  int length2, order_half, filter_order, dval1, dval2;
591  int tmp, x, code_size;
592 
593  if (length < 256)
594  return AVERROR_INVALIDDATA;
595 
596  dshift = get_bits_esc4(gb);
597  filter_order = 8 << get_bits1(gb);
598  dval1 = get_bits1(gb);
599  dval2 = get_bits1(gb);
600 
601  for (i = 0; i < filter_order; i++) {
602  if (!(i & 3))
603  code_size = 14 - get_bits(gb, 3);
604  s->filter[i] = get_sbits(gb, code_size);
605  }
606 
607  order_half = filter_order / 2;
608  length2 = length - (filter_order - 1);
609 
610  /* decorrelate beginning samples */
611  if (dval1) {
612  for (i = 0; i < order_half; i++) {
613  int32_t a = p1[i];
614  int32_t b = p2[i];
615  p1[i] = a + b;
616  }
617  }
618 
619  /* decorrelate ending samples */
620  if (dval2) {
621  for (i = length2 + order_half; i < length; i++) {
622  int32_t a = p1[i];
623  int32_t b = p2[i];
624  p1[i] = a + b;
625  }
626  }
627 
628 
629  for (i = 0; i < filter_order; i++)
630  s->residues[i] = *p2++ >> dshift;
631 
632  p1 += order_half;
633  x = FF_ARRAY_ELEMS(s->residues) - filter_order;
634  for (; length2 > 0; length2 -= tmp) {
635  tmp = FFMIN(length2, x);
636 
637  for (i = 0; i < tmp - (tmp == length2); i++)
638  s->residues[filter_order + i] = *p2++ >> dshift;
639 
640  for (i = 0; i < tmp; i++) {
641  int v = 1 << 9;
642 
643  if (filter_order == 16) {
644  v += s->adsp.scalarproduct_int16(&s->residues[i], s->filter,
645  filter_order);
646  } else {
647  v += s->residues[i + 7] * s->filter[7] +
648  s->residues[i + 6] * s->filter[6] +
649  s->residues[i + 5] * s->filter[5] +
650  s->residues[i + 4] * s->filter[4] +
651  s->residues[i + 3] * s->filter[3] +
652  s->residues[i + 2] * s->filter[2] +
653  s->residues[i + 1] * s->filter[1] +
654  s->residues[i ] * s->filter[0];
655  }
656 
657  v = av_clip_intp2(v >> 10, 13) * (1U << dshift) - *p1;
658  *p1++ = v;
659  }
660 
661  memmove(s->residues, &s->residues[tmp], 2 * filter_order);
662  }
663 
664  emms_c();
665  break;
666  }
667  }
668 
669  if (s->dmode > 0 && s->dmode < 6) {
670  p1[0] = bp1;
671  p2[0] = bp2;
672  }
673 
674  return 0;
675 }
676 
678  int *got_frame_ptr, AVPacket *pkt)
679 {
680  TAKDecContext *s = avctx->priv_data;
681  GetBitContext *gb = &s->gb;
682  int chan, i, ret, hsize;
683 
685  return AVERROR_INVALIDDATA;
686 
687  if ((ret = init_get_bits8(gb, pkt->data, pkt->size)) < 0)
688  return ret;
689 
690  if ((ret = ff_tak_decode_frame_header(avctx, gb, &s->ti, 0)) < 0)
691  return ret;
692 
693  hsize = get_bits_count(gb) / 8;
695  if (ff_tak_check_crc(pkt->data, hsize)) {
696  av_log(avctx, AV_LOG_ERROR, "CRC error\n");
697  if (avctx->err_recognition & AV_EF_EXPLODE)
698  return AVERROR_INVALIDDATA;
699  }
700  }
701 
702  if (s->ti.codec != TAK_CODEC_MONO_STEREO &&
703  s->ti.codec != TAK_CODEC_MULTICHANNEL) {
704  avpriv_report_missing_feature(avctx, "TAK codec type %d", s->ti.codec);
705  return AVERROR_PATCHWELCOME;
706  }
707  if (s->ti.data_type) {
708  av_log(avctx, AV_LOG_ERROR,
709  "unsupported data type: %d\n", s->ti.data_type);
710  return AVERROR_INVALIDDATA;
711  }
712  if (s->ti.codec == TAK_CODEC_MONO_STEREO && s->ti.channels > 2) {
713  av_log(avctx, AV_LOG_ERROR,
714  "invalid number of channels: %d\n", s->ti.channels);
715  return AVERROR_INVALIDDATA;
716  }
717  if (s->ti.channels > 6) {
718  av_log(avctx, AV_LOG_ERROR,
719  "unsupported number of channels: %d\n", s->ti.channels);
720  return AVERROR_INVALIDDATA;
721  }
722 
723  if (s->ti.frame_samples <= 0) {
724  av_log(avctx, AV_LOG_ERROR, "unsupported/invalid number of samples\n");
725  return AVERROR_INVALIDDATA;
726  }
727 
728  avctx->bits_per_raw_sample = s->ti.bps;
729  if ((ret = set_bps_params(avctx)) < 0)
730  return ret;
731  if (s->ti.sample_rate != avctx->sample_rate) {
732  avctx->sample_rate = s->ti.sample_rate;
733  set_sample_rate_params(avctx);
734  }
735 
737  if (s->ti.ch_layout) {
738  av_channel_layout_from_mask(&avctx->ch_layout, s->ti.ch_layout);
739  } else {
741  avctx->ch_layout.nb_channels = s->ti.channels;
742  }
743 
744  s->nb_samples = s->ti.last_frame_samples ? s->ti.last_frame_samples
745  : s->ti.frame_samples;
746 
747  frame->nb_samples = s->nb_samples;
748  if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
749  return ret;
750  ff_thread_finish_setup(avctx);
751 
752  if (avctx->bits_per_raw_sample <= 16) {
753  int buf_size = av_samples_get_buffer_size(NULL, avctx->ch_layout.nb_channels,
754  s->nb_samples,
755  AV_SAMPLE_FMT_S32P, 0);
756  if (buf_size < 0)
757  return buf_size;
758  av_fast_malloc(&s->decode_buffer, &s->decode_buffer_size, buf_size);
759  if (!s->decode_buffer)
760  return AVERROR(ENOMEM);
761  ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
762  s->decode_buffer, avctx->ch_layout.nb_channels,
763  s->nb_samples, AV_SAMPLE_FMT_S32P, 0);
764  if (ret < 0)
765  return ret;
766  } else {
767  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++)
768  s->decoded[chan] = (int32_t *)frame->extended_data[chan];
769  }
770 
771  if (s->nb_samples < 16) {
772  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) {
773  int32_t *decoded = s->decoded[chan];
774  for (i = 0; i < s->nb_samples; i++)
775  decoded[i] = get_sbits(gb, avctx->bits_per_raw_sample);
776  }
777  } else {
778  if (s->ti.codec == TAK_CODEC_MONO_STEREO) {
779  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++)
780  if (ret = decode_channel(s, chan))
781  return ret;
782 
783  if (avctx->ch_layout.nb_channels == 2) {
784  s->nb_subframes = get_bits(gb, 1) + 1;
785  if (s->nb_subframes > 1) {
786  s->subframe_len[1] = get_bits(gb, 6);
787  }
788 
789  s->dmode = get_bits(gb, 3);
790  if (ret = decorrelate(s, 0, 1, s->nb_samples - 1))
791  return ret;
792  }
793  } else if (s->ti.codec == TAK_CODEC_MULTICHANNEL) {
794  if (get_bits1(gb)) {
795  int ch_mask = 0;
796 
797  chan = get_bits(gb, 4) + 1;
798  if (chan > avctx->ch_layout.nb_channels)
799  return AVERROR_INVALIDDATA;
800 
801  for (i = 0; i < chan; i++) {
802  int nbit = get_bits(gb, 4);
803 
804  if (nbit >= avctx->ch_layout.nb_channels)
805  return AVERROR_INVALIDDATA;
806 
807  if (ch_mask & 1 << nbit)
808  return AVERROR_INVALIDDATA;
809 
810  s->mcdparams[i].present = get_bits1(gb);
811  if (s->mcdparams[i].present) {
812  s->mcdparams[i].index = get_bits(gb, 2);
813  s->mcdparams[i].chan2 = get_bits(gb, 4);
814  if (s->mcdparams[i].chan2 >= avctx->ch_layout.nb_channels) {
815  av_log(avctx, AV_LOG_ERROR,
816  "invalid channel 2 (%d) for %d channel(s)\n",
817  s->mcdparams[i].chan2, avctx->ch_layout.nb_channels);
818  return AVERROR_INVALIDDATA;
819  }
820  if (s->mcdparams[i].index == 1) {
821  if ((nbit == s->mcdparams[i].chan2) ||
822  (ch_mask & 1 << s->mcdparams[i].chan2))
823  return AVERROR_INVALIDDATA;
824 
825  ch_mask |= 1 << s->mcdparams[i].chan2;
826  } else if (!(ch_mask & 1 << s->mcdparams[i].chan2)) {
827  return AVERROR_INVALIDDATA;
828  }
829  }
830  s->mcdparams[i].chan1 = nbit;
831 
832  ch_mask |= 1 << nbit;
833  }
834  } else {
835  chan = avctx->ch_layout.nb_channels;
836  for (i = 0; i < chan; i++) {
837  s->mcdparams[i].present = 0;
838  s->mcdparams[i].chan1 = i;
839  }
840  }
841 
842  for (i = 0; i < chan; i++) {
843  if (s->mcdparams[i].present && s->mcdparams[i].index == 1)
844  if (ret = decode_channel(s, s->mcdparams[i].chan2))
845  return ret;
846 
847  if (ret = decode_channel(s, s->mcdparams[i].chan1))
848  return ret;
849 
850  if (s->mcdparams[i].present) {
851  s->dmode = mc_dmodes[s->mcdparams[i].index];
852  if (ret = decorrelate(s,
853  s->mcdparams[i].chan2,
854  s->mcdparams[i].chan1,
855  s->nb_samples - 1))
856  return ret;
857  }
858  }
859  }
860 
861  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) {
862  int32_t *decoded = s->decoded[chan];
863 
864  if (s->lpc_mode[chan])
865  decode_lpc(decoded, s->lpc_mode[chan], s->nb_samples);
866 
867  if (s->sample_shift[chan] > 0)
868  for (i = 0; i < s->nb_samples; i++)
869  decoded[i] *= 1U << s->sample_shift[chan];
870  }
871  }
872 
873  align_get_bits(gb);
874  skip_bits(gb, 24);
875  if (get_bits_left(gb) < 0)
876  av_log(avctx, AV_LOG_DEBUG, "overread\n");
877  else if (get_bits_left(gb) > 0)
878  av_log(avctx, AV_LOG_DEBUG, "underread\n");
879 
881  if (ff_tak_check_crc(pkt->data + hsize,
882  get_bits_count(gb) / 8 - hsize)) {
883  av_log(avctx, AV_LOG_ERROR, "CRC error\n");
884  if (avctx->err_recognition & AV_EF_EXPLODE)
885  return AVERROR_INVALIDDATA;
886  }
887  }
888 
889  /* convert to output buffer */
890  switch (avctx->sample_fmt) {
891  case AV_SAMPLE_FMT_U8P:
892  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) {
893  uint8_t *samples = (uint8_t *)frame->extended_data[chan];
894  int32_t *decoded = s->decoded[chan];
895  for (i = 0; i < s->nb_samples; i++)
896  samples[i] = decoded[i] + 0x80U;
897  }
898  break;
899  case AV_SAMPLE_FMT_S16P:
900  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) {
901  int16_t *samples = (int16_t *)frame->extended_data[chan];
902  int32_t *decoded = s->decoded[chan];
903  for (i = 0; i < s->nb_samples; i++)
904  samples[i] = decoded[i];
905  }
906  break;
907  case AV_SAMPLE_FMT_S32P:
908  for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) {
909  int32_t *samples = (int32_t *)frame->extended_data[chan];
910  for (i = 0; i < s->nb_samples; i++)
911  samples[i] *= 1U << 8;
912  }
913  break;
914  }
915 
916  *got_frame_ptr = 1;
917 
918  return pkt->size;
919 }
920 
921 #if HAVE_THREADS
922 static int update_thread_context(AVCodecContext *dst,
923  const AVCodecContext *src)
924 {
925  TAKDecContext *tsrc = src->priv_data;
926  TAKDecContext *tdst = dst->priv_data;
927 
928  if (dst == src)
929  return 0;
930  memcpy(&tdst->ti, &tsrc->ti, sizeof(TAKStreamInfo));
931  return 0;
932 }
933 #endif
934 
936 {
937  TAKDecContext *s = avctx->priv_data;
938 
939  av_freep(&s->decode_buffer);
940 
941  return 0;
942 }
943 
945  .p.name = "tak",
946  .p.long_name = NULL_IF_CONFIG_SMALL("TAK (Tom's lossless Audio Kompressor)"),
947  .p.type = AVMEDIA_TYPE_AUDIO,
948  .p.id = AV_CODEC_ID_TAK,
949  .priv_data_size = sizeof(TAKDecContext),
951  .close = tak_decode_close,
953  .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
955  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
959 };
TAK_MAX_CHANNELS
#define TAK_MAX_CHANNELS
Definition: tak.h:63
TAKDecContext::avctx
AVCodecContext * avctx
parent AVCodecContext
Definition: takdec.c:52
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
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:65
MCDParam::chan1
int8_t chan1
Definition: takdec.c:47
MCDParam::present
int8_t present
decorrelation parameter availability for this channel
Definition: takdec.c:45
mem_internal.h
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
TAKDecContext::ti
TAKStreamInfo ti
Definition: takdec.c:55
MAX_PREDICTORS
#define MAX_PREDICTORS
Definition: takdec.c:42
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1353
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
ff_tak_decode_frame_header
int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, TAKStreamInfo *ti, int log_level_offset)
Validate and decode a frame header.
Definition: tak.c:142
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:54
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
TAKDecContext::mcdparams
MCDParam mcdparams[TAK_MAX_CHANNELS]
multichannel decorrelation parameters
Definition: takdec.c:73
CParam::scale
int scale
Definition: takdec.c:89
AVPacket::data
uint8_t * data
Definition: packet.h:374
b
#define b
Definition: input.c:34
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:118
ff_audiodsp_init
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:106
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:1368
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:295
c1
static const uint64_t c1
Definition: murmur3.c:51
TAKDecContext::lpc_mode
int8_t lpc_mode[TAK_MAX_CHANNELS]
Definition: takdec.c:64
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
thread.h
TAKDecContext::subframe_len
int16_t subframe_len[MAX_SUBFRAMES]
subframe length in samples
Definition: takdec.c:68
tak_decode_close
static av_cold int tak_decode_close(AVCodecContext *avctx)
Definition: takdec.c:935
predictor_sizes
static const uint16_t predictor_sizes[]
Definition: takdec.c:82
MCDParam::chan2
int8_t chan2
Definition: takdec.c:48
init
static int init
Definition: av_tx.c:47
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
TAKDecContext::coding_mode
int8_t coding_mode[128]
Definition: takdec.c:75
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
MCDParam::index
int8_t index
index into array of decorrelation types
Definition: takdec.c:46
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
TAKDecContext::uval
int uval
Definition: takdec.c:58
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2065
GetBitContext
Definition: get_bits.h:61
ff_thread_get_buffer
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 so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() 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
samplefmt.h
MAX_SUBFRAMES
#define MAX_SUBFRAMES
max number of subframes per channel
Definition: takdec.c:41
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
a1
#define a1
Definition: regdef.h:47
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
tak_decode_init
static av_cold int tak_decode_init(AVCodecContext *avctx)
Definition: takdec.c:184
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
s
#define s(width, name)
Definition: cbs_vp9.c:256
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:106
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
CParam::bias
int bias
Definition: takdec.c:91
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1457
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
a4
#define a4
Definition: regdef.h:50
TAK_CODEC_MONO_STEREO
@ TAK_CODEC_MONO_STEREO
Definition: tak.h:99
TAKDecContext::adsp
AudioDSPContext adsp
Definition: takdec.c:53
decorrelate
static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
Definition: takdec.c:557
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:113
NULL
#define NULL
Definition: coverity.c:32
av_clip_intp2
#define av_clip_intp2
Definition: common.h:116
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
TAKDecContext::dmode
int8_t dmode
channel decorrelation type in the current frame
Definition: takdec.c:71
ff_tak_decoder
const FFCodec ff_tak_decoder
Definition: takdec.c:944
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
TAKDecContext::decode_buffer_size
unsigned int decode_buffer_size
Definition: takdec.c:61
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:156
tak.h
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1364
decode_channel
static int decode_channel(TAKDecContext *s, int chan)
Definition: takdec.c:510
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_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:630
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:109
takdsp.h
CParam::aescape
int aescape
Definition: takdec.c:90
TAKDecContext
Definition: takdec.c:51
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:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:63
codec_internal.h
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
TAKDecContext::residues
int16_t residues[544]
Definition: takdec.c:77
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
size
int size
Definition: twinvq_data.h:10344
decode_residues
static int decode_residues(TAKDecContext *s, int32_t *decoded, int length)
Definition: takdec.c:299
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:78
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
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:87
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1450
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:60
get_bits_esc4
static int get_bits_esc4(GetBitContext *gb)
Definition: takdec.c:378
a2
#define a2
Definition: regdef.h:48
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
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. If there are inter-frame dependencies
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
av_channel_layout_from_mask
FF_ENABLE_DEPRECATION_WARNINGS 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:389
set_sample_rate_params
static void set_sample_rate_params(AVCodecContext *avctx)
Definition: takdec.c:166
ret
ret
Definition: filter_design.txt:187
decode_lpc
static void decode_lpc(int32_t *coeffs, int mode, int length)
Definition: takdec.c:199
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
mc_dmodes
static const int8_t mc_dmodes[]
Definition: takdec.c:80
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:264
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: avcodec.h:1361
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:683
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:88
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:398
c2
static const uint64_t c2
Definition: murmur3.c:52
a5
#define a5
Definition: regdef.h:51
TAKDecContext::predictors
int16_t predictors[MAX_PREDICTORS]
Definition: takdec.c:66
mode
mode
Definition: ebur128.h:83
TAKDecContext::gb
GetBitContext gb
bitstream reader initialized to start at the current frame
Definition: takdec.c:56
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:76
set_bps_params
static int set_bps_params(AVCodecContext *avctx)
Definition: takdec.c:145
MCDParam
Definition: takdec.c:44
shift
static int shift(int a, int b)
Definition: sonic.c:88
audiodsp.h
TAKStreamInfo
Definition: tak.h:127
AudioDSPContext
Definition: audiodsp.h:24
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
CParam
Definition: takdec.c:86
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:565
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AV_CODEC_ID_TAK
@ AV_CODEC_ID_TAK
Definition: codec_id.h:491
TAKDecContext::nb_samples
int nb_samples
number of samples in the current frame
Definition: takdec.c:59
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
TAKDecContext::decoded
int32_t * decoded[TAK_MAX_CHANNELS]
decoded samples for each channel
Definition: takdec.c:62
tak_decode_frame
static int tak_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *pkt)
Definition: takdec.c:677
decode_subframe
static int decode_subframe(TAKDecContext *s, int32_t *decoded, int subframe_size, int prev_subframe_size)
Definition: takdec.c:386
ff_takdsp_init
av_cold void ff_takdsp_init(TAKDSPContext *c)
Definition: takdsp.c:73
TAK_MIN_FRAME_HEADER_BYTES
#define TAK_MIN_FRAME_HEADER_BYTES
Definition: tak.h:96
TAK_CODEC_MULTICHANNEL
@ TAK_CODEC_MULTICHANNEL
Definition: tak.h:100
a3
#define a3
Definition: regdef.h:49
TAKDecContext::subframe_scale
int subframe_scale
Definition: takdec.c:69
TAKDecContext::nb_subframes
int nb_subframes
number of subframes in the current frame
Definition: takdec.c:67
decode_segment
static int decode_segment(TAKDecContext *s, int8_t mode, int32_t *decoded, int len)
Definition: takdec.c:255