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