Mercurial > libavcodec.hg
changeset 11870:6b1a63ea6e61 libavcodec
RealAudio 14.4k encoder.
Patch by Francesco Lavra (firstnamelastname@interfree.it)
| author | vitor |
|---|---|
| date | Fri, 11 Jun 2010 09:01:25 +0000 |
| parents | 7d12639b4b05 |
| children | 1fccba2858dd |
| files | Makefile allcodecs.c avcodec.h ra144.h ra144enc.c |
| diffstat | 5 files changed, 522 insertions(+), 3 deletions(-) [+] |
line wrap: on
line diff
--- a/Makefile Fri Jun 11 08:49:15 2010 +0000 +++ b/Makefile Fri Jun 11 09:01:25 2010 +0000 @@ -282,6 +282,7 @@ OBJS-$(CONFIG_QTRLE_ENCODER) += qtrleenc.o OBJS-$(CONFIG_R210_DECODER) += r210dec.o OBJS-$(CONFIG_RA_144_DECODER) += ra144dec.o ra144.o celp_filters.o +OBJS-$(CONFIG_RA_144_ENCODER) += ra144enc.o ra144.o celp_filters.o OBJS-$(CONFIG_RA_288_DECODER) += ra288.o celp_math.o celp_filters.o OBJS-$(CONFIG_RAWVIDEO_DECODER) += rawdec.o OBJS-$(CONFIG_RAWVIDEO_ENCODER) += rawenc.o
--- a/allcodecs.c Fri Jun 11 08:49:15 2010 +0000 +++ b/allcodecs.c Fri Jun 11 09:01:25 2010 +0000 @@ -247,7 +247,7 @@ REGISTER_ENCDEC (NELLYMOSER, nellymoser); REGISTER_DECODER (QCELP, qcelp); REGISTER_DECODER (QDM2, qdm2); - REGISTER_DECODER (RA_144, ra_144); + REGISTER_ENCDEC (RA_144, ra_144); REGISTER_DECODER (RA_288, ra_288); REGISTER_DECODER (SHORTEN, shorten); REGISTER_DECODER (SIPR, sipr);
--- a/avcodec.h Fri Jun 11 08:49:15 2010 +0000 +++ b/avcodec.h Fri Jun 11 09:01:25 2010 +0000 @@ -30,8 +30,8 @@ #include "libavutil/avutil.h" #define LIBAVCODEC_VERSION_MAJOR 52 -#define LIBAVCODEC_VERSION_MINOR 75 -#define LIBAVCODEC_VERSION_MICRO 1 +#define LIBAVCODEC_VERSION_MINOR 76 +#define LIBAVCODEC_VERSION_MICRO 0 #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ LIBAVCODEC_VERSION_MINOR, \
--- a/ra144.h Fri Jun 11 08:49:15 2010 +0000 +++ b/ra144.h Fri Jun 11 09:01:25 2010 +0000 @@ -23,13 +23,18 @@ #define AVCODEC_RA144_H #include <stdint.h> +#include "dsputil.h" #define NBLOCKS 4 ///< number of subblocks within a block #define BLOCKSIZE 40 ///< subblock size in 16-bit words #define BUFFERSIZE 146 ///< the size of the adaptive codebook +#define FIXED_CB_SIZE 128 ///< size of fixed codebooks +#define FRAMESIZE 20 ///< size of encoded frame +#define LPC_ORDER 10 ///< order of LPC filter typedef struct { AVCodecContext *avctx; + DSPContext dsp; unsigned int old_energy; ///< previous frame energy @@ -41,6 +46,8 @@ unsigned int lpc_refl_rms[2]; + int16_t curr_block[NBLOCKS * BLOCKSIZE]; + /** The current subblock padded by the last 10 values of the previous one. */ int16_t curr_sblock[50];
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ra144enc.c Fri Jun 11 09:01:25 2010 +0000 @@ -0,0 +1,511 @@ +/* + * Real Audio 1.0 (14.4K) encoder + * Copyright (c) 2010 Francesco Lavra <francescolavra@interfree.it> + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file libavcodec/ra144enc.c + * Real Audio 1.0 (14.4K) encoder + * @author Francesco Lavra <francescolavra@interfree.it> + */ + +#include <values.h> + +#include "avcodec.h" +#include "put_bits.h" +#include "lpc.h" +#include "celp_filters.h" +#include "ra144.h" + + +static av_cold int ra144_encode_init(AVCodecContext * avctx) +{ + RA144Context *ractx; + + if (avctx->sample_fmt != SAMPLE_FMT_S16) { + av_log(avctx, AV_LOG_ERROR, "invalid sample format\n"); + return -1; + } + if (avctx->channels != 1) { + av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n", + avctx->channels); + return -1; + } + avctx->frame_size = NBLOCKS * BLOCKSIZE; + avctx->bit_rate = 8000; + ractx = avctx->priv_data; + ractx->lpc_coef[0] = ractx->lpc_tables[0]; + ractx->lpc_coef[1] = ractx->lpc_tables[1]; + ractx->avctx = avctx; + dsputil_init(&ractx->dsp, avctx); + return 0; +} + + +/** + * Quantizes a value by searching a sorted table for the element with the + * nearest value + * + * @param value value to quantize + * @param table array containing the quantization table + * @param size size of the quantization table + * @return index of the quantization table corresponding to the element with the + * nearest value + */ +static int quantize(int value, const int16_t *table, unsigned int size) +{ + unsigned int low = 0, high = size - 1; + + while (1) { + int index = (low + high) >> 1; + int error = table[index] - value; + + if (index == low) + return table[high] + error > value ? low : high; + if (error > 0) { + high = index; + } else { + low = index; + } + } +} + + +/** + * Orthogonalizes a vector to another vector + * + * @param v vector to orthogonalize + * @param u vector against which orthogonalization is performed + */ +static void orthogonalize(float *v, const float *u) +{ + int i; + float num = 0, den = 0; + + for (i = 0; i < BLOCKSIZE; i++) { + num += v[i] * u[i]; + den += u[i] * u[i]; + } + num /= den; + for (i = 0; i < BLOCKSIZE; i++) + v[i] -= num * u[i]; +} + + +/** + * Calculates match score and gain of an LPC-filtered vector with respect to + * input data, possibly othogonalizing it to up to 2 other vectors + * + * @param work array used to calculate the filtered vector + * @param coefs coefficients of the LPC filter + * @param vect original vector + * @param ortho1 first vector against which orthogonalization is performed + * @param ortho2 second vector against which orthogonalization is performed + * @param data input data + * @param score pointer to variable where match score is returned + * @param gain pointer to variable where gain is returned + */ +static void get_match_score(float *work, const float *coefs, float *vect, + const float *ortho1, const float *ortho2, + const float *data, float *score, float *gain) +{ + float c, g; + int i; + + ff_celp_lp_synthesis_filterf(work, coefs, vect, BLOCKSIZE, LPC_ORDER); + if (ortho1) + orthogonalize(work, ortho1); + if (ortho2) + orthogonalize(work, ortho2); + c = g = 0; + for (i = 0; i < BLOCKSIZE; i++) { + g += work[i] * work[i]; + c += data[i] * work[i]; + } + if (c <= 0) { + *score = 0; + return; + } + *gain = c / g; + *score = *gain * c; +} + + +/** + * Creates a vector from the adaptive codebook at a given lag value + * + * @param vect array where vector is stored + * @param cb adaptive codebook + * @param lag lag value + */ +static void create_adapt_vect(float *vect, const int16_t *cb, int lag) +{ + int i; + + cb += BUFFERSIZE - lag; + for (i = 0; i < FFMIN(BLOCKSIZE, lag); i++) + vect[i] = cb[i]; + if (lag < BLOCKSIZE) + for (i = 0; i < BLOCKSIZE - lag; i++) + vect[lag + i] = cb[i]; +} + + +/** + * Searches the adaptive codebook for the best entry and gain and removes its + * contribution from input data + * + * @param adapt_cb array from which the adaptive codebook is extracted + * @param work array used to calculate LPC-filtered vectors + * @param coefs coefficients of the LPC filter + * @param data input data + * @return index of the best entry of the adaptive codebook + */ +static int adaptive_cb_search(const int16_t *adapt_cb, float *work, + const float *coefs, float *data) +{ + int i, best_vect; + float score, gain, best_score, best_gain; + float exc[BLOCKSIZE]; + + gain = best_score = 0; + for (i = BLOCKSIZE / 2; i <= BUFFERSIZE; i++) { + create_adapt_vect(exc, adapt_cb, i); + get_match_score(work, coefs, exc, NULL, NULL, data, &score, &gain); + if (score > best_score) { + best_score = score; + best_vect = i; + best_gain = gain; + } + } + if (!best_score) + return 0; + + /** + * Re-calculate the filtered vector from the vector with maximum match score + * and remove its contribution from input data. + */ + create_adapt_vect(exc, adapt_cb, best_vect); + ff_celp_lp_synthesis_filterf(work, coefs, exc, BLOCKSIZE, LPC_ORDER); + for (i = 0; i < BLOCKSIZE; i++) + data[i] -= best_gain * work[i]; + return (best_vect - BLOCKSIZE / 2 + 1); +} + + +/** + * Finds the best vector of a fixed codebook by applying an LPC filter to + * codebook entries, possibly othogonalizing them to up to 2 other vectors and + * matching the results with input data + * + * @param work array used to calculate the filtered vectors + * @param coefs coefficients of the LPC filter + * @param cb fixed codebook + * @param ortho1 first vector against which orthogonalization is performed + * @param ortho2 second vector against which orthogonalization is performed + * @param data input data + * @param idx pointer to variable where the index of the best codebook entry is + * returned + * @param gain pointer to variable where the gain of the best codebook entry is + * returned + */ +static void find_best_vect(float *work, const float *coefs, + const int8_t cb[][BLOCKSIZE], const float *ortho1, + const float *ortho2, float *data, int *idx, + float *gain) +{ + int i, j; + float g, score, best_score; + float vect[BLOCKSIZE]; + + *idx = *gain = best_score = 0; + for (i = 0; i < FIXED_CB_SIZE; i++) { + for (j = 0; j < BLOCKSIZE; j++) + vect[j] = cb[i][j]; + get_match_score(work, coefs, vect, ortho1, ortho2, data, &score, &g); + if (score > best_score) { + best_score = score; + *idx = i; + *gain = g; + } + } +} + + +/** + * Searches the two fixed codebooks for the best entry and gain + * + * @param work array used to calculate LPC-filtered vectors + * @param coefs coefficients of the LPC filter + * @param data input data + * @param cba_idx index of the best entry of the adaptive codebook + * @param cb1_idx pointer to variable where the index of the best entry of the + * first fixed codebook is returned + * @param cb2_idx pointer to variable where the index of the best entry of the + * second fixed codebook is returned + */ +static void fixed_cb_search(float *work, const float *coefs, float *data, + int cba_idx, int *cb1_idx, int *cb2_idx) +{ + int i, ortho_cb1; + float gain; + float cba_vect[BLOCKSIZE], cb1_vect[BLOCKSIZE]; + float vect[BLOCKSIZE]; + + /** + * The filtered vector from the adaptive codebook can be retrieved from + * work, because this function is called just after adaptive_cb_search(). + */ + if (cba_idx) + memcpy(cba_vect, work, sizeof(cba_vect)); + + find_best_vect(work, coefs, ff_cb1_vects, cba_idx ? cba_vect : NULL, NULL, + data, cb1_idx, &gain); + + /** + * Re-calculate the filtered vector from the vector with maximum match score + * and remove its contribution from input data. + */ + if (gain) { + for (i = 0; i < BLOCKSIZE; i++) + vect[i] = ff_cb1_vects[*cb1_idx][i]; + ff_celp_lp_synthesis_filterf(work, coefs, vect, BLOCKSIZE, LPC_ORDER); + if (cba_idx) + orthogonalize(work, cba_vect); + for (i = 0; i < BLOCKSIZE; i++) + data[i] -= gain * work[i]; + memcpy(cb1_vect, work, sizeof(cb1_vect)); + ortho_cb1 = 1; + } else + ortho_cb1 = 0; + + find_best_vect(work, coefs, ff_cb2_vects, cba_idx ? cba_vect : NULL, + ortho_cb1 ? cb1_vect : NULL, data, cb2_idx, &gain); +} + + +/** + * Encodes a subblock of the current frame + * + * @param ractx encoder context + * @param sblock_data input data of the subblock + * @param lpc_coefs coefficients of the LPC filter + * @param rms RMS of the reflection coefficients + * @param pb pointer to PutBitContext of the current frame + */ +static void ra144_encode_subblock(RA144Context *ractx, + const int16_t *sblock_data, + const int16_t *lpc_coefs, unsigned int rms, + PutBitContext *pb) +{ + float data[BLOCKSIZE], work[LPC_ORDER + BLOCKSIZE]; + float coefs[LPC_ORDER]; + float zero[BLOCKSIZE], cba[BLOCKSIZE], cb1[BLOCKSIZE], cb2[BLOCKSIZE]; + int16_t cba_vect[BLOCKSIZE]; + int cba_idx, cb1_idx, cb2_idx, gain; + int i, n, m[3]; + float g[3]; + float error, best_error; + + for (i = 0; i < LPC_ORDER; i++) { + work[i] = ractx->curr_sblock[BLOCKSIZE + i]; + coefs[i] = lpc_coefs[i] * (1/4096.0); + } + + /** + * Calculate the zero-input response of the LPC filter and subtract it from + * input data. + */ + memset(data, 0, sizeof(data)); + ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, data, BLOCKSIZE, + LPC_ORDER); + for (i = 0; i < BLOCKSIZE; i++) { + zero[i] = work[LPC_ORDER + i]; + data[i] = sblock_data[i] - zero[i]; + } + + /** + * Codebook search is performed without taking into account the contribution + * of the previous subblock, since it has been just subtracted from input + * data. + */ + memset(work, 0, LPC_ORDER * sizeof(*work)); + + cba_idx = adaptive_cb_search(ractx->adapt_cb, work + LPC_ORDER, coefs, + data); + if (cba_idx) { + /** + * The filtered vector from the adaptive codebook can be retrieved from + * work, see implementation of adaptive_cb_search(). + */ + memcpy(cba, work + LPC_ORDER, sizeof(cba)); + + ff_copy_and_dup(cba_vect, ractx->adapt_cb, cba_idx + BLOCKSIZE / 2 - 1); + m[0] = (ff_irms(cba_vect) * rms) >> 12; + } + fixed_cb_search(work + LPC_ORDER, coefs, data, cba_idx, &cb1_idx, &cb2_idx); + for (i = 0; i < BLOCKSIZE; i++) { + cb1[i] = ff_cb1_vects[cb1_idx][i]; + cb2[i] = ff_cb2_vects[cb2_idx][i]; + } + ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, cb1, BLOCKSIZE, + LPC_ORDER); + memcpy(cb1, work + LPC_ORDER, sizeof(cb1)); + m[1] = (ff_cb1_base[cb1_idx] * rms) >> 8; + ff_celp_lp_synthesis_filterf(work + LPC_ORDER, coefs, cb2, BLOCKSIZE, + LPC_ORDER); + memcpy(cb2, work + LPC_ORDER, sizeof(cb2)); + m[2] = (ff_cb2_base[cb2_idx] * rms) >> 8; + best_error = FLT_MAX; + gain = 0; + for (n = 0; n < 256; n++) { + g[1] = ((ff_gain_val_tab[n][1] * m[1]) >> ff_gain_exp_tab[n]) * + (1/4096.0); + g[2] = ((ff_gain_val_tab[n][2] * m[2]) >> ff_gain_exp_tab[n]) * + (1/4096.0); + error = 0; + if (cba_idx) { + g[0] = ((ff_gain_val_tab[n][0] * m[0]) >> ff_gain_exp_tab[n]) * + (1/4096.0); + for (i = 0; i < BLOCKSIZE; i++) { + data[i] = zero[i] + g[0] * cba[i] + g[1] * cb1[i] + + g[2] * cb2[i]; + error += (data[i] - sblock_data[i]) * + (data[i] - sblock_data[i]); + } + } else { + for (i = 0; i < BLOCKSIZE; i++) { + data[i] = zero[i] + g[1] * cb1[i] + g[2] * cb2[i]; + error += (data[i] - sblock_data[i]) * + (data[i] - sblock_data[i]); + } + } + if (error < best_error) { + best_error = error; + gain = n; + } + } + put_bits(pb, 7, cba_idx); + put_bits(pb, 8, gain); + put_bits(pb, 7, cb1_idx); + put_bits(pb, 7, cb2_idx); + ff_subblock_synthesis(ractx, lpc_coefs, cba_idx, cb1_idx, cb2_idx, rms, + gain); +} + + +static int ra144_encode_frame(AVCodecContext *avctx, uint8_t *frame, + int buf_size, void *data) +{ + static const uint8_t sizes[LPC_ORDER] = {64, 32, 32, 16, 16, 8, 8, 8, 8, 4}; + static const uint8_t bit_sizes[LPC_ORDER] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2}; + RA144Context *ractx; + PutBitContext pb; + int32_t lpc_data[NBLOCKS * BLOCKSIZE]; + int32_t lpc_coefs[LPC_ORDER][MAX_LPC_ORDER]; + int shift[LPC_ORDER]; + int16_t block_coefs[NBLOCKS][LPC_ORDER]; + int lpc_refl[LPC_ORDER]; /**< reflection coefficients of the frame */ + unsigned int refl_rms[NBLOCKS]; /**< RMS of the reflection coefficients */ + int energy = 0; + int i, idx; + + if (buf_size < FRAMESIZE) { + av_log(avctx, AV_LOG_ERROR, "output buffer too small\n"); + return 0; + } + ractx = avctx->priv_data; + + /** + * Since the LPC coefficients are calculated on a frame centered over the + * fourth subframe, to encode a given frame, data from the next frame is + * needed. In each call to this function, the previous frame (whose data are + * saved in the encoder context) is encoded, and data from the current frame + * are saved in the encoder context to be used in the next function call. + */ + for (i = 0; i < (2 * BLOCKSIZE + BLOCKSIZE / 2); i++) { + lpc_data[i] = ractx->curr_block[BLOCKSIZE + BLOCKSIZE / 2 + i]; + energy += (lpc_data[i] * lpc_data[i]) >> 4; + } + for (i = 2 * BLOCKSIZE + BLOCKSIZE / 2; i < NBLOCKS * BLOCKSIZE; i++) { + lpc_data[i] = *((int16_t *)data + i - 2 * BLOCKSIZE - BLOCKSIZE / 2) >> + 2; + energy += (lpc_data[i] * lpc_data[i]) >> 4; + } + energy = ff_energy_tab[quantize(ff_t_sqrt(energy >> 5) >> 10, ff_energy_tab, + 32)]; + + ff_lpc_calc_coefs(&ractx->dsp, lpc_data, NBLOCKS * BLOCKSIZE, LPC_ORDER, + LPC_ORDER, 16, lpc_coefs, shift, 1, ORDER_METHOD_EST, 12, + 0); + for (i = 0; i < LPC_ORDER; i++) + block_coefs[NBLOCKS - 1][i] = -(lpc_coefs[LPC_ORDER - 1][i] << + (12 - shift[LPC_ORDER - 1])); + + /** + * TODO: apply perceptual weighting of the input speech through bandwidth + * expansion of the LPC filter. + */ + + if (ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx)) { + /** + * The filter is unstable: use the coefficients of the previous frame. + */ + ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[1]); + ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx); + } + init_put_bits(&pb, frame, buf_size); + for (i = 0; i < LPC_ORDER; i++) { + idx = quantize(lpc_refl[i], ff_lpc_refl_cb[i], sizes[i]); + put_bits(&pb, bit_sizes[i], idx); + lpc_refl[i] = ff_lpc_refl_cb[i][idx]; + } + ractx->lpc_refl_rms[0] = ff_rms(lpc_refl); + ff_eval_coefs(ractx->lpc_coef[0], lpc_refl); + refl_rms[0] = ff_interp(ractx, block_coefs[0], 1, 1, ractx->old_energy); + refl_rms[1] = ff_interp(ractx, block_coefs[1], 2, + energy <= ractx->old_energy, + ff_t_sqrt(energy * ractx->old_energy) >> 12); + refl_rms[2] = ff_interp(ractx, block_coefs[2], 3, 0, energy); + refl_rms[3] = ff_rescale_rms(ractx->lpc_refl_rms[0], energy); + ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[0]); + put_bits(&pb, 5, quantize(energy, ff_energy_tab, 32)); + for (i = 0; i < NBLOCKS; i++) + ra144_encode_subblock(ractx, ractx->curr_block + i * BLOCKSIZE, + block_coefs[i], refl_rms[i], &pb); + flush_put_bits(&pb); + ractx->old_energy = energy; + ractx->lpc_refl_rms[1] = ractx->lpc_refl_rms[0]; + FFSWAP(unsigned int *, ractx->lpc_coef[0], ractx->lpc_coef[1]); + for (i = 0; i < NBLOCKS * BLOCKSIZE; i++) + ractx->curr_block[i] = *((int16_t *)data + i) >> 2; + return FRAMESIZE; +} + + +AVCodec ra_144_encoder = +{ + "real_144", + CODEC_TYPE_AUDIO, + CODEC_ID_RA_144, + sizeof(RA144Context), + ra144_encode_init, + ra144_encode_frame, + .long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K) encoder"), +};