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/** 23 * @file 24 * TTA (The Lossless True Audio) decoder 25 * @see http://www.true-audio.com/ 26 * @see http://tta.corecodec.org/ 27 * @author Alex Beregszaszi 28 */ 29 30#define BITSTREAM_READER_LE 31#include <limits.h> 32#include "ttadata.h" 33#include "ttadsp.h" 34#include "avcodec.h" 35#include "get_bits.h" 36#include "thread.h" 37#include "unary.h" 38#include "internal.h" 39#include "libavutil/crc.h" 40#include "libavutil/intreadwrite.h" 41#include "libavutil/opt.h" 42 43#define FORMAT_SIMPLE 1 44#define FORMAT_ENCRYPTED 2 45 46typedef struct TTAContext { 47 AVClass *class; 48 AVCodecContext *avctx; 49 const AVCRC *crc_table; 50 51 int format, channels, bps; 52 unsigned data_length; 53 int frame_length, last_frame_length; 54 55 int32_t *decode_buffer; 56 57 uint8_t crc_pass[8]; 58 uint8_t *pass; 59 TTAChannel *ch_ctx; 60 TTADSPContext dsp; 61} TTAContext; 62 63static const int64_t tta_channel_layouts[7] = { 64 AV_CH_LAYOUT_STEREO, 65 AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY, 66 AV_CH_LAYOUT_QUAD, 67 0, 68 AV_CH_LAYOUT_5POINT1_BACK, 69 AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER, 70 AV_CH_LAYOUT_7POINT1_WIDE 71}; 72 73static int tta_check_crc(TTAContext *s, const uint8_t *buf, int buf_size) 74{ 75 uint32_t crc, CRC; 76 77 CRC = AV_RL32(buf + buf_size); 78 crc = av_crc(s->crc_table, 0xFFFFFFFFU, buf, buf_size); 79 if (CRC != (crc ^ 0xFFFFFFFFU)) { 80 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n"); 81 return AVERROR_INVALIDDATA; 82 } 83 84 return 0; 85} 86 87static uint64_t tta_check_crc64(uint8_t *pass) 88{ 89 uint64_t crc = UINT64_MAX, poly = 0x42F0E1EBA9EA3693U; 90 uint8_t *end = pass + strlen(pass); 91 int i; 92 93 while (pass < end) { 94 crc ^= (uint64_t)*pass++ << 56; 95 for (i = 0; i < 8; i++) 96 crc = (crc << 1) ^ (poly & (((int64_t) crc) >> 63)); 97 } 98 99 return crc ^ UINT64_MAX; 100} 101 102static int allocate_buffers(AVCodecContext *avctx) 103{ 104 TTAContext *s = avctx->priv_data; 105 106 if (s->bps < 3) { 107 s->decode_buffer = av_mallocz_array(sizeof(int32_t)*s->frame_length, s->channels); 108 if (!s->decode_buffer) 109 return AVERROR(ENOMEM); 110 } else 111 s->decode_buffer = NULL; 112 s->ch_ctx = av_malloc_array(avctx->channels, sizeof(*s->ch_ctx)); 113 if (!s->ch_ctx) { 114 av_freep(&s->decode_buffer); 115 return AVERROR(ENOMEM); 116 } 117 118 return 0; 119} 120 121static av_cold int tta_decode_init(AVCodecContext * avctx) 122{ 123 TTAContext *s = avctx->priv_data; 124 GetBitContext gb; 125 int total_frames; 126 127 s->avctx = avctx; 128 129 // 30bytes includes TTA1 header 130 if (avctx->extradata_size < 22) 131 return AVERROR_INVALIDDATA; 132 133 s->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE); 134 init_get_bits8(&gb, avctx->extradata, avctx->extradata_size); 135 if (show_bits_long(&gb, 32) == AV_RL32("TTA1")) { 136 /* signature */ 137 skip_bits_long(&gb, 32); 138 139 s->format = get_bits(&gb, 16); 140 if (s->format > 2) { 141 av_log(avctx, AV_LOG_ERROR, "Invalid format\n"); 142 return AVERROR_INVALIDDATA; 143 } 144 if (s->format == FORMAT_ENCRYPTED) { 145 if (!s->pass) { 146 av_log(avctx, AV_LOG_ERROR, "Missing password for encrypted stream. Please use the -password option\n"); 147 return AVERROR(EINVAL); 148 } 149 AV_WL64(s->crc_pass, tta_check_crc64(s->pass)); 150 } 151 avctx->channels = s->channels = get_bits(&gb, 16); 152 if (s->channels > 1 && s->channels < 9) 153 avctx->channel_layout = tta_channel_layouts[s->channels-2]; 154 avctx->bits_per_raw_sample = get_bits(&gb, 16); 155 s->bps = (avctx->bits_per_raw_sample + 7) / 8; 156 avctx->sample_rate = get_bits_long(&gb, 32); 157 s->data_length = get_bits_long(&gb, 32); 158 skip_bits_long(&gb, 32); // CRC32 of header 159 160 if (s->channels == 0) { 161 av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n"); 162 return AVERROR_INVALIDDATA; 163 } else if (avctx->sample_rate == 0) { 164 av_log(avctx, AV_LOG_ERROR, "Invalid samplerate\n"); 165 return AVERROR_INVALIDDATA; 166 } 167 168 switch(s->bps) { 169 case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break; 170 case 2: 171 avctx->sample_fmt = AV_SAMPLE_FMT_S16; 172 break; 173 case 3: 174 avctx->sample_fmt = AV_SAMPLE_FMT_S32; 175 break; 176 //case 4: avctx->sample_fmt = AV_SAMPLE_FMT_S32; break; 177 default: 178 av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n"); 179 return AVERROR_INVALIDDATA; 180 } 181 182 // prevent overflow 183 if (avctx->sample_rate > 0x7FFFFFu) { 184 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n"); 185 return AVERROR(EINVAL); 186 } 187 s->frame_length = 256 * avctx->sample_rate / 245; 188 189 s->last_frame_length = s->data_length % s->frame_length; 190 total_frames = s->data_length / s->frame_length + 191 (s->last_frame_length ? 1 : 0); 192 193 av_log(avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n", 194 s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate, 195 avctx->block_align); 196 av_log(avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n", 197 s->data_length, s->frame_length, s->last_frame_length, total_frames); 198 199 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){ 200 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n"); 201 return AVERROR_INVALIDDATA; 202 } 203 } else { 204 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n"); 205 return AVERROR_INVALIDDATA; 206 } 207 208 ff_ttadsp_init(&s->dsp); 209 210 return allocate_buffers(avctx); 211} 212 213static int tta_decode_frame(AVCodecContext *avctx, void *data, 214 int *got_frame_ptr, AVPacket *avpkt) 215{ 216 AVFrame *frame = data; 217 ThreadFrame tframe = { .f = data }; 218 const uint8_t *buf = avpkt->data; 219 int buf_size = avpkt->size; 220 TTAContext *s = avctx->priv_data; 221 GetBitContext gb; 222 int i, ret; 223 int cur_chan = 0, framelen = s->frame_length; 224 int32_t *p; 225 226 if (avctx->err_recognition & AV_EF_CRCCHECK) { 227 if (buf_size < 4 || 228 (tta_check_crc(s, buf, buf_size - 4) && avctx->err_recognition & AV_EF_EXPLODE)) 229 return AVERROR_INVALIDDATA; 230 } 231 232 if ((ret = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0) 233 return ret; 234 235 /* get output buffer */ 236 frame->nb_samples = framelen; 237 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0) 238 return ret; 239 240 // decode directly to output buffer for 24-bit sample format 241 if (s->bps == 3) 242 s->decode_buffer = (int32_t *)frame->data[0]; 243 244 // init per channel states 245 for (i = 0; i < s->channels; i++) { 246 TTAFilter *filter = &s->ch_ctx[i].filter; 247 s->ch_ctx[i].predictor = 0; 248 ff_tta_filter_init(filter, ff_tta_filter_configs[s->bps-1]); 249 if (s->format == FORMAT_ENCRYPTED) { 250 int i; 251 for (i = 0; i < 8; i++) 252 filter->qm[i] = sign_extend(s->crc_pass[i], 8); 253 } 254 ff_tta_rice_init(&s->ch_ctx[i].rice, 10, 10); 255 } 256 257 i = 0; 258 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) { 259 int32_t *predictor = &s->ch_ctx[cur_chan].predictor; 260 TTAFilter *filter = &s->ch_ctx[cur_chan].filter; 261 TTARice *rice = &s->ch_ctx[cur_chan].rice; 262 uint32_t unary, depth, k; 263 int32_t value; 264 265 unary = get_unary(&gb, 0, get_bits_left(&gb)); 266 267 if (unary == 0) { 268 depth = 0; 269 k = rice->k0; 270 } else { 271 depth = 1; 272 k = rice->k1; 273 unary--; 274 } 275 276 if (get_bits_left(&gb) < k) { 277 ret = AVERROR_INVALIDDATA; 278 goto error; 279 } 280 281 if (k) { 282 if (k > MIN_CACHE_BITS) { 283 ret = AVERROR_INVALIDDATA; 284 goto error; 285 } 286 value = (unary << k) + get_bits(&gb, k); 287 } else 288 value = unary; 289 290 // FIXME: copy paste from original 291 switch (depth) { 292 case 1: 293 rice->sum1 += value - (rice->sum1 >> 4); 294 if (rice->k1 > 0 && rice->sum1 < ff_tta_shift_16[rice->k1]) 295 rice->k1--; 296 else if(rice->sum1 > ff_tta_shift_16[rice->k1 + 1]) 297 rice->k1++; 298 value += ff_tta_shift_1[rice->k0]; 299 default: 300 rice->sum0 += value - (rice->sum0 >> 4); 301 if (rice->k0 > 0 && rice->sum0 < ff_tta_shift_16[rice->k0]) 302 rice->k0--; 303 else if(rice->sum0 > ff_tta_shift_16[rice->k0 + 1]) 304 rice->k0++; 305 } 306 307 // extract coded value 308 *p = 1 + ((value >> 1) ^ ((value & 1) - 1)); 309 310 // run hybrid filter 311 s->dsp.ttafilter_process_dec(filter->qm, filter->dx, filter->dl, &filter->error, p, 312 filter->shift, filter->round); 313 314 // fixed order prediction 315#define PRED(x, k) (int32_t)((((uint64_t)(x) << (k)) - (x)) >> (k)) 316 switch (s->bps) { 317 case 1: *p += PRED(*predictor, 4); break; 318 case 2: 319 case 3: *p += PRED(*predictor, 5); break; 320 case 4: *p += *predictor; break; 321 } 322 *predictor = *p; 323 324 // flip channels 325 if (cur_chan < (s->channels-1)) 326 cur_chan++; 327 else { 328 // decorrelate in case of multiple channels 329 if (s->channels > 1) { 330 int32_t *r = p - 1; 331 for (*p += *r / 2; r > p - s->channels; r--) 332 *r = *(r + 1) - *r; 333 } 334 cur_chan = 0; 335 i++; 336 // check for last frame 337 if (i == s->last_frame_length && get_bits_left(&gb) / 8 == 4) { 338 frame->nb_samples = framelen = s->last_frame_length; 339 break; 340 } 341 } 342 } 343 344 align_get_bits(&gb); 345 if (get_bits_left(&gb) < 32) { 346 ret = AVERROR_INVALIDDATA; 347 goto error; 348 } 349 skip_bits_long(&gb, 32); // frame crc 350 351 // convert to output buffer 352 switch (s->bps) { 353 case 1: { 354 uint8_t *samples = (uint8_t *)frame->data[0]; 355 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) 356 *samples++ = *p + 0x80; 357 break; 358 } 359 case 2: { 360 int16_t *samples = (int16_t *)frame->data[0]; 361 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) 362 *samples++ = *p; 363 break; 364 } 365 case 3: { 366 // shift samples for 24-bit sample format 367 int32_t *samples = (int32_t *)frame->data[0]; 368 for (i = 0; i < framelen * s->channels; i++) 369 *samples++ <<= 8; 370 // reset decode buffer 371 s->decode_buffer = NULL; 372 break; 373 } 374 } 375 376 *got_frame_ptr = 1; 377 378 return buf_size; 379error: 380 // reset decode buffer 381 if (s->bps == 3) 382 s->decode_buffer = NULL; 383 return ret; 384} 385 386static int init_thread_copy(AVCodecContext *avctx) 387{ 388 TTAContext *s = avctx->priv_data; 389 s->avctx = avctx; 390 return allocate_buffers(avctx); 391} 392 393static av_cold int tta_decode_close(AVCodecContext *avctx) { 394 TTAContext *s = avctx->priv_data; 395 396 if (s->bps < 3) 397 av_free(s->decode_buffer); 398 s->decode_buffer = NULL; 399 av_freep(&s->ch_ctx); 400 401 return 0; 402} 403 404#define OFFSET(x) offsetof(TTAContext, x) 405#define DEC (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM) 406static const AVOption options[] = { 407 { "password", "Set decoding password", OFFSET(pass), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, DEC }, 408 { NULL }, 409}; 410 411static const AVClass tta_decoder_class = { 412 .class_name = "TTA Decoder", 413 .item_name = av_default_item_name, 414 .option = options, 415 .version = LIBAVUTIL_VERSION_INT, 416}; 417 418AVCodec ff_tta_decoder = { 419 .name = "tta", 420 .long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"), 421 .type = AVMEDIA_TYPE_AUDIO, 422 .id = AV_CODEC_ID_TTA, 423 .priv_data_size = sizeof(TTAContext), 424 .init = tta_decode_init, 425 .close = tta_decode_close, 426 .decode = tta_decode_frame, 427 .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy), 428 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS, 429 .priv_class = &tta_decoder_class, 430}; 431