g728dec.c

Go to the documentation of this file.

/*
 * G.728 decoder
 * Copyright (c) 2025 Peter Ross
 *
 * 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 "avcodec.h"
#include "celp_filters.h"
#include "codec_internal.h"
#include "decode.h"
#include "get_bits.h"
#include "g728data.h"
#include "lpc_functions.h"
#include "ra288.h"
#include "libavutil/float_dsp.h"
#include "libavutil/mem.h"
#include "libavutil/mem_internal.h"
#include "libavutil/opt.h"
#include "libavutil/thread.h"
 
#define MAX_BACKWARD_FILTER_ORDER  LPC
#define MAX_BACKWARD_FILTER_LEN    NFRSZ
#define MAX_BACKWARD_FILTER_NONREC NONR
#define ATTEN 0.75f
#include "g728_template.c"
 
#define LPCW 10 /* Perceptual weighting filter order */
#define GOFF 32.0f /* Log-gain offset value */
 
static float g728_gq_db[8];
static float g728_y_db[128];
static DECLARE_ALIGNED(32, float, g728_wnr_r)[FFALIGN(NSBSZ,16)];
static DECLARE_ALIGNED(32, float, g728_wnrg_r)[FFALIGN(NSBGSZ, 16)];
static DECLARE_ALIGNED(32, float, g728_facv_f)[FFALIGN(LPC, 16)];
 
static av_cold void g728_init_static_data(void)
{
    for(int i = 0; i < FF_ARRAY_ELEMS(amptable); i++)
        g728_gq_db[i] = 10.0f*log10f(amptable[i] * amptable[i]);
 
    for (int i = 0; i < FF_ARRAY_ELEMS(codetable); i++) {
        float cby[IDIM];
        for (int j = 0; j < IDIM; j++)
            cby[j] = codetable[i][j] * (1.0f/(1<<11));
        g728_y_db[i] = 10.0f*log10f(ff_scalarproduct_float_c(cby, cby, IDIM) / IDIM);
    }
 
    for (int i = 0; i < NSBSZ; i++)
        g728_wnr_r[i] = g728_wnr[NSBSZ - 1 - i] * (1.0f/(1<<15));
    for (int i = 0; i < NSBGSZ; i++)
        g728_wnrg_r[i] = g728_wnrg[NSBGSZ - 1 - i] * (1.0f/(1<<15));
    for (int i = 0; i < LPC; i++)
        g728_facv_f[i] = g728_facv[i] * (1.0f/(1<<14));
}
 
typedef struct {
    AVFloatDSPContext *fdsp;
    int valid;
    float a[LPC];
    DECLARE_ALIGNED(32, float, sb)[NSBSZ];
    DECLARE_ALIGNED(32, float, sbg)[NSBGSZ];
    DECLARE_ALIGNED(32, float, gp)[FFALIGN(LPCLG, 16)];
    DECLARE_ALIGNED(32, float, atmp)[FFALIGN(LPC, 16)];
    float rexp[LPC + 1];
    float rexpg[LPCLG + 1];
    float r[LPC + 1];
    float alpha;
} G728Context;
 
static av_cold int g728_decode_init(AVCodecContext *avctx)
{
    static AVOnce init_static_once = AV_ONCE_INIT;
    G728Context *s = avctx->priv_data;
 
    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
    if (!s->fdsp)
        return AVERROR(ENOMEM);
 
    s->gp[0] = -1.0f;
    for (int i = 0; i < NUPDATE; i++)
        s->sbg[NSBGSZ - 1 -i] = -GOFF;
 
    avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
    if (!avctx->sample_rate)
        avctx->sample_rate = 8000;
 
    av_channel_layout_uninit(&avctx->ch_layout);
    avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
 
    ff_thread_once(&init_static_once, g728_init_static_data);
    return 0;
}
 
static av_cold int g728_decode_close(AVCodecContext *avctx)
{
    G728Context *s = avctx->priv_data;
    av_freep(&s->fdsp);
    return 0;
}
 
static int hybrid_window(AVFloatDSPContext *fdsp,
                         int order, int n, int non_rec, float *out,
                         const float *hist, float *out2, const float *window)
{
    do_hybrid_window(fdsp->vector_fmul, order, n, non_rec, out, hist, out2, window);
    return out[order] != 0.0f;
}
 
static void decode_frame(G728Context *s, GetBitContext *gb, float *dst)
{
    float *gstate = s->sbg + NSBGSZ - 2;
 
    for (int idx = 0; idx < NUPDATE; idx++) {
        DECLARE_ALIGNED(32, float, et)[IDIM];
        float *statelpc = s->sb + NSBSZ - NFRSZ + idx*IDIM;
        float gain, gain_db;
        int is, ig;
 
        gain_db = 0.0f;
        for (int i = 0; i < LPCLG; i++)
            gain_db -= s->gp[i] * gstate[-i];
        gain_db = av_clipf(gain_db, -GOFF, 28.0f);
 
        is = get_bits(gb, 7); // shape index
        ig = get_bits(gb, 3); // gain index
 
        gain = powf(10.0f, (gain_db + GOFF) * .05f) * amptable[ig] * (1.0f/(1<<11));
        for (int i = 0; i < IDIM; i++)
            et[i] = codetable[is][i] * gain;
 
        ff_celp_lp_synthesis_filterf(statelpc, s->a, et, IDIM, LPC);
 
        for (int i = 0; i < IDIM; i++) {
            statelpc[i] = av_clipf(statelpc[i], -4095.0f, 4095.0f);
            dst[idx*IDIM + i] = statelpc[i] * (1.0f/(1<<12));
        }
 
        gstate++;
        *gstate = FFMAX(-GOFF, g728_gq_db[ig] + g728_y_db[is] + gain_db);
 
        if (idx == 0) {
            DECLARE_ALIGNED(32, float, gptmp)[FFALIGN(LPCLG, 16)];
            if (s->valid && (s->valid = !compute_lpc_coefs(s->r + 1, LPCW, LPC, s->atmp, 0, 0, 1, &s->alpha))) {
                s->fdsp->vector_fmul(s->atmp, s->atmp, g728_facv_f, FFALIGN(LPC, 16));
            }
            if (hybrid_window(s->fdsp, LPCLG, NUPDATE, NONRLG, s->r, s->sbg, s->rexpg, g728_wnrg_r) &&
                    !compute_lpc_coefs(s->r, 0, LPCLG, gptmp, 0, 0, 1, &s->alpha)) {
                s->fdsp->vector_fmul(s->gp, gptmp, gain_bw_tab, FFALIGN(LPCLG, 16));
            }
            memmove(s->sbg, s->sbg + NUPDATE, sizeof(float)*(LPCLG + NONRLG));
            gstate = s->sbg + NSBGSZ - 1 - NUPDATE;
        } else if (idx == 1) {
            if (s->valid)
                memcpy(s->a, s->atmp, sizeof(float)*LPC);
        }
    }
 
    s->valid = 0;
    if (hybrid_window(s->fdsp, LPC, NFRSZ, NONR, s->r, s->sb, s->rexp, g728_wnr_r)) {
        s->valid = !compute_lpc_coefs(s->r, 0, LPCW, s->atmp, 0, 0, 1, &s->alpha);
    }
 
    memmove(s->sb, s->sb + NFRSZ, sizeof(float)*(LPC + NONR));
}
 
static int g728_decode_frame(AVCodecContext *avctx, AVFrame *frame,
                            int *got_frame_ptr, AVPacket *avpkt)
{
    G728Context *s = avctx->priv_data;
    GetBitContext gb;
    int ret;
    int nb_frames = avpkt->size / 5;
 
    if (!nb_frames)
        return AVERROR_INVALIDDATA;
 
    if ((ret = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0)
        return ret;
 
#define SAMPLES_PER_FRAME 20
 
    frame->nb_samples = nb_frames * SAMPLES_PER_FRAME;
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
        return ret;
 
    for (int i = 0; i < nb_frames; i++)
        decode_frame(s, &gb, (float *)frame->data[0] + i * 20);
 
    *got_frame_ptr = 1;
 
    return nb_frames * 5;
}
 
const FFCodec ff_g728_decoder = {
    .p.name         = "g728",
    CODEC_LONG_NAME("G.728)"),
    .p.type         = AVMEDIA_TYPE_AUDIO,
    .p.id           = AV_CODEC_ID_G728,
    .priv_data_size = sizeof(G728Context),
    .init           = g728_decode_init,
    .close          = g728_decode_close,
    FF_CODEC_DECODE_CB(g728_decode_frame),
    .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
                      AV_CODEC_CAP_DR1,
};