ffmpeg / libavcodec / tta.c @ 70fb031c
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 Libav.

6 
*

7 
* Libav 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 
* Libav 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 Libav; 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_ask_for_sample(s>avctx, "Unsupported sample format.\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_ask_for_sample(s>avctx, 
260 
"Invalid/unsupported sample format.\n");

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

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

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

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

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

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

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

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

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

290 
if (!s>ch_ctx)

291 
return AVERROR(ENOMEM);

292 
} else {

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

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

305 
int buf_size = avpkt>size;

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

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

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

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

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

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

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

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

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

341 
k = rice>k0; 
342 
} else {

343 
depth = 1;

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

349 
return 1; 
350  
351 
if (k) {

352 
if (k > MIN_CACHE_BITS)

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

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

359 
switch (depth) {

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

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

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

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

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

380 
ttafilter_process(filter, p, 0);

381  
382 
// fixed order prediction

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

384 
switch (s>bps) {

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

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

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

395 
uint32_t neg = *p & 0x80000000;

396 
uint32_t hi = *(p  1);

397 
uint32_t lo = abs(*p)  1;

398 

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

400 
// SWAP16: swap all the 16 bits

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

402 
}

403 
#endif

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

406 
{

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

408 
break;

409 
}*/

410  
411 
// flip channels

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

415 
// decorrelate in case of stereo integer

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

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

420 
} 
421 
cur_chan = 0;

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

430 
switch(s>bps) {

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

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

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

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

440 
} 
441 
default:

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

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

447 
return buf_size;

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

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

464 
tta_decode_init, 
465 
NULL,

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

469 
}; 