← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gst-libav1.0/trusty-proposed

« back to all changes in this revision

Viewing changes to gst-libs/ext/libav/libavcodec/tta.c

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2013-09-24 17:07:00 UTC
  • mfrom: (1.1.17) (7.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20130924170700-4dg62s3pwl0pdakz
Tags: 1.2.0-1
* New upstream stable release:
  + debian/control:
    - Build depend on GStreamer and gst-plugins-base >= 1.2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/libav/libavcodec/tta.c
32
32
#include <limits.h>
33
33
#include "avcodec.h"
34
34
#include "get_bits.h"
 
35
#include "internal.h"
35
36
#include "libavutil/crc.h"
36
37
 
37
38
#define FORMAT_SIMPLE    1
39
40
 
40
41
#define MAX_ORDER 16
41
42
typedef struct TTAFilter {
42
 
    int32_t shift, round, error, mode;
 
43
    int32_t shift, round, error;
43
44
    int32_t qm[MAX_ORDER];
44
45
    int32_t dx[MAX_ORDER];
45
46
    int32_t dl[MAX_ORDER];
63
64
 
64
65
    int format, channels, bps;
65
66
    unsigned data_length;
66
 
    int frame_length, last_frame_length, total_frames;
 
67
    int frame_length, last_frame_length;
67
68
 
68
69
    int32_t *decode_buffer;
69
70
 
85
86
 
86
87
static const uint32_t * const shift_16 = shift_1 + 4;
87
88
 
88
 
static const int32_t ttafilter_configs[4][2] = {
89
 
    {10, 1},
90
 
    {9, 1},
91
 
    {10, 1},
92
 
    {12, 0}
 
89
static const int32_t ttafilter_configs[4] = {
 
90
    10,
 
91
    9,
 
92
    10,
 
93
    12
93
94
};
94
95
 
95
 
static void ttafilter_init(TTAFilter *c, int32_t shift, int32_t mode) {
 
96
static void ttafilter_init(TTAFilter *c, int32_t shift) {
96
97
    memset(c, 0, sizeof(TTAFilter));
97
98
    c->shift = shift;
98
99
   c->round = shift_1[shift-1];
99
100
//    c->round = 1 << (shift - 1);
100
 
    c->mode = mode;
101
101
}
102
102
 
103
103
// FIXME: copy paste from original
112
112
    *a = *b;
113
113
}
114
114
 
115
 
// FIXME: copy paste from original
116
 
// mode=1 encoder, mode=0 decoder
117
 
static inline void ttafilter_process(TTAFilter *c, int32_t *in, int32_t mode) {
 
115
static inline void ttafilter_process(TTAFilter *c, int32_t *in)
 
116
{
118
117
    register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
119
118
 
120
119
    if (!c->error) {
152
151
    *(dx-2) = ((*(dl-3) >> 30) | 1) << 1;
153
152
    *(dx-3) = ((*(dl-4) >> 30) | 1);
154
153
 
155
 
    // compress
156
 
    if (mode) {
157
 
        *dl = *in;
158
 
        *in -= (sum >> c->shift);
159
 
        c->error = *in;
160
 
    } else {
161
 
        c->error = *in;
162
 
        *in += (sum >> c->shift);
163
 
        *dl = *in;
164
 
    }
 
154
    c->error = *in;
 
155
    *in += (sum >> c->shift);
 
156
    *dl = *in;
165
157
 
166
 
    if (c->mode) {
167
 
        *(dl-1) = *dl - *(dl-1);
168
 
        *(dl-2) = *(dl-1) - *(dl-2);
169
 
        *(dl-3) = *(dl-2) - *(dl-3);
170
 
    }
 
158
    *(dl-1) = *dl - *(dl-1);
 
159
    *(dl-2) = *(dl-1) - *(dl-2);
 
160
    *(dl-3) = *(dl-2) - *(dl-3);
171
161
 
172
162
    memshl(c->dl, c->dl + 1);
173
163
    memshl(c->dx, c->dx + 1);
208
198
static av_cold int tta_decode_init(AVCodecContext * avctx)
209
199
{
210
200
    TTAContext *s = avctx->priv_data;
 
201
    int total_frames;
211
202
 
212
203
    s->avctx = avctx;
213
204
 
220
211
    {
221
212
        if (avctx->err_recognition & AV_EF_CRCCHECK) {
222
213
            s->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);
223
 
            if (tta_check_crc(s, avctx->extradata, 18))
224
 
                return AVERROR_INVALIDDATA;
 
214
            tta_check_crc(s, avctx->extradata, 18);
225
215
        }
226
216
 
227
217
        /* signature */
234
224
        }
235
225
        if (s->format == FORMAT_ENCRYPTED) {
236
226
            av_log_missing_feature(s->avctx, "Encrypted TTA", 0);
237
 
            return AVERROR(EINVAL);
 
227
            return AVERROR_PATCHWELCOME;
238
228
        }
239
229
        avctx->channels = s->channels = get_bits(&s->gb, 16);
240
230
        avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
273
263
        s->frame_length = 256 * avctx->sample_rate / 245;
274
264
 
275
265
        s->last_frame_length = s->data_length % s->frame_length;
276
 
        s->total_frames = s->data_length / s->frame_length +
277
 
                        (s->last_frame_length ? 1 : 0);
 
266
        total_frames = s->data_length / s->frame_length +
 
267
                       (s->last_frame_length ? 1 : 0);
278
268
 
279
269
        av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
280
270
            s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
281
271
            avctx->block_align);
282
272
        av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
283
 
            s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
 
273
            s->data_length, s->frame_length, s->last_frame_length, total_frames);
284
274
 
285
275
        // FIXME: seek table
286
 
        if (avctx->extradata_size <= 26 || s->total_frames > INT_MAX / 4 ||
287
 
            avctx->extradata_size - 26 < s->total_frames * 4)
 
276
        if (avctx->extradata_size <= 26 || total_frames > INT_MAX / 4 ||
 
277
            avctx->extradata_size - 26 < total_frames * 4)
288
278
            av_log(avctx, AV_LOG_WARNING, "Seek table missing or too small\n");
289
279
        else if (avctx->err_recognition & AV_EF_CRCCHECK) {
290
 
            if (tta_check_crc(s, avctx->extradata + 22, s->total_frames * 4))
 
280
            if (tta_check_crc(s, avctx->extradata + 22, total_frames * 4))
291
281
                return AVERROR_INVALIDDATA;
292
282
        }
293
 
        skip_bits_long(&s->gb, 32 * s->total_frames);
 
283
        skip_bits_long(&s->gb, 32 * total_frames);
294
284
        skip_bits_long(&s->gb, 32); // CRC32 of seektable
295
285
 
296
286
        if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
336
326
 
337
327
    init_get_bits(&s->gb, buf, buf_size*8);
338
328
 
339
 
    // FIXME: seeking
340
 
    s->total_frames--;
341
 
    if (!s->total_frames && s->last_frame_length)
342
 
        framelen = s->last_frame_length;
343
 
 
344
329
    /* get output buffer */
345
330
    s->frame.nb_samples = framelen;
346
 
    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
 
331
    if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
347
332
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
348
333
        return ret;
349
334
    }
355
340
    // init per channel states
356
341
    for (i = 0; i < s->channels; i++) {
357
342
        s->ch_ctx[i].predictor = 0;
358
 
        ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
 
343
        ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1]);
359
344
        rice_init(&s->ch_ctx[i].rice, 10, 10);
360
345
    }
361
346
 
 
347
    i = 0;
362
348
    for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
363
349
        int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
364
350
        TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
377
363
            unary--;
378
364
        }
379
365
 
380
 
        if (get_bits_left(&s->gb) < k)
381
 
            return -1;
 
366
        if (get_bits_left(&s->gb) < k) {
 
367
            ret = AVERROR_INVALIDDATA;
 
368
            goto error;
 
369
        }
382
370
 
383
371
        if (k) {
384
 
            if (k > MIN_CACHE_BITS)
385
 
                return -1;
 
372
            if (k > MIN_CACHE_BITS) {
 
373
                ret = AVERROR_INVALIDDATA;
 
374
                goto error;
 
375
            }
386
376
            value = (unary << k) + get_bits(&s->gb, k);
387
377
        } else
388
378
            value = unary;
405
395
        }
406
396
 
407
397
        // extract coded value
408
 
#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
409
 
        *p = UNFOLD(value);
 
398
        *p = 1 + ((value >> 1) ^ ((value & 1) - 1));
410
399
 
411
400
        // run hybrid filter
412
 
        ttafilter_process(filter, p, 0);
 
401
        ttafilter_process(filter, p);
413
402
 
414
403
        // fixed order prediction
415
404
#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
416
405
        switch (s->bps) {
417
 
            case 1: *p += PRED(*predictor, 4); break;
418
 
            case 2:
419
 
            case 3: *p += PRED(*predictor, 5); break;
420
 
            case 4: *p += *predictor; break;
 
406
        case 1: *p += PRED(*predictor, 4); break;
 
407
        case 2:
 
408
        case 3: *p += PRED(*predictor, 5); break;
 
409
        case 4: *p +=      *predictor;     break;
421
410
        }
422
411
        *predictor = *p;
423
412
 
425
414
        if (cur_chan < (s->channels-1))
426
415
            cur_chan++;
427
416
        else {
428
 
            // decorrelate in case of stereo integer
 
417
            // decorrelate in case of multiple channels
429
418
            if (s->channels > 1) {
430
419
                int32_t *r = p - 1;
431
420
                for (*p += *r / 2; r > p - s->channels; r--)
432
421
                    *r = *(r + 1) - *r;
433
422
            }
434
423
            cur_chan = 0;
 
424
            i++;
 
425
            // check for last frame
 
426
            if (i == s->last_frame_length && get_bits_left(&s->gb) / 8 == 4) {
 
427
                s->frame.nb_samples = framelen = s->last_frame_length;
 
428
                break;
 
429
            }
435
430
        }
436
431
    }
437
432
 
438
 
    if (get_bits_left(&s->gb) < 32)
439
 
        return -1;
 
433
    align_get_bits(&s->gb);
 
434
    if (get_bits_left(&s->gb) < 32) {
 
435
        ret = AVERROR_INVALIDDATA;
 
436
        goto error;
 
437
    }
440
438
    skip_bits_long(&s->gb, 32); // frame crc
441
439
 
442
440
    // convert to output buffer
457
455
    *(AVFrame *)data = s->frame;
458
456
 
459
457
    return buf_size;
 
458
error:
 
459
    // reset decode buffer
 
460
    if (s->bps == 3)
 
461
        s->decode_buffer = NULL;
 
462
    return ret;
460
463
}
461
464
 
462
465
static av_cold int tta_decode_close(AVCodecContext *avctx) {
471
474
AVCodec ff_tta_decoder = {
472
475
    .name           = "tta",
473
476
    .type           = AVMEDIA_TYPE_AUDIO,
474
 
    .id             = CODEC_ID_TTA,
 
477
    .id             = AV_CODEC_ID_TTA,
475
478
    .priv_data_size = sizeof(TTAContext),
476
479
    .init           = tta_decode_init,
477
480
    .close          = tta_decode_close,
478
481
    .decode         = tta_decode_frame,
479
482
    .capabilities   = CODEC_CAP_DR1,
480
 
    .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
 
483
    .long_name      = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
481
484
};