Raw flac muxer, patch by Justin Ruggles (jruggle earthlink net). Can be
[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
79a32e3b 44 int32_t *decode_buffer;
a24c4a2a
AB
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
79a32e3b 64static const uint32_t shift_1[] = {
a24c4a2a
AB
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
79a32e3b 77static const uint32_t *shift_16 = shift_1 + 4;
a24c4a2a
AB
78#endif
79
80#define MAX_ORDER 16
81typedef struct TTAFilter {
79a32e3b
BL
82 int32_t shift, round, error, mode;
83 int32_t qm[MAX_ORDER];
84 int32_t dx[MAX_ORDER];
85 int32_t dl[MAX_ORDER];
a24c4a2a
AB
86} TTAFilter;
87
79a32e3b 88static int32_t ttafilter_configs[4][2] = {
a24c4a2a
AB
89 {10, 1},
90 {9, 1},
91 {10, 1},
92 {12, 0}
93};
94
79a32e3b 95static void ttafilter_init(TTAFilter *c, int32_t shift, int32_t mode) {
a24c4a2a
AB
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
79a32e3b 104static inline void memshl(register int32_t *a, register int32_t *b) {
a24c4a2a
AB
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
79a32e3b
BL
117static inline void ttafilter_process(TTAFilter *c, int32_t *in, int32_t mode) {
118 register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
a24c4a2a
AB
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 {
79a32e3b 177 uint32_t k0, k1, sum0, sum1;
a24c4a2a
AB
178} TTARice;
179
79a32e3b 180static void rice_init(TTARice *c, uint32_t k0, uint32_t k1)
a24c4a2a
AB
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
79a32e3b 279 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
a24c4a2a
AB
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 {
79a32e3b 297 int32_t predictors[s->channels];
a24c4a2a
AB
298 TTAFilter filters[s->channels];
299 TTARice rices[s->channels];
300 int cur_chan = 0, framelen = s->frame_length;
79a32e3b 301 int32_t *p;
a24c4a2a
AB
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++) {
79a32e3b 316 int32_t *predictor = &(predictors[cur_chan]);
a24c4a2a
AB
317 TTAFilter *filter = &(filters[cur_chan]);
318 TTARice *rice = &(rices[cur_chan]);
79a32e3b
BL
319 uint32_t unary, depth, k;
320 int32_t value;
a24c4a2a
AB
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
79a32e3b 363#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
a24c4a2a
AB
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)) {
79a32e3b
BL
375 uint32_t neg = *p & 0x80000000;
376 uint32_t hi = *(p - 1);
377 uint32_t lo = abs(*p) - 1;
a24c4a2a
AB
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)) {
79a32e3b 397 int32_t *r = p - 1;
a24c4a2a
AB
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};