ffmpeg / libavcodec / tta.c @ 437fb1c8
History  View  Annotate  Download (13.9 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 av_cold int tta_decode_init(AVCodecContext * avctx) 
209 
{ 
210 
TTAContext *s = avctx>priv_data; 
211 
int i;

212  
213 
s>avctx = avctx; 
214  
215 
// 30bytes includes a seektable with one frame

216 
if (avctx>extradata_size < 30) 
217 
return 1; 
218  
219 
init_get_bits(&s>gb, avctx>extradata, avctx>extradata_size); 
220 
if (show_bits_long(&s>gb, 32) == AV_RL32("TTA1")) 
221 
{ 
222 
/* signature */

223 
skip_bits(&s>gb, 32);

224 
// if (get_bits_long(&s>gb, 32) != av_bswap32(AV_RL32("TTA1"))) {

225 
// av_log(s>avctx, AV_LOG_ERROR, "Missing magic\n");

226 
// return 1;

227 
// }

228  
229 
s>flags = get_bits(&s>gb, 16);

230 
if (s>flags != 1 && s>flags != 3) 
231 
{ 
232 
av_log(s>avctx, AV_LOG_ERROR, "Invalid flags\n");

233 
return 1; 
234 
} 
235 
s>is_float = (s>flags == FORMAT_FLOAT); 
236 
avctx>channels = s>channels = get_bits(&s>gb, 16);

237 
avctx>bits_per_coded_sample = get_bits(&s>gb, 16);

238 
s>bps = (avctx>bits_per_coded_sample + 7) / 8; 
239 
avctx>sample_rate = get_bits_long(&s>gb, 32);

240 
if(avctx>sample_rate > 1000000){ //prevent FRAME_TIME * avctx>sample_rate from overflowing and sanity check 
241 
av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");

242 
return 1; 
243 
} 
244 
s>data_length = get_bits_long(&s>gb, 32);

245 
skip_bits(&s>gb, 32); // CRC32 of header 
246  
247 
if (s>is_float)

248 
{ 
249 
avctx>sample_fmt = AV_SAMPLE_FMT_FLT; 
250 
av_log(s>avctx, AV_LOG_ERROR, "Unsupported sample format. Please contact the developers.\n");

251 
return 1; 
252 
} 
253 
else switch(s>bps) { 
254 
// case 1: avctx>sample_fmt = AV_SAMPLE_FMT_U8; break;

255 
case 2: avctx>sample_fmt = AV_SAMPLE_FMT_S16; break; 
256 
// case 3: avctx>sample_fmt = AV_SAMPLE_FMT_S24; break;

257 
case 4: avctx>sample_fmt = AV_SAMPLE_FMT_S32; break; 
258 
default:

259 
av_log(s>avctx, AV_LOG_ERROR, "Invalid/unsupported sample format. Please contact the developers.\n");

260 
return 1; 
261 
} 
262  
263 
// FIXME: horribly broken, but directly from reference source

264 
#define FRAME_TIME 1.04489795918367346939 
265 
s>frame_length = (int)(FRAME_TIME * avctx>sample_rate);

266  
267 
s>last_frame_length = s>data_length % s>frame_length; 
268 
s>total_frames = s>data_length / s>frame_length + 
269 
(s>last_frame_length ? 1 : 0); 
270  
271 
av_log(s>avctx, AV_LOG_DEBUG, "flags: %x chans: %d bps: %d rate: %d block: %d\n",

272 
s>flags, avctx>channels, avctx>bits_per_coded_sample, avctx>sample_rate, 
273 
avctx>block_align); 
274 
av_log(s>avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",

275 
s>data_length, s>frame_length, s>last_frame_length, s>total_frames); 
276  
277 
// FIXME: seek table

278 
for (i = 0; i < s>total_frames; i++) 
279 
skip_bits(&s>gb, 32);

280 
skip_bits(&s>gb, 32); // CRC32 of seektable 
281  
282 
if(s>frame_length >= UINT_MAX / (s>channels * sizeof(int32_t))){ 
283 
av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");

284 
return 1; 
285 
} 
286  
287 
s>decode_buffer = av_mallocz(sizeof(int32_t)*s>frame_length*s>channels);

288 
s>ch_ctx = av_malloc(avctx>channels * sizeof(*s>ch_ctx));

289 
if (!s>ch_ctx)

290 
return AVERROR(ENOMEM);

291 
} else {

292 
av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");

293 
return 1; 
294 
} 
295  
296 
return 0; 
297 
} 
298  
299 
static int tta_decode_frame(AVCodecContext *avctx, 
300 
void *data, int *data_size, 
301 
AVPacket *avpkt) 
302 
{ 
303 
const uint8_t *buf = avpkt>data;

304 
int buf_size = avpkt>size;

305 
TTAContext *s = avctx>priv_data; 
306 
int i;

307  
308 
init_get_bits(&s>gb, buf, buf_size*8);

309 
{ 
310 
int cur_chan = 0, framelen = s>frame_length; 
311 
int32_t *p; 
312  
313 
if (*data_size < (framelen * s>channels * 2)) { 
314 
av_log(avctx, AV_LOG_ERROR, "Output buffer size is too small.\n");

315 
return 1; 
316 
} 
317 
// FIXME: seeking

318 
s>total_frames; 
319 
if (!s>total_frames && s>last_frame_length)

320 
framelen = s>last_frame_length; 
321  
322 
// init per channel states

323 
for (i = 0; i < s>channels; i++) { 
324 
s>ch_ctx[i].predictor = 0;

325 
ttafilter_init(&s>ch_ctx[i].filter, ttafilter_configs[s>bps1][0], ttafilter_configs[s>bps1][1]); 
326 
rice_init(&s>ch_ctx[i].rice, 10, 10); 
327 
} 
328  
329 
for (p = s>decode_buffer; p < s>decode_buffer + (framelen * s>channels); p++) {

330 
int32_t *predictor = &s>ch_ctx[cur_chan].predictor; 
331 
TTAFilter *filter = &s>ch_ctx[cur_chan].filter; 
332 
TTARice *rice = &s>ch_ctx[cur_chan].rice; 
333 
uint32_t unary, depth, k; 
334 
int32_t value; 
335  
336 
unary = tta_get_unary(&s>gb); 
337  
338 
if (unary == 0) { 
339 
depth = 0;

340 
k = rice>k0; 
341 
} else {

342 
depth = 1;

343 
k = rice>k1; 
344 
unary; 
345 
} 
346  
347 
if (get_bits_left(&s>gb) < k)

348 
return 1; 
349  
350 
if (k) {

351 
if (k > MIN_CACHE_BITS)

352 
return 1; 
353 
value = (unary << k) + get_bits(&s>gb, k); 
354 
} else

355 
value = unary; 
356  
357 
// FIXME: copy paste from original

358 
switch (depth) {

359 
case 1: 
360 
rice>sum1 += value  (rice>sum1 >> 4);

361 
if (rice>k1 > 0 && rice>sum1 < shift_16[rice>k1]) 
362 
rice>k1; 
363 
else if(rice>sum1 > shift_16[rice>k1 + 1]) 
364 
rice>k1++; 
365 
value += shift_1[rice>k0]; 
366 
default:

367 
rice>sum0 += value  (rice>sum0 >> 4);

368 
if (rice>k0 > 0 && rice>sum0 < shift_16[rice>k0]) 
369 
rice>k0; 
370 
else if(rice>sum0 > shift_16[rice>k0 + 1]) 
371 
rice>k0++; 
372 
} 
373  
374 
// extract coded value

375 
#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : ((x)>>1)) 
376 
*p = UNFOLD(value); 
377  
378 
// run hybrid filter

379 
ttafilter_process(filter, p, 0);

380  
381 
// fixed order prediction

382 
#define PRED(x, k) (int32_t)((((uint64_t)x << k)  x) >> k)

383 
switch (s>bps) {

384 
case 1: *p += PRED(*predictor, 4); break; 
385 
case 2: 
386 
case 3: *p += PRED(*predictor, 5); break; 
387 
case 4: *p += *predictor; break; 
388 
} 
389 
*predictor = *p; 
390  
391 
#if 0

392 
// extract 32bit float from last two int samples

393 
if (s>is_float && ((p  data) & 1)) {

394 
uint32_t neg = *p & 0x80000000;

395 
uint32_t hi = *(p  1);

396 
uint32_t lo = abs(*p)  1;

397 

398 
hi += (hi  lo) ? 0x3f80 : 0;

399 
// SWAP16: swap all the 16 bits

400 
*(p  1) = (hi << 16)  SWAP16(lo)  neg;

401 
}

402 
#endif

403  
404 
/*if ((get_bits_count(&s>gb)+7)/8 > buf_size)

405 
{

406 
av_log(NULL, AV_LOG_INFO, "overread!!\n");

407 
break;

408 
}*/

409  
410 
// flip channels

411 
if (cur_chan < (s>channels1)) 
412 
cur_chan++; 
413 
else {

414 
// decorrelate in case of stereo integer

415 
if (!s>is_float && (s>channels > 1)) { 
416 
int32_t *r = p  1;

417 
for (*p += *r / 2; r > p  s>channels; r) 
418 
*r = *(r + 1)  *r;

419 
} 
420 
cur_chan = 0;

421 
} 
422 
} 
423  
424 
if (get_bits_left(&s>gb) < 32) 
425 
return 1; 
426 
skip_bits(&s>gb, 32); // frame crc 
427  
428 
// convert to output buffer

429 
switch(s>bps) {

430 
case 2: { 
431 
uint16_t *samples = data; 
432 
for (p = s>decode_buffer; p < s>decode_buffer + (framelen * s>channels); p++) {

433 
// *samples++ = (unsigned char)*p;

434 
// *samples++ = (unsigned char)(*p >> 8);

435 
*samples++ = *p; 
436 
} 
437 
*data_size = (uint8_t *)samples  (uint8_t *)data; 
438 
break;

439 
} 
440 
default:

441 
av_log(s>avctx, AV_LOG_ERROR, "Error, only 16bit samples supported!\n");

442 
} 
443 
} 
444  
445 
// return get_bits_count(&s>gb)+7)/8;

446 
return buf_size;

447 
} 
448  
449 
static av_cold int tta_decode_close(AVCodecContext *avctx) { 
450 
TTAContext *s = avctx>priv_data; 
451  
452 
av_free(s>decode_buffer); 
453 
av_freep(&s>ch_ctx); 
454  
455 
return 0; 
456 
} 
457  
458 
AVCodec ff_tta_decoder = { 
459 
"tta",

460 
AVMEDIA_TYPE_AUDIO, 
461 
CODEC_ID_TTA, 
462 
sizeof(TTAContext),

463 
tta_decode_init, 
464 
NULL,

465 
tta_decode_close, 
466 
tta_decode_frame, 
467 
.long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),

468 
}; 