Not that we're that far from being an *initial* implementation, but
[libav.git] / libavcodec / tta.c
CommitLineData
a24c4a2a
AB
1/*
2 * TTA (The Lossless True Audio) decoder
3 * Copyright (c) 2006 Alex Beregszaszi
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20/**
21 * @file tta.c
22 * TTA (The Lossless True Audio) decoder
23 * (www.true-audio.com or tta.corecodec.org)
24 * @author Alex Beregszaszi
25 *
26 */
27
28#define ALT_BITSTREAM_READER_LE
29//#define DEBUG
30#include <limits.h>
31#include "avcodec.h"
32#include "bitstream.h"
33
34#define FORMAT_INT 1
35#define FORMAT_FLOAT 3
36
37typedef struct TTAContext {
38 AVCodecContext *avctx;
39 GetBitContext gb;
40
41 int flags, channels, bps, is_float, data_length;
42 int frame_length, last_frame_length, total_frames;
43
44 long *decode_buffer;
45} TTAContext;
46
47#if 0
48static inline int shift_1(int i)
49{
50 if (i < 32)
51 return 1 << i;
52 else
53 return 0x80000000; // 16 << 31
54}
55
56static inline int shift_16(int i)
57{
58 if (i < 28)
59 return 16 << i;
60 else
61 return 0x80000000; // 16 << 27
62}
63#else
64static const unsigned long shift_1[] = {
65 0x00000001, 0x00000002, 0x00000004, 0x00000008,
66 0x00000010, 0x00000020, 0x00000040, 0x00000080,
67 0x00000100, 0x00000200, 0x00000400, 0x00000800,
68 0x00001000, 0x00002000, 0x00004000, 0x00008000,
69 0x00010000, 0x00020000, 0x00040000, 0x00080000,
70 0x00100000, 0x00200000, 0x00400000, 0x00800000,
71 0x01000000, 0x02000000, 0x04000000, 0x08000000,
72 0x10000000, 0x20000000, 0x40000000, 0x80000000,
73 0x80000000, 0x80000000, 0x80000000, 0x80000000,
74 0x80000000, 0x80000000, 0x80000000, 0x80000000
75};
76
77static const unsigned long *shift_16 = shift_1 + 4;
78#endif
79
80#define MAX_ORDER 16
81typedef struct TTAFilter {
82 long shift, round, error, mode;
83 long qm[MAX_ORDER];
84 long dx[MAX_ORDER];
85 long dl[MAX_ORDER];
86} TTAFilter;
87
88static long ttafilter_configs[4][2] = {
89 {10, 1},
90 {9, 1},
91 {10, 1},
92 {12, 0}
93};
94
95static void ttafilter_init(TTAFilter *c, long shift, long mode) {
96 memset(c, 0, sizeof(TTAFilter));
97 c->shift = shift;
98 c->round = shift_1[shift-1];
99// c->round = 1 << (shift - 1);
100 c->mode = mode;
101}
102
103// FIXME: copy paste from original
104static inline void memshl(register long *a, register long *b) {
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
115// FIXME: copy paste from original
116// mode=1 encoder, mode=0 decoder
117static inline void ttafilter_process(TTAFilter *c, long *in, long mode) {
118 register long *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
119
120 if (!c->error) {
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 sum += *dl++ * *qm, qm++;
129 dx += 8;
130 } else if(c->error < 0) {
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 sum += *dl++ * (*qm -= *dx++), qm++;
139 } else {
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 sum += *dl++ * (*qm += *dx++), qm++;
148 }
149
150 *(dx-0) = ((*(dl-1) >> 30) | 1) << 2;
151 *(dx-1) = ((*(dl-2) >> 30) | 1) << 1;
152 *(dx-2) = ((*(dl-3) >> 30) | 1) << 1;
153 *(dx-3) = ((*(dl-4) >> 30) | 1);
154
155 // compress
156 if (mode) {
157 *dl = *in;
158 *in -= (sum >> c->shift);
159 c->error = *in;
160 } else {
161 c->error = *in;
162 *in += (sum >> c->shift);
163 *dl = *in;
164 }
165
166 if (c->mode) {
167 *(dl-1) = *dl - *(dl-1);
168 *(dl-2) = *(dl-1) - *(dl-2);
169 *(dl-3) = *(dl-2) - *(dl-3);
170 }
171
172 memshl(c->dl, c->dl + 1);
173 memshl(c->dx, c->dx + 1);
174}
175
176typedef struct TTARice {
177 unsigned long k0, k1, sum0, sum1;
178} TTARice;
179
180static void rice_init(TTARice *c, unsigned long k0, unsigned long k1)
181{
182 c->k0 = k0;
183 c->k1 = k1;
184 c->sum0 = shift_16[k0];
185 c->sum1 = shift_16[k1];
186}
187
188static int tta_get_unary(GetBitContext *gb)
189{
190 int ret = 0;
191
192 // count ones
193 while(get_bits1(gb))
194 ret++;
195 return ret;
196}
197
198// shamelessly copied from shorten.c
199static int inline get_le16(GetBitContext *gb)
200{
201 return bswap_16(get_bits_long(gb, 16));
202}
203
204static int inline get_le32(GetBitContext *gb)
205{
206 return bswap_32(get_bits_long(gb, 32));
207}
208
209static int tta_decode_init(AVCodecContext * avctx)
210{
211 TTAContext *s = avctx->priv_data;
212 int i;
213
214 s->avctx = avctx;
215
216 // 30bytes includes a seektable with one frame
217 if (avctx->extradata_size < 30)
218 return -1;
219
220 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);
221 if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("TTA1")))
222 {
223 /* signature */
224 skip_bits(&s->gb, 32);
225// if (get_bits_long(&s->gb, 32) != bswap_32(ff_get_fourcc("TTA1"))) {
226// av_log(s->avctx, AV_LOG_ERROR, "Missing magic\n");
227// return -1;
228// }
229
230 s->flags = get_le16(&s->gb);
231 if (s->flags != 1 && s->flags != 3)
232 {
233 av_log(s->avctx, AV_LOG_ERROR, "Invalid flags\n");
234 return -1;
235 }
236 s->is_float = (s->flags == FORMAT_FLOAT);
237 avctx->channels = s->channels = get_le16(&s->gb);
238 avctx->bits_per_sample = get_le16(&s->gb);
239 s->bps = (avctx->bits_per_sample + 7) / 8;
240 avctx->sample_rate = get_le32(&s->gb);
241 s->data_length = get_le32(&s->gb);
242 skip_bits(&s->gb, 32); // CRC32 of header
243
244 if (s->is_float)
245 {
246 avctx->sample_fmt = SAMPLE_FMT_FLT;
247 av_log(s->avctx, AV_LOG_ERROR, "Unsupported sample format. Please contact the developers.\n");
248 return -1;
249 }
250 else switch(s->bps) {
251// case 1: avctx->sample_fmt = SAMPLE_FMT_U8; break;
252 case 2: avctx->sample_fmt = SAMPLE_FMT_S16; break;
253// case 3: avctx->sample_fmt = SAMPLE_FMT_S24; break;
254 case 4: avctx->sample_fmt = SAMPLE_FMT_S32; break;
255 default:
256 av_log(s->avctx, AV_LOG_ERROR, "Invalid/unsupported sample format. Please contact the developers.\n");
257 return -1;
258 }
259
260 // FIXME: horribly broken, but directly from reference source
261#define FRAME_TIME 1.04489795918367346939
262 s->frame_length = (int)(FRAME_TIME * avctx->sample_rate);
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
268 av_log(s->avctx, AV_LOG_DEBUG, "flags: %x chans: %d bps: %d rate: %d block: %d\n",
269 s->flags, avctx->channels, avctx->bits_per_sample, avctx->sample_rate,
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
275 for (i = 0; i < s->total_frames; i++)
276 skip_bits(&s->gb, 32);
277 skip_bits(&s->gb, 32); // CRC32 of seektable
278
279 s->decode_buffer = av_mallocz(sizeof(long)*s->frame_length*s->channels);
280 } else {
281 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
282 return -1;
283 }
284
285 return 0;
286}
287
288static int tta_decode_frame(AVCodecContext *avctx,
289 void *data, int *data_size,
290 uint8_t *buf, int buf_size)
291{
292 TTAContext *s = avctx->priv_data;
293 int i;
294
295 init_get_bits(&s->gb, buf, buf_size*8);
296 {
297 long predictors[s->channels];
298 TTAFilter filters[s->channels];
299 TTARice rices[s->channels];
300 int cur_chan = 0, framelen = s->frame_length;
301 long *p;
302
303 // FIXME: seeking
304 s->total_frames--;
305 if (!s->total_frames && s->last_frame_length)
306 framelen = s->last_frame_length;
307
308 // init per channel states
309 for (i = 0; i < s->channels; i++) {
310 predictors[i] = 0;
311 ttafilter_init(&(filters[i]), ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
312 rice_init(&(rices[i]), 10, 10);
313 }
314
315 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
316 long *predictor = &(predictors[cur_chan]);
317 TTAFilter *filter = &(filters[cur_chan]);
318 TTARice *rice = &(rices[cur_chan]);
319 unsigned long unary, depth, k;
320 long value;
321
322 unary = tta_get_unary(&s->gb);
323
324 if (unary == 0) {
325 depth = 0;
326 k = rice->k0;
327 } else {
328 depth = 1;
329 k = rice->k1;
330 unary--;
331 }
332
333 if (k)
334 value = (unary << k) + get_bits(&s->gb, k);
335 else
336 value = unary;
337
338 // FIXME: copy paste from original
339 switch (depth) {
340 case 1:
341 rice->sum1 += value - (rice->sum1 >> 4);
342 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
343 rice->k1--;
344 else if(rice->sum1 > shift_16[rice->k1 + 1])
345 rice->k1++;
346 value += shift_1[rice->k0];
347 default:
348 rice->sum0 += value - (rice->sum0 >> 4);
349 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
350 rice->k0--;
351 else if(rice->sum0 > shift_16[rice->k0 + 1])
352 rice->k0++;
353 }
354
355 // extract sign
356#define SIGN(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
357 *p = SIGN(value);
358
359 // run hybrid filter
360 ttafilter_process(filter, p, 0);
361
362 // fixed order prediction
363#define PRED(x, k) (long)((((uint64_t)x << k) - x) >> k)
364 switch (s->bps) {
365 case 1: *p += PRED(*predictor, 4); break;
366 case 2:
367 case 3: *p += PRED(*predictor, 5); break;
368 case 4: *p += *predictor; break;
369 }
370 *predictor = *p;
371
372#if 0
373 // extract 32bit float from last two int samples
374 if (s->is_float && ((p - data) & 1)) {
375 unsigned long neg = *p & 0x80000000;
376 unsigned long hi = *(p - 1);
377 unsigned long lo = abs(*p) - 1;
378
379 hi += (hi || lo) ? 0x3f80 : 0;
380 // SWAP16: swap all the 16 bits
381 *(p - 1) = (hi << 16) | SWAP16(lo) | neg;
382 }
383#endif
384
385 /*if ((get_bits_count(&s->gb)+7)/8 > buf_size)
386 {
387 av_log(NULL, AV_LOG_INFO, "overread!!\n");
388 break;
389 }*/
390
391 // flip channels
392 if (cur_chan < (s->channels-1))
393 cur_chan++;
394 else {
395 // decorrelate in case of stereo integer
396 if (!s->is_float && (s->channels > 1)) {
397 long *r = p - 1;
398 for (*p += *r / 2; r > p - s->channels; r--)
399 *r = *(r + 1) - *r;
400 }
401 cur_chan = 0;
402 }
403 }
404
405 skip_bits(&s->gb, 32); // frame crc
406
407 // convert to output buffer
408 switch(s->bps) {
409 case 2: {
410 uint16_t *samples = data;
411 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
412// *samples++ = (unsigned char)*p;
413// *samples++ = (unsigned char)(*p >> 8);
414 *samples++ = *p;
415 }
416 *data_size = (uint8_t *)samples - (uint8_t *)data;
417 break;
418 }
419 default:
420 av_log(s->avctx, AV_LOG_ERROR, "Error, only 16bit samples supported!\n");
421 }
422 }
423
424// return get_bits_count(&s->gb)+7)/8;
425 return buf_size;
426}
427
428static int tta_decode_close(AVCodecContext *avctx) {
429 TTAContext *s = avctx->priv_data;
430
431 if (s->decode_buffer)
432 av_free(s->decode_buffer);
433
434 return 0;
435}
436
437AVCodec tta_decoder = {
438 "tta",
439 CODEC_TYPE_AUDIO,
440 CODEC_ID_TTA,
441 sizeof(TTAContext),
442 tta_decode_init,
443 NULL,
444 tta_decode_close,
445 tta_decode_frame,
446};