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 021101301 USA

20 
*/

21  
22 
/**

23 
* @file

24 
* TTA (The Lossless True Audio) decoder

25 
* (www.trueaudio.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[shift1];

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 
*(dx0) = ((*(dl1) >> 30)  1) << 2; 
165 
*(dx1) = ((*(dl2) >> 30)  1) << 1; 
166 
*(dx2) = ((*(dl3) >> 30)  1) << 1; 
167 
*(dx3) = ((*(dl4) >> 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 
*(dl1) = *dl  *(dl1); 
182 
*(dl2) = *(dl1)  *(dl2); 
183 
*(dl3) = *(dl2)  *(dl3); 
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_STEREOAV_CH_LOW_FREQUENCY, 
211 
AV_CH_LAYOUT_QUAD, 
212 
0,

213 
AV_CH_LAYOUT_5POINT1_BACK, 
214 
AV_CH_LAYOUT_5POINT1_BACKAV_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>channels2];

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>bps1][0], ttafilter_configs[s>bps1][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>channels1)) 
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 
}; 