tta.c
Go to the documentation of this file.
1 /*
2  * TTA (The Lossless True Audio) decoder
3  * Copyright (c) 2006 Alex Beregszaszi
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
30 #define BITSTREAM_READER_LE
31 //#define DEBUG
32 #include <limits.h>
33 #include "avcodec.h"
34 #include "get_bits.h"
35 #include "internal.h"
36 #include "libavutil/crc.h"
37 
38 #define FORMAT_SIMPLE 1
39 #define FORMAT_ENCRYPTED 2
40 
41 #define MAX_ORDER 16
42 typedef struct TTAFilter {
47 } TTAFilter;
48 
49 typedef struct TTARice {
50  uint32_t k0, k1, sum0, sum1;
51 } TTARice;
52 
53 typedef struct TTAChannel {
57 } TTAChannel;
58 
59 typedef struct TTAContext {
63  const AVCRC *crc_table;
64 
66  unsigned data_length;
68 
70 
72 } TTAContext;
73 
74 static const uint32_t shift_1[] = {
75  0x00000001, 0x00000002, 0x00000004, 0x00000008,
76  0x00000010, 0x00000020, 0x00000040, 0x00000080,
77  0x00000100, 0x00000200, 0x00000400, 0x00000800,
78  0x00001000, 0x00002000, 0x00004000, 0x00008000,
79  0x00010000, 0x00020000, 0x00040000, 0x00080000,
80  0x00100000, 0x00200000, 0x00400000, 0x00800000,
81  0x01000000, 0x02000000, 0x04000000, 0x08000000,
82  0x10000000, 0x20000000, 0x40000000, 0x80000000,
83  0x80000000, 0x80000000, 0x80000000, 0x80000000,
84  0x80000000, 0x80000000, 0x80000000, 0x80000000
85 };
86 
87 static const uint32_t * const shift_16 = shift_1 + 4;
88 
89 static const int32_t ttafilter_configs[4] = {
90  10,
91  9,
92  10,
93  12
94 };
95 
96 static void ttafilter_init(TTAFilter *c, int32_t shift) {
97  memset(c, 0, sizeof(TTAFilter));
98  c->shift = shift;
99  c->round = shift_1[shift-1];
100 // c->round = 1 << (shift - 1);
101 }
102 
103 // FIXME: copy paste from original
104 static inline void memshl(register int32_t *a, register int32_t *b) {
105  *a++ = *b++;
106  *a++ = *b++;
107  *a++ = *b++;
108  *a++ = *b++;
109  *a++ = *b++;
110  *a++ = *b++;
111  *a++ = *b++;
112  *a = *b;
113 }
114 
115 static inline void ttafilter_process(TTAFilter *c, int32_t *in)
116 {
117  register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
118 
119  if (!c->error) {
120  sum += *dl++ * *qm, qm++;
121  sum += *dl++ * *qm, qm++;
122  sum += *dl++ * *qm, qm++;
123  sum += *dl++ * *qm, qm++;
124  sum += *dl++ * *qm, qm++;
125  sum += *dl++ * *qm, qm++;
126  sum += *dl++ * *qm, qm++;
127  sum += *dl++ * *qm, qm++;
128  dx += 8;
129  } else if(c->error < 0) {
130  sum += *dl++ * (*qm -= *dx++), qm++;
131  sum += *dl++ * (*qm -= *dx++), qm++;
132  sum += *dl++ * (*qm -= *dx++), qm++;
133  sum += *dl++ * (*qm -= *dx++), qm++;
134  sum += *dl++ * (*qm -= *dx++), qm++;
135  sum += *dl++ * (*qm -= *dx++), qm++;
136  sum += *dl++ * (*qm -= *dx++), qm++;
137  sum += *dl++ * (*qm -= *dx++), qm++;
138  } else {
139  sum += *dl++ * (*qm += *dx++), qm++;
140  sum += *dl++ * (*qm += *dx++), qm++;
141  sum += *dl++ * (*qm += *dx++), qm++;
142  sum += *dl++ * (*qm += *dx++), qm++;
143  sum += *dl++ * (*qm += *dx++), qm++;
144  sum += *dl++ * (*qm += *dx++), qm++;
145  sum += *dl++ * (*qm += *dx++), qm++;
146  sum += *dl++ * (*qm += *dx++), qm++;
147  }
148 
149  *(dx-0) = ((*(dl-1) >> 30) | 1) << 2;
150  *(dx-1) = ((*(dl-2) >> 30) | 1) << 1;
151  *(dx-2) = ((*(dl-3) >> 30) | 1) << 1;
152  *(dx-3) = ((*(dl-4) >> 30) | 1);
153 
154  c->error = *in;
155  *in += (sum >> c->shift);
156  *dl = *in;
157 
158  *(dl-1) = *dl - *(dl-1);
159  *(dl-2) = *(dl-1) - *(dl-2);
160  *(dl-3) = *(dl-2) - *(dl-3);
161 
162  memshl(c->dl, c->dl + 1);
163  memshl(c->dx, c->dx + 1);
164 }
165 
166 static void rice_init(TTARice *c, uint32_t k0, uint32_t k1)
167 {
168  c->k0 = k0;
169  c->k1 = k1;
170  c->sum0 = shift_16[k0];
171  c->sum1 = shift_16[k1];
172 }
173 
175 {
176  int ret = 0;
177 
178  // count ones
179  while (get_bits_left(gb) > 0 && get_bits1(gb))
180  ret++;
181  return ret;
182 }
183 
184 static int tta_check_crc(TTAContext *s, const uint8_t *buf, int buf_size)
185 {
186  uint32_t crc, CRC;
187 
188  CRC = AV_RL32(buf + buf_size);
189  crc = av_crc(s->crc_table, 0xFFFFFFFFU, buf, buf_size);
190  if (CRC != (crc ^ 0xFFFFFFFFU)) {
191  av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
192  return AVERROR_INVALIDDATA;
193  }
194 
195  return 0;
196 }
197 
199 {
200  TTAContext *s = avctx->priv_data;
201  int total_frames;
202 
203  s->avctx = avctx;
204 
205  // 30bytes includes a seektable with one frame
206  if (avctx->extradata_size < 30)
207  return -1;
208 
209  init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
210  if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
211  {
212  if (avctx->err_recognition & AV_EF_CRCCHECK) {
214  tta_check_crc(s, avctx->extradata, 18);
215  }
216 
217  /* signature */
218  skip_bits_long(&s->gb, 32);
219 
220  s->format = get_bits(&s->gb, 16);
221  if (s->format > 2) {
222  av_log(s->avctx, AV_LOG_ERROR, "Invalid format\n");
223  return -1;
224  }
225  if (s->format == FORMAT_ENCRYPTED) {
226  av_log_missing_feature(s->avctx, "Encrypted TTA", 0);
227  return AVERROR_PATCHWELCOME;
228  }
229  avctx->channels = s->channels = get_bits(&s->gb, 16);
230  avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
231  s->bps = (avctx->bits_per_coded_sample + 7) / 8;
232  avctx->sample_rate = get_bits_long(&s->gb, 32);
233  s->data_length = get_bits_long(&s->gb, 32);
234  skip_bits_long(&s->gb, 32); // CRC32 of header
235 
236  if (s->channels == 0) {
237  av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
238  return AVERROR_INVALIDDATA;
239  } else if (avctx->sample_rate == 0) {
240  av_log(s->avctx, AV_LOG_ERROR, "Invalid samplerate\n");
241  return AVERROR_INVALIDDATA;
242  }
243 
244  switch(s->bps) {
245  case 2:
246  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
247  avctx->bits_per_raw_sample = 16;
248  break;
249  case 3:
250  avctx->sample_fmt = AV_SAMPLE_FMT_S32;
251  avctx->bits_per_raw_sample = 24;
252  break;
253  default:
254  av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n");
255  return AVERROR_INVALIDDATA;
256  }
257 
258  // prevent overflow
259  if (avctx->sample_rate > 0x7FFFFFu) {
260  av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
261  return AVERROR(EINVAL);
262  }
263  s->frame_length = 256 * avctx->sample_rate / 245;
264 
266  total_frames = s->data_length / s->frame_length +
267  (s->last_frame_length ? 1 : 0);
268 
269  av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
270  s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
271  avctx->block_align);
272  av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
273  s->data_length, s->frame_length, s->last_frame_length, total_frames);
274 
275  // FIXME: seek table
276  if (avctx->extradata_size <= 26 || total_frames > INT_MAX / 4 ||
277  avctx->extradata_size - 26 < total_frames * 4)
278  av_log(avctx, AV_LOG_WARNING, "Seek table missing or too small\n");
279  else if (avctx->err_recognition & AV_EF_CRCCHECK) {
280  if (tta_check_crc(s, avctx->extradata + 22, total_frames * 4))
281  return AVERROR_INVALIDDATA;
282  }
283  skip_bits_long(&s->gb, 32 * total_frames);
284  skip_bits_long(&s->gb, 32); // CRC32 of seektable
285 
286  if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
287  av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
288  return -1;
289  }
290 
291  if (s->bps == 2) {
293  if (!s->decode_buffer)
294  return AVERROR(ENOMEM);
295  }
296  s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
297  if (!s->ch_ctx) {
298  av_freep(&s->decode_buffer);
299  return AVERROR(ENOMEM);
300  }
301  } else {
302  av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
303  return -1;
304  }
305 
307  avctx->coded_frame = &s->frame;
308 
309  return 0;
310 }
311 
312 static int tta_decode_frame(AVCodecContext *avctx, void *data,
313  int *got_frame_ptr, AVPacket *avpkt)
314 {
315  const uint8_t *buf = avpkt->data;
316  int buf_size = avpkt->size;
317  TTAContext *s = avctx->priv_data;
318  int i, ret;
319  int cur_chan = 0, framelen = s->frame_length;
320  int32_t *p;
321 
322  if (avctx->err_recognition & AV_EF_CRCCHECK) {
323  if (buf_size < 4 || tta_check_crc(s, buf, buf_size - 4))
324  return AVERROR_INVALIDDATA;
325  }
326 
327  init_get_bits(&s->gb, buf, buf_size*8);
328 
329  /* get output buffer */
330  s->frame.nb_samples = framelen;
331  if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
332  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
333  return ret;
334  }
335 
336  // decode directly to output buffer for 24-bit sample format
337  if (s->bps == 3)
338  s->decode_buffer = (int32_t *)s->frame.data[0];
339 
340  // init per channel states
341  for (i = 0; i < s->channels; i++) {
342  s->ch_ctx[i].predictor = 0;
344  rice_init(&s->ch_ctx[i].rice, 10, 10);
345  }
346 
347  i = 0;
348  for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
349  int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
350  TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
351  TTARice *rice = &s->ch_ctx[cur_chan].rice;
352  uint32_t unary, depth, k;
353  int32_t value;
354 
355  unary = tta_get_unary(&s->gb);
356 
357  if (unary == 0) {
358  depth = 0;
359  k = rice->k0;
360  } else {
361  depth = 1;
362  k = rice->k1;
363  unary--;
364  }
365 
366  if (get_bits_left(&s->gb) < k) {
367  ret = AVERROR_INVALIDDATA;
368  goto error;
369  }
370 
371  if (k) {
372  if (k > MIN_CACHE_BITS) {
373  ret = AVERROR_INVALIDDATA;
374  goto error;
375  }
376  value = (unary << k) + get_bits(&s->gb, k);
377  } else
378  value = unary;
379 
380  // FIXME: copy paste from original
381  switch (depth) {
382  case 1:
383  rice->sum1 += value - (rice->sum1 >> 4);
384  if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
385  rice->k1--;
386  else if(rice->sum1 > shift_16[rice->k1 + 1])
387  rice->k1++;
388  value += shift_1[rice->k0];
389  default:
390  rice->sum0 += value - (rice->sum0 >> 4);
391  if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
392  rice->k0--;
393  else if(rice->sum0 > shift_16[rice->k0 + 1])
394  rice->k0++;
395  }
396 
397  // extract coded value
398  *p = 1 + ((value >> 1) ^ ((value & 1) - 1));
399 
400  // run hybrid filter
401  ttafilter_process(filter, p);
402 
403  // fixed order prediction
404 #define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
405  switch (s->bps) {
406  case 1: *p += PRED(*predictor, 4); break;
407  case 2:
408  case 3: *p += PRED(*predictor, 5); break;
409  case 4: *p += *predictor; break;
410  }
411  *predictor = *p;
412 
413  // flip channels
414  if (cur_chan < (s->channels-1))
415  cur_chan++;
416  else {
417  // decorrelate in case of multiple channels
418  if (s->channels > 1) {
419  int32_t *r = p - 1;
420  for (*p += *r / 2; r > p - s->channels; r--)
421  *r = *(r + 1) - *r;
422  }
423  cur_chan = 0;
424  i++;
425  // check for last frame
426  if (i == s->last_frame_length && get_bits_left(&s->gb) / 8 == 4) {
427  s->frame.nb_samples = framelen = s->last_frame_length;
428  break;
429  }
430  }
431  }
432 
433  align_get_bits(&s->gb);
434  if (get_bits_left(&s->gb) < 32) {
435  ret = AVERROR_INVALIDDATA;
436  goto error;
437  }
438  skip_bits_long(&s->gb, 32); // frame crc
439 
440  // convert to output buffer
441  if (s->bps == 2) {
442  int16_t *samples = (int16_t *)s->frame.data[0];
443  for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
444  *samples++ = *p;
445  } else {
446  // shift samples for 24-bit sample format
447  int32_t *samples = (int32_t *)s->frame.data[0];
448  for (i = 0; i < framelen * s->channels; i++)
449  *samples++ <<= 8;
450  // reset decode buffer
451  s->decode_buffer = NULL;
452  }
453 
454  *got_frame_ptr = 1;
455  *(AVFrame *)data = s->frame;
456 
457  return buf_size;
458 error:
459  // reset decode buffer
460  if (s->bps == 3)
461  s->decode_buffer = NULL;
462  return ret;
463 }
464 
466  TTAContext *s = avctx->priv_data;
467 
469  av_freep(&s->ch_ctx);
470 
471  return 0;
472 }
473 
475  .name = "tta",
476  .type = AVMEDIA_TYPE_AUDIO,
477  .id = AV_CODEC_ID_TTA,
478  .priv_data_size = sizeof(TTAContext),
482  .capabilities = CODEC_CAP_DR1,
483  .long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
484 };
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:345
static int tta_check_crc(TTAContext *s, const uint8_t *buf, int buf_size)
Definition: tta.c:184
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:61
static int16_t * samples
static void rice_init(TTARice *c, uint32_t k0, uint32_t k1)
Definition: tta.c:166
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:90
TTAChannel * ch_ctx
Definition: tta.c:71
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:197
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2725
static av_cold int tta_decode_init(AVCodecContext *avctx)
Definition: tta.c:198
static int tta_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: tta.c:312
static void align_get_bits(GetBitContext *s)
Definition: get_bits.h:412
int size
Definition: avcodec.h:916
int32_t predictor
Definition: tta.c:54
Definition: tta.c:59
int format
Definition: tta.c:65
int bps
Definition: tta.c:65
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2711
GetBitContext gb
Definition: tta.c:62
signed 16 bits
Definition: samplefmt.h:52
AVCodec.
Definition: avcodec.h:2960
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2141
static int tta_get_unary(GetBitContext *gb)
Definition: tta.c:174
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:151
Definition: tta.c:53
struct TTAFilter TTAFilter
int32_t error
Definition: tta.c:43
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
int32_t round
Definition: tta.c:43
static av_cold int tta_decode_close(AVCodecContext *avctx)
Definition: tta.c:465
static const uint32_t *const shift_16
Definition: tta.c:87
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2112
uint8_t
Definition: tta.c:49
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:76
#define b
Definition: input.c:52
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1454
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:915
int32_t qm[MAX_ORDER]
Definition: tta.c:44
bitstream reader API header.
int32_t shift
Definition: tta.c:43
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2704
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
#define r
Definition: input.c:51
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:547
static const uint32_t shift_1[]
Definition: tta.c:74
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:139
struct TTAContext TTAContext
AVCodec ff_tta_decoder
Definition: tta.c:474
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
struct TTAChannel TTAChannel
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
const AVCRC * crc_table
Definition: tta.c:63
uint32_t sum1
Definition: tta.c:50
unsigned data_length
Definition: tta.c:66
signed 32 bits
Definition: samplefmt.h:53
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
Definition: mpegaudioenc.c:318
struct TTARice TTARice
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2602
static void ttafilter_init(TTAFilter *c, int32_t shift)
Definition: tta.c:96
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
Definition: utils.c:464
int32_t
#define AV_RL32
Definition: intreadwrite.h:146
static void ttafilter_process(TTAFilter *c, int32_t *in)
Definition: tta.c:115
static void memshl(register int32_t *a, register int32_t *b)
Definition: tta.c:104
uint32_t k1
Definition: tta.c:50
NULL
Definition: eval.c:52
external API header
AVCodecContext * avctx
Definition: tta.c:60
Definition: tta.c:42
int sample_rate
samples per second
Definition: avcodec.h:2104
main external API structure.
Definition: avcodec.h:1339
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
int32_t dx[MAX_ORDER]
Definition: tta.c:45
int extradata_size
Definition: avcodec.h:1455
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:604
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
Definition: utils.c:2007
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:372
AVFrame frame
Definition: tta.c:61
int frame_length
Definition: tta.c:67
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:301
int last_frame_length
Definition: tta.c:67
#define MIN_CACHE_BITS
Definition: get_bits.h:120
static const int32_t ttafilter_configs[4]
Definition: tta.c:89
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
uint32_t k0
Definition: tta.c:50
#define PRED(x, k)
int channels
Definition: tta.c:65
common internal api header.
int32_t * decode_buffer
Definition: tta.c:69
uint32_t AVCRC
Definition: crc.h:28
void * priv_data
Definition: avcodec.h:1382
TTAFilter filter
Definition: tta.c:55
int channels
number of audio channels
Definition: avcodec.h:2105
int32_t dl[MAX_ORDER]
Definition: tta.c:46
#define FORMAT_ENCRYPTED
Definition: tta.c:39
#define MAX_ORDER
Definition: tta.c:41
TTARice rice
Definition: tta.c:56
This structure stores compressed data.
Definition: avcodec.h:898
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1042
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:158
for(j=16;j >0;--j)
uint32_t sum0
Definition: tta.c:50
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)