movenc: Support muxing VC1
[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"
a24c4a2a 35
b16960a8
JR
36#define FORMAT_SIMPLE 1
37#define FORMAT_ENCRYPTED 2
a24c4a2a 38
5113b3bd
MR
39#define MAX_ORDER 16
40typedef struct TTAFilter {
41 int32_t shift, round, error, mode;
42 int32_t qm[MAX_ORDER];
43 int32_t dx[MAX_ORDER];
44 int32_t dl[MAX_ORDER];
45} TTAFilter;
46
47typedef struct TTARice {
48 uint32_t k0, k1, sum0, sum1;
49} TTARice;
50
51typedef struct TTAChannel {
52 int32_t predictor;
53 TTAFilter filter;
54 TTARice rice;
55} TTAChannel;
56
a24c4a2a
AB
57typedef struct TTAContext {
58 AVCodecContext *avctx;
0eea2129 59 AVFrame frame;
a24c4a2a
AB
60 GetBitContext gb;
61
b16960a8 62 int format, channels, bps, data_length;
a24c4a2a
AB
63 int frame_length, last_frame_length, total_frames;
64
79a32e3b 65 int32_t *decode_buffer;
5113b3bd 66
c058dc22 67 TTAChannel *ch_ctx;
a24c4a2a
AB
68} TTAContext;
69
79a32e3b 70static const uint32_t shift_1[] = {
a24c4a2a
AB
71 0x00000001, 0x00000002, 0x00000004, 0x00000008,
72 0x00000010, 0x00000020, 0x00000040, 0x00000080,
73 0x00000100, 0x00000200, 0x00000400, 0x00000800,
74 0x00001000, 0x00002000, 0x00004000, 0x00008000,
75 0x00010000, 0x00020000, 0x00040000, 0x00080000,
76 0x00100000, 0x00200000, 0x00400000, 0x00800000,
77 0x01000000, 0x02000000, 0x04000000, 0x08000000,
78 0x10000000, 0x20000000, 0x40000000, 0x80000000,
79 0x80000000, 0x80000000, 0x80000000, 0x80000000,
80 0x80000000, 0x80000000, 0x80000000, 0x80000000
81};
82
cf2baeb3 83static const uint32_t * const shift_16 = shift_1 + 4;
a24c4a2a 84
cf2baeb3 85static const int32_t ttafilter_configs[4][2] = {
a24c4a2a
AB
86 {10, 1},
87 {9, 1},
88 {10, 1},
89 {12, 0}
90};
91
79a32e3b 92static void ttafilter_init(TTAFilter *c, int32_t shift, int32_t mode) {
a24c4a2a
AB
93 memset(c, 0, sizeof(TTAFilter));
94 c->shift = shift;
95 c->round = shift_1[shift-1];
96// c->round = 1 << (shift - 1);
97 c->mode = mode;
98}
99
100// FIXME: copy paste from original
79a32e3b 101static inline void memshl(register int32_t *a, register int32_t *b) {
a24c4a2a
AB
102 *a++ = *b++;
103 *a++ = *b++;
104 *a++ = *b++;
105 *a++ = *b++;
106 *a++ = *b++;
107 *a++ = *b++;
108 *a++ = *b++;
109 *a = *b;
110}
111
112// FIXME: copy paste from original
113// mode=1 encoder, mode=0 decoder
79a32e3b
BL
114static inline void ttafilter_process(TTAFilter *c, int32_t *in, int32_t mode) {
115 register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
a24c4a2a
AB
116
117 if (!c->error) {
118 sum += *dl++ * *qm, qm++;
119 sum += *dl++ * *qm, qm++;
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 dx += 8;
127 } else if(c->error < 0) {
128 sum += *dl++ * (*qm -= *dx++), qm++;
129 sum += *dl++ * (*qm -= *dx++), qm++;
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 } else {
137 sum += *dl++ * (*qm += *dx++), qm++;
138 sum += *dl++ * (*qm += *dx++), qm++;
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 }
146
147 *(dx-0) = ((*(dl-1) >> 30) | 1) << 2;
148 *(dx-1) = ((*(dl-2) >> 30) | 1) << 1;
149 *(dx-2) = ((*(dl-3) >> 30) | 1) << 1;
150 *(dx-3) = ((*(dl-4) >> 30) | 1);
151
152 // compress
153 if (mode) {
154 *dl = *in;
155 *in -= (sum >> c->shift);
156 c->error = *in;
157 } else {
158 c->error = *in;
159 *in += (sum >> c->shift);
160 *dl = *in;
161 }
162
163 if (c->mode) {
164 *(dl-1) = *dl - *(dl-1);
165 *(dl-2) = *(dl-1) - *(dl-2);
166 *(dl-3) = *(dl-2) - *(dl-3);
167 }
168
169 memshl(c->dl, c->dl + 1);
170 memshl(c->dx, c->dx + 1);
171}
172
79a32e3b 173static void rice_init(TTARice *c, uint32_t k0, uint32_t k1)
a24c4a2a
AB
174{
175 c->k0 = k0;
176 c->k1 = k1;
177 c->sum0 = shift_16[k0];
178 c->sum1 = shift_16[k1];
179}
180
181static int tta_get_unary(GetBitContext *gb)
182{
183 int ret = 0;
184
185 // count ones
35f9d8c2 186 while (get_bits_left(gb) > 0 && get_bits1(gb))
a24c4a2a
AB
187 ret++;
188 return ret;
189}
190
98a6fff9 191static av_cold int tta_decode_init(AVCodecContext * avctx)
a24c4a2a
AB
192{
193 TTAContext *s = avctx->priv_data;
a24c4a2a
AB
194
195 s->avctx = avctx;
196
197 // 30bytes includes a seektable with one frame
198 if (avctx->extradata_size < 30)
199 return -1;
200
b59efc94 201 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
2bb6eba2 202 if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
a24c4a2a
AB
203 {
204 /* signature */
9aff2d17 205 skip_bits_long(&s->gb, 32);
a24c4a2a 206
b16960a8
JR
207 s->format = get_bits(&s->gb, 16);
208 if (s->format > 2) {
209 av_log(s->avctx, AV_LOG_ERROR, "Invalid format\n");
a24c4a2a
AB
210 return -1;
211 }
b16960a8
JR
212 if (s->format == FORMAT_ENCRYPTED) {
213 av_log_missing_feature(s->avctx, "Encrypted TTA", 0);
214 return AVERROR(EINVAL);
215 }
1a174c28 216 avctx->channels = s->channels = get_bits(&s->gb, 16);
dd1c8f3e
LA
217 avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
218 s->bps = (avctx->bits_per_coded_sample + 7) / 8;
1a174c28 219 avctx->sample_rate = get_bits_long(&s->gb, 32);
1a174c28 220 s->data_length = get_bits_long(&s->gb, 32);
9aff2d17 221 skip_bits_long(&s->gb, 32); // CRC32 of header
a24c4a2a 222
8bd1f1a4
SG
223 if (s->channels == 0) {
224 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
225 return AVERROR_INVALIDDATA;
7416d610
RB
226 } else if (avctx->sample_rate == 0) {
227 av_log(s->avctx, AV_LOG_ERROR, "Invalid samplerate\n");
228 return AVERROR_INVALIDDATA;
8bd1f1a4
SG
229 }
230
b16960a8 231 switch(s->bps) {
c6056d40
JR
232 case 2:
233 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
234 avctx->bits_per_raw_sample = 16;
235 break;
236 case 3:
237 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
238 avctx->bits_per_raw_sample = 24;
239 break;
240 default:
241 av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n");
242 return AVERROR_INVALIDDATA;
a24c4a2a
AB
243 }
244
b5050539
JR
245 // prevent overflow
246 if (avctx->sample_rate > 0x7FFFFF) {
247 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
248 return AVERROR(EINVAL);
249 }
250 s->frame_length = 256 * avctx->sample_rate / 245;
a24c4a2a
AB
251
252 s->last_frame_length = s->data_length % s->frame_length;
253 s->total_frames = s->data_length / s->frame_length +
254 (s->last_frame_length ? 1 : 0);
255
b16960a8
JR
256 av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
257 s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
a24c4a2a
AB
258 avctx->block_align);
259 av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
260 s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
261
262 // FIXME: seek table
9aff2d17
PM
263 skip_bits_long(&s->gb, 32 * s->total_frames);
264 skip_bits_long(&s->gb, 32); // CRC32 of seektable
a24c4a2a 265
3a1a7e32
MN
266 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
267 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
268 return -1;
269 }
270
c6056d40
JR
271 if (s->bps == 2) {
272 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
2f1d212f
JR
273 if (!s->decode_buffer)
274 return AVERROR(ENOMEM);
c6056d40 275 }
5113b3bd 276 s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
2f1d212f
JR
277 if (!s->ch_ctx) {
278 av_freep(&s->decode_buffer);
5113b3bd 279 return AVERROR(ENOMEM);
2f1d212f 280 }
a24c4a2a
AB
281 } else {
282 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
283 return -1;
284 }
285
0eea2129
JR
286 avcodec_get_frame_defaults(&s->frame);
287 avctx->coded_frame = &s->frame;
288
a24c4a2a
AB
289 return 0;
290}
291
0eea2129
JR
292static int tta_decode_frame(AVCodecContext *avctx, void *data,
293 int *got_frame_ptr, AVPacket *avpkt)
a24c4a2a 294{
7a00bbad
TB
295 const uint8_t *buf = avpkt->data;
296 int buf_size = avpkt->size;
a24c4a2a 297 TTAContext *s = avctx->priv_data;
0eea2129 298 int i, ret;
7b7a74a1
JR
299 int cur_chan = 0, framelen = s->frame_length;
300 int32_t *p;
a24c4a2a
AB
301
302 init_get_bits(&s->gb, buf, buf_size*8);
a24c4a2a 303
8664682d
JR
304 // FIXME: seeking
305 s->total_frames--;
306 if (!s->total_frames && s->last_frame_length)
307 framelen = s->last_frame_length;
a24c4a2a 308
0eea2129
JR
309 /* get output buffer */
310 s->frame.nb_samples = framelen;
311 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
312 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
313 return ret;
8664682d
JR
314 }
315
c6056d40
JR
316 // decode directly to output buffer for 24-bit sample format
317 if (s->bps == 3)
01ed1c39 318 s->decode_buffer = (int32_t *)s->frame.data[0];
c6056d40 319
8664682d
JR
320 // init per channel states
321 for (i = 0; i < s->channels; i++) {
322 s->ch_ctx[i].predictor = 0;
323 ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
324 rice_init(&s->ch_ctx[i].rice, 10, 10);
325 }
e6923f68 326
8664682d
JR
327 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
328 int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
329 TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
330 TTARice *rice = &s->ch_ctx[cur_chan].rice;
331 uint32_t unary, depth, k;
332 int32_t value;
333
334 unary = tta_get_unary(&s->gb);
335
336 if (unary == 0) {
337 depth = 0;
338 k = rice->k0;
339 } else {
340 depth = 1;
341 k = rice->k1;
342 unary--;
a24c4a2a
AB
343 }
344
6ab681a4
JR
345 if (get_bits_left(&s->gb) < k) {
346 ret = AVERROR_INVALIDDATA;
347 goto error;
348 }
a24c4a2a 349
8664682d 350 if (k) {
6ab681a4
JR
351 if (k > MIN_CACHE_BITS) {
352 ret = AVERROR_INVALIDDATA;
353 goto error;
354 }
8664682d
JR
355 value = (unary << k) + get_bits(&s->gb, k);
356 } else
357 value = unary;
358
359 // FIXME: copy paste from original
360 switch (depth) {
361 case 1:
362 rice->sum1 += value - (rice->sum1 >> 4);
363 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
364 rice->k1--;
365 else if(rice->sum1 > shift_16[rice->k1 + 1])
366 rice->k1++;
367 value += shift_1[rice->k0];
368 default:
369 rice->sum0 += value - (rice->sum0 >> 4);
370 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
371 rice->k0--;
372 else if(rice->sum0 > shift_16[rice->k0 + 1])
373 rice->k0++;
374 }
a9837b58 375
8664682d 376 // extract coded value
15e35274 377#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
8664682d 378 *p = UNFOLD(value);
a24c4a2a 379
8664682d
JR
380 // run hybrid filter
381 ttafilter_process(filter, p, 0);
a24c4a2a 382
8664682d 383 // fixed order prediction
79a32e3b 384#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
8664682d
JR
385 switch (s->bps) {
386 case 1: *p += PRED(*predictor, 4); break;
387 case 2:
388 case 3: *p += PRED(*predictor, 5); break;
389 case 4: *p += *predictor; break;
390 }
391 *predictor = *p;
392
393 // flip channels
394 if (cur_chan < (s->channels-1))
395 cur_chan++;
396 else {
397 // decorrelate in case of stereo integer
398 if (s->channels > 1) {
399 int32_t *r = p - 1;
400 for (*p += *r / 2; r > p - s->channels; r--)
401 *r = *(r + 1) - *r;
a24c4a2a 402 }
8664682d 403 cur_chan = 0;
a24c4a2a 404 }
8664682d 405 }
a24c4a2a 406
6ab681a4
JR
407 if (get_bits_left(&s->gb) < 32) {
408 ret = AVERROR_INVALIDDATA;
409 goto error;
410 }
9aff2d17 411 skip_bits_long(&s->gb, 32); // frame crc
8664682d
JR
412
413 // convert to output buffer
c6056d40 414 if (s->bps == 2) {
0eea2129 415 int16_t *samples = (int16_t *)s->frame.data[0];
c6056d40
JR
416 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
417 *samples++ = *p;
418 } else {
419 // shift samples for 24-bit sample format
0eea2129 420 int32_t *samples = (int32_t *)s->frame.data[0];
b656c4d0 421 for (i = 0; i < framelen * s->channels; i++)
c6056d40
JR
422 *samples++ <<= 8;
423 // reset decode buffer
424 s->decode_buffer = NULL;
8664682d 425 }
a24c4a2a 426
0eea2129
JR
427 *got_frame_ptr = 1;
428 *(AVFrame *)data = s->frame;
c6056d40 429
a24c4a2a 430 return buf_size;
6ab681a4
JR
431error:
432 // reset decode buffer
433 if (s->bps == 3)
434 s->decode_buffer = NULL;
435 return ret;
a24c4a2a
AB
436}
437
98a6fff9 438static av_cold int tta_decode_close(AVCodecContext *avctx) {
a24c4a2a
AB
439 TTAContext *s = avctx->priv_data;
440
437fb1c8 441 av_free(s->decode_buffer);
5113b3bd 442 av_freep(&s->ch_ctx);
a24c4a2a
AB
443
444 return 0;
445}
446
d36beb3f 447AVCodec ff_tta_decoder = {
ec6402b7
AK
448 .name = "tta",
449 .type = AVMEDIA_TYPE_AUDIO,
450 .id = CODEC_ID_TTA,
451 .priv_data_size = sizeof(TTAContext),
452 .init = tta_decode_init,
453 .close = tta_decode_close,
454 .decode = tta_decode_frame,
0eea2129 455 .capabilities = CODEC_CAP_DR1,
68dddf53 456 .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
a24c4a2a 457};