← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/truespeech.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/truespeech.c
21
21
 
22
22
#include "libavutil/intreadwrite.h"
23
23
#include "avcodec.h"
 
24
#include "dsputil.h"
 
25
#include "get_bits.h"
24
26
 
25
27
#include "truespeech_data.h"
26
28
/**
32
34
 * TrueSpeech decoder context
33
35
 */
34
36
typedef struct {
 
37
    AVFrame frame;
 
38
    DSPContext dsp;
35
39
    /* input data */
36
 
    int16_t vector[8];  //< input vector: 5/5/4/4/4/3/3/3
37
 
    int offset1[2];     //< 8-bit value, used in one copying offset
38
 
    int offset2[4];     //< 7-bit value, encodes offsets for copying and for two-point filter
39
 
    int pulseoff[4];    //< 4-bit offset of pulse values block
40
 
    int pulsepos[4];    //< 27-bit variable, encodes 7 pulse positions
41
 
    int pulseval[4];    //< 7x2-bit pulse values
42
 
    int flag;           //< 1-bit flag, shows how to choose filters
 
40
    uint8_t buffer[32];
 
41
    int16_t vector[8];  ///< input vector: 5/5/4/4/4/3/3/3
 
42
    int offset1[2];     ///< 8-bit value, used in one copying offset
 
43
    int offset2[4];     ///< 7-bit value, encodes offsets for copying and for two-point filter
 
44
    int pulseoff[4];    ///< 4-bit offset of pulse values block
 
45
    int pulsepos[4];    ///< 27-bit variable, encodes 7 pulse positions
 
46
    int pulseval[4];    ///< 7x2-bit pulse values
 
47
    int flag;           ///< 1-bit flag, shows how to choose filters
43
48
    /* temporary data */
44
49
    int filtbuf[146];   // some big vector used for storing filters
45
50
    int prevfilt[8];    // filter from previous frame
54
59
 
55
60
static av_cold int truespeech_decode_init(AVCodecContext * avctx)
56
61
{
57
 
//    TSContext *c = avctx->priv_data;
 
62
    TSContext *c = avctx->priv_data;
 
63
 
 
64
    if (avctx->channels != 1) {
 
65
        av_log_ask_for_sample(avctx, "Unsupported channel count: %d\n", avctx->channels);
 
66
        return AVERROR(EINVAL);
 
67
    }
58
68
 
59
69
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 
70
 
 
71
    dsputil_init(&c->dsp, avctx);
 
72
 
 
73
    avcodec_get_frame_defaults(&c->frame);
 
74
    avctx->coded_frame = &c->frame;
 
75
 
60
76
    return 0;
61
77
}
62
78
 
63
79
static void truespeech_read_frame(TSContext *dec, const uint8_t *input)
64
80
{
65
 
    uint32_t t;
66
 
 
67
 
    /* first dword */
68
 
    t = AV_RL32(input);
69
 
    input += 4;
70
 
 
71
 
    dec->flag = t & 1;
72
 
 
73
 
    dec->vector[0] = ts_codebook[0][(t >>  1) & 0x1F];
74
 
    dec->vector[1] = ts_codebook[1][(t >>  6) & 0x1F];
75
 
    dec->vector[2] = ts_codebook[2][(t >> 11) &  0xF];
76
 
    dec->vector[3] = ts_codebook[3][(t >> 15) &  0xF];
77
 
    dec->vector[4] = ts_codebook[4][(t >> 19) &  0xF];
78
 
    dec->vector[5] = ts_codebook[5][(t >> 23) &  0x7];
79
 
    dec->vector[6] = ts_codebook[6][(t >> 26) &  0x7];
80
 
    dec->vector[7] = ts_codebook[7][(t >> 29) &  0x7];
81
 
 
82
 
    /* second dword */
83
 
    t = AV_RL32(input);
84
 
    input += 4;
85
 
 
86
 
    dec->offset2[0] = (t >>  0) & 0x7F;
87
 
    dec->offset2[1] = (t >>  7) & 0x7F;
88
 
    dec->offset2[2] = (t >> 14) & 0x7F;
89
 
    dec->offset2[3] = (t >> 21) & 0x7F;
90
 
 
91
 
    dec->offset1[0] = ((t >> 28) & 0xF) << 4;
92
 
 
93
 
    /* third dword */
94
 
    t = AV_RL32(input);
95
 
    input += 4;
96
 
 
97
 
    dec->pulseval[0] = (t >>  0) & 0x3FFF;
98
 
    dec->pulseval[1] = (t >> 14) & 0x3FFF;
99
 
 
100
 
    dec->offset1[1] = (t >> 28) & 0x0F;
101
 
 
102
 
    /* fourth dword */
103
 
    t = AV_RL32(input);
104
 
    input += 4;
105
 
 
106
 
    dec->pulseval[2] = (t >>  0) & 0x3FFF;
107
 
    dec->pulseval[3] = (t >> 14) & 0x3FFF;
108
 
 
109
 
    dec->offset1[1] |= ((t >> 28) & 0x0F) << 4;
110
 
 
111
 
    /* fifth dword */
112
 
    t = AV_RL32(input);
113
 
    input += 4;
114
 
 
115
 
    dec->pulsepos[0] = (t >> 4) & 0x7FFFFFF;
116
 
 
117
 
    dec->pulseoff[0] = (t >> 0) & 0xF;
118
 
 
119
 
    dec->offset1[0] |= (t >> 31) & 1;
120
 
 
121
 
    /* sixth dword */
122
 
    t = AV_RL32(input);
123
 
    input += 4;
124
 
 
125
 
    dec->pulsepos[1] = (t >> 4) & 0x7FFFFFF;
126
 
 
127
 
    dec->pulseoff[1] = (t >> 0) & 0xF;
128
 
 
129
 
    dec->offset1[0] |= ((t >> 31) & 1) << 1;
130
 
 
131
 
    /* seventh dword */
132
 
    t = AV_RL32(input);
133
 
    input += 4;
134
 
 
135
 
    dec->pulsepos[2] = (t >> 4) & 0x7FFFFFF;
136
 
 
137
 
    dec->pulseoff[2] = (t >> 0) & 0xF;
138
 
 
139
 
    dec->offset1[0] |= ((t >> 31) & 1) << 2;
140
 
 
141
 
    /* eighth dword */
142
 
    t = AV_RL32(input);
143
 
    input += 4;
144
 
 
145
 
    dec->pulsepos[3] = (t >> 4) & 0x7FFFFFF;
146
 
 
147
 
    dec->pulseoff[3] = (t >> 0) & 0xF;
148
 
 
149
 
    dec->offset1[0] |= ((t >> 31) & 1) << 3;
150
 
 
 
81
    GetBitContext gb;
 
82
 
 
83
    dec->dsp.bswap_buf((uint32_t *)dec->buffer, (const uint32_t *)input, 8);
 
84
    init_get_bits(&gb, dec->buffer, 32 * 8);
 
85
 
 
86
    dec->vector[7] = ts_codebook[7][get_bits(&gb, 3)];
 
87
    dec->vector[6] = ts_codebook[6][get_bits(&gb, 3)];
 
88
    dec->vector[5] = ts_codebook[5][get_bits(&gb, 3)];
 
89
    dec->vector[4] = ts_codebook[4][get_bits(&gb, 4)];
 
90
    dec->vector[3] = ts_codebook[3][get_bits(&gb, 4)];
 
91
    dec->vector[2] = ts_codebook[2][get_bits(&gb, 4)];
 
92
    dec->vector[1] = ts_codebook[1][get_bits(&gb, 5)];
 
93
    dec->vector[0] = ts_codebook[0][get_bits(&gb, 5)];
 
94
    dec->flag      = get_bits1(&gb);
 
95
 
 
96
    dec->offset1[0] = get_bits(&gb, 4) << 4;
 
97
    dec->offset2[3] = get_bits(&gb, 7);
 
98
    dec->offset2[2] = get_bits(&gb, 7);
 
99
    dec->offset2[1] = get_bits(&gb, 7);
 
100
    dec->offset2[0] = get_bits(&gb, 7);
 
101
 
 
102
    dec->offset1[1]  = get_bits(&gb, 4);
 
103
    dec->pulseval[1] = get_bits(&gb, 14);
 
104
    dec->pulseval[0] = get_bits(&gb, 14);
 
105
 
 
106
    dec->offset1[1] |= get_bits(&gb, 4) << 4;
 
107
    dec->pulseval[3] = get_bits(&gb, 14);
 
108
    dec->pulseval[2] = get_bits(&gb, 14);
 
109
 
 
110
    dec->offset1[0] |= get_bits1(&gb);
 
111
    dec->pulsepos[0] = get_bits_long(&gb, 27);
 
112
    dec->pulseoff[0] = get_bits(&gb, 4);
 
113
 
 
114
    dec->offset1[0] |= get_bits1(&gb) << 1;
 
115
    dec->pulsepos[1] = get_bits_long(&gb, 27);
 
116
    dec->pulseoff[1] = get_bits(&gb, 4);
 
117
 
 
118
    dec->offset1[0] |= get_bits1(&gb) << 2;
 
119
    dec->pulsepos[2] = get_bits_long(&gb, 27);
 
120
    dec->pulseoff[2] = get_bits(&gb, 4);
 
121
 
 
122
    dec->offset1[0] |= get_bits1(&gb) << 3;
 
123
    dec->pulsepos[3] = get_bits_long(&gb, 27);
 
124
    dec->pulseoff[3] = get_bits(&gb, 4);
151
125
}
152
126
 
153
127
static void truespeech_correlate_filter(TSContext *dec)
157
131
 
158
132
    for(i = 0; i < 8; i++){
159
133
        if(i > 0){
160
 
            memcpy(tmp, dec->cvector, i * 2);
 
134
            memcpy(tmp, dec->cvector, i * sizeof(*tmp));
161
135
            for(j = 0; j < i; j++)
162
136
                dec->cvector[j] = ((tmp[i - j - 1] * dec->vector[i]) +
163
137
                                   (dec->cvector[j] << 15) + 0x4000) >> 15;
199
173
 
200
174
    t = dec->offset2[quart];
201
175
    if(t == 127){
202
 
        memset(dec->newvec, 0, 60 * 2);
 
176
        memset(dec->newvec, 0, 60 * sizeof(*dec->newvec));
203
177
        return;
204
178
    }
205
179
    for(i = 0; i < 146; i++)
206
180
        tmp[i] = dec->filtbuf[i];
207
181
    off = (t / 25) + dec->offset1[quart >> 1] + 18;
 
182
    off = av_clip(off, 0, 145);
208
183
    ptr0 = tmp + 145 - off;
209
184
    ptr1 = tmp + 146;
210
185
    filter = (const int16_t*)ts_order2_coeffs + (t % 25) * 2;
224
199
    int16_t *ptr2;
225
200
    int coef;
226
201
 
227
 
    memset(out, 0, 60 * 2);
 
202
    memset(out, 0, 60 * sizeof(*out));
228
203
    for(i = 0; i < 7; i++) {
229
204
        t = dec->pulseval[quart] & 3;
230
205
        dec->pulseval[quart] >>= 2;
263
238
{
264
239
    int i;
265
240
 
266
 
    for(i = 0; i < 86; i++)
267
 
        dec->filtbuf[i] = dec->filtbuf[i + 60];
 
241
    memmove(dec->filtbuf, &dec->filtbuf[60], 86 * sizeof(*dec->filtbuf));
268
242
    for(i = 0; i < 60; i++){
269
243
        dec->filtbuf[i + 86] = out[i] + dec->newvec[i] - (dec->newvec[i] >> 3);
270
244
        out[i] += dec->newvec[i];
330
304
        c->prevfilt[i] = c->cvector[i];
331
305
}
332
306
 
333
 
static int truespeech_decode_frame(AVCodecContext *avctx,
334
 
                void *data, int *data_size,
335
 
                AVPacket *avpkt)
 
307
static int truespeech_decode_frame(AVCodecContext *avctx, void *data,
 
308
                                   int *got_frame_ptr, AVPacket *avpkt)
336
309
{
337
310
    const uint8_t *buf = avpkt->data;
338
311
    int buf_size = avpkt->size;
339
312
    TSContext *c = avctx->priv_data;
340
313
 
341
314
    int i, j;
342
 
    short *samples = data;
343
 
    int consumed = 0;
344
 
    int16_t out_buf[240];
345
 
    int iterations;
346
 
 
347
 
    if (!buf_size)
348
 
        return 0;
349
 
 
350
 
    if (buf_size < 32) {
 
315
    int16_t *samples;
 
316
    int iterations, ret;
 
317
 
 
318
    iterations = buf_size / 32;
 
319
 
 
320
    if (!iterations) {
351
321
        av_log(avctx, AV_LOG_ERROR,
352
322
               "Too small input buffer (%d bytes), need at least 32 bytes\n", buf_size);
353
323
        return -1;
354
324
    }
355
 
    iterations = FFMIN(buf_size / 32, *data_size / 480);
 
325
 
 
326
    /* get output buffer */
 
327
    c->frame.nb_samples = iterations * 240;
 
328
    if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {
 
329
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 
330
        return ret;
 
331
    }
 
332
    samples = (int16_t *)c->frame.data[0];
 
333
 
 
334
    memset(samples, 0, iterations * 240 * sizeof(*samples));
 
335
 
356
336
    for(j = 0; j < iterations; j++) {
357
 
        truespeech_read_frame(c, buf + consumed);
358
 
        consumed += 32;
 
337
        truespeech_read_frame(c, buf);
 
338
        buf += 32;
359
339
 
360
340
        truespeech_correlate_filter(c);
361
341
        truespeech_filters_merge(c);
362
342
 
363
 
        memset(out_buf, 0, 240 * 2);
364
343
        for(i = 0; i < 4; i++) {
365
344
            truespeech_apply_twopoint_filter(c, i);
366
 
            truespeech_place_pulses(c, out_buf + i * 60, i);
367
 
            truespeech_update_filters(c, out_buf + i * 60, i);
368
 
            truespeech_synth(c, out_buf + i * 60, i);
 
345
            truespeech_place_pulses  (c, samples, i);
 
346
            truespeech_update_filters(c, samples, i);
 
347
            truespeech_synth         (c, samples, i);
 
348
            samples += 60;
369
349
        }
370
350
 
371
351
        truespeech_save_prevvec(c);
372
 
 
373
 
        /* finally output decoded frame */
374
 
        for(i = 0; i < 240; i++)
375
 
            *samples++ = out_buf[i];
376
 
 
377
352
    }
378
353
 
379
 
    *data_size = consumed * 15;
 
354
    *got_frame_ptr   = 1;
 
355
    *(AVFrame *)data = c->frame;
380
356
 
381
 
    return consumed;
 
357
    return buf_size;
382
358
}
383
359
 
384
360
AVCodec ff_truespeech_decoder = {
385
 
    "truespeech",
386
 
    AVMEDIA_TYPE_AUDIO,
387
 
    CODEC_ID_TRUESPEECH,
388
 
    sizeof(TSContext),
389
 
    truespeech_decode_init,
390
 
    NULL,
391
 
    NULL,
392
 
    truespeech_decode_frame,
 
361
    .name           = "truespeech",
 
362
    .type           = AVMEDIA_TYPE_AUDIO,
 
363
    .id             = CODEC_ID_TRUESPEECH,
 
364
    .priv_data_size = sizeof(TSContext),
 
365
    .init           = truespeech_decode_init,
 
366
    .decode         = truespeech_decode_frame,
 
367
    .capabilities   = CODEC_CAP_DR1,
393
368
    .long_name = NULL_IF_CONFIG_SMALL("DSP Group TrueSpeech"),
394
369
};