alacdec: do not be too strict about the extradata size
[libav.git] / libavcodec / tta.c
CommitLineData
a24c4a2a
AB
1/*
2 * TTA (The Lossless True Audio) decoder
3 * Copyright (c) 2006 Alex Beregszaszi
4 *
2912e87a 5 * This file is part of Libav.
b78e7197 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
a24c4a2a
AB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
a24c4a2a 11 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
a24c4a2a
AB
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
2912e87a 18 * License along with Libav; if not, write to the Free Software
e5a389a1 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
a24c4a2a
AB
20 */
21
22/**
ba87f080 23 * @file
a24c4a2a 24 * TTA (The Lossless True Audio) decoder
ad4cd0c2
DB
25 * @see http://www.true-audio.com/
26 * @see http://tta.corecodec.org/
a24c4a2a 27 * @author Alex Beregszaszi
a24c4a2a
AB
28 */
29
aaf47bcd 30#define BITSTREAM_READER_LE
a24c4a2a
AB
31//#define DEBUG
32#include <limits.h>
33#include "avcodec.h"
9106a698 34#include "get_bits.h"
594d4d5d 35#include "internal.h"
2af3dc86 36#include "libavutil/crc.h"
a24c4a2a 37
b16960a8
JR
38#define FORMAT_SIMPLE 1
39#define FORMAT_ENCRYPTED 2
a24c4a2a 40
5113b3bd
MR
41#define MAX_ORDER 16
42typedef struct TTAFilter {
323b9da9 43 int32_t shift, round, error;
5113b3bd
MR
44 int32_t qm[MAX_ORDER];
45 int32_t dx[MAX_ORDER];
46 int32_t dl[MAX_ORDER];
47} TTAFilter;
48
49typedef struct TTARice {
50 uint32_t k0, k1, sum0, sum1;
51} TTARice;
52
53typedef struct TTAChannel {
54 int32_t predictor;
55 TTAFilter filter;
56 TTARice rice;
57} TTAChannel;
58
a24c4a2a
AB
59typedef struct TTAContext {
60 AVCodecContext *avctx;
0eea2129 61 AVFrame frame;
a24c4a2a 62 GetBitContext gb;
2af3dc86 63 const AVCRC *crc_table;
a24c4a2a 64
ac80b812
RB
65 int format, channels, bps;
66 unsigned data_length;
a24c4a2a
AB
67 int frame_length, last_frame_length, total_frames;
68
79a32e3b 69 int32_t *decode_buffer;
5113b3bd 70
c058dc22 71 TTAChannel *ch_ctx;
a24c4a2a
AB
72} TTAContext;
73
79a32e3b 74static const uint32_t shift_1[] = {
a24c4a2a
AB
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
cf2baeb3 87static const uint32_t * const shift_16 = shift_1 + 4;
a24c4a2a 88
323b9da9
PM
89static const int32_t ttafilter_configs[4] = {
90 10,
91 9,
92 10,
93 12
a24c4a2a
AB
94};
95
323b9da9 96static void ttafilter_init(TTAFilter *c, int32_t shift) {
a24c4a2a
AB
97 memset(c, 0, sizeof(TTAFilter));
98 c->shift = shift;
99 c->round = shift_1[shift-1];
100// c->round = 1 << (shift - 1);
a24c4a2a
AB
101}
102
103// FIXME: copy paste from original
79a32e3b 104static inline void memshl(register int32_t *a, register int32_t *b) {
a24c4a2a
AB
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
323b9da9
PM
115static inline void ttafilter_process(TTAFilter *c, int32_t *in)
116{
79a32e3b 117 register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
a24c4a2a
AB
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
323b9da9
PM
154 c->error = *in;
155 *in += (sum >> c->shift);
156 *dl = *in;
a24c4a2a 157
323b9da9
PM
158 *(dl-1) = *dl - *(dl-1);
159 *(dl-2) = *(dl-1) - *(dl-2);
160 *(dl-3) = *(dl-2) - *(dl-3);
a24c4a2a
AB
161
162 memshl(c->dl, c->dl + 1);
163 memshl(c->dx, c->dx + 1);
164}
165
79a32e3b 166static void rice_init(TTARice *c, uint32_t k0, uint32_t k1)
a24c4a2a
AB
167{
168 c->k0 = k0;
169 c->k1 = k1;
170 c->sum0 = shift_16[k0];
171 c->sum1 = shift_16[k1];
172}
173
174static int tta_get_unary(GetBitContext *gb)
175{
176 int ret = 0;
177
178 // count ones
35f9d8c2 179 while (get_bits_left(gb) > 0 && get_bits1(gb))
a24c4a2a
AB
180 ret++;
181 return ret;
182}
183
2af3dc86
PM
184static 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
98a6fff9 198static av_cold int tta_decode_init(AVCodecContext * avctx)
a24c4a2a
AB
199{
200 TTAContext *s = avctx->priv_data;
a24c4a2a
AB
201
202 s->avctx = avctx;
203
204 // 30bytes includes a seektable with one frame
205 if (avctx->extradata_size < 30)
206 return -1;
207
b59efc94 208 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
2bb6eba2 209 if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
a24c4a2a 210 {
2af3dc86
PM
211 if (avctx->err_recognition & AV_EF_CRCCHECK) {
212 s->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);
ea1d64ab 213 tta_check_crc(s, avctx->extradata, 18);
2af3dc86
PM
214 }
215
a24c4a2a 216 /* signature */
9aff2d17 217 skip_bits_long(&s->gb, 32);
a24c4a2a 218
b16960a8
JR
219 s->format = get_bits(&s->gb, 16);
220 if (s->format > 2) {
221 av_log(s->avctx, AV_LOG_ERROR, "Invalid format\n");
a24c4a2a
AB
222 return -1;
223 }
b16960a8
JR
224 if (s->format == FORMAT_ENCRYPTED) {
225 av_log_missing_feature(s->avctx, "Encrypted TTA", 0);
717addec 226 return AVERROR_PATCHWELCOME;
b16960a8 227 }
1a174c28 228 avctx->channels = s->channels = get_bits(&s->gb, 16);
dd1c8f3e
LA
229 avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
230 s->bps = (avctx->bits_per_coded_sample + 7) / 8;
1a174c28 231 avctx->sample_rate = get_bits_long(&s->gb, 32);
1a174c28 232 s->data_length = get_bits_long(&s->gb, 32);
9aff2d17 233 skip_bits_long(&s->gb, 32); // CRC32 of header
a24c4a2a 234
8bd1f1a4
SG
235 if (s->channels == 0) {
236 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
237 return AVERROR_INVALIDDATA;
7416d610
RB
238 } else if (avctx->sample_rate == 0) {
239 av_log(s->avctx, AV_LOG_ERROR, "Invalid samplerate\n");
240 return AVERROR_INVALIDDATA;
8bd1f1a4
SG
241 }
242
b16960a8 243 switch(s->bps) {
c6056d40
JR
244 case 2:
245 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
246 avctx->bits_per_raw_sample = 16;
247 break;
248 case 3:
249 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
250 avctx->bits_per_raw_sample = 24;
251 break;
252 default:
253 av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n");
254 return AVERROR_INVALIDDATA;
a24c4a2a
AB
255 }
256
b5050539 257 // prevent overflow
ac80b812 258 if (avctx->sample_rate > 0x7FFFFFu) {
b5050539
JR
259 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
260 return AVERROR(EINVAL);
261 }
262 s->frame_length = 256 * avctx->sample_rate / 245;
a24c4a2a
AB
263
264 s->last_frame_length = s->data_length % s->frame_length;
265 s->total_frames = s->data_length / s->frame_length +
266 (s->last_frame_length ? 1 : 0);
267
b16960a8
JR
268 av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
269 s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
a24c4a2a
AB
270 avctx->block_align);
271 av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
272 s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
273
274 // FIXME: seek table
ac80b812
RB
275 if (avctx->extradata_size <= 26 || s->total_frames > INT_MAX / 4 ||
276 avctx->extradata_size - 26 < s->total_frames * 4)
2af3dc86
PM
277 av_log(avctx, AV_LOG_WARNING, "Seek table missing or too small\n");
278 else if (avctx->err_recognition & AV_EF_CRCCHECK) {
279 if (tta_check_crc(s, avctx->extradata + 22, s->total_frames * 4))
280 return AVERROR_INVALIDDATA;
281 }
9aff2d17
PM
282 skip_bits_long(&s->gb, 32 * s->total_frames);
283 skip_bits_long(&s->gb, 32); // CRC32 of seektable
a24c4a2a 284
3a1a7e32
MN
285 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
286 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
287 return -1;
288 }
289
c6056d40
JR
290 if (s->bps == 2) {
291 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
2f1d212f
JR
292 if (!s->decode_buffer)
293 return AVERROR(ENOMEM);
c6056d40 294 }
5113b3bd 295 s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
2f1d212f
JR
296 if (!s->ch_ctx) {
297 av_freep(&s->decode_buffer);
5113b3bd 298 return AVERROR(ENOMEM);
2f1d212f 299 }
a24c4a2a
AB
300 } else {
301 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
302 return -1;
303 }
304
0eea2129
JR
305 avcodec_get_frame_defaults(&s->frame);
306 avctx->coded_frame = &s->frame;
307
a24c4a2a
AB
308 return 0;
309}
310
0eea2129
JR
311static int tta_decode_frame(AVCodecContext *avctx, void *data,
312 int *got_frame_ptr, AVPacket *avpkt)
a24c4a2a 313{
7a00bbad
TB
314 const uint8_t *buf = avpkt->data;
315 int buf_size = avpkt->size;
a24c4a2a 316 TTAContext *s = avctx->priv_data;
0eea2129 317 int i, ret;
7b7a74a1
JR
318 int cur_chan = 0, framelen = s->frame_length;
319 int32_t *p;
a24c4a2a 320
2af3dc86
PM
321 if (avctx->err_recognition & AV_EF_CRCCHECK) {
322 if (buf_size < 4 || tta_check_crc(s, buf, buf_size - 4))
323 return AVERROR_INVALIDDATA;
324 }
325
a24c4a2a 326 init_get_bits(&s->gb, buf, buf_size*8);
a24c4a2a 327
8664682d
JR
328 // FIXME: seeking
329 s->total_frames--;
330 if (!s->total_frames && s->last_frame_length)
331 framelen = s->last_frame_length;
a24c4a2a 332
0eea2129
JR
333 /* get output buffer */
334 s->frame.nb_samples = framelen;
594d4d5d 335 if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
0eea2129
JR
336 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
337 return ret;
8664682d
JR
338 }
339
c6056d40
JR
340 // decode directly to output buffer for 24-bit sample format
341 if (s->bps == 3)
01ed1c39 342 s->decode_buffer = (int32_t *)s->frame.data[0];
c6056d40 343
8664682d
JR
344 // init per channel states
345 for (i = 0; i < s->channels; i++) {
346 s->ch_ctx[i].predictor = 0;
323b9da9 347 ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1]);
8664682d
JR
348 rice_init(&s->ch_ctx[i].rice, 10, 10);
349 }
e6923f68 350
8664682d
JR
351 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
352 int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
353 TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
354 TTARice *rice = &s->ch_ctx[cur_chan].rice;
355 uint32_t unary, depth, k;
356 int32_t value;
357
358 unary = tta_get_unary(&s->gb);
359
360 if (unary == 0) {
361 depth = 0;
362 k = rice->k0;
363 } else {
364 depth = 1;
365 k = rice->k1;
366 unary--;
a24c4a2a
AB
367 }
368
6ab681a4
JR
369 if (get_bits_left(&s->gb) < k) {
370 ret = AVERROR_INVALIDDATA;
371 goto error;
372 }
a24c4a2a 373
8664682d 374 if (k) {
6ab681a4
JR
375 if (k > MIN_CACHE_BITS) {
376 ret = AVERROR_INVALIDDATA;
377 goto error;
378 }
8664682d
JR
379 value = (unary << k) + get_bits(&s->gb, k);
380 } else
381 value = unary;
382
383 // FIXME: copy paste from original
384 switch (depth) {
385 case 1:
386 rice->sum1 += value - (rice->sum1 >> 4);
387 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
388 rice->k1--;
389 else if(rice->sum1 > shift_16[rice->k1 + 1])
390 rice->k1++;
391 value += shift_1[rice->k0];
392 default:
393 rice->sum0 += value - (rice->sum0 >> 4);
394 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
395 rice->k0--;
396 else if(rice->sum0 > shift_16[rice->k0 + 1])
397 rice->k0++;
398 }
a9837b58 399
8664682d 400 // extract coded value
f2a4559c 401 *p = 1 + ((value >> 1) ^ ((value & 1) - 1));
a24c4a2a 402
8664682d 403 // run hybrid filter
323b9da9 404 ttafilter_process(filter, p);
a24c4a2a 405
8664682d 406 // fixed order prediction
79a32e3b 407#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
8664682d 408 switch (s->bps) {
e04ca1d4
PM
409 case 1: *p += PRED(*predictor, 4); break;
410 case 2:
411 case 3: *p += PRED(*predictor, 5); break;
412 case 4: *p += *predictor; break;
8664682d
JR
413 }
414 *predictor = *p;
415
416 // flip channels
417 if (cur_chan < (s->channels-1))
418 cur_chan++;
419 else {
46ea4635 420 // decorrelate in case of multiple channels
8664682d
JR
421 if (s->channels > 1) {
422 int32_t *r = p - 1;
423 for (*p += *r / 2; r > p - s->channels; r--)
424 *r = *(r + 1) - *r;
a24c4a2a 425 }
8664682d 426 cur_chan = 0;
a24c4a2a 427 }
8664682d 428 }
a24c4a2a 429
6ab681a4
JR
430 if (get_bits_left(&s->gb) < 32) {
431 ret = AVERROR_INVALIDDATA;
432 goto error;
433 }
9aff2d17 434 skip_bits_long(&s->gb, 32); // frame crc
8664682d
JR
435
436 // convert to output buffer
c6056d40 437 if (s->bps == 2) {
0eea2129 438 int16_t *samples = (int16_t *)s->frame.data[0];
c6056d40
JR
439 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
440 *samples++ = *p;
441 } else {
442 // shift samples for 24-bit sample format
0eea2129 443 int32_t *samples = (int32_t *)s->frame.data[0];
b656c4d0 444 for (i = 0; i < framelen * s->channels; i++)
c6056d40
JR
445 *samples++ <<= 8;
446 // reset decode buffer
447 s->decode_buffer = NULL;
8664682d 448 }
a24c4a2a 449
0eea2129
JR
450 *got_frame_ptr = 1;
451 *(AVFrame *)data = s->frame;
c6056d40 452
a24c4a2a 453 return buf_size;
6ab681a4
JR
454error:
455 // reset decode buffer
456 if (s->bps == 3)
457 s->decode_buffer = NULL;
458 return ret;
a24c4a2a
AB
459}
460
98a6fff9 461static av_cold int tta_decode_close(AVCodecContext *avctx) {
a24c4a2a
AB
462 TTAContext *s = avctx->priv_data;
463
437fb1c8 464 av_free(s->decode_buffer);
5113b3bd 465 av_freep(&s->ch_ctx);
a24c4a2a
AB
466
467 return 0;
468}
469
d36beb3f 470AVCodec ff_tta_decoder = {
ec6402b7
AK
471 .name = "tta",
472 .type = AVMEDIA_TYPE_AUDIO,
36ef5369 473 .id = AV_CODEC_ID_TTA,
ec6402b7
AK
474 .priv_data_size = sizeof(TTAContext),
475 .init = tta_decode_init,
476 .close = tta_decode_close,
477 .decode = tta_decode_frame,
0eea2129 478 .capabilities = CODEC_CAP_DR1,
0177b7d2 479 .long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
a24c4a2a 480};