## ffmpeg / libavcodec / tta.c @ a24c4a2a

History | View | Annotate | Download (13 KB)

1 | a24c4a2a | Alex Beregszaszi | ```
/*
``` |
---|---|---|---|

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

37 | typedef 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 | |||

44 | ```
long *decode_buffer;
``` |
||

45 | } TTAContext; |
||

46 | |||

47 | ```
#if 0
``` |
||

48 | ```
static inline int shift_1(int i)
``` |
||

49 | ```
{
``` |
||

50 | ```
if (i < 32)
``` |
||

51 | ```
return 1 << i;
``` |
||

52 | ```
else
``` |
||

53 | ```
return 0x80000000; // 16 << 31
``` |
||

54 | ```
}
``` |
||

55 | |||

56 | ```
static 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
``` |
||

64 | static const unsigned long shift_1[] = { |
||

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

77 | static const unsigned long *shift_16 = shift_1 + 4; |
||

78 | ```
#endif
``` |
||

79 | |||

80 | #define MAX_ORDER 16 |
||

81 | typedef struct TTAFilter { |
||

82 | ```
long shift, round, error, mode;
``` |
||

83 | ```
long qm[MAX_ORDER];
``` |
||

84 | ```
long dx[MAX_ORDER];
``` |
||

85 | ```
long dl[MAX_ORDER];
``` |
||

86 | } TTAFilter; |
||

87 | |||

88 | static long ttafilter_configs[4][2] = { |
||

89 | {10, 1}, |
||

90 | {9, 1}, |
||

91 | {10, 1}, |
||

92 | {12, 0} |
||

93 | }; |
||

94 | |||

95 | static void ttafilter_init(TTAFilter *c, long shift, long mode) { |
||

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
``` |
||

104 | static inline void memshl(register long *a, register long *b) { |
||

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
``` |
||

117 | static inline void ttafilter_process(TTAFilter *c, long *in, long mode) { |
||

118 | register long *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round; |
||

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

176 | typedef struct TTARice { |
||

177 | unsigned long k0, k1, sum0, sum1; |
||

178 | } TTARice; |
||

179 | |||

180 | static void rice_init(TTARice *c, unsigned long k0, unsigned long k1) |
||

181 | { |
||

182 | c->k0 = k0; |
||

183 | c->k1 = k1; |
||

184 | c->sum0 = shift_16[k0]; |
||

185 | c->sum1 = shift_16[k1]; |
||

186 | } |
||

187 | |||

188 | static 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
``` |
||

199 | static int inline get_le16(GetBitContext *gb) |
||

200 | { |
||

201 | return bswap_16(get_bits_long(gb, 16)); |
||

202 | } |
||

203 | |||

204 | static int inline get_le32(GetBitContext *gb) |
||

205 | { |
||

206 | return bswap_32(get_bits_long(gb, 32)); |
||

207 | } |
||

208 | |||

209 | static 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 | |||

279 | s->decode_buffer = av_mallocz(sizeof(long)*s->frame_length*s->channels); |
||

280 | ```
} else {
``` |
||

281 | ```
av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
``` |
||

282 | return -1; |
||

283 | } |
||

284 | |||

285 | return 0; |
||

286 | } |
||

287 | |||

288 | static 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 | { |
||

297 | ```
long predictors[s->channels];
``` |
||

298 | TTAFilter filters[s->channels]; |
||

299 | TTARice rices[s->channels]; |
||

300 | int cur_chan = 0, framelen = s->frame_length; |
||

301 | ```
long *p;
``` |
||

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++) {
``` |
||

316 | ```
long *predictor = &(predictors[cur_chan]);
``` |
||

317 | TTAFilter *filter = &(filters[cur_chan]); |
||

318 | TTARice *rice = &(rices[cur_chan]); |
||

319 | unsigned long unary, depth, k; |
||

320 | ```
long value;
``` |
||

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
``` |
||

363 | #define PRED(x, k) (long)((((uint64_t)x << k) - x) >> k) |
||

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)) {
``` |
||

375 | ```
unsigned long neg = *p & 0x80000000;
``` |
||

376 | ```
unsigned long hi = *(p - 1);
``` |
||

377 | ```
unsigned long lo = abs(*p) - 1;
``` |
||

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)) { |
||

397 | long *r = p - 1; |
||

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

428 | static 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 | |||

437 | AVCodec 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 | }; |