Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ra144enc.c @ b9f9e59a

History | View | Annotate | Download (17.2 KB)

1
/*
2
 * Real Audio 1.0 (14.4K) encoder
3
 * Copyright (c) 2010 Francesco Lavra <francescolavra@interfree.it>
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
/**
23
 * @file
24
 * Real Audio 1.0 (14.4K) encoder
25
 * @author Francesco Lavra <francescolavra@interfree.it>
26
 */
27

    
28
#include <float.h>
29

    
30
#include "avcodec.h"
31
#include "put_bits.h"
32
#include "lpc.h"
33
#include "celp_filters.h"
34
#include "ra144.h"
35

    
36

    
37
static av_cold int ra144_encode_init(AVCodecContext * avctx)
38
{
39
    RA144Context *ractx;
40

    
41
    if (avctx->sample_fmt != SAMPLE_FMT_S16) {
42
        av_log(avctx, AV_LOG_ERROR, "invalid sample format\n");
43
        return -1;
44
    }
45
    if (avctx->channels != 1) {
46
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n",
47
               avctx->channels);
48
        return -1;
49
    }
50
    avctx->frame_size = NBLOCKS * BLOCKSIZE;
51
    avctx->bit_rate = 8000;
52
    ractx = avctx->priv_data;
53
    ractx->lpc_coef[0] = ractx->lpc_tables[0];
54
    ractx->lpc_coef[1] = ractx->lpc_tables[1];
55
    ractx->avctx = avctx;
56
    dsputil_init(&ractx->dsp, avctx);
57
    return 0;
58
}
59

    
60

    
61
/**
62
 * Quantize a value by searching a sorted table for the element with the
63
 * nearest value
64
 *
65
 * @param value value to quantize
66
 * @param table array containing the quantization table
67
 * @param size size of the quantization table
68
 * @return index of the quantization table corresponding to the element with the
69
 *         nearest value
70
 */
71
static int quantize(int value, const int16_t *table, unsigned int size)
72
{
73
    unsigned int low = 0, high = size - 1;
74

    
75
    while (1) {
76
        int index = (low + high) >> 1;
77
        int error = table[index] - value;
78

    
79
        if (index == low)
80
            return table[high] + error > value ? low : high;
81
        if (error > 0) {
82
            high = index;
83
        } else {
84
            low = index;
85
        }
86
    }
87
}
88

    
89

    
90
/**
91
 * Orthogonalize a vector to another vector
92
 *
93
 * @param v vector to orthogonalize
94
 * @param u vector against which orthogonalization is performed
95
 */
96
static void orthogonalize(float *v, const float *u)
97
{
98
    int i;
99
    float num = 0, den = 0;
100

    
101
    for (i = 0; i < BLOCKSIZE; i++) {
102
        num += v[i] * u[i];
103
        den += u[i] * u[i];
104
    }
105
    num /= den;
106
    for (i = 0; i < BLOCKSIZE; i++)
107
        v[i] -= num * u[i];
108
}
109

    
110

    
111
/**
112
 * Calculate match score and gain of an LPC-filtered vector with respect to
113
 * input data, possibly othogonalizing it to up to 2 other vectors
114
 *
115
 * @param work array used to calculate the filtered vector
116
 * @param coefs coefficients of the LPC filter
117
 * @param vect original vector
118
 * @param ortho1 first vector against which orthogonalization is performed
119
 * @param ortho2 second vector against which orthogonalization is performed
120
 * @param data input data
121
 * @param score pointer to variable where match score is returned
122
 * @param gain pointer to variable where gain is returned
123
 */
124
static void get_match_score(float *work, const float *coefs, float *vect,
125
                            const float *ortho1, const float *ortho2,
126
                            const float *data, float *score, float *gain)
127
{
128
    float c, g;
129
    int i;
130

    
131
    ff_celp_lp_synthesis_filterf(work, coefs, vect, BLOCKSIZE, LPC_ORDER);
132
    if (ortho1)
133
        orthogonalize(work, ortho1);
134
    if (ortho2)
135
        orthogonalize(work, ortho2);
136
    c = g = 0;
137
    for (i = 0; i < BLOCKSIZE; i++) {
138
        g += work[i] * work[i];
139
        c += data[i] * work[i];
140
    }
141
    if (c <= 0) {
142
        *score = 0;
143
        return;
144
    }
145
    *gain = c / g;
146
    *score = *gain * c;
147
}
148

    
149

    
150
/**
151
 * Create a vector from the adaptive codebook at a given lag value
152
 *
153
 * @param vect array where vector is stored
154
 * @param cb adaptive codebook
155
 * @param lag lag value
156
 */
157
static void create_adapt_vect(float *vect, const int16_t *cb, int lag)
158
{
159
    int i;
160

    
161
    cb += BUFFERSIZE - lag;
162
    for (i = 0; i < FFMIN(BLOCKSIZE, lag); i++)
163
        vect[i] = cb[i];
164
    if (lag < BLOCKSIZE)
165
        for (i = 0; i < BLOCKSIZE - lag; i++)
166
            vect[lag + i] = cb[i];
167
}
168

    
169

    
170
/**
171
 * Search the adaptive codebook for the best entry and gain and remove its
172
 * contribution from input data
173
 *
174
 * @param adapt_cb array from which the adaptive codebook is extracted
175
 * @param work array used to calculate LPC-filtered vectors
176
 * @param coefs coefficients of the LPC filter
177
 * @param data input data
178
 * @return index of the best entry of the adaptive codebook
179
 */
180
static int adaptive_cb_search(const int16_t *adapt_cb, float *work,
181
                              const float *coefs, float *data)
182
{
183
    int i, best_vect;
184
    float score, gain, best_score, best_gain;
185
    float exc[BLOCKSIZE];
186

    
187
    gain = best_score = 0;
188
    for (i = BLOCKSIZE / 2; i <= BUFFERSIZE; i++) {
189
        create_adapt_vect(exc, adapt_cb, i);
190
        get_match_score(work, coefs, exc, NULL, NULL, data, &score, &gain);
191
        if (score > best_score) {
192
            best_score = score;
193
            best_vect = i;
194
            best_gain = gain;
195
        }
196
    }
197
    if (!best_score)
198
        return 0;
199

    
200
    /**
201
     * Re-calculate the filtered vector from the vector with maximum match score
202
     * and remove its contribution from input data.
203
     */
204
    create_adapt_vect(exc, adapt_cb, best_vect);
205
    ff_celp_lp_synthesis_filterf(work, coefs, exc, BLOCKSIZE, LPC_ORDER);
206
    for (i = 0; i < BLOCKSIZE; i++)
207
        data[i] -= best_gain * work[i];
208
    return (best_vect - BLOCKSIZE / 2 + 1);
209
}
210

    
211

    
212
/**
213
 * Find the best vector of a fixed codebook by applying an LPC filter to
214
 * codebook entries, possibly othogonalizing them to up to 2 other vectors and
215
 * matching the results with input data
216
 *
217
 * @param work array used to calculate the filtered vectors
218
 * @param coefs coefficients of the LPC filter
219
 * @param cb fixed codebook
220
 * @param ortho1 first vector against which orthogonalization is performed
221
 * @param ortho2 second vector against which orthogonalization is performed
222
 * @param data input data
223
 * @param idx pointer to variable where the index of the best codebook entry is
224
 *        returned
225
 * @param gain pointer to variable where the gain of the best codebook entry is
226
 *        returned
227
 */
228
static void find_best_vect(float *work, const float *coefs,
229
                           const int8_t cb[][BLOCKSIZE], const float *ortho1,
230
                           const float *ortho2, float *data, int *idx,
231
                           float *gain)
232
{
233
    int i, j;
234
    float g, score, best_score;
235
    float vect[BLOCKSIZE];
236

    
237
    *idx = *gain = best_score = 0;
238
    for (i = 0; i < FIXED_CB_SIZE; i++) {
239
        for (j = 0; j < BLOCKSIZE; j++)
240
            vect[j] = cb[i][j];
241
        get_match_score(work, coefs, vect, ortho1, ortho2, data, &score, &g);
242
        if (score > best_score) {
243
            best_score = score;
244
            *idx = i;
245
            *gain = g;
246
        }
247
    }
248
}
249

    
250

    
251
/**
252
 * Search the two fixed codebooks for the best entry and gain
253
 *
254
 * @param work array used to calculate LPC-filtered vectors
255
 * @param coefs coefficients of the LPC filter
256
 * @param data input data
257
 * @param cba_idx index of the best entry of the adaptive codebook
258
 * @param cb1_idx pointer to variable where the index of the best entry of the
259
 *        first fixed codebook is returned
260
 * @param cb2_idx pointer to variable where the index of the best entry of the
261
 *        second fixed codebook is returned
262
 */
263
static void fixed_cb_search(float *work, const float *coefs, float *data,
264
                            int cba_idx, int *cb1_idx, int *cb2_idx)
265
{
266
    int i, ortho_cb1;
267
    float gain;
268
    float cba_vect[BLOCKSIZE], cb1_vect[BLOCKSIZE];
269
    float vect[BLOCKSIZE];
270

    
271
    /**
272
     * The filtered vector from the adaptive codebook can be retrieved from
273
     * work, because this function is called just after adaptive_cb_search().
274
     */
275
    if (cba_idx)
276
        memcpy(cba_vect, work, sizeof(cba_vect));
277

    
278
    find_best_vect(work, coefs, ff_cb1_vects, cba_idx ? cba_vect : NULL, NULL,
279
                   data, cb1_idx, &gain);
280

    
281
    /**
282
     * Re-calculate the filtered vector from the vector with maximum match score
283
     * and remove its contribution from input data.
284
     */
285
    if (gain) {
286
        for (i = 0; i < BLOCKSIZE; i++)
287
            vect[i] = ff_cb1_vects[*cb1_idx][i];
288
        ff_celp_lp_synthesis_filterf(work, coefs, vect, BLOCKSIZE, LPC_ORDER);
289
        if (cba_idx)
290
            orthogonalize(work, cba_vect);
291
        for (i = 0; i < BLOCKSIZE; i++)
292
            data[i] -= gain * work[i];
293
        memcpy(cb1_vect, work, sizeof(cb1_vect));
294
        ortho_cb1 = 1;
295
    } else
296
        ortho_cb1 = 0;
297

    
298
    find_best_vect(work, coefs, ff_cb2_vects, cba_idx ? cba_vect : NULL,
299
                   ortho_cb1 ? cb1_vect : NULL, data, cb2_idx, &gain);
300
}
301

    
302

    
303
/**
304
 * Encode a subblock of the current frame
305
 *
306
 * @param ractx encoder context
307
 * @param sblock_data input data of the subblock
308
 * @param lpc_coefs coefficients of the LPC filter
309
 * @param rms RMS of the reflection coefficients
310
 * @param pb pointer to PutBitContext of the current frame
311
 */
312
static void ra144_encode_subblock(RA144Context *ractx,
313
                                  const int16_t *sblock_data,
314
                                  const int16_t *lpc_coefs, unsigned int rms,
315
                                  PutBitContext *pb)
316
{
317
    float data[BLOCKSIZE], work[LPC_ORDER + BLOCKSIZE];
318
    float coefs[LPC_ORDER];
319
    float zero[BLOCKSIZE], cba[BLOCKSIZE], cb1[BLOCKSIZE], cb2[BLOCKSIZE];
320
    int16_t cba_vect[BLOCKSIZE];
321
    int cba_idx, cb1_idx, cb2_idx, gain;
322
    int i, n, m[3];
323
    float g[3];
324
    float error, best_error;
325

    
326
    for (i = 0; i < LPC_ORDER; i++) {
327
        work[i] = ractx->curr_sblock[BLOCKSIZE + i];
328
        coefs[i] = lpc_coefs[i] * (1/4096.0);
329
    }
330

    
331
    /**
332
     * Calculate the zero-input response of the LPC filter and subtract it from
333
     * input data.
334
     */
335
    memset(data, 0, sizeof(data));
336
    ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, data, BLOCKSIZE,
337
                                 LPC_ORDER);
338
    for (i = 0; i < BLOCKSIZE; i++) {
339
        zero[i] = work[LPC_ORDER + i];
340
        data[i] = sblock_data[i] - zero[i];
341
    }
342

    
343
    /**
344
     * Codebook search is performed without taking into account the contribution
345
     * of the previous subblock, since it has been just subtracted from input
346
     * data.
347
     */
348
    memset(work, 0, LPC_ORDER * sizeof(*work));
349

    
350
    cba_idx = adaptive_cb_search(ractx->adapt_cb, work + LPC_ORDER, coefs,
351
                                 data);
352
    if (cba_idx) {
353
        /**
354
         * The filtered vector from the adaptive codebook can be retrieved from
355
         * work, see implementation of adaptive_cb_search().
356
         */
357
        memcpy(cba, work + LPC_ORDER, sizeof(cba));
358

    
359
        ff_copy_and_dup(cba_vect, ractx->adapt_cb, cba_idx + BLOCKSIZE / 2 - 1);
360
        m[0] = (ff_irms(cba_vect) * rms) >> 12;
361
    }
362
    fixed_cb_search(work + LPC_ORDER, coefs, data, cba_idx, &cb1_idx, &cb2_idx);
363
    for (i = 0; i < BLOCKSIZE; i++) {
364
        cb1[i] = ff_cb1_vects[cb1_idx][i];
365
        cb2[i] = ff_cb2_vects[cb2_idx][i];
366
    }
367
    ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, cb1, BLOCKSIZE,
368
                                 LPC_ORDER);
369
    memcpy(cb1, work + LPC_ORDER, sizeof(cb1));
370
    m[1] = (ff_cb1_base[cb1_idx] * rms) >> 8;
371
    ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, cb2, BLOCKSIZE,
372
                                 LPC_ORDER);
373
    memcpy(cb2, work + LPC_ORDER, sizeof(cb2));
374
    m[2] = (ff_cb2_base[cb2_idx] * rms) >> 8;
375
    best_error = FLT_MAX;
376
    gain = 0;
377
    for (n = 0; n < 256; n++) {
378
        g[1] = ((ff_gain_val_tab[n][1] * m[1]) >> ff_gain_exp_tab[n]) *
379
               (1/4096.0);
380
        g[2] = ((ff_gain_val_tab[n][2] * m[2]) >> ff_gain_exp_tab[n]) *
381
               (1/4096.0);
382
        error = 0;
383
        if (cba_idx) {
384
            g[0] = ((ff_gain_val_tab[n][0] * m[0]) >> ff_gain_exp_tab[n]) *
385
                   (1/4096.0);
386
            for (i = 0; i < BLOCKSIZE; i++) {
387
                data[i] = zero[i] + g[0] * cba[i] + g[1] * cb1[i] +
388
                          g[2] * cb2[i];
389
                error += (data[i] - sblock_data[i]) *
390
                         (data[i] - sblock_data[i]);
391
            }
392
        } else {
393
            for (i = 0; i < BLOCKSIZE; i++) {
394
                data[i] = zero[i] + g[1] * cb1[i] + g[2] * cb2[i];
395
                error += (data[i] - sblock_data[i]) *
396
                         (data[i] - sblock_data[i]);
397
            }
398
        }
399
        if (error < best_error) {
400
            best_error = error;
401
            gain = n;
402
        }
403
    }
404
    put_bits(pb, 7, cba_idx);
405
    put_bits(pb, 8, gain);
406
    put_bits(pb, 7, cb1_idx);
407
    put_bits(pb, 7, cb2_idx);
408
    ff_subblock_synthesis(ractx, lpc_coefs, cba_idx, cb1_idx, cb2_idx, rms,
409
                          gain);
410
}
411

    
412

    
413
static int ra144_encode_frame(AVCodecContext *avctx, uint8_t *frame,
414
                              int buf_size, void *data)
415
{
416
    static const uint8_t sizes[LPC_ORDER] = {64, 32, 32, 16, 16, 8, 8, 8, 8, 4};
417
    static const uint8_t bit_sizes[LPC_ORDER] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};
418
    RA144Context *ractx;
419
    PutBitContext pb;
420
    int32_t lpc_data[NBLOCKS * BLOCKSIZE];
421
    int32_t lpc_coefs[LPC_ORDER][MAX_LPC_ORDER];
422
    int shift[LPC_ORDER];
423
    int16_t block_coefs[NBLOCKS][LPC_ORDER];
424
    int lpc_refl[LPC_ORDER];    /**< reflection coefficients of the frame */
425
    unsigned int refl_rms[NBLOCKS]; /**< RMS of the reflection coefficients */
426
    int energy = 0;
427
    int i, idx;
428

    
429
    if (buf_size < FRAMESIZE) {
430
        av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");
431
        return 0;
432
    }
433
    ractx = avctx->priv_data;
434

    
435
    /**
436
     * Since the LPC coefficients are calculated on a frame centered over the
437
     * fourth subframe, to encode a given frame, data from the next frame is
438
     * needed. In each call to this function, the previous frame (whose data are
439
     * saved in the encoder context) is encoded, and data from the current frame
440
     * are saved in the encoder context to be used in the next function call.
441
     */
442
    for (i = 0; i < (2 * BLOCKSIZE + BLOCKSIZE / 2); i++) {
443
        lpc_data[i] = ractx->curr_block[BLOCKSIZE + BLOCKSIZE / 2 + i];
444
        energy += (lpc_data[i] * lpc_data[i]) >> 4;
445
    }
446
    for (i = 2 * BLOCKSIZE + BLOCKSIZE / 2; i < NBLOCKS * BLOCKSIZE; i++) {
447
        lpc_data[i] = *((int16_t *)data + i - 2 * BLOCKSIZE - BLOCKSIZE / 2) >>
448
                      2;
449
        energy += (lpc_data[i] * lpc_data[i]) >> 4;
450
    }
451
    energy = ff_energy_tab[quantize(ff_t_sqrt(energy >> 5) >> 10, ff_energy_tab,
452
                                    32)];
453

    
454
    ff_lpc_calc_coefs(&ractx->dsp, lpc_data, NBLOCKS * BLOCKSIZE, LPC_ORDER,
455
                      LPC_ORDER, 16, lpc_coefs, shift, AV_LPC_TYPE_LEVINSON,
456
                      0, ORDER_METHOD_EST, 12, 0);
457
    for (i = 0; i < LPC_ORDER; i++)
458
        block_coefs[NBLOCKS - 1][i] = -(lpc_coefs[LPC_ORDER - 1][i] <<
459
                                        (12 - shift[LPC_ORDER - 1]));
460

    
461
    /**
462
     * TODO: apply perceptual weighting of the input speech through bandwidth
463
     * expansion of the LPC filter.
464
     */
465

    
466
    if (ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx)) {
467
        /**
468
         * The filter is unstable: use the coefficients of the previous frame.
469
         */
470
        ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[1]);
471
        ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx);
472
    }
473
    init_put_bits(&pb, frame, buf_size);
474
    for (i = 0; i < LPC_ORDER; i++) {
475
        idx = quantize(lpc_refl[i], ff_lpc_refl_cb[i], sizes[i]);
476
        put_bits(&pb, bit_sizes[i], idx);
477
        lpc_refl[i] = ff_lpc_refl_cb[i][idx];
478
    }
479
    ractx->lpc_refl_rms[0] = ff_rms(lpc_refl);
480
    ff_eval_coefs(ractx->lpc_coef[0], lpc_refl);
481
    refl_rms[0] = ff_interp(ractx, block_coefs[0], 1, 1, ractx->old_energy);
482
    refl_rms[1] = ff_interp(ractx, block_coefs[1], 2,
483
                            energy <= ractx->old_energy,
484
                            ff_t_sqrt(energy * ractx->old_energy) >> 12);
485
    refl_rms[2] = ff_interp(ractx, block_coefs[2], 3, 0, energy);
486
    refl_rms[3] = ff_rescale_rms(ractx->lpc_refl_rms[0], energy);
487
    ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[0]);
488
    put_bits(&pb, 5, quantize(energy, ff_energy_tab, 32));
489
    for (i = 0; i < NBLOCKS; i++)
490
        ra144_encode_subblock(ractx, ractx->curr_block + i * BLOCKSIZE,
491
                              block_coefs[i], refl_rms[i], &pb);
492
    flush_put_bits(&pb);
493
    ractx->old_energy = energy;
494
    ractx->lpc_refl_rms[1] = ractx->lpc_refl_rms[0];
495
    FFSWAP(unsigned int *, ractx->lpc_coef[0], ractx->lpc_coef[1]);
496
    for (i = 0; i < NBLOCKS * BLOCKSIZE; i++)
497
        ractx->curr_block[i] = *((int16_t *)data + i) >> 2;
498
    return FRAMESIZE;
499
}
500

    
501

    
502
AVCodec ra_144_encoder =
503
{
504
    "real_144",
505
    AVMEDIA_TYPE_AUDIO,
506
    CODEC_ID_RA_144,
507
    sizeof(RA144Context),
508
    ra144_encode_init,
509
    ra144_encode_frame,
510
    .long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K) encoder"),
511
};