LCOV - code coverage report
Current view: top level - libavcodec - g729dec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 231 0.0 %
Date: 2017-12-18 06:23:41 Functions: 0 9 0.0 %

          Line data    Source code
       1             : /*
       2             :  * G.729, G729 Annex D decoders
       3             :  * Copyright (c) 2008 Vladimir Voroshilov
       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 <inttypes.h>
      23             : #include <string.h>
      24             : 
      25             : #include "avcodec.h"
      26             : #include "libavutil/avutil.h"
      27             : #include "get_bits.h"
      28             : #include "audiodsp.h"
      29             : #include "internal.h"
      30             : 
      31             : 
      32             : #include "g729.h"
      33             : #include "lsp.h"
      34             : #include "celp_math.h"
      35             : #include "celp_filters.h"
      36             : #include "acelp_filters.h"
      37             : #include "acelp_pitch_delay.h"
      38             : #include "acelp_vectors.h"
      39             : #include "g729data.h"
      40             : #include "g729postfilter.h"
      41             : 
      42             : /**
      43             :  * minimum quantized LSF value (3.2.4)
      44             :  * 0.005 in Q13
      45             :  */
      46             : #define LSFQ_MIN                   40
      47             : 
      48             : /**
      49             :  * maximum quantized LSF value (3.2.4)
      50             :  * 3.135 in Q13
      51             :  */
      52             : #define LSFQ_MAX                   25681
      53             : 
      54             : /**
      55             :  * minimum LSF distance (3.2.4)
      56             :  * 0.0391 in Q13
      57             :  */
      58             : #define LSFQ_DIFF_MIN              321
      59             : 
      60             : /// interpolation filter length
      61             : #define INTERPOL_LEN              11
      62             : 
      63             : /**
      64             :  * minimum gain pitch value (3.8, Equation 47)
      65             :  * 0.2 in (1.14)
      66             :  */
      67             : #define SHARP_MIN                  3277
      68             : 
      69             : /**
      70             :  * maximum gain pitch value (3.8, Equation 47)
      71             :  * (EE) This does not comply with the specification.
      72             :  * Specification says about 0.8, which should be
      73             :  * 13107 in (1.14), but reference C code uses
      74             :  * 13017 (equals to 0.7945) instead of it.
      75             :  */
      76             : #define SHARP_MAX                  13017
      77             : 
      78             : /**
      79             :  * MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26  * subframe_size) in (7.13)
      80             :  */
      81             : #define MR_ENERGY 1018156
      82             : 
      83             : #define DECISION_NOISE        0
      84             : #define DECISION_INTERMEDIATE 1
      85             : #define DECISION_VOICE        2
      86             : 
      87             : typedef enum {
      88             :     FORMAT_G729_8K = 0,
      89             :     FORMAT_G729D_6K4,
      90             :     FORMAT_COUNT,
      91             : } G729Formats;
      92             : 
      93             : typedef struct {
      94             :     uint8_t ac_index_bits[2];   ///< adaptive codebook index for second subframe (size in bits)
      95             :     uint8_t parity_bit;         ///< parity bit for pitch delay
      96             :     uint8_t gc_1st_index_bits;  ///< gain codebook (first stage) index (size in bits)
      97             :     uint8_t gc_2nd_index_bits;  ///< gain codebook (second stage) index (size in bits)
      98             :     uint8_t fc_signs_bits;      ///< number of pulses in fixed-codebook vector
      99             :     uint8_t fc_indexes_bits;    ///< size (in bits) of fixed-codebook index entry
     100             : } G729FormatDescription;
     101             : 
     102             : typedef struct {
     103             :     AudioDSPContext adsp;
     104             : 
     105             :     /// past excitation signal buffer
     106             :     int16_t exc_base[2*SUBFRAME_SIZE+PITCH_DELAY_MAX+INTERPOL_LEN];
     107             : 
     108             :     int16_t* exc;               ///< start of past excitation data in buffer
     109             :     int pitch_delay_int_prev;   ///< integer part of previous subframe's pitch delay (4.1.3)
     110             : 
     111             :     /// (2.13) LSP quantizer outputs
     112             :     int16_t  past_quantizer_output_buf[MA_NP + 1][10];
     113             :     int16_t* past_quantizer_outputs[MA_NP + 1];
     114             : 
     115             :     int16_t lsfq[10];           ///< (2.13) quantized LSF coefficients from previous frame
     116             :     int16_t lsp_buf[2][10];     ///< (0.15) LSP coefficients (previous and current frames) (3.2.5)
     117             :     int16_t *lsp[2];            ///< pointers to lsp_buf
     118             : 
     119             :     int16_t quant_energy[4];    ///< (5.10) past quantized energy
     120             : 
     121             :     /// previous speech data for LP synthesis filter
     122             :     int16_t syn_filter_data[10];
     123             : 
     124             : 
     125             :     /// residual signal buffer (used in long-term postfilter)
     126             :     int16_t residual[SUBFRAME_SIZE + RES_PREV_DATA_SIZE];
     127             : 
     128             :     /// previous speech data for residual calculation filter
     129             :     int16_t res_filter_data[SUBFRAME_SIZE+10];
     130             : 
     131             :     /// previous speech data for short-term postfilter
     132             :     int16_t pos_filter_data[SUBFRAME_SIZE+10];
     133             : 
     134             :     /// (1.14) pitch gain of current and five previous subframes
     135             :     int16_t past_gain_pitch[6];
     136             : 
     137             :     /// (14.1) gain code from current and previous subframe
     138             :     int16_t past_gain_code[2];
     139             : 
     140             :     /// voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
     141             :     int16_t voice_decision;
     142             : 
     143             :     int16_t onset;              ///< detected onset level (0-2)
     144             :     int16_t was_periodic;       ///< whether previous frame was declared as periodic or not (4.4)
     145             :     int16_t ht_prev_data;       ///< previous data for 4.2.3, equation 86
     146             :     int gain_coeff;             ///< (1.14) gain coefficient (4.2.4)
     147             :     uint16_t rand_value;        ///< random number generator value (4.4.4)
     148             :     int ma_predictor_prev;      ///< switched MA predictor of LSP quantizer from last good frame
     149             : 
     150             :     /// (14.14) high-pass filter data (past input)
     151             :     int hpf_f[2];
     152             : 
     153             :     /// high-pass filter data (past output)
     154             :     int16_t hpf_z[2];
     155             : }  G729Context;
     156             : 
     157             : static const G729FormatDescription format_g729_8k = {
     158             :     .ac_index_bits     = {8,5},
     159             :     .parity_bit        = 1,
     160             :     .gc_1st_index_bits = GC_1ST_IDX_BITS_8K,
     161             :     .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K,
     162             :     .fc_signs_bits     = 4,
     163             :     .fc_indexes_bits   = 13,
     164             : };
     165             : 
     166             : static const G729FormatDescription format_g729d_6k4 = {
     167             :     .ac_index_bits     = {8,4},
     168             :     .parity_bit        = 0,
     169             :     .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4,
     170             :     .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4,
     171             :     .fc_signs_bits     = 2,
     172             :     .fc_indexes_bits   = 9,
     173             : };
     174             : 
     175             : /**
     176             :  * @brief pseudo random number generator
     177             :  */
     178           0 : static inline uint16_t g729_prng(uint16_t value)
     179             : {
     180           0 :     return 31821 * value + 13849;
     181             : }
     182             : 
     183             : /**
     184             :  * Decodes LSF (Line Spectral Frequencies) from L0-L3 (3.2.4).
     185             :  * @param[out] lsfq (2.13) quantized LSF coefficients
     186             :  * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
     187             :  * @param ma_predictor switched MA predictor of LSP quantizer
     188             :  * @param vq_1st first stage vector of quantizer
     189             :  * @param vq_2nd_low second stage lower vector of LSP quantizer
     190             :  * @param vq_2nd_high second stage higher vector of LSP quantizer
     191             :  */
     192           0 : static void lsf_decode(int16_t* lsfq, int16_t* past_quantizer_outputs[MA_NP + 1],
     193             :                        int16_t ma_predictor,
     194             :                        int16_t vq_1st, int16_t vq_2nd_low, int16_t vq_2nd_high)
     195             : {
     196             :     int i,j;
     197             :     static const uint8_t min_distance[2]={10, 5}; //(2.13)
     198           0 :     int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
     199             : 
     200           0 :     for (i = 0; i < 5; i++) {
     201           0 :         quantizer_output[i]     = cb_lsp_1st[vq_1st][i    ] + cb_lsp_2nd[vq_2nd_low ][i    ];
     202           0 :         quantizer_output[i + 5] = cb_lsp_1st[vq_1st][i + 5] + cb_lsp_2nd[vq_2nd_high][i + 5];
     203             :     }
     204             : 
     205           0 :     for (j = 0; j < 2; j++) {
     206           0 :         for (i = 1; i < 10; i++) {
     207           0 :             int diff = (quantizer_output[i - 1] - quantizer_output[i] + min_distance[j]) >> 1;
     208           0 :             if (diff > 0) {
     209           0 :                 quantizer_output[i - 1] -= diff;
     210           0 :                 quantizer_output[i    ] += diff;
     211             :             }
     212             :         }
     213             :     }
     214             : 
     215           0 :     for (i = 0; i < 10; i++) {
     216           0 :         int sum = quantizer_output[i] * cb_ma_predictor_sum[ma_predictor][i];
     217           0 :         for (j = 0; j < MA_NP; j++)
     218           0 :             sum += past_quantizer_outputs[j][i] * cb_ma_predictor[ma_predictor][j][i];
     219             : 
     220           0 :         lsfq[i] = sum >> 15;
     221             :     }
     222             : 
     223           0 :     ff_acelp_reorder_lsf(lsfq, LSFQ_DIFF_MIN, LSFQ_MIN, LSFQ_MAX, 10);
     224           0 : }
     225             : 
     226             : /**
     227             :  * Restores past LSP quantizer output using LSF from previous frame
     228             :  * @param[in,out] lsfq (2.13) quantized LSF coefficients
     229             :  * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
     230             :  * @param ma_predictor_prev MA predictor from previous frame
     231             :  * @param lsfq_prev (2.13) quantized LSF coefficients from previous frame
     232             :  */
     233           0 : static void lsf_restore_from_previous(int16_t* lsfq,
     234             :                                       int16_t* past_quantizer_outputs[MA_NP + 1],
     235             :                                       int ma_predictor_prev)
     236             : {
     237           0 :     int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
     238             :     int i,k;
     239             : 
     240           0 :     for (i = 0; i < 10; i++) {
     241           0 :         int tmp = lsfq[i] << 15;
     242             : 
     243           0 :         for (k = 0; k < MA_NP; k++)
     244           0 :             tmp -= past_quantizer_outputs[k][i] * cb_ma_predictor[ma_predictor_prev][k][i];
     245             : 
     246           0 :         quantizer_output[i] = ((tmp >> 15) * cb_ma_predictor_sum_inv[ma_predictor_prev][i]) >> 12;
     247             :     }
     248           0 : }
     249             : 
     250             : /**
     251             :  * Constructs new excitation signal and applies phase filter to it
     252             :  * @param[out] out constructed speech signal
     253             :  * @param in original excitation signal
     254             :  * @param fc_cur (2.13) original fixed-codebook vector
     255             :  * @param gain_code (14.1) gain code
     256             :  * @param subframe_size length of the subframe
     257             :  */
     258           0 : static void g729d_get_new_exc(
     259             :         int16_t* out,
     260             :         const int16_t* in,
     261             :         const int16_t* fc_cur,
     262             :         int dstate,
     263             :         int gain_code,
     264             :         int subframe_size)
     265             : {
     266             :     int i;
     267             :     int16_t fc_new[SUBFRAME_SIZE];
     268             : 
     269           0 :     ff_celp_convolve_circ(fc_new, fc_cur, phase_filter[dstate], subframe_size);
     270             : 
     271           0 :     for(i=0; i<subframe_size; i++)
     272             :     {
     273           0 :         out[i]  = in[i];
     274           0 :         out[i] -= (gain_code * fc_cur[i] + 0x2000) >> 14;
     275           0 :         out[i] += (gain_code * fc_new[i] + 0x2000) >> 14;
     276             :     }
     277           0 : }
     278             : 
     279             : /**
     280             :  * Makes decision about onset in current subframe
     281             :  * @param past_onset decision result of previous subframe
     282             :  * @param past_gain_code gain code of current and previous subframe
     283             :  *
     284             :  * @return onset decision result for current subframe
     285             :  */
     286           0 : static int g729d_onset_decision(int past_onset, const int16_t* past_gain_code)
     287             : {
     288           0 :     if((past_gain_code[0] >> 1) > past_gain_code[1])
     289           0 :         return 2;
     290             :     else
     291           0 :         return FFMAX(past_onset-1, 0);
     292             : }
     293             : 
     294             : /**
     295             :  * Makes decision about voice presence in current subframe
     296             :  * @param onset onset level
     297             :  * @param prev_voice_decision voice decision result from previous subframe
     298             :  * @param past_gain_pitch pitch gain of current and previous subframes
     299             :  *
     300             :  * @return voice decision result for current subframe
     301             :  */
     302           0 : static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const int16_t* past_gain_pitch)
     303             : {
     304             :     int i, low_gain_pitch_cnt, voice_decision;
     305             : 
     306           0 :     if(past_gain_pitch[0] >= 14745)      // 0.9
     307           0 :         voice_decision = DECISION_VOICE;
     308           0 :     else if (past_gain_pitch[0] <= 9830) // 0.6
     309           0 :         voice_decision = DECISION_NOISE;
     310             :     else
     311           0 :         voice_decision = DECISION_INTERMEDIATE;
     312             : 
     313           0 :     for(i=0, low_gain_pitch_cnt=0; i<6; i++)
     314           0 :         if(past_gain_pitch[i] < 9830)
     315           0 :             low_gain_pitch_cnt++;
     316             : 
     317           0 :     if(low_gain_pitch_cnt > 2 && !onset)
     318           0 :         voice_decision = DECISION_NOISE;
     319             : 
     320           0 :     if(!onset && voice_decision > prev_voice_decision + 1)
     321           0 :         voice_decision--;
     322             : 
     323           0 :     if(onset && voice_decision < DECISION_VOICE)
     324           0 :         voice_decision++;
     325             : 
     326           0 :     return voice_decision;
     327             : }
     328             : 
     329           0 : static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order)
     330             : {
     331           0 :     int res = 0;
     332             : 
     333           0 :     while (order--)
     334           0 :         res += *v1++ * *v2++;
     335             : 
     336           0 :     return res;
     337             : }
     338             : 
     339           0 : static av_cold int decoder_init(AVCodecContext * avctx)
     340             : {
     341           0 :     G729Context* ctx = avctx->priv_data;
     342             :     int i,k;
     343             : 
     344           0 :     if (avctx->channels != 1) {
     345           0 :         av_log(avctx, AV_LOG_ERROR, "Only mono sound is supported (requested channels: %d).\n", avctx->channels);
     346           0 :         return AVERROR(EINVAL);
     347             :     }
     348           0 :     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
     349             : 
     350             :     /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
     351           0 :     avctx->frame_size = SUBFRAME_SIZE << 1;
     352             : 
     353           0 :     ctx->gain_coeff = 16384; // 1.0 in (1.14)
     354             : 
     355           0 :     for (k = 0; k < MA_NP + 1; k++) {
     356           0 :         ctx->past_quantizer_outputs[k] = ctx->past_quantizer_output_buf[k];
     357           0 :         for (i = 1; i < 11; i++)
     358           0 :             ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3;
     359             :     }
     360             : 
     361           0 :     ctx->lsp[0] = ctx->lsp_buf[0];
     362           0 :     ctx->lsp[1] = ctx->lsp_buf[1];
     363           0 :     memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t));
     364             : 
     365           0 :     ctx->exc = &ctx->exc_base[PITCH_DELAY_MAX+INTERPOL_LEN];
     366             : 
     367           0 :     ctx->pitch_delay_int_prev = PITCH_DELAY_MIN;
     368             : 
     369             :     /* random seed initialization */
     370           0 :     ctx->rand_value = 21845;
     371             : 
     372             :     /* quantized prediction error */
     373           0 :     for(i=0; i<4; i++)
     374           0 :         ctx->quant_energy[i] = -14336; // -14 in (5.10)
     375             : 
     376           0 :     ff_audiodsp_init(&ctx->adsp);
     377           0 :     ctx->adsp.scalarproduct_int16 = scalarproduct_int16_c;
     378             : 
     379           0 :     return 0;
     380             : }
     381             : 
     382           0 : static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
     383             :                         AVPacket *avpkt)
     384             : {
     385           0 :     const uint8_t *buf = avpkt->data;
     386           0 :     int buf_size       = avpkt->size;
     387             :     int16_t *out_frame;
     388             :     GetBitContext gb;
     389             :     const G729FormatDescription *format;
     390           0 :     int frame_erasure = 0;    ///< frame erasure detected during decoding
     391           0 :     int bad_pitch = 0;        ///< parity check failed
     392             :     int i;
     393             :     int16_t *tmp;
     394             :     G729Formats packet_type;
     395           0 :     G729Context *ctx = avctx->priv_data;
     396             :     int16_t lp[2][11];           // (3.12)
     397             :     uint8_t ma_predictor;     ///< switched MA predictor of LSP quantizer
     398             :     uint8_t quantizer_1st;    ///< first stage vector of quantizer
     399             :     uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
     400             :     uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
     401             : 
     402             :     int pitch_delay_int[2];      // pitch delay, integer part
     403             :     int pitch_delay_3x;          // pitch delay, multiplied by 3
     404             :     int16_t fc[SUBFRAME_SIZE];   // fixed-codebook vector
     405             :     int16_t synth[SUBFRAME_SIZE+10]; // fixed-codebook vector
     406             :     int j, ret;
     407             :     int gain_before, gain_after;
     408           0 :     int is_periodic = 0;         // whether one of the subframes is declared as periodic or not
     409           0 :     AVFrame *frame = data;
     410             : 
     411           0 :     frame->nb_samples = SUBFRAME_SIZE<<1;
     412           0 :     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
     413           0 :         return ret;
     414           0 :     out_frame = (int16_t*) frame->data[0];
     415             : 
     416           0 :     if (buf_size % 10 == 0) {
     417           0 :         packet_type = FORMAT_G729_8K;
     418           0 :         format = &format_g729_8k;
     419             :         //Reset voice decision
     420           0 :         ctx->onset = 0;
     421           0 :         ctx->voice_decision = DECISION_VOICE;
     422           0 :         av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
     423           0 :     } else if (buf_size == 8) {
     424           0 :         packet_type = FORMAT_G729D_6K4;
     425           0 :         format = &format_g729d_6k4;
     426           0 :         av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
     427             :     } else {
     428           0 :         av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
     429           0 :         return AVERROR_INVALIDDATA;
     430             :     }
     431             : 
     432           0 :     for (i=0; i < buf_size; i++)
     433           0 :         frame_erasure |= buf[i];
     434           0 :     frame_erasure = !frame_erasure;
     435             : 
     436           0 :     init_get_bits(&gb, buf, 8*buf_size);
     437             : 
     438           0 :     ma_predictor     = get_bits(&gb, 1);
     439           0 :     quantizer_1st    = get_bits(&gb, VQ_1ST_BITS);
     440           0 :     quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
     441           0 :     quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
     442             : 
     443           0 :     if(frame_erasure)
     444           0 :         lsf_restore_from_previous(ctx->lsfq, ctx->past_quantizer_outputs,
     445             :                                   ctx->ma_predictor_prev);
     446             :     else {
     447           0 :         lsf_decode(ctx->lsfq, ctx->past_quantizer_outputs,
     448             :                    ma_predictor,
     449             :                    quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
     450           0 :         ctx->ma_predictor_prev = ma_predictor;
     451             :     }
     452             : 
     453           0 :     tmp = ctx->past_quantizer_outputs[MA_NP];
     454           0 :     memmove(ctx->past_quantizer_outputs + 1, ctx->past_quantizer_outputs,
     455             :             MA_NP * sizeof(int16_t*));
     456           0 :     ctx->past_quantizer_outputs[0] = tmp;
     457             : 
     458           0 :     ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
     459             : 
     460           0 :     ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
     461             : 
     462           0 :     FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
     463             : 
     464           0 :     for (i = 0; i < 2; i++) {
     465             :         int gain_corr_factor;
     466             : 
     467             :         uint8_t ac_index;      ///< adaptive codebook index
     468             :         uint8_t pulses_signs;  ///< fixed-codebook vector pulse signs
     469             :         int fc_indexes;        ///< fixed-codebook indexes
     470             :         uint8_t gc_1st_index;  ///< gain codebook (first stage) index
     471             :         uint8_t gc_2nd_index;  ///< gain codebook (second stage) index
     472             : 
     473           0 :         ac_index      = get_bits(&gb, format->ac_index_bits[i]);
     474           0 :         if(!i && format->parity_bit)
     475           0 :             bad_pitch = av_parity(ac_index >> 2) == get_bits1(&gb);
     476           0 :         fc_indexes    = get_bits(&gb, format->fc_indexes_bits);
     477           0 :         pulses_signs  = get_bits(&gb, format->fc_signs_bits);
     478           0 :         gc_1st_index  = get_bits(&gb, format->gc_1st_index_bits);
     479           0 :         gc_2nd_index  = get_bits(&gb, format->gc_2nd_index_bits);
     480             : 
     481           0 :         if (frame_erasure)
     482           0 :             pitch_delay_3x   = 3 * ctx->pitch_delay_int_prev;
     483           0 :         else if(!i) {
     484           0 :             if (bad_pitch)
     485           0 :                 pitch_delay_3x   = 3 * ctx->pitch_delay_int_prev;
     486             :             else
     487           0 :                 pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index);
     488             :         } else {
     489           0 :             int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5,
     490             :                                           PITCH_DELAY_MIN, PITCH_DELAY_MAX - 9);
     491             : 
     492           0 :             if(packet_type == FORMAT_G729D_6K4)
     493           0 :                 pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min);
     494             :             else
     495           0 :                 pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min);
     496             :         }
     497             : 
     498             :         /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
     499           0 :         pitch_delay_int[i]  = (pitch_delay_3x + 1) / 3;
     500           0 :         if (pitch_delay_int[i] > PITCH_DELAY_MAX) {
     501           0 :             av_log(avctx, AV_LOG_WARNING, "pitch_delay_int %d is too large\n", pitch_delay_int[i]);
     502           0 :             pitch_delay_int[i] = PITCH_DELAY_MAX;
     503             :         }
     504             : 
     505           0 :         if (frame_erasure) {
     506           0 :             ctx->rand_value = g729_prng(ctx->rand_value);
     507           0 :             fc_indexes   = av_mod_uintp2(ctx->rand_value, format->fc_indexes_bits);
     508             : 
     509           0 :             ctx->rand_value = g729_prng(ctx->rand_value);
     510           0 :             pulses_signs = ctx->rand_value;
     511             :         }
     512             : 
     513             : 
     514           0 :         memset(fc, 0, sizeof(int16_t) * SUBFRAME_SIZE);
     515           0 :         switch (packet_type) {
     516           0 :             case FORMAT_G729_8K:
     517           0 :                 ff_acelp_fc_pulse_per_track(fc, ff_fc_4pulses_8bits_tracks_13,
     518             :                                             ff_fc_4pulses_8bits_track_4,
     519             :                                             fc_indexes, pulses_signs, 3, 3);
     520           0 :                 break;
     521           0 :             case FORMAT_G729D_6K4:
     522           0 :                 ff_acelp_fc_pulse_per_track(fc, ff_fc_2pulses_9bits_track1_gray,
     523             :                                             ff_fc_2pulses_9bits_track2_gray,
     524             :                                             fc_indexes, pulses_signs, 1, 4);
     525           0 :                 break;
     526             :         }
     527             : 
     528             :         /*
     529             :           This filter enhances harmonic components of the fixed-codebook vector to
     530             :           improve the quality of the reconstructed speech.
     531             : 
     532             :                      / fc_v[i],                                    i < pitch_delay
     533             :           fc_v[i] = <
     534             :                      \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
     535             :         */
     536           0 :         ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
     537           0 :                                      fc + pitch_delay_int[i],
     538             :                                      fc, 1 << 14,
     539           0 :                                      av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX),
     540             :                                      0, 14,
     541           0 :                                      SUBFRAME_SIZE - pitch_delay_int[i]);
     542             : 
     543           0 :         memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t));
     544           0 :         ctx->past_gain_code[1] = ctx->past_gain_code[0];
     545             : 
     546           0 :         if (frame_erasure) {
     547           0 :             ctx->past_gain_pitch[0] = (29491 * ctx->past_gain_pitch[0]) >> 15; // 0.90 (0.15)
     548           0 :             ctx->past_gain_code[0]  = ( 2007 * ctx->past_gain_code[0] ) >> 11; // 0.98 (0.11)
     549             : 
     550           0 :             gain_corr_factor = 0;
     551             :         } else {
     552           0 :             if (packet_type == FORMAT_G729D_6K4) {
     553           0 :                 ctx->past_gain_pitch[0]  = cb_gain_1st_6k4[gc_1st_index][0] +
     554           0 :                                            cb_gain_2nd_6k4[gc_2nd_index][0];
     555           0 :                 gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] +
     556           0 :                                    cb_gain_2nd_6k4[gc_2nd_index][1];
     557             : 
     558             :                 /* Without check below overflow can occur in ff_acelp_update_past_gain.
     559             :                    It is not issue for G.729, because gain_corr_factor in it's case is always
     560             :                    greater than 1024, while in G.729D it can be even zero. */
     561           0 :                 gain_corr_factor = FFMAX(gain_corr_factor, 1024);
     562             : #ifndef G729_BITEXACT
     563           0 :                 gain_corr_factor >>= 1;
     564             : #endif
     565             :             } else {
     566           0 :                 ctx->past_gain_pitch[0]  = cb_gain_1st_8k[gc_1st_index][0] +
     567           0 :                                            cb_gain_2nd_8k[gc_2nd_index][0];
     568           0 :                 gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
     569           0 :                                    cb_gain_2nd_8k[gc_2nd_index][1];
     570             :             }
     571             : 
     572             :             /* Decode the fixed-codebook gain. */
     573           0 :             ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&ctx->adsp, gain_corr_factor,
     574             :                                                                fc, MR_ENERGY,
     575           0 :                                                                ctx->quant_energy,
     576             :                                                                ma_prediction_coeff,
     577             :                                                                SUBFRAME_SIZE, 4);
     578             : #ifdef G729_BITEXACT
     579             :             /*
     580             :               This correction required to get bit-exact result with
     581             :               reference code, because gain_corr_factor in G.729D is
     582             :               two times larger than in original G.729.
     583             : 
     584             :               If bit-exact result is not issue then gain_corr_factor
     585             :               can be simpler divided by 2 before call to g729_get_gain_code
     586             :               instead of using correction below.
     587             :             */
     588             :             if (packet_type == FORMAT_G729D_6K4) {
     589             :                 gain_corr_factor >>= 1;
     590             :                 ctx->past_gain_code[0] >>= 1;
     591             :             }
     592             : #endif
     593             :         }
     594           0 :         ff_acelp_update_past_gain(ctx->quant_energy, gain_corr_factor, 2, frame_erasure);
     595             : 
     596             :         /* Routine requires rounding to lowest. */
     597           0 :         ff_acelp_interpolate(ctx->exc + i * SUBFRAME_SIZE,
     598           0 :                              ctx->exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3,
     599             :                              ff_acelp_interp_filter, 6,
     600           0 :                              (pitch_delay_3x % 3) << 1,
     601             :                              10, SUBFRAME_SIZE);
     602             : 
     603           0 :         ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE,
     604           0 :                                      ctx->exc + i * SUBFRAME_SIZE, fc,
     605           0 :                                      (!ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_pitch[0],
     606           0 :                                      ( ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_code[0],
     607             :                                      1 << 13, 14, SUBFRAME_SIZE);
     608             : 
     609           0 :         memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t));
     610             : 
     611           0 :         if (ff_celp_lp_synthesis_filter(
     612             :             synth+10,
     613           0 :             &lp[i][1],
     614           0 :             ctx->exc  + i * SUBFRAME_SIZE,
     615             :             SUBFRAME_SIZE,
     616             :             10,
     617             :             1,
     618             :             0,
     619             :             0x800))
     620             :             /* Overflow occurred, downscale excitation signal... */
     621           0 :             for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++)
     622           0 :                 ctx->exc_base[j] >>= 2;
     623             : 
     624             :         /* ... and make synthesis again. */
     625           0 :         if (packet_type == FORMAT_G729D_6K4) {
     626             :             int16_t exc_new[SUBFRAME_SIZE];
     627             : 
     628           0 :             ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code);
     629           0 :             ctx->voice_decision = g729d_voice_decision(ctx->onset, ctx->voice_decision, ctx->past_gain_pitch);
     630             : 
     631           0 :             g729d_get_new_exc(exc_new, ctx->exc  + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE);
     632             : 
     633           0 :             ff_celp_lp_synthesis_filter(
     634             :                     synth+10,
     635           0 :                     &lp[i][1],
     636             :                     exc_new,
     637             :                     SUBFRAME_SIZE,
     638             :                     10,
     639             :                     0,
     640             :                     0,
     641             :                     0x800);
     642             :         } else {
     643           0 :             ff_celp_lp_synthesis_filter(
     644             :                     synth+10,
     645           0 :                     &lp[i][1],
     646           0 :                     ctx->exc  + i * SUBFRAME_SIZE,
     647             :                     SUBFRAME_SIZE,
     648             :                     10,
     649             :                     0,
     650             :                     0,
     651             :                     0x800);
     652             :         }
     653             :         /* Save data (without postfilter) for use in next subframe. */
     654           0 :         memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t));
     655             : 
     656             :         /* Calculate gain of unfiltered signal for use in AGC. */
     657           0 :         gain_before = 0;
     658           0 :         for (j = 0; j < SUBFRAME_SIZE; j++)
     659           0 :             gain_before += FFABS(synth[j+10]);
     660             : 
     661             :         /* Call postfilter and also update voicing decision for use in next frame. */
     662           0 :         ff_g729_postfilter(
     663             :                 &ctx->adsp,
     664             :                 &ctx->ht_prev_data,
     665             :                 &is_periodic,
     666           0 :                 &lp[i][0],
     667             :                 pitch_delay_int[0],
     668           0 :                 ctx->residual,
     669           0 :                 ctx->res_filter_data,
     670           0 :                 ctx->pos_filter_data,
     671             :                 synth+10,
     672             :                 SUBFRAME_SIZE);
     673             : 
     674             :         /* Calculate gain of filtered signal for use in AGC. */
     675           0 :         gain_after = 0;
     676           0 :         for(j=0; j<SUBFRAME_SIZE; j++)
     677           0 :             gain_after += FFABS(synth[j+10]);
     678             : 
     679           0 :         ctx->gain_coeff = ff_g729_adaptive_gain_control(
     680             :                 gain_before,
     681             :                 gain_after,
     682             :                 synth+10,
     683             :                 SUBFRAME_SIZE,
     684           0 :                 ctx->gain_coeff);
     685             : 
     686           0 :         if (frame_erasure)
     687           0 :             ctx->pitch_delay_int_prev = FFMIN(ctx->pitch_delay_int_prev + 1, PITCH_DELAY_MAX);
     688             :         else
     689           0 :             ctx->pitch_delay_int_prev = pitch_delay_int[i];
     690             : 
     691           0 :         memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t));
     692           0 :         ff_acelp_high_pass_filter(
     693             :                 out_frame + i*SUBFRAME_SIZE,
     694           0 :                 ctx->hpf_f,
     695             :                 synth+10,
     696             :                 SUBFRAME_SIZE);
     697           0 :         memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t));
     698             :     }
     699             : 
     700           0 :     ctx->was_periodic = is_periodic;
     701             : 
     702             :     /* Save signal for use in next frame. */
     703           0 :     memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t));
     704             : 
     705           0 :     *got_frame_ptr = 1;
     706           0 :     return packet_type == FORMAT_G729_8K ? 10 : 8;
     707             : }
     708             : 
     709             : AVCodec ff_g729_decoder = {
     710             :     .name           = "g729",
     711             :     .long_name      = NULL_IF_CONFIG_SMALL("G.729"),
     712             :     .type           = AVMEDIA_TYPE_AUDIO,
     713             :     .id             = AV_CODEC_ID_G729,
     714             :     .priv_data_size = sizeof(G729Context),
     715             :     .init           = decoder_init,
     716             :     .decode         = decode_frame,
     717             :     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
     718             : };

Generated by: LCOV version 1.13