Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ra288.c @ 1be0fc29

History | View | Annotate | Download (6.81 KB)

1
/*
2
 * RealAudio 2.0 (28.8K)
3
 * Copyright (c) 2003 the ffmpeg project
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include "avcodec.h"
23
#define ALT_BITSTREAM_READER_LE
24
#include "bitstream.h"
25
#include "ra288.h"
26
#include "lpc.h"
27

    
28
typedef struct {
29
    float sp_lpc[36];      ///< LPC coefficients for speech data (spec: A)
30
    float gain_lpc[10];    ///< LPC coefficients for gain (spec: GB)
31

    
32
    float sp_hist[111];    ///< Speech data history (spec: SB)
33

    
34
    /** Speech part of the gain autocorrelation (spec: REXP) */
35
    float sp_rec[37];
36

    
37
    float gain_hist[38];   ///< Log-gain history (spec: SBLG)
38

    
39
    /** Recursive part of the gain autocorrelation (spec: REXPLG) */
40
    float gain_rec[11];
41

    
42
    float sp_block[41];    ///< Speech data of four blocks (spec: STTMP)
43
    float gain_block[10];  ///< Gain data of four blocks (spec: GSTATE)
44
} RA288Context;
45

    
46
static av_cold int ra288_decode_init(AVCodecContext *avctx)
47
{
48
    avctx->sample_fmt = SAMPLE_FMT_S16;
49
    return 0;
50
}
51

    
52
static inline float scalar_product_float(const float * v1, const float * v2,
53
                                         int size)
54
{
55
    float res = 0.;
56

    
57
    while (size--)
58
        res += *v1++ * *v2++;
59

    
60
    return res;
61
}
62

    
63
static void colmult(float *tgt, const float *m1, const float *m2, int n)
64
{
65
    while (n--)
66
        *tgt++ = *m1++ * *m2++;
67
}
68

    
69
static void decode(RA288Context *ractx, float gain, int cb_coef)
70
{
71
    int i, j;
72
    double sumsum;
73
    float sum, buffer[5];
74
    float *block = ractx->sp_block + 36; // Current block
75

    
76
    memmove(ractx->sp_block, ractx->sp_block + 5, 36*sizeof(*ractx->sp_block));
77

    
78
    for (i=0; i < 5; i++) {
79
        block[i] = 0.;
80
        for (j=0; j < 36; j++)
81
            block[i] -= block[i-1-j]*ractx->sp_lpc[j];
82
    }
83

    
84
    /* block 46 of G.728 spec */
85
    sum = 32.;
86
    for (i=0; i < 10; i++)
87
        sum -= ractx->gain_block[9-i] * ractx->gain_lpc[i];
88

    
89
    /* block 47 of G.728 spec */
90
    sum = av_clipf(sum, 0, 60);
91

    
92
    /* block 48 of G.728 spec */
93
    sumsum = exp(sum * 0.1151292546497) * gain; /* pow(10.0,sum/20)*gain */
94

    
95
    for (i=0; i < 5; i++)
96
        buffer[i] = codetable[cb_coef][i] * sumsum;
97

    
98
    sum = scalar_product_float(buffer, buffer, 5) / 5;
99

    
100
    sum = FFMAX(sum, 1);
101

    
102
    /* shift and store */
103
    memmove(ractx->gain_block, ractx->gain_block + 1,
104
            9 * sizeof(*ractx->gain_block));
105

    
106
    ractx->gain_block[9] = 10 * log10(sum) - 32;
107

    
108
    for (i=1; i < 5; i++)
109
        for (j=i-1; j >= 0; j--)
110
            buffer[i] -= ractx->sp_lpc[i-j-1] * buffer[j];
111

    
112
    /* output */
113
    for (i=0; i < 5; i++)
114
        block[i] = av_clipf(block[i] + buffer[i], -4095, 4095);
115
}
116

    
117
static void convolve(float *tgt, const float *src, int len, int n)
118
{
119
    for (; n >= 0; n--)
120
        tgt[n] = scalar_product_float(src, src - n, len);
121

    
122
}
123

    
124
/**
125
 * Hybrid window filtering. See blocks 36 and 49 of the G.728 specification.
126
 *
127
 * @param order   the order of the filter
128
 * @param n       the length of the input
129
 * @param non_rec the number of non-recursive samples
130
 * @param out     the filter output
131
 * @param in      pointer to the input of the filter
132
 * @param hist    pointer to the input history of the filter. It is updated by
133
 *                this function.
134
 * @param out     pointer to the non-recursive part of the output
135
 * @param out2    pointer to the recursive part of the output
136
 * @param window  pointer to the windowing function table
137
 */
138
static void do_hybrid_window(int order, int n, int non_rec, const float *in,
139
                             float *out, float *hist, float *out2,
140
                             const float *window)
141
{
142
    int i;
143
    float buffer1[order + 1];
144
    float buffer2[order + 1];
145
    float work[order + n + non_rec];
146

    
147
    /* update history */
148
    memmove(hist                  , hist + n, (order + non_rec)*sizeof(*hist));
149
    memcpy (hist + order + non_rec, in      , n                *sizeof(*hist));
150

    
151
    colmult(work, window, hist, order + n + non_rec);
152

    
153
    convolve(buffer1, work + order    , n      , order);
154
    convolve(buffer2, work + order + n, non_rec, order);
155

    
156
    for (i=0; i <= order; i++) {
157
        out2[i] = out2[i] * 0.5625 + buffer1[i];
158
        out [i] = out2[i]          + buffer2[i];
159
    }
160

    
161
    /* Multiply by the white noise correcting factor (WNCF) */
162
    *out *= 257./256.;
163
}
164

    
165
/**
166
 * Backward synthesis filter. Find the LPC coefficients from past speech data.
167
 */
168
static void backward_filter(RA288Context *ractx)
169
{
170
    float temp1[37]; // RTMP in the spec
171
    float temp2[11]; // GPTPMP in the spec
172

    
173
    do_hybrid_window(36, 40, 35, ractx->sp_block+1, temp1, ractx->sp_hist,
174
                     ractx->sp_rec, syn_window);
175

    
176
    if (!compute_lpc_coefs(temp1, 36, ractx->sp_lpc, 0, 1, 1))
177
        colmult(ractx->sp_lpc, ractx->sp_lpc, syn_bw_tab, 36);
178

    
179
    do_hybrid_window(10, 8, 20, ractx->gain_block+2, temp2, ractx->gain_hist,
180
                     ractx->gain_rec, gain_window);
181

    
182
    if (!compute_lpc_coefs(temp2, 10, ractx->gain_lpc, 0, 1, 1))
183
        colmult(ractx->gain_lpc, ractx->gain_lpc, gain_bw_tab, 10);
184
}
185

    
186
static int ra288_decode_frame(AVCodecContext * avctx, void *data,
187
                              int *data_size, const uint8_t * buf,
188
                              int buf_size)
189
{
190
    int16_t *out = data;
191
    int i, j;
192
    RA288Context *ractx = avctx->priv_data;
193
    GetBitContext gb;
194

    
195
    if (buf_size < avctx->block_align) {
196
        av_log(avctx, AV_LOG_ERROR,
197
               "Error! Input buffer is too small [%d<%d]\n",
198
               buf_size, avctx->block_align);
199
        return 0;
200
    }
201

    
202
    if (*data_size < 32*5*2)
203
        return -1;
204

    
205
    init_get_bits(&gb, buf, avctx->block_align * 8);
206

    
207
    for (i=0; i < 32; i++) {
208
        float gain = amptable[get_bits(&gb, 3)];
209
        int cb_coef = get_bits(&gb, 6 + (i&1));
210

    
211
        decode(ractx, gain, cb_coef);
212

    
213
        for (j=0; j < 5; j++)
214
            *(out++) = 8 * ractx->sp_block[36 + j];
215

    
216
        if ((i & 7) == 3)
217
            backward_filter(ractx);
218
    }
219

    
220
    *data_size = (char *)out - (char *)data;
221
    return avctx->block_align;
222
}
223

    
224
AVCodec ra_288_decoder =
225
{
226
    "real_288",
227
    CODEC_TYPE_AUDIO,
228
    CODEC_ID_RA_288,
229
    sizeof(RA288Context),
230
    ra288_decode_init,
231
    NULL,
232
    NULL,
233
    ra288_decode_frame,
234
    .long_name = NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),
235
};