avcodec/gsmdec_template: Fix runtime error: signed integer overflow: -22527 * 99113...
[ffmpeg.git] / libavcodec / g729dec.c
index c1d0905..2e1bf18 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * G.729 decoder
+ * G.729, G729 Annex D decoders
  * Copyright (c) 2008 Vladimir Voroshilov
  *
  * This file is part of FFmpeg.
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
-#include <stdlib.h>
+
 #include <inttypes.h>
-#include <limits.h>
-#include <stdio.h>
 #include <string.h>
-#include <math.h>
-#include <assert.h>
 
 #include "avcodec.h"
 #include "libavutil/avutil.h"
 #include "get_bits.h"
-#include "dsputil.h"
+#include "audiodsp.h"
+#include "internal.h"
+
 
 #include "g729.h"
 #include "lsp.h"
@@ -39,6 +37,7 @@
 #include "acelp_pitch_delay.h"
 #include "acelp_vectors.h"
 #include "g729data.h"
+#include "g729postfilter.h"
 
 /**
  * minimum quantized LSF value (3.2.4)
  */
 #define MR_ENERGY 1018156
 
+#define DECISION_NOISE        0
+#define DECISION_INTERMEDIATE 1
+#define DECISION_VOICE        2
+
 typedef enum {
     FORMAT_G729_8K = 0,
     FORMAT_G729D_6K4,
@@ -97,7 +100,7 @@ typedef struct {
 } G729FormatDescription;
 
 typedef struct {
-    DSPContext dsp;
+    AudioDSPContext adsp;
 
     /// past excitation signal buffer
     int16_t exc_base[2*SUBFRAME_SIZE+PITCH_DELAY_MAX+INTERPOL_LEN];
@@ -118,15 +121,37 @@ typedef struct {
     /// previous speech data for LP synthesis filter
     int16_t syn_filter_data[10];
 
+
+    /// residual signal buffer (used in long-term postfilter)
+    int16_t residual[SUBFRAME_SIZE + RES_PREV_DATA_SIZE];
+
+    /// previous speech data for residual calculation filter
+    int16_t res_filter_data[SUBFRAME_SIZE+10];
+
+    /// previous speech data for short-term postfilter
+    int16_t pos_filter_data[SUBFRAME_SIZE+10];
+
     /// (1.14) pitch gain of current and five previous subframes
     int16_t past_gain_pitch[6];
 
     /// (14.1) gain code from current and previous subframe
     int16_t past_gain_code[2];
 
+    /// voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
+    int16_t voice_decision;
+
+    int16_t onset;              ///< detected onset level (0-2)
     int16_t was_periodic;       ///< whether previous frame was declared as periodic or not (4.4)
+    int16_t ht_prev_data;       ///< previous data for 4.2.3, equation 86
+    int gain_coeff;             ///< (1.14) gain coefficient (4.2.4)
     uint16_t rand_value;        ///< random number generator value (4.4.4)
     int ma_predictor_prev;      ///< switched MA predictor of LSP quantizer from last good frame
+
+    /// (14.14) high-pass filter data (past input)
+    int hpf_f[2];
+
+    /// high-pass filter data (past output)
+    int16_t hpf_z[2];
 }  G729Context;
 
 static const G729FormatDescription format_g729_8k = {
@@ -156,17 +181,9 @@ static inline uint16_t g729_prng(uint16_t value)
 }
 
 /**
- * Get parity bit of bit 2..7
- */
-static inline int get_parity(uint8_t value)
-{
-   return (0x6996966996696996ULL >> (value >> 2)) & 1;
-}
-
-/*
  * Decodes LSF (Line Spectral Frequencies) from L0-L3 (3.2.4).
- * @param lsfq [out] (2.13) quantized LSF coefficients
- * @param past_quantizer_outputs [in/out] (2.13) quantizer outputs from previous frames
+ * @param[out] lsfq (2.13) quantized LSF coefficients
+ * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
  * @param ma_predictor switched MA predictor of LSP quantizer
  * @param vq_1st first stage vector of quantizer
  * @param vq_2nd_low second stage lower vector of LSP quantizer
@@ -208,8 +225,8 @@ static void lsf_decode(int16_t* lsfq, int16_t* past_quantizer_outputs[MA_NP + 1]
 
 /**
  * Restores past LSP quantizer output using LSF from previous frame
- * @param lsfq [in/out] (2.13) quantized LSF coefficients
- * @param past_quantizer_outputs [in/out] (2.13) quantizer outputs from previous frames
+ * @param[in,out] lsfq (2.13) quantized LSF coefficients
+ * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
  * @param ma_predictor_prev MA predictor from previous frame
  * @param lsfq_prev (2.13) quantized LSF coefficients from previous frame
  */
@@ -230,6 +247,95 @@ static void lsf_restore_from_previous(int16_t* lsfq,
     }
 }
 
+/**
+ * Constructs new excitation signal and applies phase filter to it
+ * @param[out] out constructed speech signal
+ * @param in original excitation signal
+ * @param fc_cur (2.13) original fixed-codebook vector
+ * @param gain_code (14.1) gain code
+ * @param subframe_size length of the subframe
+ */
+static void g729d_get_new_exc(
+        int16_t* out,
+        const int16_t* in,
+        const int16_t* fc_cur,
+        int dstate,
+        int gain_code,
+        int subframe_size)
+{
+    int i;
+    int16_t fc_new[SUBFRAME_SIZE];
+
+    ff_celp_convolve_circ(fc_new, fc_cur, phase_filter[dstate], subframe_size);
+
+    for(i=0; i<subframe_size; i++)
+    {
+        out[i]  = in[i];
+        out[i] -= (gain_code * fc_cur[i] + 0x2000) >> 14;
+        out[i] += (gain_code * fc_new[i] + 0x2000) >> 14;
+    }
+}
+
+/**
+ * Makes decision about onset in current subframe
+ * @param past_onset decision result of previous subframe
+ * @param past_gain_code gain code of current and previous subframe
+ *
+ * @return onset decision result for current subframe
+ */
+static int g729d_onset_decision(int past_onset, const int16_t* past_gain_code)
+{
+    if((past_gain_code[0] >> 1) > past_gain_code[1])
+        return 2;
+    else
+        return FFMAX(past_onset-1, 0);
+}
+
+/**
+ * Makes decision about voice presence in current subframe
+ * @param onset onset level
+ * @param prev_voice_decision voice decision result from previous subframe
+ * @param past_gain_pitch pitch gain of current and previous subframes
+ *
+ * @return voice decision result for current subframe
+ */
+static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const int16_t* past_gain_pitch)
+{
+    int i, low_gain_pitch_cnt, voice_decision;
+
+    if(past_gain_pitch[0] >= 14745)      // 0.9
+        voice_decision = DECISION_VOICE;
+    else if (past_gain_pitch[0] <= 9830) // 0.6
+        voice_decision = DECISION_NOISE;
+    else
+        voice_decision = DECISION_INTERMEDIATE;
+
+    for(i=0, low_gain_pitch_cnt=0; i<6; i++)
+        if(past_gain_pitch[i] < 9830)
+            low_gain_pitch_cnt++;
+
+    if(low_gain_pitch_cnt > 2 && !onset)
+        voice_decision = DECISION_NOISE;
+
+    if(!onset && voice_decision > prev_voice_decision + 1)
+        voice_decision--;
+
+    if(onset && voice_decision < DECISION_VOICE)
+        voice_decision++;
+
+    return voice_decision;
+}
+
+static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order)
+{
+    int res = 0;
+
+    while (order--)
+        res += *v1++ * *v2++;
+
+    return res;
+}
+
 static av_cold int decoder_init(AVCodecContext * avctx)
 {
     G729Context* ctx = avctx->priv_data;
@@ -239,10 +345,13 @@ static av_cold int decoder_init(AVCodecContext * avctx)
         av_log(avctx, AV_LOG_ERROR, "Only mono sound is supported (requested channels: %d).\n", avctx->channels);
         return AVERROR(EINVAL);
     }
+    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 
     /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
     avctx->frame_size = SUBFRAME_SIZE << 1;
 
+    ctx->gain_coeff = 16384; // 1.0 in (1.14)
+
     for (k = 0; k < MA_NP + 1; k++) {
         ctx->past_quantizer_outputs[k] = ctx->past_quantizer_output_buf[k];
         for (i = 1; i < 11; i++)
@@ -255,6 +364,8 @@ static av_cold int decoder_init(AVCodecContext * avctx)
 
     ctx->exc = &ctx->exc_base[PITCH_DELAY_MAX+INTERPOL_LEN];
 
+    ctx->pitch_delay_int_prev = PITCH_DELAY_MIN;
+
     /* random seed initialization */
     ctx->rand_value = 21845;
 
@@ -262,19 +373,20 @@ static av_cold int decoder_init(AVCodecContext * avctx)
     for(i=0; i<4; i++)
         ctx->quant_energy[i] = -14336; // -14 in (5.10)
 
-    dsputil_init(&ctx->dsp, avctx);
+    ff_audiodsp_init(&ctx->adsp);
+    ctx->adsp.scalarproduct_int16 = scalarproduct_int16_c;
 
     return 0;
 }
 
-static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
+static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
                         AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
-    int16_t *out_frame = data;
+    int16_t *out_frame;
     GetBitContext gb;
-    G729FormatDescription format;
+    const G729FormatDescription *format;
     int frame_erasure = 0;    ///< frame erasure detected during decoding
     int bad_pitch = 0;        ///< parity check failed
     int i;
@@ -287,25 +399,30 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
     uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
     uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
 
-    int pitch_delay_int;         // pitch delay, integer part
+    int pitch_delay_int[2];      // pitch delay, integer part
     int pitch_delay_3x;          // pitch delay, multiplied by 3
     int16_t fc[SUBFRAME_SIZE];   // fixed-codebook vector
     int16_t synth[SUBFRAME_SIZE+10]; // fixed-codebook vector
-    int j;
+    int j, ret;
+    int gain_before, gain_after;
     int is_periodic = 0;         // whether one of the subframes is declared as periodic or not
+    AVFrame *frame = data;
 
-    if (*data_size < SUBFRAME_SIZE << 2) {
-        av_log(avctx, AV_LOG_ERROR, "Error processing packet: output buffer too small\n");
-        return AVERROR(EIO);
-    }
+    frame->nb_samples = SUBFRAME_SIZE<<1;
+    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
+        return ret;
+    out_frame = (int16_t*) frame->data[0];
 
-    if (buf_size == 10) {
+    if (buf_size % 10 == 0) {
         packet_type = FORMAT_G729_8K;
-        format = format_g729_8k;
+        format = &format_g729_8k;
+        //Reset voice decision
+        ctx->onset = 0;
+        ctx->voice_decision = DECISION_VOICE;
         av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
     } else if (buf_size == 8) {
         packet_type = FORMAT_G729D_6K4;
-        format = format_g729d_6k4;
+        format = &format_g729d_6k4;
         av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
     } else {
         av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
@@ -316,7 +433,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
         frame_erasure |= buf[i];
     frame_erasure = !frame_erasure;
 
-    init_get_bits(&gb, buf, buf_size);
+    init_get_bits(&gb, buf, 8*buf_size);
 
     ma_predictor     = get_bits(&gb, 1);
     quantizer_1st    = get_bits(&gb, VQ_1ST_BITS);
@@ -353,13 +470,13 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
         uint8_t gc_1st_index;  ///< gain codebook (first stage) index
         uint8_t gc_2nd_index;  ///< gain codebook (second stage) index
 
-        ac_index      = get_bits(&gb, format.ac_index_bits[i]);
-        if(!i && format.parity_bit)
-            bad_pitch = get_parity(ac_index) == get_bits1(&gb);
-        fc_indexes    = get_bits(&gb, format.fc_indexes_bits);
-        pulses_signs  = get_bits(&gb, format.fc_signs_bits);
-        gc_1st_index  = get_bits(&gb, format.gc_1st_index_bits);
-        gc_2nd_index  = get_bits(&gb, format.gc_2nd_index_bits);
+        ac_index      = get_bits(&gb, format->ac_index_bits[i]);
+        if(!i && format->parity_bit)
+            bad_pitch = av_parity(ac_index >> 2) == get_bits1(&gb);
+        fc_indexes    = get_bits(&gb, format->fc_indexes_bits);
+        pulses_signs  = get_bits(&gb, format->fc_signs_bits);
+        gc_1st_index  = get_bits(&gb, format->gc_1st_index_bits);
+        gc_2nd_index  = get_bits(&gb, format->gc_2nd_index_bits);
 
         if (frame_erasure)
             pitch_delay_3x   = 3 * ctx->pitch_delay_int_prev;
@@ -379,11 +496,15 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
         }
 
         /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
-        pitch_delay_int  = (pitch_delay_3x + 1) / 3;
+        pitch_delay_int[i]  = (pitch_delay_3x + 1) / 3;
+        if (pitch_delay_int[i] > PITCH_DELAY_MAX) {
+            av_log(avctx, AV_LOG_WARNING, "pitch_delay_int %d is too large\n", pitch_delay_int[i]);
+            pitch_delay_int[i] = PITCH_DELAY_MAX;
+        }
 
         if (frame_erasure) {
             ctx->rand_value = g729_prng(ctx->rand_value);
-            fc_indexes   = ctx->rand_value & ((1 << format.fc_indexes_bits) - 1);
+            fc_indexes   = av_mod_uintp2(ctx->rand_value, format->fc_indexes_bits);
 
             ctx->rand_value = g729_prng(ctx->rand_value);
             pulses_signs = ctx->rand_value;
@@ -412,12 +533,12 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
           fc_v[i] = <
                      \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
         */
-        ff_acelp_weighted_vector_sum(fc + pitch_delay_int,
-                                     fc + pitch_delay_int,
+        ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
+                                     fc + pitch_delay_int[i],
                                      fc, 1 << 14,
                                      av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX),
                                      0, 14,
-                                     SUBFRAME_SIZE - pitch_delay_int);
+                                     SUBFRAME_SIZE - pitch_delay_int[i]);
 
         memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t));
         ctx->past_gain_code[1] = ctx->past_gain_code[0];
@@ -434,7 +555,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
                 gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] +
                                    cb_gain_2nd_6k4[gc_2nd_index][1];
 
-                /* Without check below overflow can occure in ff_acelp_update_past_gain.
+                /* Without check below overflow can occur in ff_acelp_update_past_gain.
                    It is not issue for G.729, because gain_corr_factor in it's case is always
                    greater than 1024, while in G.729D it can be even zero. */
                 gain_corr_factor = FFMAX(gain_corr_factor, 1024);
@@ -449,7 +570,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
             }
 
             /* Decode the fixed-codebook gain. */
-            ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&ctx->dsp, gain_corr_factor,
+            ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&ctx->adsp, gain_corr_factor,
                                                                fc, MR_ENERGY,
                                                                ctx->quant_energy,
                                                                ma_prediction_coeff,
@@ -461,7 +582,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
               two times larger than in original G.729.
 
               If bit-exact result is not issue then gain_corr_factor
-              can be simpler devided by 2 before call to g729_get_gain_code
+              can be simpler divided by 2 before call to g729_get_gain_code
               instead of using correction below.
             */
             if (packet_type == FORMAT_G729D_6K4) {
@@ -487,9 +608,6 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 
         memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t));
 
-        /* Temporary synth buffer is required since filter needs additional space at top of buffer and, thus,
-           synthesis can not be done directly to output buffer. This buffer will be reused by future
-           postprocessing filters. */
         if (ff_celp_lp_synthesis_filter(
             synth+10,
             &lp[i][1],
@@ -497,11 +615,31 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
             SUBFRAME_SIZE,
             10,
             1,
-            0x800)) {
-            /* Overflow occured, downscale excitation signal... */
+            0,
+            0x800))
+            /* Overflow occurred, downscale excitation signal... */
             for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++)
                 ctx->exc_base[j] >>= 2;
 
+        /* ... and make synthesis again. */
+        if (packet_type == FORMAT_G729D_6K4) {
+            int16_t exc_new[SUBFRAME_SIZE];
+
+            ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code);
+            ctx->voice_decision = g729d_voice_decision(ctx->onset, ctx->voice_decision, ctx->past_gain_pitch);
+
+            g729d_get_new_exc(exc_new, ctx->exc  + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE);
+
+            ff_celp_lp_synthesis_filter(
+                    synth+10,
+                    &lp[i][1],
+                    exc_new,
+                    SUBFRAME_SIZE,
+                    10,
+                    0,
+                    0,
+                    0x800);
+        } else {
             ff_celp_lp_synthesis_filter(
                     synth+10,
                     &lp[i][1],
@@ -509,18 +647,54 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
                     SUBFRAME_SIZE,
                     10,
                     0,
+                    0,
                     0x800);
         }
         /* Save data (without postfilter) for use in next subframe. */
         memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t));
 
+        /* Calculate gain of unfiltered signal for use in AGC. */
+        gain_before = 0;
+        for (j = 0; j < SUBFRAME_SIZE; j++)
+            gain_before += FFABS(synth[j+10]);
+
+        /* Call postfilter and also update voicing decision for use in next frame. */
+        ff_g729_postfilter(
+                &ctx->adsp,
+                &ctx->ht_prev_data,
+                &is_periodic,
+                &lp[i][0],
+                pitch_delay_int[0],
+                ctx->residual,
+                ctx->res_filter_data,
+                ctx->pos_filter_data,
+                synth+10,
+                SUBFRAME_SIZE);
+
+        /* Calculate gain of filtered signal for use in AGC. */
+        gain_after = 0;
+        for(j=0; j<SUBFRAME_SIZE; j++)
+            gain_after += FFABS(synth[j+10]);
+
+        ctx->gain_coeff = ff_g729_adaptive_gain_control(
+                gain_before,
+                gain_after,
+                synth+10,
+                SUBFRAME_SIZE,
+                ctx->gain_coeff);
+
         if (frame_erasure)
             ctx->pitch_delay_int_prev = FFMIN(ctx->pitch_delay_int_prev + 1, PITCH_DELAY_MAX);
         else
-            ctx->pitch_delay_int_prev = pitch_delay_int;
-
-        /* Dumb. Will be replaced by high-pass filter */
-        memcpy(out_frame + i * SUBFRAME_SIZE, synth + 10, SUBFRAME_SIZE * sizeof(int16_t));
+            ctx->pitch_delay_int_prev = pitch_delay_int[i];
+
+        memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t));
+        ff_acelp_high_pass_filter(
+                out_frame + i*SUBFRAME_SIZE,
+                ctx->hpf_f,
+                synth+10,
+                SUBFRAME_SIZE);
+        memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t));
     }
 
     ctx->was_periodic = is_periodic;
@@ -528,19 +702,17 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
     /* Save signal for use in next frame. */
     memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t));
 
-    *data_size = SUBFRAME_SIZE << 2;
-    return buf_size;
+    *got_frame_ptr = 1;
+    return packet_type == FORMAT_G729_8K ? 10 : 8;
 }
 
-AVCodec ff_g729_decoder =
-{
-    "g729",
-    AVMEDIA_TYPE_AUDIO,
-    CODEC_ID_G729,
-    sizeof(G729Context),
-    decoder_init,
-    NULL,
-    NULL,
-    decode_frame,
-    .long_name = NULL_IF_CONFIG_SMALL("G.729"),
+AVCodec ff_g729_decoder = {
+    .name           = "g729",
+    .long_name      = NULL_IF_CONFIG_SMALL("G.729"),
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = AV_CODEC_ID_G729,
+    .priv_data_size = sizeof(G729Context),
+    .init           = decoder_init,
+    .decode         = decode_frame,
+    .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
 };