tta: cast output data pointer to the correct type
[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;
194 int i;
195
196 s->avctx = avctx;
197
198 // 30bytes includes a seektable with one frame
199 if (avctx->extradata_size < 30)
200 return -1;
201
b59efc94 202 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
2bb6eba2 203 if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
a24c4a2a
AB
204 {
205 /* signature */
206 skip_bits(&s->gb, 32);
a24c4a2a 207
b16960a8
JR
208 s->format = get_bits(&s->gb, 16);
209 if (s->format > 2) {
210 av_log(s->avctx, AV_LOG_ERROR, "Invalid format\n");
a24c4a2a
AB
211 return -1;
212 }
b16960a8
JR
213 if (s->format == FORMAT_ENCRYPTED) {
214 av_log_missing_feature(s->avctx, "Encrypted TTA", 0);
215 return AVERROR(EINVAL);
216 }
1a174c28 217 avctx->channels = s->channels = get_bits(&s->gb, 16);
dd1c8f3e
LA
218 avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
219 s->bps = (avctx->bits_per_coded_sample + 7) / 8;
1a174c28 220 avctx->sample_rate = get_bits_long(&s->gb, 32);
1a174c28 221 s->data_length = get_bits_long(&s->gb, 32);
a24c4a2a
AB
222 skip_bits(&s->gb, 32); // CRC32 of header
223
8bd1f1a4
SG
224 if (s->channels == 0) {
225 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
226 return AVERROR_INVALIDDATA;
227 }
228
b16960a8 229 switch(s->bps) {
c6056d40
JR
230 case 2:
231 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
232 avctx->bits_per_raw_sample = 16;
233 break;
234 case 3:
235 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
236 avctx->bits_per_raw_sample = 24;
237 break;
238 default:
239 av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n");
240 return AVERROR_INVALIDDATA;
a24c4a2a
AB
241 }
242
b5050539
JR
243 // prevent overflow
244 if (avctx->sample_rate > 0x7FFFFF) {
245 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
246 return AVERROR(EINVAL);
247 }
248 s->frame_length = 256 * avctx->sample_rate / 245;
a24c4a2a
AB
249
250 s->last_frame_length = s->data_length % s->frame_length;
251 s->total_frames = s->data_length / s->frame_length +
252 (s->last_frame_length ? 1 : 0);
253
b16960a8
JR
254 av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
255 s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
a24c4a2a
AB
256 avctx->block_align);
257 av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
258 s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
259
260 // FIXME: seek table
261 for (i = 0; i < s->total_frames; i++)
262 skip_bits(&s->gb, 32);
263 skip_bits(&s->gb, 32); // CRC32 of seektable
264
3a1a7e32
MN
265 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
266 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
267 return -1;
268 }
269
c6056d40
JR
270 if (s->bps == 2) {
271 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
2f1d212f
JR
272 if (!s->decode_buffer)
273 return AVERROR(ENOMEM);
c6056d40 274 }
5113b3bd 275 s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
2f1d212f
JR
276 if (!s->ch_ctx) {
277 av_freep(&s->decode_buffer);
5113b3bd 278 return AVERROR(ENOMEM);
2f1d212f 279 }
a24c4a2a
AB
280 } else {
281 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
282 return -1;
283 }
284
0eea2129
JR
285 avcodec_get_frame_defaults(&s->frame);
286 avctx->coded_frame = &s->frame;
287
a24c4a2a
AB
288 return 0;
289}
290
0eea2129
JR
291static int tta_decode_frame(AVCodecContext *avctx, void *data,
292 int *got_frame_ptr, AVPacket *avpkt)
a24c4a2a 293{
7a00bbad
TB
294 const uint8_t *buf = avpkt->data;
295 int buf_size = avpkt->size;
a24c4a2a 296 TTAContext *s = avctx->priv_data;
0eea2129 297 int i, ret;
7b7a74a1
JR
298 int cur_chan = 0, framelen = s->frame_length;
299 int32_t *p;
a24c4a2a
AB
300
301 init_get_bits(&s->gb, buf, buf_size*8);
a24c4a2a 302
8664682d
JR
303 // FIXME: seeking
304 s->total_frames--;
305 if (!s->total_frames && s->last_frame_length)
306 framelen = s->last_frame_length;
a24c4a2a 307
0eea2129
JR
308 /* get output buffer */
309 s->frame.nb_samples = framelen;
310 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
311 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
312 return ret;
8664682d
JR
313 }
314
c6056d40
JR
315 // decode directly to output buffer for 24-bit sample format
316 if (s->bps == 3)
01ed1c39 317 s->decode_buffer = (int32_t *)s->frame.data[0];
c6056d40 318
8664682d
JR
319 // init per channel states
320 for (i = 0; i < s->channels; i++) {
321 s->ch_ctx[i].predictor = 0;
322 ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
323 rice_init(&s->ch_ctx[i].rice, 10, 10);
324 }
e6923f68 325
8664682d
JR
326 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
327 int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
328 TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
329 TTARice *rice = &s->ch_ctx[cur_chan].rice;
330 uint32_t unary, depth, k;
331 int32_t value;
332
333 unary = tta_get_unary(&s->gb);
334
335 if (unary == 0) {
336 depth = 0;
337 k = rice->k0;
338 } else {
339 depth = 1;
340 k = rice->k1;
341 unary--;
a24c4a2a
AB
342 }
343
8664682d
JR
344 if (get_bits_left(&s->gb) < k)
345 return -1;
a24c4a2a 346
8664682d
JR
347 if (k) {
348 if (k > MIN_CACHE_BITS)
a9837b58 349 return -1;
8664682d
JR
350 value = (unary << k) + get_bits(&s->gb, k);
351 } else
352 value = unary;
353
354 // FIXME: copy paste from original
355 switch (depth) {
356 case 1:
357 rice->sum1 += value - (rice->sum1 >> 4);
358 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
359 rice->k1--;
360 else if(rice->sum1 > shift_16[rice->k1 + 1])
361 rice->k1++;
362 value += shift_1[rice->k0];
363 default:
364 rice->sum0 += value - (rice->sum0 >> 4);
365 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
366 rice->k0--;
367 else if(rice->sum0 > shift_16[rice->k0 + 1])
368 rice->k0++;
369 }
a9837b58 370
8664682d 371 // extract coded value
15e35274 372#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
8664682d 373 *p = UNFOLD(value);
a24c4a2a 374
8664682d
JR
375 // run hybrid filter
376 ttafilter_process(filter, p, 0);
a24c4a2a 377
8664682d 378 // fixed order prediction
79a32e3b 379#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
8664682d
JR
380 switch (s->bps) {
381 case 1: *p += PRED(*predictor, 4); break;
382 case 2:
383 case 3: *p += PRED(*predictor, 5); break;
384 case 4: *p += *predictor; break;
385 }
386 *predictor = *p;
387
388 // flip channels
389 if (cur_chan < (s->channels-1))
390 cur_chan++;
391 else {
392 // decorrelate in case of stereo integer
393 if (s->channels > 1) {
394 int32_t *r = p - 1;
395 for (*p += *r / 2; r > p - s->channels; r--)
396 *r = *(r + 1) - *r;
a24c4a2a 397 }
8664682d 398 cur_chan = 0;
a24c4a2a 399 }
8664682d 400 }
a24c4a2a 401
8664682d
JR
402 if (get_bits_left(&s->gb) < 32)
403 return -1;
404 skip_bits(&s->gb, 32); // frame crc
405
406 // convert to output buffer
c6056d40 407 if (s->bps == 2) {
0eea2129 408 int16_t *samples = (int16_t *)s->frame.data[0];
c6056d40
JR
409 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
410 *samples++ = *p;
411 } else {
412 // shift samples for 24-bit sample format
0eea2129 413 int32_t *samples = (int32_t *)s->frame.data[0];
b656c4d0 414 for (i = 0; i < framelen * s->channels; i++)
c6056d40
JR
415 *samples++ <<= 8;
416 // reset decode buffer
417 s->decode_buffer = NULL;
8664682d 418 }
a24c4a2a 419
0eea2129
JR
420 *got_frame_ptr = 1;
421 *(AVFrame *)data = s->frame;
c6056d40 422
a24c4a2a
AB
423 return buf_size;
424}
425
98a6fff9 426static av_cold int tta_decode_close(AVCodecContext *avctx) {
a24c4a2a
AB
427 TTAContext *s = avctx->priv_data;
428
437fb1c8 429 av_free(s->decode_buffer);
5113b3bd 430 av_freep(&s->ch_ctx);
a24c4a2a
AB
431
432 return 0;
433}
434
d36beb3f 435AVCodec ff_tta_decoder = {
ec6402b7
AK
436 .name = "tta",
437 .type = AVMEDIA_TYPE_AUDIO,
438 .id = CODEC_ID_TTA,
439 .priv_data_size = sizeof(TTAContext),
440 .init = tta_decode_init,
441 .close = tta_decode_close,
442 .decode = tta_decode_frame,
0eea2129 443 .capabilities = CODEC_CAP_DR1,
68dddf53 444 .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
a24c4a2a 445};