tta: remove useless commented-out lines
[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
30#define ALT_BITSTREAM_READER_LE
31//#define DEBUG
32#include <limits.h>
33#include "avcodec.h"
9106a698 34#include "get_bits.h"
a24c4a2a
AB
35
36#define FORMAT_INT 1
37#define FORMAT_FLOAT 3
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;
59 GetBitContext gb;
60
61 int flags, channels, bps, is_float, data_length;
62 int frame_length, last_frame_length, total_frames;
63
79a32e3b 64 int32_t *decode_buffer;
5113b3bd 65
c058dc22 66 TTAChannel *ch_ctx;
a24c4a2a
AB
67} TTAContext;
68
79a32e3b 69static const uint32_t shift_1[] = {
a24c4a2a
AB
70 0x00000001, 0x00000002, 0x00000004, 0x00000008,
71 0x00000010, 0x00000020, 0x00000040, 0x00000080,
72 0x00000100, 0x00000200, 0x00000400, 0x00000800,
73 0x00001000, 0x00002000, 0x00004000, 0x00008000,
74 0x00010000, 0x00020000, 0x00040000, 0x00080000,
75 0x00100000, 0x00200000, 0x00400000, 0x00800000,
76 0x01000000, 0x02000000, 0x04000000, 0x08000000,
77 0x10000000, 0x20000000, 0x40000000, 0x80000000,
78 0x80000000, 0x80000000, 0x80000000, 0x80000000,
79 0x80000000, 0x80000000, 0x80000000, 0x80000000
80};
81
cf2baeb3 82static const uint32_t * const shift_16 = shift_1 + 4;
a24c4a2a 83
cf2baeb3 84static const int32_t ttafilter_configs[4][2] = {
a24c4a2a
AB
85 {10, 1},
86 {9, 1},
87 {10, 1},
88 {12, 0}
89};
90
79a32e3b 91static void ttafilter_init(TTAFilter *c, int32_t shift, int32_t mode) {
a24c4a2a
AB
92 memset(c, 0, sizeof(TTAFilter));
93 c->shift = shift;
94 c->round = shift_1[shift-1];
95// c->round = 1 << (shift - 1);
96 c->mode = mode;
97}
98
99// FIXME: copy paste from original
79a32e3b 100static inline void memshl(register int32_t *a, register int32_t *b) {
a24c4a2a
AB
101 *a++ = *b++;
102 *a++ = *b++;
103 *a++ = *b++;
104 *a++ = *b++;
105 *a++ = *b++;
106 *a++ = *b++;
107 *a++ = *b++;
108 *a = *b;
109}
110
111// FIXME: copy paste from original
112// mode=1 encoder, mode=0 decoder
79a32e3b
BL
113static inline void ttafilter_process(TTAFilter *c, int32_t *in, int32_t mode) {
114 register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
a24c4a2a
AB
115
116 if (!c->error) {
117 sum += *dl++ * *qm, qm++;
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 dx += 8;
126 } else if(c->error < 0) {
127 sum += *dl++ * (*qm -= *dx++), qm++;
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 } else {
136 sum += *dl++ * (*qm += *dx++), qm++;
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 }
145
146 *(dx-0) = ((*(dl-1) >> 30) | 1) << 2;
147 *(dx-1) = ((*(dl-2) >> 30) | 1) << 1;
148 *(dx-2) = ((*(dl-3) >> 30) | 1) << 1;
149 *(dx-3) = ((*(dl-4) >> 30) | 1);
150
151 // compress
152 if (mode) {
153 *dl = *in;
154 *in -= (sum >> c->shift);
155 c->error = *in;
156 } else {
157 c->error = *in;
158 *in += (sum >> c->shift);
159 *dl = *in;
160 }
161
162 if (c->mode) {
163 *(dl-1) = *dl - *(dl-1);
164 *(dl-2) = *(dl-1) - *(dl-2);
165 *(dl-3) = *(dl-2) - *(dl-3);
166 }
167
168 memshl(c->dl, c->dl + 1);
169 memshl(c->dx, c->dx + 1);
170}
171
79a32e3b 172static void rice_init(TTARice *c, uint32_t k0, uint32_t k1)
a24c4a2a
AB
173{
174 c->k0 = k0;
175 c->k1 = k1;
176 c->sum0 = shift_16[k0];
177 c->sum1 = shift_16[k1];
178}
179
180static int tta_get_unary(GetBitContext *gb)
181{
182 int ret = 0;
183
184 // count ones
35f9d8c2 185 while (get_bits_left(gb) > 0 && get_bits1(gb))
a24c4a2a
AB
186 ret++;
187 return ret;
188}
189
98a6fff9 190static av_cold int tta_decode_init(AVCodecContext * avctx)
a24c4a2a
AB
191{
192 TTAContext *s = avctx->priv_data;
193 int i;
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 */
205 skip_bits(&s->gb, 32);
a24c4a2a 206
1a174c28 207 s->flags = get_bits(&s->gb, 16);
a24c4a2a
AB
208 if (s->flags != 1 && s->flags != 3)
209 {
210 av_log(s->avctx, AV_LOG_ERROR, "Invalid flags\n");
211 return -1;
212 }
213 s->is_float = (s->flags == FORMAT_FLOAT);
1a174c28 214 avctx->channels = s->channels = get_bits(&s->gb, 16);
dd1c8f3e
LA
215 avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
216 s->bps = (avctx->bits_per_coded_sample + 7) / 8;
1a174c28 217 avctx->sample_rate = get_bits_long(&s->gb, 32);
3a1a7e32
MN
218 if(avctx->sample_rate > 1000000){ //prevent FRAME_TIME * avctx->sample_rate from overflowing and sanity check
219 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
220 return -1;
221 }
1a174c28 222 s->data_length = get_bits_long(&s->gb, 32);
a24c4a2a
AB
223 skip_bits(&s->gb, 32); // CRC32 of header
224
225 if (s->is_float)
226 {
5d6e4c16 227 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
70fb031c 228 av_log_ask_for_sample(s->avctx, "Unsupported sample format.\n");
a24c4a2a
AB
229 return -1;
230 }
231 else switch(s->bps) {
5d6e4c16
SS
232// case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break;
233 case 2: avctx->sample_fmt = AV_SAMPLE_FMT_S16; break;
234// case 3: avctx->sample_fmt = AV_SAMPLE_FMT_S24; break;
235 case 4: avctx->sample_fmt = AV_SAMPLE_FMT_S32; break;
a24c4a2a 236 default:
70fb031c
DB
237 av_log_ask_for_sample(s->avctx,
238 "Invalid/unsupported sample format.\n");
a24c4a2a
AB
239 return -1;
240 }
241
242 // FIXME: horribly broken, but directly from reference source
243#define FRAME_TIME 1.04489795918367346939
244 s->frame_length = (int)(FRAME_TIME * avctx->sample_rate);
245
246 s->last_frame_length = s->data_length % s->frame_length;
247 s->total_frames = s->data_length / s->frame_length +
248 (s->last_frame_length ? 1 : 0);
249
250 av_log(s->avctx, AV_LOG_DEBUG, "flags: %x chans: %d bps: %d rate: %d block: %d\n",
dd1c8f3e 251 s->flags, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
a24c4a2a
AB
252 avctx->block_align);
253 av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
254 s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
255
256 // FIXME: seek table
257 for (i = 0; i < s->total_frames; i++)
258 skip_bits(&s->gb, 32);
259 skip_bits(&s->gb, 32); // CRC32 of seektable
260
3a1a7e32
MN
261 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
262 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
263 return -1;
264 }
265
79a32e3b 266 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
5113b3bd
MR
267 s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
268 if (!s->ch_ctx)
269 return AVERROR(ENOMEM);
a24c4a2a
AB
270 } else {
271 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
272 return -1;
273 }
274
275 return 0;
276}
277
278static int tta_decode_frame(AVCodecContext *avctx,
279 void *data, int *data_size,
7a00bbad 280 AVPacket *avpkt)
a24c4a2a 281{
7a00bbad
TB
282 const uint8_t *buf = avpkt->data;
283 int buf_size = avpkt->size;
a24c4a2a
AB
284 TTAContext *s = avctx->priv_data;
285 int i;
286
287 init_get_bits(&s->gb, buf, buf_size*8);
288 {
a24c4a2a 289 int cur_chan = 0, framelen = s->frame_length;
79a32e3b 290 int32_t *p;
a24c4a2a 291
bac6ed4a 292 if (*data_size < (framelen * s->channels * 2)) {
a0d5f3d3 293 av_log(avctx, AV_LOG_ERROR, "Output buffer size is too small.\n");
bac6ed4a
JM
294 return -1;
295 }
a24c4a2a
AB
296 // FIXME: seeking
297 s->total_frames--;
298 if (!s->total_frames && s->last_frame_length)
299 framelen = s->last_frame_length;
300
301 // init per channel states
302 for (i = 0; i < s->channels; i++) {
5113b3bd
MR
303 s->ch_ctx[i].predictor = 0;
304 ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
305 rice_init(&s->ch_ctx[i].rice, 10, 10);
a24c4a2a
AB
306 }
307
308 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
5113b3bd
MR
309 int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
310 TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
311 TTARice *rice = &s->ch_ctx[cur_chan].rice;
79a32e3b
BL
312 uint32_t unary, depth, k;
313 int32_t value;
a24c4a2a
AB
314
315 unary = tta_get_unary(&s->gb);
316
317 if (unary == 0) {
318 depth = 0;
319 k = rice->k0;
320 } else {
321 depth = 1;
322 k = rice->k1;
323 unary--;
324 }
325
a9837b58
LA
326 if (get_bits_left(&s->gb) < k)
327 return -1;
328
329 if (k) {
330 if (k > MIN_CACHE_BITS)
331 return -1;
a24c4a2a 332 value = (unary << k) + get_bits(&s->gb, k);
a9837b58 333 } else
a24c4a2a
AB
334 value = unary;
335
336 // FIXME: copy paste from original
337 switch (depth) {
338 case 1:
339 rice->sum1 += value - (rice->sum1 >> 4);
340 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
341 rice->k1--;
342 else if(rice->sum1 > shift_16[rice->k1 + 1])
343 rice->k1++;
344 value += shift_1[rice->k0];
345 default:
346 rice->sum0 += value - (rice->sum0 >> 4);
347 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
348 rice->k0--;
349 else if(rice->sum0 > shift_16[rice->k0 + 1])
350 rice->k0++;
351 }
352
15e35274
DB
353 // extract coded value
354#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
355 *p = UNFOLD(value);
a24c4a2a
AB
356
357 // run hybrid filter
358 ttafilter_process(filter, p, 0);
359
360 // fixed order prediction
79a32e3b 361#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
a24c4a2a
AB
362 switch (s->bps) {
363 case 1: *p += PRED(*predictor, 4); break;
364 case 2:
365 case 3: *p += PRED(*predictor, 5); break;
366 case 4: *p += *predictor; break;
367 }
368 *predictor = *p;
369
a24c4a2a
AB
370 // flip channels
371 if (cur_chan < (s->channels-1))
372 cur_chan++;
373 else {
374 // decorrelate in case of stereo integer
375 if (!s->is_float && (s->channels > 1)) {
79a32e3b 376 int32_t *r = p - 1;
a24c4a2a
AB
377 for (*p += *r / 2; r > p - s->channels; r--)
378 *r = *(r + 1) - *r;
379 }
380 cur_chan = 0;
381 }
382 }
383
a9837b58
LA
384 if (get_bits_left(&s->gb) < 32)
385 return -1;
a24c4a2a
AB
386 skip_bits(&s->gb, 32); // frame crc
387
388 // convert to output buffer
389 switch(s->bps) {
390 case 2: {
391 uint16_t *samples = data;
392 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
a24c4a2a
AB
393 *samples++ = *p;
394 }
395 *data_size = (uint8_t *)samples - (uint8_t *)data;
396 break;
397 }
398 default:
399 av_log(s->avctx, AV_LOG_ERROR, "Error, only 16bit samples supported!\n");
400 }
401 }
402
a24c4a2a
AB
403 return buf_size;
404}
405
98a6fff9 406static av_cold int tta_decode_close(AVCodecContext *avctx) {
a24c4a2a
AB
407 TTAContext *s = avctx->priv_data;
408
437fb1c8 409 av_free(s->decode_buffer);
5113b3bd 410 av_freep(&s->ch_ctx);
a24c4a2a
AB
411
412 return 0;
413}
414
d36beb3f 415AVCodec ff_tta_decoder = {
ec6402b7
AK
416 .name = "tta",
417 .type = AVMEDIA_TYPE_AUDIO,
418 .id = CODEC_ID_TTA,
419 .priv_data_size = sizeof(TTAContext),
420 .init = tta_decode_init,
421 .close = tta_decode_close,
422 .decode = tta_decode_frame,
68dddf53 423 .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
a24c4a2a 424};