avcodec/gsmdec_template: Fix runtime error: signed integer overflow: -22527 * 99113...
[ffmpeg.git] / libavcodec / g729dec.c
index bc7fbc1..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"
@@ -102,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];
@@ -145,6 +143,7 @@ typedef struct {
     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
 
@@ -182,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
@@ -234,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
  */
@@ -258,7 +249,7 @@ 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[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
@@ -335,6 +326,16 @@ static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const in
     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;
@@ -344,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++)
@@ -360,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;
 
@@ -367,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;
@@ -396,24 +403,26 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
     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);
@@ -424,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);
@@ -461,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;
@@ -488,10 +497,14 @@ 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[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;
@@ -542,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);
@@ -557,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,
@@ -569,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) {
@@ -602,8 +615,9 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
             SUBFRAME_SIZE,
             10,
             1,
+            0,
             0x800))
-            /* Overflow occured, downscale excitation signal... */
+            /* Overflow occurred, downscale excitation signal... */
             for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++)
                 ctx->exc_base[j] >>= 2;
 
@@ -623,6 +637,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
                     SUBFRAME_SIZE,
                     10,
                     0,
+                    0,
                     0x800);
         } else {
             ff_celp_lp_synthesis_filter(
@@ -632,14 +647,20 @@ 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. */
-        g729_postfilter(
-                &ctx->dsp,
+        ff_g729_postfilter(
+                &ctx->adsp,
                 &ctx->ht_prev_data,
                 &is_periodic,
                 &lp[i][0],
@@ -650,6 +671,18 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
                 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
@@ -669,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,
 };