You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

466 lines
14KB

  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. * @file
  23. * TTA (The Lossless True Audio) decoder
  24. * @see http://www.true-audio.com/
  25. * @see http://tta.corecodec.org/
  26. * @author Alex Beregszaszi
  27. */
  28. #define ALT_BITSTREAM_READER_LE
  29. //#define DEBUG
  30. #include <limits.h>
  31. #include "avcodec.h"
  32. #include "get_bits.h"
  33. #define FORMAT_INT 1
  34. #define FORMAT_FLOAT 3
  35. #define MAX_ORDER 16
  36. typedef struct TTAFilter {
  37. int32_t shift, round, error, mode;
  38. int32_t qm[MAX_ORDER];
  39. int32_t dx[MAX_ORDER];
  40. int32_t dl[MAX_ORDER];
  41. } TTAFilter;
  42. typedef struct TTARice {
  43. uint32_t k0, k1, sum0, sum1;
  44. } TTARice;
  45. typedef struct TTAChannel {
  46. int32_t predictor;
  47. TTAFilter filter;
  48. TTARice rice;
  49. } TTAChannel;
  50. typedef struct TTAContext {
  51. AVCodecContext *avctx;
  52. GetBitContext gb;
  53. int flags, channels, bps, is_float, data_length;
  54. int frame_length, last_frame_length, total_frames;
  55. int32_t *decode_buffer;
  56. TTAChannel *ch_ctx;
  57. } TTAContext;
  58. static const uint32_t shift_1[] = {
  59. 0x00000001, 0x00000002, 0x00000004, 0x00000008,
  60. 0x00000010, 0x00000020, 0x00000040, 0x00000080,
  61. 0x00000100, 0x00000200, 0x00000400, 0x00000800,
  62. 0x00001000, 0x00002000, 0x00004000, 0x00008000,
  63. 0x00010000, 0x00020000, 0x00040000, 0x00080000,
  64. 0x00100000, 0x00200000, 0x00400000, 0x00800000,
  65. 0x01000000, 0x02000000, 0x04000000, 0x08000000,
  66. 0x10000000, 0x20000000, 0x40000000, 0x80000000,
  67. 0x80000000, 0x80000000, 0x80000000, 0x80000000,
  68. 0x80000000, 0x80000000, 0x80000000, 0x80000000
  69. };
  70. static const uint32_t * const shift_16 = shift_1 + 4;
  71. static const int32_t ttafilter_configs[4][2] = {
  72. {10, 1},
  73. {9, 1},
  74. {10, 1},
  75. {12, 0}
  76. };
  77. static void ttafilter_init(TTAFilter *c, int32_t shift, int32_t mode) {
  78. memset(c, 0, sizeof(TTAFilter));
  79. c->shift = shift;
  80. c->round = shift_1[shift-1];
  81. // c->round = 1 << (shift - 1);
  82. c->mode = mode;
  83. }
  84. // FIXME: copy paste from original
  85. static inline void memshl(register int32_t *a, register int32_t *b) {
  86. *a++ = *b++;
  87. *a++ = *b++;
  88. *a++ = *b++;
  89. *a++ = *b++;
  90. *a++ = *b++;
  91. *a++ = *b++;
  92. *a++ = *b++;
  93. *a = *b;
  94. }
  95. // FIXME: copy paste from original
  96. // mode=1 encoder, mode=0 decoder
  97. static inline void ttafilter_process(TTAFilter *c, int32_t *in, int32_t mode) {
  98. register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
  99. if (!c->error) {
  100. sum += *dl++ * *qm, qm++;
  101. sum += *dl++ * *qm, qm++;
  102. sum += *dl++ * *qm, qm++;
  103. sum += *dl++ * *qm, qm++;
  104. sum += *dl++ * *qm, qm++;
  105. sum += *dl++ * *qm, qm++;
  106. sum += *dl++ * *qm, qm++;
  107. sum += *dl++ * *qm, qm++;
  108. dx += 8;
  109. } else if(c->error < 0) {
  110. sum += *dl++ * (*qm -= *dx++), qm++;
  111. sum += *dl++ * (*qm -= *dx++), qm++;
  112. sum += *dl++ * (*qm -= *dx++), qm++;
  113. sum += *dl++ * (*qm -= *dx++), qm++;
  114. sum += *dl++ * (*qm -= *dx++), qm++;
  115. sum += *dl++ * (*qm -= *dx++), qm++;
  116. sum += *dl++ * (*qm -= *dx++), qm++;
  117. sum += *dl++ * (*qm -= *dx++), qm++;
  118. } else {
  119. sum += *dl++ * (*qm += *dx++), qm++;
  120. sum += *dl++ * (*qm += *dx++), qm++;
  121. sum += *dl++ * (*qm += *dx++), qm++;
  122. sum += *dl++ * (*qm += *dx++), qm++;
  123. sum += *dl++ * (*qm += *dx++), qm++;
  124. sum += *dl++ * (*qm += *dx++), qm++;
  125. sum += *dl++ * (*qm += *dx++), qm++;
  126. sum += *dl++ * (*qm += *dx++), qm++;
  127. }
  128. *(dx-0) = ((*(dl-1) >> 30) | 1) << 2;
  129. *(dx-1) = ((*(dl-2) >> 30) | 1) << 1;
  130. *(dx-2) = ((*(dl-3) >> 30) | 1) << 1;
  131. *(dx-3) = ((*(dl-4) >> 30) | 1);
  132. // compress
  133. if (mode) {
  134. *dl = *in;
  135. *in -= (sum >> c->shift);
  136. c->error = *in;
  137. } else {
  138. c->error = *in;
  139. *in += (sum >> c->shift);
  140. *dl = *in;
  141. }
  142. if (c->mode) {
  143. *(dl-1) = *dl - *(dl-1);
  144. *(dl-2) = *(dl-1) - *(dl-2);
  145. *(dl-3) = *(dl-2) - *(dl-3);
  146. }
  147. memshl(c->dl, c->dl + 1);
  148. memshl(c->dx, c->dx + 1);
  149. }
  150. static void rice_init(TTARice *c, uint32_t k0, uint32_t k1)
  151. {
  152. c->k0 = k0;
  153. c->k1 = k1;
  154. c->sum0 = shift_16[k0];
  155. c->sum1 = shift_16[k1];
  156. }
  157. static int tta_get_unary(GetBitContext *gb)
  158. {
  159. int ret = 0;
  160. // count ones
  161. while(get_bits1(gb))
  162. ret++;
  163. return ret;
  164. }
  165. static const int64_t tta_channel_layouts[7] = {
  166. AV_CH_LAYOUT_STEREO,
  167. AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY,
  168. AV_CH_LAYOUT_QUAD,
  169. 0,
  170. AV_CH_LAYOUT_5POINT1_BACK,
  171. AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER,
  172. AV_CH_LAYOUT_7POINT1_WIDE
  173. };
  174. static av_cold int tta_decode_init(AVCodecContext * avctx)
  175. {
  176. TTAContext *s = avctx->priv_data;
  177. int i;
  178. s->avctx = avctx;
  179. // 30bytes includes a seektable with one frame
  180. if (avctx->extradata_size < 30)
  181. return -1;
  182. init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
  183. if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
  184. {
  185. /* signature */
  186. skip_bits(&s->gb, 32);
  187. // if (get_bits_long(&s->gb, 32) != av_bswap32(AV_RL32("TTA1"))) {
  188. // av_log(s->avctx, AV_LOG_ERROR, "Missing magic\n");
  189. // return -1;
  190. // }
  191. s->flags = get_bits(&s->gb, 16);
  192. if (s->flags != 1 && s->flags != 3)
  193. {
  194. av_log(s->avctx, AV_LOG_ERROR, "Invalid flags\n");
  195. return -1;
  196. }
  197. s->is_float = (s->flags == FORMAT_FLOAT);
  198. avctx->channels = s->channels = get_bits(&s->gb, 16);
  199. if (s->channels > 1 && s->channels < 9)
  200. avctx->channel_layout = tta_channel_layouts[s->channels-2];
  201. avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
  202. s->bps = (avctx->bits_per_coded_sample + 7) / 8;
  203. avctx->sample_rate = get_bits_long(&s->gb, 32);
  204. if(avctx->sample_rate > 1000000){ //prevent FRAME_TIME * avctx->sample_rate from overflowing and sanity check
  205. av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
  206. return -1;
  207. }
  208. s->data_length = get_bits_long(&s->gb, 32);
  209. skip_bits(&s->gb, 32); // CRC32 of header
  210. if (s->is_float)
  211. {
  212. avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
  213. av_log_ask_for_sample(s->avctx, "Unsupported sample format.\n");
  214. return -1;
  215. }
  216. else switch(s->bps) {
  217. case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break;
  218. case 2: avctx->sample_fmt = AV_SAMPLE_FMT_S16; break;
  219. case 3: avctx->bits_per_coded_sample = 24;
  220. case 4: avctx->sample_fmt = AV_SAMPLE_FMT_S32; break;
  221. default:
  222. av_log_ask_for_sample(s->avctx,
  223. "Invalid/unsupported sample format.\n");
  224. return -1;
  225. }
  226. // FIXME: horribly broken, but directly from reference source
  227. #define FRAME_TIME 1.04489795918367346939
  228. s->frame_length = (int)(FRAME_TIME * avctx->sample_rate);
  229. s->last_frame_length = s->data_length % s->frame_length;
  230. s->total_frames = s->data_length / s->frame_length +
  231. (s->last_frame_length ? 1 : 0);
  232. av_log(s->avctx, AV_LOG_DEBUG, "flags: %x chans: %d bps: %d rate: %d block: %d\n",
  233. s->flags, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
  234. avctx->block_align);
  235. av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
  236. s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
  237. // FIXME: seek table
  238. for (i = 0; i < s->total_frames; i++)
  239. skip_bits(&s->gb, 32);
  240. skip_bits(&s->gb, 32); // CRC32 of seektable
  241. if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
  242. av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
  243. return -1;
  244. }
  245. s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
  246. if (!s->decode_buffer)
  247. return AVERROR(ENOMEM);
  248. s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
  249. if (!s->ch_ctx)
  250. return AVERROR(ENOMEM);
  251. } else {
  252. av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
  253. return -1;
  254. }
  255. return 0;
  256. }
  257. static int tta_decode_frame(AVCodecContext *avctx,
  258. void *data, int *data_size,
  259. AVPacket *avpkt)
  260. {
  261. const uint8_t *buf = avpkt->data;
  262. int buf_size = avpkt->size;
  263. TTAContext *s = avctx->priv_data;
  264. int i;
  265. init_get_bits(&s->gb, buf, buf_size*8);
  266. {
  267. int cur_chan = 0, framelen = s->frame_length;
  268. int32_t *p;
  269. if (*data_size < (framelen * s->channels * av_get_bits_per_sample_fmt(avctx->sample_fmt) / 8)) {
  270. av_log(avctx, AV_LOG_ERROR, "Output buffer size is too small.\n");
  271. return -1;
  272. }
  273. // FIXME: seeking
  274. s->total_frames--;
  275. if (!s->total_frames && s->last_frame_length)
  276. framelen = s->last_frame_length;
  277. // init per channel states
  278. for (i = 0; i < s->channels; i++) {
  279. s->ch_ctx[i].predictor = 0;
  280. ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
  281. rice_init(&s->ch_ctx[i].rice, 10, 10);
  282. }
  283. for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
  284. int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
  285. TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
  286. TTARice *rice = &s->ch_ctx[cur_chan].rice;
  287. uint32_t unary, depth, k;
  288. int32_t value;
  289. unary = tta_get_unary(&s->gb);
  290. if (unary == 0) {
  291. depth = 0;
  292. k = rice->k0;
  293. } else {
  294. depth = 1;
  295. k = rice->k1;
  296. unary--;
  297. }
  298. if (get_bits_left(&s->gb) < k)
  299. return -1;
  300. if (k) {
  301. if (k > MIN_CACHE_BITS)
  302. return -1;
  303. value = (unary << k) + get_bits(&s->gb, k);
  304. } else
  305. value = unary;
  306. // FIXME: copy paste from original
  307. switch (depth) {
  308. case 1:
  309. rice->sum1 += value - (rice->sum1 >> 4);
  310. if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
  311. rice->k1--;
  312. else if(rice->sum1 > shift_16[rice->k1 + 1])
  313. rice->k1++;
  314. value += shift_1[rice->k0];
  315. default:
  316. rice->sum0 += value - (rice->sum0 >> 4);
  317. if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
  318. rice->k0--;
  319. else if(rice->sum0 > shift_16[rice->k0 + 1])
  320. rice->k0++;
  321. }
  322. // extract coded value
  323. #define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
  324. *p = UNFOLD(value);
  325. // run hybrid filter
  326. ttafilter_process(filter, p, 0);
  327. // fixed order prediction
  328. #define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
  329. switch (s->bps) {
  330. case 1: *p += PRED(*predictor, 4); break;
  331. case 2:
  332. case 3: *p += PRED(*predictor, 5); break;
  333. case 4: *p += *predictor; break;
  334. }
  335. *predictor = *p;
  336. /*if ((get_bits_count(&s->gb)+7)/8 > buf_size)
  337. {
  338. av_log(NULL, AV_LOG_INFO, "overread!!\n");
  339. break;
  340. }*/
  341. // flip channels
  342. if (cur_chan < (s->channels-1))
  343. cur_chan++;
  344. else {
  345. // decorrelate in case of stereo integer
  346. if (!s->is_float && (s->channels > 1)) {
  347. int32_t *r = p - 1;
  348. for (*p += *r / 2; r > p - s->channels; r--)
  349. *r = *(r + 1) - *r;
  350. }
  351. cur_chan = 0;
  352. }
  353. }
  354. if (get_bits_left(&s->gb) < 32)
  355. return -1;
  356. skip_bits(&s->gb, 32); // frame crc
  357. // convert to output buffer
  358. switch(s->bps) {
  359. case 1: {
  360. uint8_t *samples = data;
  361. for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
  362. *samples++ = *p + 0x80;
  363. *data_size = samples - (uint8_t *)data;
  364. break;
  365. }
  366. case 2: {
  367. uint16_t *samples = data;
  368. for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
  369. // *samples++ = (unsigned char)*p;
  370. // *samples++ = (unsigned char)(*p >> 8);
  371. *samples++ = *p;
  372. }
  373. *data_size = (uint8_t *)samples - (uint8_t *)data;
  374. break;
  375. }
  376. case 3: {
  377. int32_t *samples = data;
  378. for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
  379. *samples++ = AV_RN32(p) << 8;
  380. *data_size = (uint8_t *)samples - (uint8_t *)data;
  381. break;
  382. }
  383. default:
  384. av_log(s->avctx, AV_LOG_ERROR, "Error, only 16bit samples supported!\n");
  385. }
  386. }
  387. // return get_bits_count(&s->gb)+7)/8;
  388. return buf_size;
  389. }
  390. static av_cold int tta_decode_close(AVCodecContext *avctx) {
  391. TTAContext *s = avctx->priv_data;
  392. av_free(s->decode_buffer);
  393. av_freep(&s->ch_ctx);
  394. return 0;
  395. }
  396. AVCodec ff_tta_decoder = {
  397. .name = "tta",
  398. .type = AVMEDIA_TYPE_AUDIO,
  399. .id = CODEC_ID_TTA,
  400. .priv_data_size = sizeof(TTAContext),
  401. .init = tta_decode_init,
  402. .close = tta_decode_close,
  403. .decode = tta_decode_frame,
  404. .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
  405. };