[deb_ffmpeg.git] / ffmpeg / libavcodec / ra288.c

/*
 * RealAudio 2.0 (28.8K)
 * Copyright (c) 2003 The FFmpeg Project
 *
 * 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
 */

#include "libavutil/channel_layout.h"
#include "libavutil/float_dsp.h"
#include "libavutil/internal.h"
#include "avcodec.h"
#include "internal.h"
#define BITSTREAM_READER_LE
#include "get_bits.h"
#include "ra288.h"
#include "lpc.h"
#include "celp_filters.h"

#define MAX_BACKWARD_FILTER_ORDER  36
#define MAX_BACKWARD_FILTER_LEN    40
#define MAX_BACKWARD_FILTER_NONREC 35

#define RA288_BLOCK_SIZE        5
#define RA288_BLOCKS_PER_FRAME 32

typedef struct {
    AVFloatDSPContext *fdsp;
    DECLARE_ALIGNED(32, float,   sp_lpc)[FFALIGN(36, 16)];   ///< LPC coefficients for speech data (spec: A)
    DECLARE_ALIGNED(32, float, gain_lpc)[FFALIGN(10, 16)];   ///< LPC coefficients for gain        (spec: GB)

    /** speech data history                                      (spec: SB).
     *  Its first 70 coefficients are updated only at backward filtering.
     */
    float sp_hist[111];

    /// speech part of the gain autocorrelation                  (spec: REXP)
    float sp_rec[37];

    /** log-gain history                                         (spec: SBLG).
     *  Its first 28 coefficients are updated only at backward filtering.
     */
    float gain_hist[38];

    /// recursive part of the gain autocorrelation               (spec: REXPLG)
    float gain_rec[11];
} RA288Context;

static av_cold int ra288_decode_close(AVCodecContext *avctx)
{
    RA288Context *ractx = avctx->priv_data;

    av_freep(&ractx->fdsp);

    return 0;
}

static av_cold int ra288_decode_init(AVCodecContext *avctx)
{
    RA288Context *ractx = avctx->priv_data;

    avctx->channels       = 1;
    avctx->channel_layout = AV_CH_LAYOUT_MONO;
    avctx->sample_fmt     = AV_SAMPLE_FMT_FLT;

    if (avctx->block_align <= 0) {
        av_log(avctx, AV_LOG_ERROR, "unsupported block align\n");
        return AVERROR_PATCHWELCOME;
    }

    ractx->fdsp = avpriv_float_dsp_alloc(avctx->flags & CODEC_FLAG_BITEXACT);
    if (!ractx->fdsp)
        return AVERROR(ENOMEM);

    return 0;
}

static void convolve(float *tgt, const float *src, int len, int n)
{
    for (; n >= 0; n--)
        tgt[n] = avpriv_scalarproduct_float_c(src, src - n, len);

}

static void decode(RA288Context *ractx, float gain, int cb_coef)
{
    int i;
    double sumsum;
    float sum, buffer[5];
    float *block = ractx->sp_hist + 70 + 36; // current block
    float *gain_block = ractx->gain_hist + 28;

    memmove(ractx->sp_hist + 70, ractx->sp_hist + 75, 36*sizeof(*block));

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

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

    /* block 48 of G.728 spec */
    /* exp(sum * 0.1151292546497) == pow(10.0,sum/20) */
    sumsum = exp(sum * 0.1151292546497) * gain * (1.0/(1<<23));

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

    sum = avpriv_scalarproduct_float_c(buffer, buffer, 5);

    sum = FFMAX(sum, 5.0 / (1<<24));

    /* shift and store */
    memmove(gain_block, gain_block + 1, 9 * sizeof(*gain_block));

    gain_block[9] = 10 * log10(sum) + (10*log10(((1<<24)/5.)) - 32);

    ff_celp_lp_synthesis_filterf(block, ractx->sp_lpc, buffer, 5, 36);
}

/**
 * Hybrid window filtering, see blocks 36 and 49 of the G.728 specification.
 *
 * @param order   filter order
 * @param n       input length
 * @param non_rec number of non-recursive samples
 * @param out     filter output
 * @param hist    pointer to the input history of the filter
 * @param out     pointer to the non-recursive part of the output
 * @param out2    pointer to the recursive part of the output
 * @param window  pointer to the windowing function table
 */
static void do_hybrid_window(RA288Context *ractx,
                             int order, int n, int non_rec, float *out,
                             float *hist, float *out2, const float *window)
{
    int i;
    float buffer1[MAX_BACKWARD_FILTER_ORDER + 1];
    float buffer2[MAX_BACKWARD_FILTER_ORDER + 1];
    LOCAL_ALIGNED(32, float, work, [FFALIGN(MAX_BACKWARD_FILTER_ORDER +
                                            MAX_BACKWARD_FILTER_LEN   +
                                            MAX_BACKWARD_FILTER_NONREC, 16)]);

    av_assert2(order>=0);

    ractx->fdsp->vector_fmul(work, window, hist, FFALIGN(order + n + non_rec, 16));

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

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

    /* Multiply by the white noise correcting factor (WNCF). */
    *out *= 257.0 / 256.0;
}

/**
 * Backward synthesis filter, find the LPC coefficients from past speech data.
 */
static void backward_filter(RA288Context *ractx,
                            float *hist, float *rec, const float *window,
                            float *lpc, const float *tab,
                            int order, int n, int non_rec, int move_size)
{
    float temp[MAX_BACKWARD_FILTER_ORDER+1];

    do_hybrid_window(ractx, order, n, non_rec, temp, hist, rec, window);

    if (!compute_lpc_coefs(temp, order, lpc, 0, 1, 1))
        ractx->fdsp->vector_fmul(lpc, lpc, tab, FFALIGN(order, 16));

    memmove(hist, hist + n, move_size*sizeof(*hist));
}

static int ra288_decode_frame(AVCodecContext * avctx, void *data,
                              int *got_frame_ptr, AVPacket *avpkt)
{
    AVFrame *frame     = data;
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
    float *out;
    int i, ret;
    RA288Context *ractx = avctx->priv_data;
    GetBitContext gb;

    if (buf_size < avctx->block_align) {
        av_log(avctx, AV_LOG_ERROR,
               "Error! Input buffer is too small [%d<%d]\n",
               buf_size, avctx->block_align);
        return AVERROR_INVALIDDATA;
    }

    /* get output buffer */
    frame->nb_samples = RA288_BLOCK_SIZE * RA288_BLOCKS_PER_FRAME;
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
        return ret;
    out = (float *)frame->data[0];

    init_get_bits8(&gb, buf, avctx->block_align);

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

        decode(ractx, gain, cb_coef);

        memcpy(out, &ractx->sp_hist[70 + 36], RA288_BLOCK_SIZE * sizeof(*out));
        out += RA288_BLOCK_SIZE;

        if ((i & 7) == 3) {
            backward_filter(ractx, ractx->sp_hist, ractx->sp_rec, syn_window,
                            ractx->sp_lpc, syn_bw_tab, 36, 40, 35, 70);

            backward_filter(ractx, ractx->gain_hist, ractx->gain_rec, gain_window,
                            ractx->gain_lpc, gain_bw_tab, 10, 8, 20, 28);
        }
    }

    *got_frame_ptr = 1;

    return avctx->block_align;
}

AVCodec ff_ra_288_decoder = {
    .name           = "real_288",
    .long_name      = NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_RA_288,
    .priv_data_size = sizeof(RA288Context),
    .init           = ra288_decode_init,
    .decode         = ra288_decode_frame,
    .close          = ra288_decode_close,
    .capabilities   = CODEC_CAP_DR1,
};
Commit	Line	Data
2ba45a60 DM	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 "libavutil/channel_layout.h"
	23	#include "libavutil/float_dsp.h"
	24	#include "libavutil/internal.h"
	25	#include "avcodec.h"
	26	#include "internal.h"
	27	#define BITSTREAM_READER_LE
	28	#include "get_bits.h"
	29	#include "ra288.h"
	30	#include "lpc.h"
	31	#include "celp_filters.h"
	32
	33	#define MAX_BACKWARD_FILTER_ORDER 36
	34	#define MAX_BACKWARD_FILTER_LEN 40
	35	#define MAX_BACKWARD_FILTER_NONREC 35
	36
	37	#define RA288_BLOCK_SIZE 5
	38	#define RA288_BLOCKS_PER_FRAME 32
	39
	40	typedef struct {
f6fa7814	41	AVFloatDSPContext *fdsp;
2ba45a60 DM	42	DECLARE_ALIGNED(32, float, sp_lpc)[FFALIGN(36, 16)]; ///< LPC coefficients for speech data (spec: A)
	43	DECLARE_ALIGNED(32, float, gain_lpc)[FFALIGN(10, 16)]; ///< LPC coefficients for gain (spec: GB)
	44
	45	/** speech data history (spec: SB).
	46	* Its first 70 coefficients are updated only at backward filtering.
	47	*/
	48	float sp_hist[111];
	49
	50	/// speech part of the gain autocorrelation (spec: REXP)
	51	float sp_rec[37];
	52
	53	/** log-gain history (spec: SBLG).
	54	* Its first 28 coefficients are updated only at backward filtering.
	55	*/
	56	float gain_hist[38];
	57
	58	/// recursive part of the gain autocorrelation (spec: REXPLG)
	59	float gain_rec[11];
	60	} RA288Context;
	61
f6fa7814 DM	62	static av_cold int ra288_decode_close(AVCodecContext *avctx)
	63	{
	64	RA288Context *ractx = avctx->priv_data;
	65
	66	av_freep(&ractx->fdsp);
	67
	68	return 0;
	69	}
	70
2ba45a60 DM	71	static av_cold int ra288_decode_init(AVCodecContext *avctx)
	72	{
	73	RA288Context *ractx = avctx->priv_data;
	74
	75	avctx->channels = 1;
	76	avctx->channel_layout = AV_CH_LAYOUT_MONO;
	77	avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
	78
	79	if (avctx->block_align <= 0) {
	80	av_log(avctx, AV_LOG_ERROR, "unsupported block align\n");
	81	return AVERROR_PATCHWELCOME;
	82	}
	83
f6fa7814 DM	84	ractx->fdsp = avpriv_float_dsp_alloc(avctx->flags & CODEC_FLAG_BITEXACT);
	85	if (!ractx->fdsp)
	86	return AVERROR(ENOMEM);
2ba45a60 DM	87
	88	return 0;
	89	}
	90
	91	static void convolve(float tgt, const float src, int len, int n)
	92	{
	93	for (; n >= 0; n--)
	94	tgt[n] = avpriv_scalarproduct_float_c(src, src - n, len);
	95
	96	}
	97
	98	static void decode(RA288Context *ractx, float gain, int cb_coef)
	99	{
	100	int i;
	101	double sumsum;
	102	float sum, buffer[5];
	103	float *block = ractx->sp_hist + 70 + 36; // current block
	104	float *gain_block = ractx->gain_hist + 28;
	105
	106	memmove(ractx->sp_hist + 70, ractx->sp_hist + 75, 36sizeof(block));
	107
	108	/* block 46 of G.728 spec */
	109	sum = 32.0;
	110	for (i=0; i < 10; i++)
	111	sum -= gain_block[9-i] * ractx->gain_lpc[i];
	112
	113	/* block 47 of G.728 spec */
	114	sum = av_clipf(sum, 0, 60);
	115
	116	/* block 48 of G.728 spec */
	117	/* exp(sum * 0.1151292546497) == pow(10.0,sum/20) */
	118	sumsum = exp(sum * 0.1151292546497) * gain * (1.0/(1<<23));
	119
	120	for (i=0; i < 5; i++)
	121	buffer[i] = codetable[cb_coef][i] * sumsum;
	122
	123	sum = avpriv_scalarproduct_float_c(buffer, buffer, 5);
	124
	125	sum = FFMAX(sum, 5.0 / (1<<24));
	126
	127	/* shift and store */
	128	memmove(gain_block, gain_block + 1, 9 * sizeof(*gain_block));
	129
	130	gain_block[9] = 10 * log10(sum) + (10*log10(((1<<24)/5.)) - 32);
	131
	132	ff_celp_lp_synthesis_filterf(block, ractx->sp_lpc, buffer, 5, 36);
	133	}
	134
	135	/**
	136	* Hybrid window filtering, see blocks 36 and 49 of the G.728 specification.
	137	*
	138	* @param order filter order
	139	* @param n input length
	140	* @param non_rec number of non-recursive samples
	141	* @param out filter output
	142	* @param hist pointer to the input history of the filter
	143	* @param out pointer to the non-recursive part of the output
	144	* @param out2 pointer to the recursive part of the output
	145	* @param window pointer to the windowing function table
	146	*/
	147	static void do_hybrid_window(RA288Context *ractx,
	148	int order, int n, int non_rec, float *out,
	149	float hist, float out2, const float *window)
	150	{
151	int i;
152	float buffer1[MAX_BACKWARD_FILTER_ORDER + 1];
153	float buffer2[MAX_BACKWARD_FILTER_ORDER + 1];
154	LOCAL_ALIGNED(32, float, work, [FFALIGN(MAX_BACKWARD_FILTER_ORDER +
155	MAX_BACKWARD_FILTER_LEN +
156	MAX_BACKWARD_FILTER_NONREC, 16)]);
157
158	av_assert2(order>=0);
159
f6fa7814	160	ractx->fdsp->vector_fmul(work, window, hist, FFALIGN(order + n + non_rec, 16));
2ba45a60 DM	161
	162	convolve(buffer1, work + order , n , order);
	163	convolve(buffer2, work + order + n, non_rec, order);
	164
	165	for (i=0; i <= order; i++) {
	166	out2[i] = out2[i] * 0.5625 + buffer1[i];
	167	out [i] = out2[i] + buffer2[i];
	168	}
	169
	170	/* Multiply by the white noise correcting factor (WNCF). */
	171	out = 257.0 / 256.0;
	172	}
	173
	174	/**
	175	* Backward synthesis filter, find the LPC coefficients from past speech data.
	176	*/
	177	static void backward_filter(RA288Context *ractx,
	178	float hist, float rec, const float *window,
	179	float lpc, const float tab,
	180	int order, int n, int non_rec, int move_size)
	181	{
	182	float temp[MAX_BACKWARD_FILTER_ORDER+1];
	183
	184	do_hybrid_window(ractx, order, n, non_rec, temp, hist, rec, window);
	185
	186	if (!compute_lpc_coefs(temp, order, lpc, 0, 1, 1))
f6fa7814	187	ractx->fdsp->vector_fmul(lpc, lpc, tab, FFALIGN(order, 16));
2ba45a60 DM	188
	189	memmove(hist, hist + n, move_sizesizeof(hist));
	190	}
	191
	192	static int ra288_decode_frame(AVCodecContext * avctx, void *data,
	193	int got_frame_ptr, AVPacket avpkt)
	194	{
	195	AVFrame *frame = data;
	196	const uint8_t *buf = avpkt->data;
	197	int buf_size = avpkt->size;
	198	float *out;
	199	int i, ret;
	200	RA288Context *ractx = avctx->priv_data;
	201	GetBitContext gb;
	202
	203	if (buf_size < avctx->block_align) {
	204	av_log(avctx, AV_LOG_ERROR,
	205	"Error! Input buffer is too small [%d<%d]\n",
	206	buf_size, avctx->block_align);
	207	return AVERROR_INVALIDDATA;
	208	}
	209
	210	/* get output buffer */
	211	frame->nb_samples = RA288_BLOCK_SIZE * RA288_BLOCKS_PER_FRAME;
	212	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
	213	return ret;
	214	out = (float *)frame->data[0];
	215
	216	init_get_bits8(&gb, buf, avctx->block_align);
	217
	218	for (i=0; i < RA288_BLOCKS_PER_FRAME; i++) {
	219	float gain = amptable[get_bits(&gb, 3)];
	220	int cb_coef = get_bits(&gb, 6 + (i&1));
	221
	222	decode(ractx, gain, cb_coef);
	223
	224	memcpy(out, &ractx->sp_hist[70 + 36], RA288_BLOCK_SIZE * sizeof(*out));
	225	out += RA288_BLOCK_SIZE;
	226
	227	if ((i & 7) == 3) {
	228	backward_filter(ractx, ractx->sp_hist, ractx->sp_rec, syn_window,
	229	ractx->sp_lpc, syn_bw_tab, 36, 40, 35, 70);
	230
	231	backward_filter(ractx, ractx->gain_hist, ractx->gain_rec, gain_window,
	232	ractx->gain_lpc, gain_bw_tab, 10, 8, 20, 28);
	233	}
	234	}
	235
	236	*got_frame_ptr = 1;
	237
	238	return avctx->block_align;
	239	}
	240
	241	AVCodec ff_ra_288_decoder = {
	242	.name = "real_288",
	243	.long_name = NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),
	244	.type = AVMEDIA_TYPE_AUDIO,
	245	.id = AV_CODEC_ID_RA_288,
	246	.priv_data_size = sizeof(RA288Context),
	247	.init = ra288_decode_init,
	248	.decode = ra288_decode_frame,
f6fa7814	249	.close = ra288_decode_close,
2ba45a60 DM	250	.capabilities = CODEC_CAP_DR1,
2ba45a60 DM	251	};