ffmpeg / libavcodec / tta.c @ 4cf2e30f
History | View | Annotate | Download (14.7 KB)
1 |
/*
|
---|---|
2 |
* TTA (The Lossless True Audio) decoder
|
3 |
* Copyright (c) 2006 Alex Beregszaszi
|
4 |
*
|
5 |
* This file is part of FFmpeg.
|
6 |
*
|
7 |
* FFmpeg is free software; you can redistribute it and/or
|
8 |
* modify it under the terms of the GNU Lesser General Public
|
9 |
* License as published by the Free Software Foundation; either
|
10 |
* version 2.1 of the License, or (at your option) any later version.
|
11 |
*
|
12 |
* FFmpeg is distributed in the hope that it will be useful,
|
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
|
18 |
* License along with FFmpeg; if not, write to the Free Software
|
19 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
20 |
*/
|
21 |
|
22 |
/**
|
23 |
* @file
|
24 |
* TTA (The Lossless True Audio) decoder
|
25 |
* (www.true-audio.com or tta.corecodec.org)
|
26 |
* @author Alex Beregszaszi
|
27 |
*
|
28 |
*/
|
29 |
|
30 |
#define ALT_BITSTREAM_READER_LE
|
31 |
//#define DEBUG
|
32 |
#include <limits.h> |
33 |
#include "avcodec.h" |
34 |
#include "get_bits.h" |
35 |
|
36 |
#define FORMAT_INT 1 |
37 |
#define FORMAT_FLOAT 3 |
38 |
|
39 |
#define MAX_ORDER 16 |
40 |
typedef 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 |
|
47 |
typedef struct TTARice { |
48 |
uint32_t k0, k1, sum0, sum1; |
49 |
} TTARice; |
50 |
|
51 |
typedef struct TTAChannel { |
52 |
int32_t predictor; |
53 |
TTAFilter filter; |
54 |
TTARice rice; |
55 |
} TTAChannel; |
56 |
|
57 |
typedef 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 |
|
64 |
int32_t *decode_buffer; |
65 |
|
66 |
TTAChannel *ch_ctx; |
67 |
} TTAContext; |
68 |
|
69 |
#if 0
|
70 |
static inline int shift_1(int i)
|
71 |
{
|
72 |
if (i < 32)
|
73 |
return 1 << i;
|
74 |
else
|
75 |
return 0x80000000; // 16 << 31
|
76 |
}
|
77 |
|
78 |
static inline int shift_16(int i)
|
79 |
{
|
80 |
if (i < 28)
|
81 |
return 16 << i;
|
82 |
else
|
83 |
return 0x80000000; // 16 << 27
|
84 |
}
|
85 |
#else
|
86 |
static const uint32_t shift_1[] = { |
87 |
0x00000001, 0x00000002, 0x00000004, 0x00000008, |
88 |
0x00000010, 0x00000020, 0x00000040, 0x00000080, |
89 |
0x00000100, 0x00000200, 0x00000400, 0x00000800, |
90 |
0x00001000, 0x00002000, 0x00004000, 0x00008000, |
91 |
0x00010000, 0x00020000, 0x00040000, 0x00080000, |
92 |
0x00100000, 0x00200000, 0x00400000, 0x00800000, |
93 |
0x01000000, 0x02000000, 0x04000000, 0x08000000, |
94 |
0x10000000, 0x20000000, 0x40000000, 0x80000000, |
95 |
0x80000000, 0x80000000, 0x80000000, 0x80000000, |
96 |
0x80000000, 0x80000000, 0x80000000, 0x80000000 |
97 |
}; |
98 |
|
99 |
static const uint32_t * const shift_16 = shift_1 + 4; |
100 |
#endif
|
101 |
|
102 |
static const int32_t ttafilter_configs[4][2] = { |
103 |
{10, 1}, |
104 |
{9, 1}, |
105 |
{10, 1}, |
106 |
{12, 0} |
107 |
}; |
108 |
|
109 |
static void ttafilter_init(TTAFilter *c, int32_t shift, int32_t mode) { |
110 |
memset(c, 0, sizeof(TTAFilter)); |
111 |
c->shift = shift; |
112 |
c->round = shift_1[shift-1];
|
113 |
// c->round = 1 << (shift - 1);
|
114 |
c->mode = mode; |
115 |
} |
116 |
|
117 |
// FIXME: copy paste from original
|
118 |
static inline void memshl(register int32_t *a, register int32_t *b) { |
119 |
*a++ = *b++; |
120 |
*a++ = *b++; |
121 |
*a++ = *b++; |
122 |
*a++ = *b++; |
123 |
*a++ = *b++; |
124 |
*a++ = *b++; |
125 |
*a++ = *b++; |
126 |
*a = *b; |
127 |
} |
128 |
|
129 |
// FIXME: copy paste from original
|
130 |
// mode=1 encoder, mode=0 decoder
|
131 |
static inline void ttafilter_process(TTAFilter *c, int32_t *in, int32_t mode) { |
132 |
register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
|
133 |
|
134 |
if (!c->error) {
|
135 |
sum += *dl++ * *qm, qm++; |
136 |
sum += *dl++ * *qm, qm++; |
137 |
sum += *dl++ * *qm, qm++; |
138 |
sum += *dl++ * *qm, qm++; |
139 |
sum += *dl++ * *qm, qm++; |
140 |
sum += *dl++ * *qm, qm++; |
141 |
sum += *dl++ * *qm, qm++; |
142 |
sum += *dl++ * *qm, qm++; |
143 |
dx += 8;
|
144 |
} else if(c->error < 0) { |
145 |
sum += *dl++ * (*qm -= *dx++), qm++; |
146 |
sum += *dl++ * (*qm -= *dx++), qm++; |
147 |
sum += *dl++ * (*qm -= *dx++), qm++; |
148 |
sum += *dl++ * (*qm -= *dx++), qm++; |
149 |
sum += *dl++ * (*qm -= *dx++), qm++; |
150 |
sum += *dl++ * (*qm -= *dx++), qm++; |
151 |
sum += *dl++ * (*qm -= *dx++), qm++; |
152 |
sum += *dl++ * (*qm -= *dx++), qm++; |
153 |
} else {
|
154 |
sum += *dl++ * (*qm += *dx++), qm++; |
155 |
sum += *dl++ * (*qm += *dx++), qm++; |
156 |
sum += *dl++ * (*qm += *dx++), qm++; |
157 |
sum += *dl++ * (*qm += *dx++), qm++; |
158 |
sum += *dl++ * (*qm += *dx++), qm++; |
159 |
sum += *dl++ * (*qm += *dx++), qm++; |
160 |
sum += *dl++ * (*qm += *dx++), qm++; |
161 |
sum += *dl++ * (*qm += *dx++), qm++; |
162 |
} |
163 |
|
164 |
*(dx-0) = ((*(dl-1) >> 30) | 1) << 2; |
165 |
*(dx-1) = ((*(dl-2) >> 30) | 1) << 1; |
166 |
*(dx-2) = ((*(dl-3) >> 30) | 1) << 1; |
167 |
*(dx-3) = ((*(dl-4) >> 30) | 1); |
168 |
|
169 |
// compress
|
170 |
if (mode) {
|
171 |
*dl = *in; |
172 |
*in -= (sum >> c->shift); |
173 |
c->error = *in; |
174 |
} else {
|
175 |
c->error = *in; |
176 |
*in += (sum >> c->shift); |
177 |
*dl = *in; |
178 |
} |
179 |
|
180 |
if (c->mode) {
|
181 |
*(dl-1) = *dl - *(dl-1); |
182 |
*(dl-2) = *(dl-1) - *(dl-2); |
183 |
*(dl-3) = *(dl-2) - *(dl-3); |
184 |
} |
185 |
|
186 |
memshl(c->dl, c->dl + 1);
|
187 |
memshl(c->dx, c->dx + 1);
|
188 |
} |
189 |
|
190 |
static void rice_init(TTARice *c, uint32_t k0, uint32_t k1) |
191 |
{ |
192 |
c->k0 = k0; |
193 |
c->k1 = k1; |
194 |
c->sum0 = shift_16[k0]; |
195 |
c->sum1 = shift_16[k1]; |
196 |
} |
197 |
|
198 |
static int tta_get_unary(GetBitContext *gb) |
199 |
{ |
200 |
int ret = 0; |
201 |
|
202 |
// count ones
|
203 |
while(get_bits1(gb))
|
204 |
ret++; |
205 |
return ret;
|
206 |
} |
207 |
|
208 |
static const int64_t tta_channel_layouts[7] = { |
209 |
AV_CH_LAYOUT_STEREO, |
210 |
AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY, |
211 |
AV_CH_LAYOUT_QUAD, |
212 |
0,
|
213 |
AV_CH_LAYOUT_5POINT1_BACK, |
214 |
AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER, |
215 |
AV_CH_LAYOUT_7POINT1_WIDE |
216 |
}; |
217 |
|
218 |
static av_cold int tta_decode_init(AVCodecContext * avctx) |
219 |
{ |
220 |
TTAContext *s = avctx->priv_data; |
221 |
int i;
|
222 |
|
223 |
s->avctx = avctx; |
224 |
|
225 |
// 30bytes includes a seektable with one frame
|
226 |
if (avctx->extradata_size < 30) |
227 |
return -1; |
228 |
|
229 |
init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size); |
230 |
if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1")) |
231 |
{ |
232 |
/* signature */
|
233 |
skip_bits(&s->gb, 32);
|
234 |
// if (get_bits_long(&s->gb, 32) != av_bswap32(AV_RL32("TTA1"))) {
|
235 |
// av_log(s->avctx, AV_LOG_ERROR, "Missing magic\n");
|
236 |
// return -1;
|
237 |
// }
|
238 |
|
239 |
s->flags = get_bits(&s->gb, 16);
|
240 |
if (s->flags != 1 && s->flags != 3) |
241 |
{ |
242 |
av_log(s->avctx, AV_LOG_ERROR, "Invalid flags\n");
|
243 |
return -1; |
244 |
} |
245 |
s->is_float = (s->flags == FORMAT_FLOAT); |
246 |
avctx->channels = s->channels = get_bits(&s->gb, 16);
|
247 |
if (s->channels > 1 && s->channels < 9) |
248 |
avctx->channel_layout = tta_channel_layouts[s->channels-2];
|
249 |
avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
|
250 |
s->bps = (avctx->bits_per_coded_sample + 7) / 8; |
251 |
avctx->sample_rate = get_bits_long(&s->gb, 32);
|
252 |
if(avctx->sample_rate > 1000000){ //prevent FRAME_TIME * avctx->sample_rate from overflowing and sanity check |
253 |
av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
|
254 |
return -1; |
255 |
} |
256 |
s->data_length = get_bits_long(&s->gb, 32);
|
257 |
skip_bits(&s->gb, 32); // CRC32 of header |
258 |
|
259 |
if (s->is_float)
|
260 |
{ |
261 |
avctx->sample_fmt = AV_SAMPLE_FMT_FLT; |
262 |
av_log_ask_for_sample(s->avctx, "Unsupported sample format.\n");
|
263 |
return -1; |
264 |
} |
265 |
else switch(s->bps) { |
266 |
case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break; |
267 |
case 2: avctx->sample_fmt = AV_SAMPLE_FMT_S16; break; |
268 |
// case 3: avctx->sample_fmt = AV_SAMPLE_FMT_S24; break;
|
269 |
case 4: avctx->sample_fmt = AV_SAMPLE_FMT_S32; break; |
270 |
default:
|
271 |
av_log_ask_for_sample(s->avctx, |
272 |
"Invalid/unsupported sample format.\n");
|
273 |
return -1; |
274 |
} |
275 |
|
276 |
// FIXME: horribly broken, but directly from reference source
|
277 |
#define FRAME_TIME 1.04489795918367346939 |
278 |
s->frame_length = (int)(FRAME_TIME * avctx->sample_rate);
|
279 |
|
280 |
s->last_frame_length = s->data_length % s->frame_length; |
281 |
s->total_frames = s->data_length / s->frame_length + |
282 |
(s->last_frame_length ? 1 : 0); |
283 |
|
284 |
av_log(s->avctx, AV_LOG_DEBUG, "flags: %x chans: %d bps: %d rate: %d block: %d\n",
|
285 |
s->flags, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate, |
286 |
avctx->block_align); |
287 |
av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
|
288 |
s->data_length, s->frame_length, s->last_frame_length, s->total_frames); |
289 |
|
290 |
// FIXME: seek table
|
291 |
for (i = 0; i < s->total_frames; i++) |
292 |
skip_bits(&s->gb, 32);
|
293 |
skip_bits(&s->gb, 32); // CRC32 of seektable |
294 |
|
295 |
if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){ |
296 |
av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
|
297 |
return -1; |
298 |
} |
299 |
|
300 |
s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
|
301 |
if (!s->decode_buffer)
|
302 |
return AVERROR(ENOMEM);
|
303 |
s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
|
304 |
if (!s->ch_ctx)
|
305 |
return AVERROR(ENOMEM);
|
306 |
} else {
|
307 |
av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
|
308 |
return -1; |
309 |
} |
310 |
|
311 |
return 0; |
312 |
} |
313 |
|
314 |
static int tta_decode_frame(AVCodecContext *avctx, |
315 |
void *data, int *data_size, |
316 |
AVPacket *avpkt) |
317 |
{ |
318 |
const uint8_t *buf = avpkt->data;
|
319 |
int buf_size = avpkt->size;
|
320 |
TTAContext *s = avctx->priv_data; |
321 |
int i;
|
322 |
|
323 |
init_get_bits(&s->gb, buf, buf_size*8);
|
324 |
{ |
325 |
int cur_chan = 0, framelen = s->frame_length; |
326 |
int32_t *p; |
327 |
|
328 |
if (*data_size < (framelen * s->channels * av_get_bits_per_sample_fmt(avctx->sample_fmt) / 8)) { |
329 |
av_log(avctx, AV_LOG_ERROR, "Output buffer size is too small.\n");
|
330 |
return -1; |
331 |
} |
332 |
// FIXME: seeking
|
333 |
s->total_frames--; |
334 |
if (!s->total_frames && s->last_frame_length)
|
335 |
framelen = s->last_frame_length; |
336 |
|
337 |
// init per channel states
|
338 |
for (i = 0; i < s->channels; i++) { |
339 |
s->ch_ctx[i].predictor = 0;
|
340 |
ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]); |
341 |
rice_init(&s->ch_ctx[i].rice, 10, 10); |
342 |
} |
343 |
|
344 |
for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
|
345 |
int32_t *predictor = &s->ch_ctx[cur_chan].predictor; |
346 |
TTAFilter *filter = &s->ch_ctx[cur_chan].filter; |
347 |
TTARice *rice = &s->ch_ctx[cur_chan].rice; |
348 |
uint32_t unary, depth, k; |
349 |
int32_t value; |
350 |
|
351 |
unary = tta_get_unary(&s->gb); |
352 |
|
353 |
if (unary == 0) { |
354 |
depth = 0;
|
355 |
k = rice->k0; |
356 |
} else {
|
357 |
depth = 1;
|
358 |
k = rice->k1; |
359 |
unary--; |
360 |
} |
361 |
|
362 |
if (get_bits_left(&s->gb) < k)
|
363 |
return -1; |
364 |
|
365 |
if (k) {
|
366 |
if (k > MIN_CACHE_BITS)
|
367 |
return -1; |
368 |
value = (unary << k) + get_bits(&s->gb, k); |
369 |
} else
|
370 |
value = unary; |
371 |
|
372 |
// FIXME: copy paste from original
|
373 |
switch (depth) {
|
374 |
case 1: |
375 |
rice->sum1 += value - (rice->sum1 >> 4);
|
376 |
if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1]) |
377 |
rice->k1--; |
378 |
else if(rice->sum1 > shift_16[rice->k1 + 1]) |
379 |
rice->k1++; |
380 |
value += shift_1[rice->k0]; |
381 |
default:
|
382 |
rice->sum0 += value - (rice->sum0 >> 4);
|
383 |
if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0]) |
384 |
rice->k0--; |
385 |
else if(rice->sum0 > shift_16[rice->k0 + 1]) |
386 |
rice->k0++; |
387 |
} |
388 |
|
389 |
// extract coded value
|
390 |
#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1)) |
391 |
*p = UNFOLD(value); |
392 |
|
393 |
// run hybrid filter
|
394 |
ttafilter_process(filter, p, 0);
|
395 |
|
396 |
// fixed order prediction
|
397 |
#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
|
398 |
switch (s->bps) {
|
399 |
case 1: *p += PRED(*predictor, 4); break; |
400 |
case 2: |
401 |
case 3: *p += PRED(*predictor, 5); break; |
402 |
case 4: *p += *predictor; break; |
403 |
} |
404 |
*predictor = *p; |
405 |
|
406 |
#if 0
|
407 |
// extract 32bit float from last two int samples
|
408 |
if (s->is_float && ((p - data) & 1)) {
|
409 |
uint32_t neg = *p & 0x80000000;
|
410 |
uint32_t hi = *(p - 1);
|
411 |
uint32_t lo = abs(*p) - 1;
|
412 |
|
413 |
hi += (hi || lo) ? 0x3f80 : 0;
|
414 |
// SWAP16: swap all the 16 bits
|
415 |
*(p - 1) = (hi << 16) | SWAP16(lo) | neg;
|
416 |
}
|
417 |
#endif
|
418 |
|
419 |
/*if ((get_bits_count(&s->gb)+7)/8 > buf_size)
|
420 |
{
|
421 |
av_log(NULL, AV_LOG_INFO, "overread!!\n");
|
422 |
break;
|
423 |
}*/
|
424 |
|
425 |
// flip channels
|
426 |
if (cur_chan < (s->channels-1)) |
427 |
cur_chan++; |
428 |
else {
|
429 |
// decorrelate in case of stereo integer
|
430 |
if (!s->is_float && (s->channels > 1)) { |
431 |
int32_t *r = p - 1;
|
432 |
for (*p += *r / 2; r > p - s->channels; r--) |
433 |
*r = *(r + 1) - *r;
|
434 |
} |
435 |
cur_chan = 0;
|
436 |
} |
437 |
} |
438 |
|
439 |
if (get_bits_left(&s->gb) < 32) |
440 |
return -1; |
441 |
skip_bits(&s->gb, 32); // frame crc |
442 |
|
443 |
// convert to output buffer
|
444 |
switch(s->bps) {
|
445 |
case 1: { |
446 |
uint8_t *samples = data; |
447 |
for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
|
448 |
*samples++ = *p + 0x80;
|
449 |
*data_size = samples - (uint8_t *)data; |
450 |
break;
|
451 |
} |
452 |
case 2: { |
453 |
uint16_t *samples = data; |
454 |
for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
|
455 |
// *samples++ = (unsigned char)*p;
|
456 |
// *samples++ = (unsigned char)(*p >> 8);
|
457 |
*samples++ = *p; |
458 |
} |
459 |
*data_size = (uint8_t *)samples - (uint8_t *)data; |
460 |
break;
|
461 |
} |
462 |
default:
|
463 |
av_log(s->avctx, AV_LOG_ERROR, "Error, only 16bit samples supported!\n");
|
464 |
} |
465 |
} |
466 |
|
467 |
// return get_bits_count(&s->gb)+7)/8;
|
468 |
return buf_size;
|
469 |
} |
470 |
|
471 |
static av_cold int tta_decode_close(AVCodecContext *avctx) { |
472 |
TTAContext *s = avctx->priv_data; |
473 |
|
474 |
av_free(s->decode_buffer); |
475 |
av_freep(&s->ch_ctx); |
476 |
|
477 |
return 0; |
478 |
} |
479 |
|
480 |
AVCodec ff_tta_decoder = { |
481 |
"tta",
|
482 |
AVMEDIA_TYPE_AUDIO, |
483 |
CODEC_ID_TTA, |
484 |
sizeof(TTAContext),
|
485 |
tta_decode_init, |
486 |
NULL,
|
487 |
tta_decode_close, |
488 |
tta_decode_frame, |
489 |
.long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
|
490 |
}; |