@@ -161,6 +161,7 @@ OBJS-$(CONFIG_FRAPS_DECODER)           += fraps.o

 OBJS-$(CONFIG_FRWU_DECODER)            += frwu.o

 OBJS-$(CONFIG_G723_1_DECODER)          += g723_1.o acelp_vectors.o \

                                           celp_filters.o celp_math.o

+OBJS-$(CONFIG_G723_1_ENCODER)          += g723_1.o

 OBJS-$(CONFIG_G729_DECODER)            += g729dec.o lsp.o celp_math.o acelp_filters.o acelp_pitch_delay.o acelp_vectors.o g729postfilter.o

 OBJS-$(CONFIG_GIF_DECODER)             += gifdec.o lzw.o

 OBJS-$(CONFIG_GIF_ENCODER)             += gif.o lzwenc.o

@@ -258,7 +258,7 @@ void avcodec_register_all(void)

     REGISTER_DECODER (DSICINAUDIO, dsicinaudio);

     REGISTER_ENCDEC  (EAC3, eac3);

     REGISTER_ENCDEC  (FLAC, flac);

-    REGISTER_DECODER (G723_1, g723_1);

+    REGISTER_ENCDEC  (G723_1, g723_1);

     REGISTER_DECODER (G729, g729);

     REGISTER_DECODER (GSM, gsm);

     REGISTER_DECODER (GSM_MS, gsm_ms);

@@ -59,6 +59,17 @@ typedef struct g723_1_context {

     int reflection_coef;

     int pf_gain;                 ///< formant postfilter

                                  ///< gain scaling unit memory

+

+    int16_t prev_data[HALF_FRAME_LEN];

+    int16_t prev_weight_sig[PITCH_MAX];

+

+

+    int16_t hpf_fir_mem;                   ///< highpass filter fir

+    int     hpf_iir_mem;                   ///< and iir memories

+    int16_t perf_fir_mem[LPC_ORDER];       ///< perceptual filter fir

+    int16_t perf_iir_mem[LPC_ORDER];       ///< and iir memories

+

+    int16_t harmonic_mem[PITCH_MAX];

 } G723_1_Context;

 static av_cold int g723_1_decode_init(AVCodecContext *avctx)

@@ -221,6 +232,10 @@ static int normalize_bits(int num, int width)

     return i;

 }

+#define normalize_bits_int16(num) normalize_bits(num, 0)

+#define normalize_bits_int32(num) normalize_bits(num, 1)

+#define dot_product(a,b,c,d) (ff_dot_product(a,b,c)<<(d))

+

 /**

  * Scale vector contents based on the largest of their absolutes.

  */

@@ -1068,3 +1083,1134 @@ AVCodec ff_g723_1_decoder = {

     .long_name      = NULL_IF_CONFIG_SMALL("G.723.1"),

     .capabilities   = CODEC_CAP_SUBFRAMES,

 };

+

+#if CONFIG_G723_1_ENCODER

+#define BITSTREAM_WRITER_LE

+#include "put_bits.h"

+

+static av_cold int g723_1_encode_init(AVCodecContext *avctx)

+{

+    G723_1_Context *p = avctx->priv_data;

+

+    if (avctx->sample_rate != 8000) {

+        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");

+        return -1;

+    }

+

+    if (avctx->channels != 1) {

+        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");

+        return AVERROR(EINVAL);

+    }

+

+    if (avctx->bit_rate == 6300) {

+        p->cur_rate = Rate6k3;

+    } else if (avctx->bit_rate == 5300) {

+        av_log(avctx, AV_LOG_ERROR, "Bitrate not supported yet, use 6.3k\n");

+        return AVERROR_PATCHWELCOME;

+    } else {

+        av_log(avctx, AV_LOG_ERROR,

+               "Bitrate not supported, use 6.3k\n");

+        return AVERROR(EINVAL);

+    }

+    avctx->frame_size = 240;

+    memcpy(p->prev_lsp, dc_lsp, LPC_ORDER * sizeof(int16_t));

+

+    return 0;

+}

+

+/**

+ * Remove DC component from the input signal.

+ *

+ * @param buf input signal

+ * @param fir zero memory

+ * @param iir pole memory

+ */

+static void highpass_filter(int16_t *buf, int16_t *fir, int *iir)

+{

+    int i;

+    for (i = 0; i < FRAME_LEN; i++) {

+        *iir   = (buf[i] << 15) + ((-*fir) << 15) + MULL2(*iir, 0x7f00);

+        *fir   = buf[i];

+        buf[i] = av_clipl_int32((int64_t)*iir + (1 << 15)) >> 16;

+    }

+}

+

+/**

+ * Estimate autocorrelation of the input vector.

+ *

+ * @param buf      input buffer

+ * @param autocorr autocorrelation coefficients vector

+ */

+static void comp_autocorr(int16_t *buf, int16_t *autocorr)

+{

+    int i, scale, temp;

+    int16_t vector[LPC_FRAME];

+

+    memcpy(vector, buf, LPC_FRAME * sizeof(int16_t));

+    scale_vector(vector, LPC_FRAME);

+

+    /* Apply the Hamming window */

+    for (i = 0; i < LPC_FRAME; i++)

+        vector[i] = (vector[i] * hamming_window[i] + (1 << 14)) >> 15;

+

+    /* Compute the first autocorrelation coefficient */

+    temp = dot_product(vector, vector, LPC_FRAME, 0);

+

+    /* Apply a white noise correlation factor of (1025/1024) */

+    temp += temp >> 10;

+

+    /* Normalize */

+    scale = normalize_bits_int32(temp);

+    autocorr[0] = av_clipl_int32((int64_t)(temp << scale) +

+                                 (1 << 15)) >> 16;

+

+    /* Compute the remaining coefficients */

+    if (!autocorr[0]) {

+        memset(autocorr + 1, 0, LPC_ORDER * sizeof(int16_t));

+    } else {

+        for (i = 1; i <= LPC_ORDER; i++) {

+           temp = dot_product(vector, vector + i, LPC_FRAME - i, 0);

+           temp = MULL2((temp << scale), binomial_window[i - 1]);

+           autocorr[i] = av_clipl_int32((int64_t)temp + (1 << 15)) >> 16;

+        }

+    }

+}

+

+/**

+ * Use Levinson-Durbin recursion to compute LPC coefficients from

+ * autocorrelation values.

+ *

+ * @param lpc      LPC coefficients vector

+ * @param autocorr autocorrelation coefficients vector

+ * @param error    prediction error

+ */

+static void levinson_durbin(int16_t *lpc, int16_t *autocorr, int16_t error)

+{

+    int16_t vector[LPC_ORDER];

+    int16_t partial_corr;

+    int i, j, temp;

+

+    memset(lpc, 0, LPC_ORDER * sizeof(int16_t));

+

+    for (i = 0; i < LPC_ORDER; i++) {

+        /* Compute the partial correlation coefficient */

+        temp = 0;

+        for (j = 0; j < i; j++)

+            temp -= lpc[j] * autocorr[i - j - 1];

+        temp = ((autocorr[i] << 13) + temp) << 3;

+

+        if (FFABS(temp) >= (error << 16))

+            break;

+

+        partial_corr = temp / (error << 1);

+

+        lpc[i] = av_clipl_int32((int64_t)(partial_corr << 14) +

+                                (1 << 15)) >> 16;

+

+        /* Update the prediction error */

+        temp  = MULL2(temp, partial_corr);

+        error = av_clipl_int32((int64_t)(error << 16) - temp +

+                                (1 << 15)) >> 16;

+

+        memcpy(vector, lpc, i * sizeof(int16_t));

+        for (j = 0; j < i; j++) {

+            temp = partial_corr * vector[i - j - 1] << 1;

+            lpc[j] = av_clipl_int32((int64_t)(lpc[j] << 16) - temp +

+                                    (1 << 15)) >> 16;

+        }

+    }

+}

+

+/**

+ * Calculate LPC coefficients for the current frame.

+ *

+ * @param buf       current frame

+ * @param prev_data 2 trailing subframes of the previous frame

+ * @param lpc       LPC coefficients vector

+ */

+static void comp_lpc_coeff(int16_t *buf, int16_t *lpc)

+{

+    int16_t autocorr[(LPC_ORDER + 1) * SUBFRAMES];

+    int16_t *autocorr_ptr = autocorr;

+    int16_t *lpc_ptr      = lpc;

+    int i, j;

+

+    for (i = 0, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++) {

+        comp_autocorr(buf + i, autocorr_ptr);

+        levinson_durbin(lpc_ptr, autocorr_ptr + 1, autocorr_ptr[0]);

+

+        lpc_ptr += LPC_ORDER;

+        autocorr_ptr += LPC_ORDER + 1;

+    }

+}

+

+static void lpc2lsp(int16_t *lpc, int16_t *prev_lsp, int16_t *lsp)

+{

+    int f[LPC_ORDER + 2]; ///< coefficients of the sum and difference

+                          ///< polynomials (F1, F2) ordered as

+                          ///< f1[0], f2[0], ...., f1[5], f2[5]

+

+    int max, shift, cur_val, prev_val, count, p;

+    int i, j;

+    int64_t temp;

+

+    /* Initialize f1[0] and f2[0] to 1 in Q25 */

+    for (i = 0; i < LPC_ORDER; i++)

+        lsp[i] = (lpc[i] * bandwidth_expand[i] + (1 << 14)) >> 15;

+

+    /* Apply bandwidth expansion on the LPC coefficients */

+    f[0] = f[1] = 1 << 25;

+

+    /* Compute the remaining coefficients */

+    for (i = 0; i < LPC_ORDER / 2; i++) {

+        /* f1 */

+        f[2 * i + 2] = -f[2 * i] - ((lsp[i] + lsp[LPC_ORDER - 1 - i]) << 12);

+        /* f2 */

+        f[2 * i + 3] = f[2 * i + 1] - ((lsp[i] - lsp[LPC_ORDER - 1 - i]) << 12);

+    }

+

+    /* Divide f1[5] and f2[5] by 2 for use in polynomial evaluation */

+    f[LPC_ORDER] >>= 1;

+    f[LPC_ORDER + 1] >>= 1;

+

+    /* Normalize and shorten */

+    max = FFABS(f[0]);

+    for (i = 1; i < LPC_ORDER + 2; i++)

+        max = FFMAX(max, FFABS(f[i]));

+

+    shift = normalize_bits_int32(max);

+

+    for (i = 0; i < LPC_ORDER + 2; i++)

+        f[i] = av_clipl_int32((int64_t)(f[i] << shift) + (1 << 15)) >> 16;

+

+    /**

+     * Evaluate F1 and F2 at uniform intervals of pi/256 along the

+     * unit circle and check for zero crossings.

+     */

+    p    = 0;

+    temp = 0;

+    for (i = 0; i <= LPC_ORDER / 2; i++)

+        temp += f[2 * i] * cos_tab[0];

+    prev_val = av_clipl_int32(temp << 1);

+    count    = 0;

+    for ( i = 1; i < COS_TBL_SIZE / 2; i++) {

+        /* Evaluate */

+        temp = 0;

+        for (j = 0; j <= LPC_ORDER / 2; j++)

+            temp += f[LPC_ORDER - 2 * j + p] * cos_tab[i * j % COS_TBL_SIZE];

+        cur_val = av_clipl_int32(temp << 1);

+

+        /* Check for sign change, indicating a zero crossing */

+        if ((cur_val ^ prev_val) < 0) {

+            int abs_cur  = FFABS(cur_val);

+            int abs_prev = FFABS(prev_val);

+            int sum      = abs_cur + abs_prev;

+

+            shift        = normalize_bits_int32(sum);

+            sum          <<= shift;

+            abs_prev     = abs_prev << shift >> 8;

+            lsp[count++] = ((i - 1) << 7) + (abs_prev >> 1) / (sum >> 16);

+

+            if (count == LPC_ORDER)

+                break;

+

+            /* Switch between sum and difference polynomials */

+            p ^= 1;

+

+            /* Evaluate */

+            temp = 0;

+            for (j = 0; j <= LPC_ORDER / 2; j++){

+                temp += f[LPC_ORDER - 2 * j + p] *

+                        cos_tab[i * j % COS_TBL_SIZE];

+            }

+            cur_val = av_clipl_int32(temp<<1);

+        }

+        prev_val = cur_val;

+    }

+

+    if (count != LPC_ORDER)

+        memcpy(lsp, prev_lsp, LPC_ORDER * sizeof(int16_t));

+}

+

+/**

+ * Quantize the current LSP subvector.

+ *

+ * @param num    band number

+ * @param offset offset of the current subvector in an LPC_ORDER vector

+ * @param size   size of the current subvector

+ */

+#define get_index(num, offset, size) \

+{\

+    int error, max = -1;\

+    int16_t temp[4];\

+    int i, j;\

+    for (i = 0; i < LSP_CB_SIZE; i++) {\

+        for (j = 0; j < size; j++){\

+            temp[j] = (weight[j + (offset)] * lsp_band##num[i][j] +\

+                      (1 << 14)) >> 15;\

+        }\

+        error =  dot_product(lsp + (offset), temp, size, 1) << 1;\

+        error -= dot_product(lsp_band##num[i], temp, size, 1);\

+        if (error > max) {\

+            max = error;\

+            lsp_index[num] = i;\

+        }\

+    }\

+}

+

+/**

+ * Vector quantize the LSP frequencies.

+ *

+ * @param lsp      the current lsp vector

+ * @param prev_lsp the previous lsp vector

+ */

+static void lsp_quantize(uint8_t *lsp_index, int16_t *lsp, int16_t *prev_lsp)

+{

+    int16_t weight[LPC_ORDER];

+    int16_t min, max;

+    int shift, i;

+

+    /* Calculate the VQ weighting vector */

+    weight[0] = (1 << 20) / (lsp[1] - lsp[0]);

+    weight[LPC_ORDER - 1] = (1 << 20) /

+                            (lsp[LPC_ORDER - 1] - lsp[LPC_ORDER - 2]);

+

+    for (i = 1; i < LPC_ORDER - 1; i++) {

+        min  = FFMIN(lsp[i] - lsp[i - 1], lsp[i + 1] - lsp[i]);

+        if (min > 0x20)

+            weight[i] = (1 << 20) / min;

+        else

+            weight[i] = INT16_MAX;

+    }

+

+    /* Normalize */

+    max = 0;

+    for (i = 0; i < LPC_ORDER; i++)

+        max = FFMAX(weight[i], max);

+

+    shift = normalize_bits_int16(max);

+    for (i = 0; i < LPC_ORDER; i++) {

+        weight[i] <<= shift;

+    }

+

+    /* Compute the VQ target vector */

+    for (i = 0; i < LPC_ORDER; i++) {

+        lsp[i] -= dc_lsp[i] +

+                  (((prev_lsp[i] - dc_lsp[i]) * 12288 + (1 << 14)) >> 15);

+    }

+

+    get_index(0, 0, 3);

+    get_index(1, 3, 3);

+    get_index(2, 6, 4);

+}

+

+/**

+ * Apply the formant perceptual weighting filter.

+ *

+ * @param flt_coef filter coefficients

+ * @param unq_lpc  unquantized lpc vector

+ */

+static void perceptual_filter(G723_1_Context *p, int16_t *flt_coef,

+                              int16_t *unq_lpc, int16_t *buf)

+{

+    int16_t vector[FRAME_LEN + LPC_ORDER];

+    int i, j, k, l = 0;

+

+    memcpy(buf, p->iir_mem, sizeof(int16_t) * LPC_ORDER);

+    memcpy(vector, p->fir_mem, sizeof(int16_t) * LPC_ORDER);

+    memcpy(vector + LPC_ORDER, buf + LPC_ORDER, sizeof(int16_t) * FRAME_LEN);

+

+    for (i = LPC_ORDER, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++) {

+        for (k = 0; k < LPC_ORDER; k++) {

+            flt_coef[k + 2 * l] = (unq_lpc[k + l] * percept_flt_tbl[0][k] +

+                                  (1 << 14)) >> 15;

+            flt_coef[k + 2 * l + LPC_ORDER] = (unq_lpc[k + l] *

+                                             percept_flt_tbl[1][k] +

+                                             (1 << 14)) >> 15;

+        }

+        iir_filter(flt_coef + 2 * l, flt_coef + 2 * l + LPC_ORDER, vector + i,

+                   buf + i, 0);

+        l += LPC_ORDER;

+    }

+    memcpy(p->iir_mem, buf + FRAME_LEN, sizeof(int16_t) * LPC_ORDER);

+    memcpy(p->fir_mem, vector + FRAME_LEN, sizeof(int16_t) * LPC_ORDER);

+}

+

+/**

+ * Estimate the open loop pitch period.

+ *

+ * @param buf   perceptually weighted speech

+ * @param start estimation is carried out from this position

+ */

+static int estimate_pitch(int16_t *buf, int start)

+{

+    int max_exp = 32;

+    int max_ccr = 0x4000;

+    int max_eng = 0x7fff;

+    int index   = PITCH_MIN;

+    int offset  = start - PITCH_MIN + 1;

+

+    int ccr, eng, orig_eng, ccr_eng, exp;

+    int diff, temp;

+

+    int i;

+

+    orig_eng = dot_product(buf + offset, buf + offset, HALF_FRAME_LEN, 0);

+

+    for (i = PITCH_MIN; i <= PITCH_MAX - 3; i++) {

+        offset--;

+

+        /* Update energy and compute correlation */

+        orig_eng += buf[offset] * buf[offset] -

+                    buf[offset + HALF_FRAME_LEN] * buf[offset + HALF_FRAME_LEN];

+        ccr      =  dot_product(buf + start, buf + offset, HALF_FRAME_LEN, 0);

+        if (ccr <= 0)

+            continue;

+

+        /* Split into mantissa and exponent to maintain precision */

+        exp  =   normalize_bits_int32(ccr);

+        ccr  =   av_clipl_int32((int64_t)(ccr << exp) + (1 << 15)) >> 16;

+        exp  <<= 1;

+        ccr  *=  ccr;

+        temp =   normalize_bits_int32(ccr);

+        ccr  =   ccr << temp >> 16;

+        exp  +=  temp;

+

+        temp =   normalize_bits_int32(orig_eng);

+        eng  =   av_clipl_int32((int64_t)(orig_eng << temp) + (1 << 15)) >> 16;

+        exp  -=  temp;

+

+        if (ccr >= eng) {

+            exp--;

+            ccr >>= 1;

+        }

+        if (exp > max_exp)

+            continue;

+

+        if (exp + 1 < max_exp)

+            goto update;

+

+        /* Equalize exponents before comparison */

+        if (exp + 1 == max_exp)

+            temp = max_ccr >> 1;

+        else

+            temp = max_ccr;

+        ccr_eng = ccr * max_eng;

+        diff    = ccr_eng - eng * temp;

+        if (diff > 0 && (i - index < PITCH_MIN || diff > ccr_eng >> 2)) {

+update:

+            index   = i;

+            max_exp = exp;

+            max_ccr = ccr;

+            max_eng = eng;

+        }

+    }

+    return index;

+}

+

+/**

+ * Compute harmonic noise filter parameters.

+ *

+ * @param buf       perceptually weighted speech

+ * @param pitch_lag open loop pitch period

+ * @param hf        harmonic filter parameters

+ */

+static void comp_harmonic_coeff(int16_t *buf, int16_t pitch_lag, HFParam *hf)

+{

+    int ccr, eng, max_ccr, max_eng;

+    int exp, max, diff;

+    int energy[15];

+    int i, j;

+

+    for (i = 0, j = pitch_lag - 3; j <= pitch_lag + 3; i++, j++) {

+        /* Compute residual energy */

+        energy[i << 1] = dot_product(buf - j, buf - j, SUBFRAME_LEN, 0);

+        /* Compute correlation */

+        energy[(i << 1) + 1] = dot_product(buf, buf - j, SUBFRAME_LEN, 0);

+    }

+

+    /* Compute target energy */

+    energy[14] = dot_product(buf, buf, SUBFRAME_LEN, 0);

+

+    /* Normalize */

+    max = 0;

+    for (i = 0; i < 15; i++)

+        max = FFMAX(max, FFABS(energy[i]));

+

+    exp = normalize_bits_int32(max);

+    for (i = 0; i < 15; i++) {

+        energy[i] = av_clipl_int32((int64_t)(energy[i] << exp) +

+                                   (1 << 15)) >> 16;

+    }

+

+    hf->index = -1;

+    hf->gain  =  0;

+    max_ccr   =  1;

+    max_eng   =  0x7fff;

+

+    for (i = 0; i <= 6; i++) {

+        eng = energy[i << 1];

+        ccr = energy[(i << 1) + 1];

+

+        if (ccr <= 0)

+            continue;

+

+        ccr  = (ccr * ccr + (1 << 14)) >> 15;

+        diff = ccr * max_eng - eng * max_ccr;

+        if (diff > 0) {

+            max_ccr   = ccr;

+            max_eng   = eng;

+            hf->index = i;

+        }

+    }

+

+    if (hf->index == -1) {

+        hf->index = pitch_lag;

+        return;

+    }

+

+    eng = energy[14] * max_eng;

+    eng = (eng >> 2) + (eng >> 3);

+    ccr = energy[(hf->index << 1) + 1] * energy[(hf->index << 1) + 1];

+    if (eng < ccr) {

+        eng = energy[(hf->index << 1) + 1];

+

+        if (eng >= max_eng)

+            hf->gain = 0x2800;

+        else

+            hf->gain = ((eng << 15) / max_eng * 0x2800 + (1 << 14)) >> 15;

+    }

+    hf->index += pitch_lag - 3;

+}

+

+/**

+ * Apply the harmonic noise shaping filter.

+ *

+ * @param hf filter parameters

+ */

+static void harmonic_filter(HFParam *hf, int16_t *src, int16_t *dest)

+{

+    int i;

+

+    for (i = 0; i < SUBFRAME_LEN; i++) {

+        int64_t temp = hf->gain * src[i - hf->index] << 1;

+        dest[i] = av_clipl_int32((src[i] << 16) - temp + (1 << 15)) >> 16;

+    }

+}

+

+static void harmonic_noise_sub(HFParam *hf, int16_t *src, int16_t *dest)

+{

+    int i;

+    for (i = 0; i < SUBFRAME_LEN; i++) {

+        int64_t temp = hf->gain * src[i - hf->index] << 1;

+        dest[i] = av_clipl_int32(((dest[i] - src[i]) << 16) + temp +

+                                 (1 << 15)) >> 16;

+

+    }

+}

+

+/**

+ * Combined synthesis and formant perceptual weighting filer.

+ *

+ * @param qnt_lpc  quantized lpc coefficients

+ * @param perf_lpc perceptual filter coefficients

+ * @param perf_fir perceptual filter fir memory

+ * @param perf_iir perceptual filter iir memory

+ * @param scale    the filter output will be scaled by 2^scale

+ */

+static void synth_percept_filter(int16_t *qnt_lpc, int16_t *perf_lpc,

+                                 int16_t *perf_fir, int16_t *perf_iir,

+                                 int16_t *src, int16_t *dest, int scale)

+{

+    int i, j;

+    int16_t buf_16[SUBFRAME_LEN + LPC_ORDER];

+    int64_t buf[SUBFRAME_LEN];

+

+    int16_t *bptr_16 = buf_16 + LPC_ORDER;

+

+    memcpy(buf_16, perf_fir, sizeof(int16_t) * LPC_ORDER);

+    memcpy(dest - LPC_ORDER, perf_iir, sizeof(int16_t) * LPC_ORDER);

+

+    for (i = 0; i < SUBFRAME_LEN; i++) {

+        int64_t temp = 0;

+        for (j = 1; j <= LPC_ORDER; j++)

+            temp -= qnt_lpc[j - 1] * bptr_16[i - j];

+

+        buf[i]     = (src[i] << 15) + (temp << 3);

+        bptr_16[i] = av_clipl_int32(buf[i] + (1 << 15)) >> 16;

+    }

+

+    for (i = 0; i < SUBFRAME_LEN; i++) {

+        int64_t fir = 0, iir = 0;

+        for (j = 1; j <= LPC_ORDER; j++) {

+            fir -= perf_lpc[j - 1] * bptr_16[i - j];

+            iir += perf_lpc[j + LPC_ORDER - 1] * dest[i - j];

+        }

+        dest[i] = av_clipl_int32(((buf[i] + (fir << 3)) << scale) + (iir << 3) +

+                                 (1 << 15)) >> 16;

+    }

+    memcpy(perf_fir, buf_16 + SUBFRAME_LEN, sizeof(int16_t) * LPC_ORDER);

+    memcpy(perf_iir, dest + SUBFRAME_LEN - LPC_ORDER,

+           sizeof(int16_t) * LPC_ORDER);

+}

+

+/**

+ * Compute the adaptive codebook contribution.

+ *

+ * @param buf   input signal

+ * @param index the current subframe index

+ */

+static void acb_search(G723_1_Context *p, int16_t *residual,

+                       int16_t *impulse_resp, int16_t *buf,

+                       int index)

+{

+

+    int16_t flt_buf[PITCH_ORDER][SUBFRAME_LEN];

+

+    const int16_t *cb_tbl = adaptive_cb_gain85;

+

+    int ccr_buf[PITCH_ORDER * SUBFRAMES << 2];

+

+    int pitch_lag = p->pitch_lag[index >> 1];

+    int acb_lag   = 1;

+    int acb_gain  = 0;

+    int odd_frame = index & 1;

+    int iter      = 3 + odd_frame;

+    int count     = 0;

+    int tbl_size  = 85;

+

+    int i, j, k, l, max;

+    int64_t temp;

+

+    if (!odd_frame) {

+        if (pitch_lag == PITCH_MIN)

+            pitch_lag++;

+        else

+            pitch_lag = FFMIN(pitch_lag, PITCH_MAX - 5);

+    }

+

+    for (i = 0; i < iter; i++) {

+        get_residual(residual, p->prev_excitation, pitch_lag + i - 1);

+

+        for (j = 0; j < SUBFRAME_LEN; j++) {

+            temp = 0;

+            for (k = 0; k <= j; k++)

+                temp += residual[PITCH_ORDER - 1 + k] * impulse_resp[j - k];

+            flt_buf[PITCH_ORDER - 1][j] = av_clipl_int32((temp << 1) +

+                                                         (1 << 15)) >> 16;

+        }

+

+        for (j = PITCH_ORDER - 2; j >= 0; j--) {

+            flt_buf[j][0] = ((residual[j] << 13) + (1 << 14)) >> 15;

+            for (k = 1; k < SUBFRAME_LEN; k++) {

+                temp = (flt_buf[j + 1][k - 1] << 15) +

+                       residual[j] * impulse_resp[k];

+                flt_buf[j][k] = av_clipl_int32((temp << 1) + (1 << 15)) >> 16;

+            }

+        }

+

+        /* Compute crosscorrelation with the signal */

+        for (j = 0; j < PITCH_ORDER; j++) {

+            temp = dot_product(buf, flt_buf[j], SUBFRAME_LEN, 0);

+            ccr_buf[count++] = av_clipl_int32(temp << 1);

+        }

+

+        /* Compute energies */

+        for (j = 0; j < PITCH_ORDER; j++) {

+            ccr_buf[count++] = dot_product(flt_buf[j], flt_buf[j],

+                                           SUBFRAME_LEN, 1);

+        }

+

+        for (j = 1; j < PITCH_ORDER; j++) {

+            for (k = 0; k < j; k++) {

+                temp = dot_product(flt_buf[j], flt_buf[k], SUBFRAME_LEN, 0);

+                ccr_buf[count++] = av_clipl_int32(temp<<2);

+            }

+        }

+    }

+

+    /* Normalize and shorten */

+    max = 0;

+    for (i = 0; i < 20 * iter; i++)

+        max = FFMAX(max, FFABS(ccr_buf[i]));

+

+    temp = normalize_bits_int32(max);

+

+    for (i = 0; i < 20 * iter; i++){

+        ccr_buf[i] = av_clipl_int32((int64_t)(ccr_buf[i] << temp) +

+                                    (1 << 15)) >> 16;

+    }

+

+    max = 0;

+    for (i = 0; i < iter; i++) {

+        /* Select quantization table */

+        if (!odd_frame && pitch_lag + i - 1 >= SUBFRAME_LEN - 2 ||

+            odd_frame && pitch_lag >= SUBFRAME_LEN - 2) {

+            cb_tbl = adaptive_cb_gain170;

+            tbl_size = 170;

+        }

+

+        for (j = 0, k = 0; j < tbl_size; j++, k += 20) {

+            temp = 0;

+            for (l = 0; l < 20; l++)

+                temp += ccr_buf[20 * i + l] * cb_tbl[k + l];

+            temp =  av_clipl_int32(temp);

+

+            if (temp > max) {

+                max      = temp;

+                acb_gain = j;

+                acb_lag  = i;

+            }

+        }

+    }

+

+    if (!odd_frame) {

+        pitch_lag += acb_lag - 1;

+        acb_lag   =  1;

+    }

+

+    p->pitch_lag[index >> 1]      = pitch_lag;

+    p->subframe[index].ad_cb_lag  = acb_lag;

+    p->subframe[index].ad_cb_gain = acb_gain;

+}

+

+/**

+ * Subtract the adaptive codebook contribution from the input

+ * to obtain the residual.

+ *

+ * @param buf target vector

+ */

+static void sub_acb_contrib(int16_t *residual, int16_t *impulse_resp,

+                            int16_t *buf)

+{

+    int i, j;

+    /* Subtract adaptive CB contribution to obtain the residual */

+    for (i = 0; i < SUBFRAME_LEN; i++) {

+        int64_t temp = buf[i] << 14;

+        for (j = 0; j <= i; j++)

+            temp -= residual[j] * impulse_resp[i - j];

+

+        buf[i] = av_clipl_int32((temp << 2) + (1 << 15)) >> 16;

+    }

+}

+

+/**

+ * Quantize the residual signal using the fixed codebook (MP-MLQ).

+ *

+ * @param optim optimized fixed codebook parameters

+ * @param buf   excitation vector

+ */

+static void get_fcb_param(FCBParam *optim, int16_t *impulse_resp,

+                          int16_t *buf, int pulse_cnt, int pitch_lag)

+{

+    FCBParam param;

+    int16_t impulse_r[SUBFRAME_LEN];

+    int16_t temp_corr[SUBFRAME_LEN];

+    int16_t impulse_corr[SUBFRAME_LEN];

+

+    int ccr1[SUBFRAME_LEN];

+    int ccr2[SUBFRAME_LEN];

+    int amp, err, max, max_amp_index, min, scale, i, j, k, l;

+

+    int64_t temp;

+

+    /* Update impulse response */

+    memcpy(impulse_r, impulse_resp, sizeof(int16_t) * SUBFRAME_LEN);

+    param.dirac_train = 0;

+    if (pitch_lag < SUBFRAME_LEN - 2) {

+        param.dirac_train = 1;

+        gen_dirac_train(impulse_r, pitch_lag);

+    }

+

+    for (i = 0; i < SUBFRAME_LEN; i++)

+        temp_corr[i] = impulse_r[i] >> 1;

+

+    /* Compute impulse response autocorrelation */

+    temp = dot_product(temp_corr, temp_corr, SUBFRAME_LEN, 1);

+

+    scale = normalize_bits_int32(temp);

+    impulse_corr[0] = av_clipl_int32((temp << scale) + (1 << 15)) >> 16;

+

+    for (i = 1; i < SUBFRAME_LEN; i++) {

+        temp = dot_product(temp_corr + i, temp_corr, SUBFRAME_LEN - i, 1);

+        impulse_corr[i] = av_clipl_int32((temp << scale) + (1 << 15)) >> 16;

+    }

+

+    /* Compute crosscorrelation of impulse response with residual signal */

+    scale -= 4;

+    for (i = 0; i < SUBFRAME_LEN; i++){

+        temp = dot_product(buf + i, impulse_r, SUBFRAME_LEN - i, 1);

+        if (scale < 0)

+            ccr1[i] = temp >> -scale;

+        else

+            ccr1[i] = av_clipl_int32(temp << scale);

+    }

+

+    /* Search loop */

+    for (i = 0; i < GRID_SIZE; i++) {

+        /* Maximize the crosscorrelation */

+        max = 0;

+        for (j = i; j < SUBFRAME_LEN; j += GRID_SIZE) {

+            temp = FFABS(ccr1[j]);

+            if (temp >= max) {

+                max = temp;

+                param.pulse_pos[0] = j;

+            }

+        }

+

+        /* Quantize the gain (max crosscorrelation/impulse_corr[0]) */

+        amp = max;

+        min = 1 << 30;

+        max_amp_index = GAIN_LEVELS - 2;

+        for (j = max_amp_index; j >= 2; j--) {

+            temp = av_clipl_int32((int64_t)fixed_cb_gain[j] *

+                                  impulse_corr[0] << 1);

+            temp = FFABS(temp - amp);

+            if (temp < min) {

+                min = temp;

+                max_amp_index = j;

+            }

+        }

+

+        max_amp_index--;

+        /* Select additional gain values */

+        for (j = 1; j < 5; j++) {

+            for (k = i; k < SUBFRAME_LEN; k += GRID_SIZE) {

+                temp_corr[k] = 0;

+                ccr2[k]      = ccr1[k];

+            }

+            param.amp_index = max_amp_index + j - 2;

+            amp = fixed_cb_gain[param.amp_index];

+

+            param.pulse_sign[0] = (ccr2[param.pulse_pos[0]] < 0) ? -amp : amp;

+            temp_corr[param.pulse_pos[0]] = 1;

+

+            for (k = 1; k < pulse_cnt; k++) {

+                max = -1 << 30;

+                for (l = i; l < SUBFRAME_LEN; l += GRID_SIZE) {

+                    if (temp_corr[l])

+                        continue;

+                    temp = impulse_corr[FFABS(l - param.pulse_pos[k - 1])];

+                    temp = av_clipl_int32((int64_t)temp *

+                                          param.pulse_sign[k - 1] << 1);

+                    ccr2[l] -= temp;

+                    temp = FFABS(ccr2[l]);

+                    if (temp > max) {

+                        max = temp;

+                        param.pulse_pos[k] = l;

+                    }

+                }

+

+                param.pulse_sign[k] = (ccr2[param.pulse_pos[k]] < 0) ?

+                                      -amp : amp;

+                temp_corr[param.pulse_pos[k]] = 1;

+            }

+

+            /* Create the error vector */

+            memset(temp_corr, 0, sizeof(int16_t) * SUBFRAME_LEN);

+

+            for (k = 0; k < pulse_cnt; k++)

+                temp_corr[param.pulse_pos[k]] = param.pulse_sign[k];

+

+            for (k = SUBFRAME_LEN - 1; k >= 0; k--) {

+                temp = 0;