← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/tta.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-01-12 22:23:28 UTC
  • mfrom: (0.4.7 sid)
  • mto: This revision was merged to the branch mainline in revision 76.
  • Revision ID: package-import@ubuntu.com-20120112222328-8jqdyodym3p84ygu
Tags: 2:1.0~rc4.dfsg1+svn34540-1
* New upstream snapshot
* upload to unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/tta.c
22
22
/**
23
23
 * @file
24
24
 * TTA (The Lossless True Audio) decoder
25
 
 * (www.true-audio.com or tta.corecodec.org)
 
25
 * @see http://www.true-audio.com/
 
26
 * @see http://tta.corecodec.org/
26
27
 * @author Alex Beregszaszi
27
 
 *
28
28
 */
29
29
 
30
 
#define ALT_BITSTREAM_READER_LE
 
30
#define BITSTREAM_READER_LE
31
31
//#define DEBUG
32
32
#include <limits.h>
33
33
#include "avcodec.h"
34
34
#include "get_bits.h"
35
35
 
36
 
#define FORMAT_INT 1
37
 
#define FORMAT_FLOAT 3
 
36
#define FORMAT_SIMPLE    1
 
37
#define FORMAT_ENCRYPTED 2
38
38
 
39
39
#define MAX_ORDER 16
40
40
typedef struct TTAFilter {
56
56
 
57
57
typedef struct TTAContext {
58
58
    AVCodecContext *avctx;
 
59
    AVFrame frame;
59
60
    GetBitContext gb;
60
61
 
61
 
    int flags, channels, bps, is_float, data_length;
 
62
    int format, channels, bps, data_length;
62
63
    int frame_length, last_frame_length, total_frames;
63
64
 
64
65
    int32_t *decode_buffer;
66
67
    TTAChannel *ch_ctx;
67
68
} TTAContext;
68
69
 
69
 
#if 0
70
 
static inline int shift_1(int i)
71
 
{
72
 
    if (i < 32)
73
 
        return 1 << i;
74
 
    else
75
 
        return 0x80000000; // 16 << 31
76
 
}
77
 
 
78
 
static inline int shift_16(int i)
79
 
{
80
 
    if (i < 28)
81
 
        return 16 << i;
82
 
    else
83
 
        return 0x80000000; // 16 << 27
84
 
}
85
 
#else
86
70
static const uint32_t shift_1[] = {
87
71
    0x00000001, 0x00000002, 0x00000004, 0x00000008,
88
72
    0x00000010, 0x00000020, 0x00000040, 0x00000080,
97
81
};
98
82
 
99
83
static const uint32_t * const shift_16 = shift_1 + 4;
100
 
#endif
101
84
 
102
85
static const int32_t ttafilter_configs[4][2] = {
103
86
    {10, 1},
200
183
    int ret = 0;
201
184
 
202
185
    // count ones
203
 
    while(get_bits1(gb))
 
186
    while (get_bits_left(gb) > 0 && get_bits1(gb))
204
187
        ret++;
205
188
    return ret;
206
189
}
216
199
    if (avctx->extradata_size < 30)
217
200
        return -1;
218
201
 
219
 
    init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);
 
202
    init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
220
203
    if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
221
204
    {
222
205
        /* signature */
223
206
        skip_bits(&s->gb, 32);
224
 
//        if (get_bits_long(&s->gb, 32) != av_bswap32(AV_RL32("TTA1"))) {
225
 
//            av_log(s->avctx, AV_LOG_ERROR, "Missing magic\n");
226
 
//            return -1;
227
 
//        }
228
207
 
229
 
        s->flags = get_bits(&s->gb, 16);
230
 
        if (s->flags != 1 && s->flags != 3)
231
 
        {
232
 
            av_log(s->avctx, AV_LOG_ERROR, "Invalid flags\n");
 
208
        s->format = get_bits(&s->gb, 16);
 
209
        if (s->format > 2) {
 
210
            av_log(s->avctx, AV_LOG_ERROR, "Invalid format\n");
233
211
            return -1;
234
212
        }
235
 
        s->is_float = (s->flags == FORMAT_FLOAT);
 
213
        if (s->format == FORMAT_ENCRYPTED) {
 
214
            av_log_missing_feature(s->avctx, "Encrypted TTA", 0);
 
215
            return AVERROR(EINVAL);
 
216
        }
236
217
        avctx->channels = s->channels = get_bits(&s->gb, 16);
237
218
        avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
238
219
        s->bps = (avctx->bits_per_coded_sample + 7) / 8;
239
220
        avctx->sample_rate = get_bits_long(&s->gb, 32);
240
 
        if(avctx->sample_rate > 1000000){ //prevent FRAME_TIME * avctx->sample_rate from overflowing and sanity check
241
 
            av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
242
 
            return -1;
243
 
        }
244
221
        s->data_length = get_bits_long(&s->gb, 32);
245
222
        skip_bits(&s->gb, 32); // CRC32 of header
246
223
 
247
 
        if (s->is_float)
248
 
        {
249
 
            avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
250
 
            av_log_ask_for_sample(s->avctx, "Unsupported sample format.\n");
251
 
            return -1;
252
 
        }
253
 
        else switch(s->bps) {
254
 
//            case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break;
255
 
            case 2: avctx->sample_fmt = AV_SAMPLE_FMT_S16; break;
256
 
//            case 3: avctx->sample_fmt = AV_SAMPLE_FMT_S24; break;
257
 
            case 4: avctx->sample_fmt = AV_SAMPLE_FMT_S32; break;
258
 
            default:
259
 
                av_log_ask_for_sample(s->avctx,
260
 
                                      "Invalid/unsupported sample format.\n");
261
 
                return -1;
262
 
        }
263
 
 
264
 
        // FIXME: horribly broken, but directly from reference source
265
 
#define FRAME_TIME 1.04489795918367346939
266
 
        s->frame_length = (int)(FRAME_TIME * avctx->sample_rate);
 
224
        if (s->channels == 0) {
 
225
            av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
 
226
            return AVERROR_INVALIDDATA;
 
227
        }
 
228
 
 
229
        switch(s->bps) {
 
230
        case 2:
 
231
            avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 
232
            avctx->bits_per_raw_sample = 16;
 
233
            break;
 
234
        case 3:
 
235
            avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 
236
            avctx->bits_per_raw_sample = 24;
 
237
            break;
 
238
        default:
 
239
            av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n");
 
240
            return AVERROR_INVALIDDATA;
 
241
        }
 
242
 
 
243
        // prevent overflow
 
244
        if (avctx->sample_rate > 0x7FFFFF) {
 
245
            av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
 
246
            return AVERROR(EINVAL);
 
247
        }
 
248
        s->frame_length = 256 * avctx->sample_rate / 245;
267
249
 
268
250
        s->last_frame_length = s->data_length % s->frame_length;
269
251
        s->total_frames = s->data_length / s->frame_length +
270
252
                        (s->last_frame_length ? 1 : 0);
271
253
 
272
 
        av_log(s->avctx, AV_LOG_DEBUG, "flags: %x chans: %d bps: %d rate: %d block: %d\n",
273
 
            s->flags, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
 
254
        av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
 
255
            s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
274
256
            avctx->block_align);
275
257
        av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
276
258
            s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
285
267
            return -1;
286
268
        }
287
269
 
288
 
        s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
 
270
        if (s->bps == 2) {
 
271
            s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
 
272
            if (!s->decode_buffer)
 
273
                return AVERROR(ENOMEM);
 
274
        }
289
275
        s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
290
 
        if (!s->ch_ctx)
 
276
        if (!s->ch_ctx) {
 
277
            av_freep(&s->decode_buffer);
291
278
            return AVERROR(ENOMEM);
 
279
        }
292
280
    } else {
293
281
        av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
294
282
        return -1;
295
283
    }
296
284
 
 
285
    avcodec_get_frame_defaults(&s->frame);
 
286
    avctx->coded_frame = &s->frame;
 
287
 
297
288
    return 0;
298
289
}
299
290
 
300
 
static int tta_decode_frame(AVCodecContext *avctx,
301
 
        void *data, int *data_size,
302
 
        AVPacket *avpkt)
 
291
static int tta_decode_frame(AVCodecContext *avctx, void *data,
 
292
                            int *got_frame_ptr, AVPacket *avpkt)
303
293
{
304
294
    const uint8_t *buf = avpkt->data;
305
295
    int buf_size = avpkt->size;
306
296
    TTAContext *s = avctx->priv_data;
307
 
    int i;
 
297
    int i, ret;
 
298
    int cur_chan = 0, framelen = s->frame_length;
 
299
    int32_t *p;
308
300
 
309
301
    init_get_bits(&s->gb, buf, buf_size*8);
310
 
    {
311
 
        int cur_chan = 0, framelen = s->frame_length;
312
 
        int32_t *p;
313
 
 
314
 
        if (*data_size < (framelen * s->channels * 2)) {
315
 
            av_log(avctx, AV_LOG_ERROR, "Output buffer size is too small.\n");
 
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
    /* get output buffer */
 
309
    s->frame.nb_samples = framelen;
 
310
    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
 
311
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 
312
        return ret;
 
313
    }
 
314
 
 
315
    // decode directly to output buffer for 24-bit sample format
 
316
    if (s->bps == 3)
 
317
        s->decode_buffer = s->frame.data[0];
 
318
 
 
319
    // init per channel states
 
320
    for (i = 0; i < s->channels; i++) {
 
321
        s->ch_ctx[i].predictor = 0;
 
322
        ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
 
323
        rice_init(&s->ch_ctx[i].rice, 10, 10);
 
324
    }
 
325
 
 
326
    for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
 
327
        int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
 
328
        TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
 
329
        TTARice *rice = &s->ch_ctx[cur_chan].rice;
 
330
        uint32_t unary, depth, k;
 
331
        int32_t value;
 
332
 
 
333
        unary = tta_get_unary(&s->gb);
 
334
 
 
335
        if (unary == 0) {
 
336
            depth = 0;
 
337
            k = rice->k0;
 
338
        } else {
 
339
            depth = 1;
 
340
            k = rice->k1;
 
341
            unary--;
 
342
        }
 
343
 
 
344
        if (get_bits_left(&s->gb) < k)
316
345
            return -1;
317
 
        }
318
 
        // FIXME: seeking
319
 
        s->total_frames--;
320
 
        if (!s->total_frames && s->last_frame_length)
321
 
            framelen = s->last_frame_length;
322
 
 
323
 
        // init per channel states
324
 
        for (i = 0; i < s->channels; i++) {
325
 
            s->ch_ctx[i].predictor = 0;
326
 
            ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
327
 
            rice_init(&s->ch_ctx[i].rice, 10, 10);
328
 
        }
329
 
 
330
 
        for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
331
 
            int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
332
 
            TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
333
 
            TTARice *rice = &s->ch_ctx[cur_chan].rice;
334
 
            uint32_t unary, depth, k;
335
 
            int32_t value;
336
 
 
337
 
            unary = tta_get_unary(&s->gb);
338
 
 
339
 
            if (unary == 0) {
340
 
                depth = 0;
341
 
                k = rice->k0;
342
 
            } else {
343
 
                depth = 1;
344
 
                k = rice->k1;
345
 
                unary--;
346
 
            }
347
 
 
348
 
            if (get_bits_left(&s->gb) < k)
 
346
 
 
347
        if (k) {
 
348
            if (k > MIN_CACHE_BITS)
349
349
                return -1;
350
 
 
351
 
            if (k) {
352
 
                if (k > MIN_CACHE_BITS)
353
 
                    return -1;
354
 
                value = (unary << k) + get_bits(&s->gb, k);
355
 
            } else
356
 
                value = unary;
357
 
 
358
 
            // FIXME: copy paste from original
359
 
            switch (depth) {
360
 
            case 1:
361
 
                rice->sum1 += value - (rice->sum1 >> 4);
362
 
                if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
363
 
                    rice->k1--;
364
 
                else if(rice->sum1 > shift_16[rice->k1 + 1])
365
 
                    rice->k1++;
366
 
                value += shift_1[rice->k0];
367
 
            default:
368
 
                rice->sum0 += value - (rice->sum0 >> 4);
369
 
                if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
370
 
                    rice->k0--;
371
 
                else if(rice->sum0 > shift_16[rice->k0 + 1])
372
 
                    rice->k0++;
373
 
            }
374
 
 
375
 
            // extract coded value
 
350
            value = (unary << k) + get_bits(&s->gb, k);
 
351
        } else
 
352
            value = unary;
 
353
 
 
354
        // FIXME: copy paste from original
 
355
        switch (depth) {
 
356
        case 1:
 
357
            rice->sum1 += value - (rice->sum1 >> 4);
 
358
            if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
 
359
                rice->k1--;
 
360
            else if(rice->sum1 > shift_16[rice->k1 + 1])
 
361
                rice->k1++;
 
362
            value += shift_1[rice->k0];
 
363
        default:
 
364
            rice->sum0 += value - (rice->sum0 >> 4);
 
365
            if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
 
366
                rice->k0--;
 
367
            else if(rice->sum0 > shift_16[rice->k0 + 1])
 
368
                rice->k0++;
 
369
        }
 
370
 
 
371
        // extract coded value
376
372
#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
377
 
            *p = UNFOLD(value);
378
 
 
379
 
            // run hybrid filter
380
 
            ttafilter_process(filter, p, 0);
381
 
 
382
 
            // fixed order prediction
 
373
        *p = UNFOLD(value);
 
374
 
 
375
        // run hybrid filter
 
376
        ttafilter_process(filter, p, 0);
 
377
 
 
378
        // fixed order prediction
383
379
#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
384
 
            switch (s->bps) {
385
 
                case 1: *p += PRED(*predictor, 4); break;
386
 
                case 2:
387
 
                case 3: *p += PRED(*predictor, 5); break;
388
 
                case 4: *p += *predictor; break;
389
 
            }
390
 
            *predictor = *p;
391
 
 
392
 
#if 0
393
 
            // extract 32bit float from last two int samples
394
 
            if (s->is_float && ((p - data) & 1)) {
395
 
                uint32_t neg = *p & 0x80000000;
396
 
                uint32_t hi = *(p - 1);
397
 
                uint32_t lo = abs(*p) - 1;
398
 
 
399
 
                hi += (hi || lo) ? 0x3f80 : 0;
400
 
                // SWAP16: swap all the 16 bits
401
 
                *(p - 1) = (hi << 16) | SWAP16(lo) | neg;
402
 
            }
403
 
#endif
404
 
 
405
 
            /*if ((get_bits_count(&s->gb)+7)/8 > buf_size)
406
 
            {
407
 
                av_log(NULL, AV_LOG_INFO, "overread!!\n");
408
 
                break;
409
 
            }*/
410
 
 
411
 
            // flip channels
412
 
            if (cur_chan < (s->channels-1))
413
 
                cur_chan++;
414
 
            else {
415
 
                // decorrelate in case of stereo integer
416
 
                if (!s->is_float && (s->channels > 1)) {
417
 
                    int32_t *r = p - 1;
418
 
                    for (*p += *r / 2; r > p - s->channels; r--)
419
 
                        *r = *(r + 1) - *r;
420
 
                }
421
 
                cur_chan = 0;
422
 
            }
423
 
        }
424
 
 
425
 
        if (get_bits_left(&s->gb) < 32)
426
 
            return -1;
427
 
        skip_bits(&s->gb, 32); // frame crc
428
 
 
429
 
        // convert to output buffer
430
 
        switch(s->bps) {
431
 
            case 2: {
432
 
                uint16_t *samples = data;
433
 
                for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
434
 
//                    *samples++ = (unsigned char)*p;
435
 
//                    *samples++ = (unsigned char)(*p >> 8);
436
 
                    *samples++ = *p;
437
 
                }
438
 
                *data_size = (uint8_t *)samples - (uint8_t *)data;
439
 
                break;
440
 
            }
441
 
            default:
442
 
                av_log(s->avctx, AV_LOG_ERROR, "Error, only 16bit samples supported!\n");
443
 
        }
444
 
    }
445
 
 
446
 
//    return get_bits_count(&s->gb)+7)/8;
 
380
        switch (s->bps) {
 
381
            case 1: *p += PRED(*predictor, 4); break;
 
382
            case 2:
 
383
            case 3: *p += PRED(*predictor, 5); break;
 
384
            case 4: *p += *predictor; break;
 
385
        }
 
386
        *predictor = *p;
 
387
 
 
388
        // flip channels
 
389
        if (cur_chan < (s->channels-1))
 
390
            cur_chan++;
 
391
        else {
 
392
            // decorrelate in case of stereo integer
 
393
            if (s->channels > 1) {
 
394
                int32_t *r = p - 1;
 
395
                for (*p += *r / 2; r > p - s->channels; r--)
 
396
                    *r = *(r + 1) - *r;
 
397
            }
 
398
            cur_chan = 0;
 
399
        }
 
400
    }
 
401
 
 
402
    if (get_bits_left(&s->gb) < 32)
 
403
        return -1;
 
404
    skip_bits(&s->gb, 32); // frame crc
 
405
 
 
406
    // convert to output buffer
 
407
    if (s->bps == 2) {
 
408
        int16_t *samples = (int16_t *)s->frame.data[0];
 
409
        for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
 
410
            *samples++ = *p;
 
411
    } else {
 
412
        // shift samples for 24-bit sample format
 
413
        int32_t *samples = (int32_t *)s->frame.data[0];
 
414
        for (i = 0; i < framelen * s->channels; i++)
 
415
            *samples++ <<= 8;
 
416
        // reset decode buffer
 
417
        s->decode_buffer = NULL;
 
418
    }
 
419
 
 
420
    *got_frame_ptr   = 1;
 
421
    *(AVFrame *)data = s->frame;
 
422
 
447
423
    return buf_size;
448
424
}
449
425
 
457
433
}
458
434
 
459
435
AVCodec ff_tta_decoder = {
460
 
    "tta",
461
 
    AVMEDIA_TYPE_AUDIO,
462
 
    CODEC_ID_TTA,
463
 
    sizeof(TTAContext),
464
 
    tta_decode_init,
465
 
    NULL,
466
 
    tta_decode_close,
467
 
    tta_decode_frame,
 
436
    .name           = "tta",
 
437
    .type           = AVMEDIA_TYPE_AUDIO,
 
438
    .id             = CODEC_ID_TTA,
 
439
    .priv_data_size = sizeof(TTAContext),
 
440
    .init           = tta_decode_init,
 
441
    .close          = tta_decode_close,
 
442
    .decode         = tta_decode_frame,
 
443
    .capabilities   = CODEC_CAP_DR1,
468
444
    .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
469
445
};