tta: remove pointless braces
[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 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;
59 GetBitContext gb;
60
b16960a8 61 int format, channels, bps, data_length;
a24c4a2a
AB
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
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);
3a1a7e32
MN
220 if(avctx->sample_rate > 1000000){ //prevent FRAME_TIME * avctx->sample_rate from overflowing and sanity check
221 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
222 return -1;
223 }
1a174c28 224 s->data_length = get_bits_long(&s->gb, 32);
a24c4a2a
AB
225 skip_bits(&s->gb, 32); // CRC32 of header
226
b16960a8 227 switch(s->bps) {
5d6e4c16
SS
228// case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break;
229 case 2: avctx->sample_fmt = AV_SAMPLE_FMT_S16; break;
230// case 3: avctx->sample_fmt = AV_SAMPLE_FMT_S24; break;
231 case 4: avctx->sample_fmt = AV_SAMPLE_FMT_S32; break;
a24c4a2a 232 default:
70fb031c
DB
233 av_log_ask_for_sample(s->avctx,
234 "Invalid/unsupported sample format.\n");
a24c4a2a
AB
235 return -1;
236 }
237
238 // FIXME: horribly broken, but directly from reference source
239#define FRAME_TIME 1.04489795918367346939
240 s->frame_length = (int)(FRAME_TIME * avctx->sample_rate);
241
242 s->last_frame_length = s->data_length % s->frame_length;
243 s->total_frames = s->data_length / s->frame_length +
244 (s->last_frame_length ? 1 : 0);
245
b16960a8
JR
246 av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
247 s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
a24c4a2a
AB
248 avctx->block_align);
249 av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
250 s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
251
252 // FIXME: seek table
253 for (i = 0; i < s->total_frames; i++)
254 skip_bits(&s->gb, 32);
255 skip_bits(&s->gb, 32); // CRC32 of seektable
256
3a1a7e32
MN
257 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
258 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
259 return -1;
260 }
261
79a32e3b 262 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
5113b3bd
MR
263 s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
264 if (!s->ch_ctx)
265 return AVERROR(ENOMEM);
a24c4a2a
AB
266 } else {
267 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
268 return -1;
269 }
270
271 return 0;
272}
273
274static int tta_decode_frame(AVCodecContext *avctx,
275 void *data, int *data_size,
7a00bbad 276 AVPacket *avpkt)
a24c4a2a 277{
7a00bbad
TB
278 const uint8_t *buf = avpkt->data;
279 int buf_size = avpkt->size;
a24c4a2a
AB
280 TTAContext *s = avctx->priv_data;
281 int i;
7b7a74a1
JR
282 int cur_chan = 0, framelen = s->frame_length;
283 int32_t *p;
a24c4a2a
AB
284
285 init_get_bits(&s->gb, buf, buf_size*8);
a24c4a2a
AB
286
287 // FIXME: seeking
288 s->total_frames--;
289 if (!s->total_frames && s->last_frame_length)
290 framelen = s->last_frame_length;
291
e6923f68
JR
292 if (*data_size < (framelen * s->channels * 2)) {
293 av_log(avctx, AV_LOG_ERROR, "Output buffer size is too small.\n");
294 return -1;
295 }
296
a24c4a2a
AB
297 // init per channel states
298 for (i = 0; i < s->channels; i++) {
5113b3bd
MR
299 s->ch_ctx[i].predictor = 0;
300 ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
301 rice_init(&s->ch_ctx[i].rice, 10, 10);
a24c4a2a
AB
302 }
303
304 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
5113b3bd
MR
305 int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
306 TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
307 TTARice *rice = &s->ch_ctx[cur_chan].rice;
79a32e3b
BL
308 uint32_t unary, depth, k;
309 int32_t value;
a24c4a2a
AB
310
311 unary = tta_get_unary(&s->gb);
312
313 if (unary == 0) {
314 depth = 0;
315 k = rice->k0;
316 } else {
317 depth = 1;
318 k = rice->k1;
319 unary--;
320 }
321
a9837b58
LA
322 if (get_bits_left(&s->gb) < k)
323 return -1;
324
325 if (k) {
326 if (k > MIN_CACHE_BITS)
327 return -1;
a24c4a2a 328 value = (unary << k) + get_bits(&s->gb, k);
a9837b58 329 } else
a24c4a2a
AB
330 value = unary;
331
332 // FIXME: copy paste from original
333 switch (depth) {
334 case 1:
335 rice->sum1 += value - (rice->sum1 >> 4);
336 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
337 rice->k1--;
338 else if(rice->sum1 > shift_16[rice->k1 + 1])
339 rice->k1++;
340 value += shift_1[rice->k0];
341 default:
342 rice->sum0 += value - (rice->sum0 >> 4);
343 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
344 rice->k0--;
345 else if(rice->sum0 > shift_16[rice->k0 + 1])
346 rice->k0++;
347 }
348
15e35274
DB
349 // extract coded value
350#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
351 *p = UNFOLD(value);
a24c4a2a
AB
352
353 // run hybrid filter
354 ttafilter_process(filter, p, 0);
355
356 // fixed order prediction
79a32e3b 357#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
a24c4a2a
AB
358 switch (s->bps) {
359 case 1: *p += PRED(*predictor, 4); break;
360 case 2:
361 case 3: *p += PRED(*predictor, 5); break;
362 case 4: *p += *predictor; break;
363 }
364 *predictor = *p;
365
a24c4a2a
AB
366 // flip channels
367 if (cur_chan < (s->channels-1))
368 cur_chan++;
369 else {
370 // decorrelate in case of stereo integer
b16960a8 371 if (s->channels > 1) {
79a32e3b 372 int32_t *r = p - 1;
a24c4a2a
AB
373 for (*p += *r / 2; r > p - s->channels; r--)
374 *r = *(r + 1) - *r;
375 }
376 cur_chan = 0;
377 }
378 }
379
a9837b58
LA
380 if (get_bits_left(&s->gb) < 32)
381 return -1;
a24c4a2a
AB
382 skip_bits(&s->gb, 32); // frame crc
383
384 // convert to output buffer
385 switch(s->bps) {
386 case 2: {
387 uint16_t *samples = data;
388 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
a24c4a2a
AB
389 *samples++ = *p;
390 }
391 *data_size = (uint8_t *)samples - (uint8_t *)data;
392 break;
393 }
394 default:
395 av_log(s->avctx, AV_LOG_ERROR, "Error, only 16bit samples supported!\n");
396 }
a24c4a2a 397
a24c4a2a
AB
398 return buf_size;
399}
400
98a6fff9 401static av_cold int tta_decode_close(AVCodecContext *avctx) {
a24c4a2a
AB
402 TTAContext *s = avctx->priv_data;
403
437fb1c8 404 av_free(s->decode_buffer);
5113b3bd 405 av_freep(&s->ch_ctx);
a24c4a2a
AB
406
407 return 0;
408}
409
d36beb3f 410AVCodec ff_tta_decoder = {
ec6402b7
AK
411 .name = "tta",
412 .type = AVMEDIA_TYPE_AUDIO,
413 .id = CODEC_ID_TTA,
414 .priv_data_size = sizeof(TTAContext),
415 .init = tta_decode_init,
416 .close = tta_decode_close,
417 .decode = tta_decode_frame,
68dddf53 418 .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
a24c4a2a 419};