00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00030 #define BITSTREAM_READER_LE
00031
00032 #include <limits.h>
00033 #include "avcodec.h"
00034 #include "get_bits.h"
00035 #include "internal.h"
00036 #include "libavutil/crc.h"
00037
00038 #define FORMAT_SIMPLE 1
00039 #define FORMAT_ENCRYPTED 2
00040
00041 #define MAX_ORDER 16
00042 typedef struct TTAFilter {
00043 int32_t shift, round, error;
00044 int32_t qm[MAX_ORDER];
00045 int32_t dx[MAX_ORDER];
00046 int32_t dl[MAX_ORDER];
00047 } TTAFilter;
00048
00049 typedef struct TTARice {
00050 uint32_t k0, k1, sum0, sum1;
00051 } TTARice;
00052
00053 typedef struct TTAChannel {
00054 int32_t predictor;
00055 TTAFilter filter;
00056 TTARice rice;
00057 } TTAChannel;
00058
00059 typedef struct TTAContext {
00060 AVCodecContext *avctx;
00061 AVFrame frame;
00062 GetBitContext gb;
00063 const AVCRC *crc_table;
00064
00065 int format, channels, bps;
00066 unsigned data_length;
00067 int frame_length, last_frame_length, total_frames;
00068
00069 int32_t *decode_buffer;
00070
00071 TTAChannel *ch_ctx;
00072 } TTAContext;
00073
00074 static const uint32_t shift_1[] = {
00075 0x00000001, 0x00000002, 0x00000004, 0x00000008,
00076 0x00000010, 0x00000020, 0x00000040, 0x00000080,
00077 0x00000100, 0x00000200, 0x00000400, 0x00000800,
00078 0x00001000, 0x00002000, 0x00004000, 0x00008000,
00079 0x00010000, 0x00020000, 0x00040000, 0x00080000,
00080 0x00100000, 0x00200000, 0x00400000, 0x00800000,
00081 0x01000000, 0x02000000, 0x04000000, 0x08000000,
00082 0x10000000, 0x20000000, 0x40000000, 0x80000000,
00083 0x80000000, 0x80000000, 0x80000000, 0x80000000,
00084 0x80000000, 0x80000000, 0x80000000, 0x80000000
00085 };
00086
00087 static const uint32_t * const shift_16 = shift_1 + 4;
00088
00089 static const int32_t ttafilter_configs[4] = {
00090 10,
00091 9,
00092 10,
00093 12
00094 };
00095
00096 static void ttafilter_init(TTAFilter *c, int32_t shift) {
00097 memset(c, 0, sizeof(TTAFilter));
00098 c->shift = shift;
00099 c->round = shift_1[shift-1];
00100
00101 }
00102
00103 static inline void ttafilter_process(TTAFilter *c, int32_t *in)
00104 {
00105 register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
00106
00107 if (c->error < 0) {
00108 qm[0] -= dx[0]; qm[1] -= dx[1]; qm[2] -= dx[2]; qm[3] -= dx[3];
00109 qm[4] -= dx[4]; qm[5] -= dx[5]; qm[6] -= dx[6]; qm[7] -= dx[7];
00110 } else if (c->error > 0) {
00111 qm[0] += dx[0]; qm[1] += dx[1]; qm[2] += dx[2]; qm[3] += dx[3];
00112 qm[4] += dx[4]; qm[5] += dx[5]; qm[6] += dx[6]; qm[7] += dx[7];
00113 }
00114
00115 sum += dl[0] * qm[0] + dl[1] * qm[1] + dl[2] * qm[2] + dl[3] * qm[3] +
00116 dl[4] * qm[4] + dl[5] * qm[5] + dl[6] * qm[6] + dl[7] * qm[7];
00117
00118 dx[0] = dx[1]; dx[1] = dx[2]; dx[2] = dx[3]; dx[3] = dx[4];
00119 dl[0] = dl[1]; dl[1] = dl[2]; dl[2] = dl[3]; dl[3] = dl[4];
00120
00121 dx[4] = ((dl[4] >> 30) | 1);
00122 dx[5] = ((dl[5] >> 30) | 2) & ~1;
00123 dx[6] = ((dl[6] >> 30) | 2) & ~1;
00124 dx[7] = ((dl[7] >> 30) | 4) & ~3;
00125
00126 c->error = *in;
00127 *in += (sum >> c->shift);
00128
00129 dl[4] = -dl[5]; dl[5] = -dl[6];
00130 dl[6] = *in - dl[7]; dl[7] = *in;
00131 dl[5] += dl[6]; dl[4] += dl[5];
00132 }
00133
00134 static void rice_init(TTARice *c, uint32_t k0, uint32_t k1)
00135 {
00136 c->k0 = k0;
00137 c->k1 = k1;
00138 c->sum0 = shift_16[k0];
00139 c->sum1 = shift_16[k1];
00140 }
00141
00142 static int tta_get_unary(GetBitContext *gb)
00143 {
00144 int ret = 0;
00145
00146
00147 while (get_bits_left(gb) > 0 && get_bits1(gb))
00148 ret++;
00149 return ret;
00150 }
00151
00152 static const int64_t tta_channel_layouts[7] = {
00153 AV_CH_LAYOUT_STEREO,
00154 AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY,
00155 AV_CH_LAYOUT_QUAD,
00156 0,
00157 AV_CH_LAYOUT_5POINT1_BACK,
00158 AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER,
00159 AV_CH_LAYOUT_7POINT1_WIDE
00160 };
00161
00162 static int tta_check_crc(TTAContext *s, const uint8_t *buf, int buf_size)
00163 {
00164 uint32_t crc, CRC;
00165
00166 CRC = AV_RL32(buf + buf_size);
00167 crc = av_crc(s->crc_table, 0xFFFFFFFFU, buf, buf_size);
00168 if (CRC != (crc ^ 0xFFFFFFFFU)) {
00169 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
00170 return AVERROR_INVALIDDATA;
00171 }
00172
00173 return 0;
00174 }
00175
00176 static av_cold int tta_decode_init(AVCodecContext * avctx)
00177 {
00178 TTAContext *s = avctx->priv_data;
00179
00180 s->avctx = avctx;
00181
00182
00183 if (avctx->extradata_size < 30)
00184 return AVERROR_INVALIDDATA;
00185
00186 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
00187 if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
00188 {
00189 if (avctx->err_recognition & AV_EF_CRCCHECK) {
00190 s->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);
00191 tta_check_crc(s, avctx->extradata, 18);
00192 }
00193
00194
00195 skip_bits_long(&s->gb, 32);
00196
00197 s->format = get_bits(&s->gb, 16);
00198 if (s->format > 2) {
00199 av_log(s->avctx, AV_LOG_ERROR, "Invalid format\n");
00200 return AVERROR_INVALIDDATA;
00201 }
00202 if (s->format == FORMAT_ENCRYPTED) {
00203 av_log_missing_feature(s->avctx, "Encrypted TTA", 0);
00204 return AVERROR_PATCHWELCOME;
00205 }
00206 avctx->channels = s->channels = get_bits(&s->gb, 16);
00207 if (s->channels > 1 && s->channels < 9)
00208 avctx->channel_layout = tta_channel_layouts[s->channels-2];
00209 avctx->bits_per_raw_sample = get_bits(&s->gb, 16);
00210 s->bps = (avctx->bits_per_raw_sample + 7) / 8;
00211 avctx->sample_rate = get_bits_long(&s->gb, 32);
00212 s->data_length = get_bits_long(&s->gb, 32);
00213 skip_bits_long(&s->gb, 32);
00214
00215 if (s->channels == 0) {
00216 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
00217 return AVERROR_INVALIDDATA;
00218 } else if (avctx->sample_rate == 0) {
00219 av_log(s->avctx, AV_LOG_ERROR, "Invalid samplerate\n");
00220 return AVERROR_INVALIDDATA;
00221 }
00222
00223 switch(s->bps) {
00224 case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break;
00225 case 2:
00226 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00227 break;
00228 case 3:
00229 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
00230 break;
00231
00232 default:
00233 av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n");
00234 return AVERROR_INVALIDDATA;
00235 }
00236
00237
00238 if (avctx->sample_rate > 0x7FFFFFu) {
00239 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
00240 return AVERROR(EINVAL);
00241 }
00242 s->frame_length = 256 * avctx->sample_rate / 245;
00243
00244 s->last_frame_length = s->data_length % s->frame_length;
00245 s->total_frames = s->data_length / s->frame_length +
00246 (s->last_frame_length ? 1 : 0);
00247
00248 av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
00249 s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
00250 avctx->block_align);
00251 av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
00252 s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
00253
00254 if (s->total_frames < 0)
00255 return AVERROR_INVALIDDATA;
00256
00257
00258 if (avctx->extradata_size <= 26 || s->total_frames > INT_MAX / 4 ||
00259 avctx->extradata_size - 26 < s->total_frames * 4)
00260 av_log(avctx, AV_LOG_WARNING, "Seek table missing or too small\n");
00261 else if (avctx->err_recognition & AV_EF_CRCCHECK) {
00262 if (avctx->extradata_size < 26 + s->total_frames * 4 || tta_check_crc(s, avctx->extradata + 22, s->total_frames * 4))
00263 return AVERROR_INVALIDDATA;
00264 }
00265 skip_bits_long(&s->gb, 32 * s->total_frames);
00266 skip_bits_long(&s->gb, 32);
00267
00268 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
00269 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
00270 return AVERROR_INVALIDDATA;
00271 }
00272
00273 if (s->bps < 3) {
00274 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
00275 if (!s->decode_buffer)
00276 return AVERROR(ENOMEM);
00277 } else
00278 s->decode_buffer = NULL;
00279 s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
00280 if (!s->ch_ctx) {
00281 av_freep(&s->decode_buffer);
00282 return AVERROR(ENOMEM);
00283 }
00284 } else {
00285 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
00286 return AVERROR_INVALIDDATA;
00287 }
00288
00289 avcodec_get_frame_defaults(&s->frame);
00290 avctx->coded_frame = &s->frame;
00291
00292 return 0;
00293 }
00294
00295 static int tta_decode_frame(AVCodecContext *avctx, void *data,
00296 int *got_frame_ptr, AVPacket *avpkt)
00297 {
00298 const uint8_t *buf = avpkt->data;
00299 int buf_size = avpkt->size;
00300 TTAContext *s = avctx->priv_data;
00301 int i, ret;
00302 int cur_chan = 0, framelen = s->frame_length;
00303 int32_t *p;
00304
00305 if (avctx->err_recognition & AV_EF_CRCCHECK) {
00306 if (buf_size < 4 || tta_check_crc(s, buf, buf_size - 4))
00307 return AVERROR_INVALIDDATA;
00308 }
00309
00310 init_get_bits(&s->gb, buf, buf_size*8);
00311
00312
00313 s->total_frames--;
00314 if (!s->total_frames && s->last_frame_length)
00315 framelen = s->last_frame_length;
00316
00317
00318 s->frame.nb_samples = framelen;
00319 if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
00320 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00321 return ret;
00322 }
00323
00324
00325 if (s->bps == 3)
00326 s->decode_buffer = (int32_t *)s->frame.data[0];
00327
00328
00329 for (i = 0; i < s->channels; i++) {
00330 s->ch_ctx[i].predictor = 0;
00331 ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1]);
00332 rice_init(&s->ch_ctx[i].rice, 10, 10);
00333 }
00334
00335 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
00336 int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
00337 TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
00338 TTARice *rice = &s->ch_ctx[cur_chan].rice;
00339 uint32_t unary, depth, k;
00340 int32_t value;
00341
00342 unary = tta_get_unary(&s->gb);
00343
00344 if (unary == 0) {
00345 depth = 0;
00346 k = rice->k0;
00347 } else {
00348 depth = 1;
00349 k = rice->k1;
00350 unary--;
00351 }
00352
00353 if (get_bits_left(&s->gb) < k) {
00354 ret = AVERROR_INVALIDDATA;
00355 goto error;
00356 }
00357
00358 if (k) {
00359 if (k > MIN_CACHE_BITS) {
00360 ret = AVERROR_INVALIDDATA;
00361 goto error;
00362 }
00363 value = (unary << k) + get_bits(&s->gb, k);
00364 } else
00365 value = unary;
00366
00367
00368 switch (depth) {
00369 case 1:
00370 rice->sum1 += value - (rice->sum1 >> 4);
00371 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
00372 rice->k1--;
00373 else if(rice->sum1 > shift_16[rice->k1 + 1])
00374 rice->k1++;
00375 value += shift_1[rice->k0];
00376 default:
00377 rice->sum0 += value - (rice->sum0 >> 4);
00378 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
00379 rice->k0--;
00380 else if(rice->sum0 > shift_16[rice->k0 + 1])
00381 rice->k0++;
00382 }
00383
00384
00385 *p = 1 + ((value >> 1) ^ ((value & 1) - 1));
00386
00387
00388 ttafilter_process(filter, p);
00389
00390
00391 #define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
00392 switch (s->bps) {
00393 case 1: *p += PRED(*predictor, 4); break;
00394 case 2:
00395 case 3: *p += PRED(*predictor, 5); break;
00396 case 4: *p += *predictor; break;
00397 }
00398 *predictor = *p;
00399
00400
00401 if (cur_chan < (s->channels-1))
00402 cur_chan++;
00403 else {
00404
00405 if (s->channels > 1) {
00406 int32_t *r = p - 1;
00407 for (*p += *r / 2; r > p - s->channels; r--)
00408 *r = *(r + 1) - *r;
00409 }
00410 cur_chan = 0;
00411 }
00412 }
00413
00414 if (get_bits_left(&s->gb) < 32) {
00415 ret = AVERROR_INVALIDDATA;
00416 goto error;
00417 }
00418 skip_bits_long(&s->gb, 32);
00419
00420
00421 switch (s->bps) {
00422 case 1: {
00423 uint8_t *samples = (uint8_t *)s->frame.data[0];
00424 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
00425 *samples++ = *p + 0x80;
00426 break;
00427 }
00428 case 2: {
00429 int16_t *samples = (int16_t *)s->frame.data[0];
00430 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
00431 *samples++ = *p;
00432 break;
00433 }
00434 case 3: {
00435
00436 int32_t *samples = (int32_t *)s->frame.data[0];
00437 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
00438 *samples++ <<= 8;
00439
00440 s->decode_buffer = NULL;
00441 break;
00442 }
00443 }
00444
00445 *got_frame_ptr = 1;
00446 *(AVFrame *)data = s->frame;
00447
00448 return buf_size;
00449 error:
00450
00451 if (s->bps == 3)
00452 s->decode_buffer = NULL;
00453 return ret;
00454 }
00455
00456 static av_cold int tta_decode_close(AVCodecContext *avctx) {
00457 TTAContext *s = avctx->priv_data;
00458
00459 if (s->bps < 3)
00460 av_free(s->decode_buffer);
00461 s->decode_buffer = NULL;
00462 av_freep(&s->ch_ctx);
00463
00464 return 0;
00465 }
00466
00467 AVCodec ff_tta_decoder = {
00468 .name = "tta",
00469 .type = AVMEDIA_TYPE_AUDIO,
00470 .id = AV_CODEC_ID_TTA,
00471 .priv_data_size = sizeof(TTAContext),
00472 .init = tta_decode_init,
00473 .close = tta_decode_close,
00474 .decode = tta_decode_frame,
00475 .capabilities = CODEC_CAP_DR1,
00476 .long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
00477 };