LCOV - code coverage report
Current view: top level - libavcodec - sipr16k.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 100 101 99.0 %
Date: 2017-12-17 16:07:53 Functions: 10 10 100.0 %

          Line data    Source code
       1             : /*
       2             :  * SIPR decoder for the 16k mode
       3             :  *
       4             :  * Copyright (c) 2008 Vladimir Voroshilov
       5             :  * Copyright (c) 2009 Vitor Sessak
       6             :  *
       7             :  * This file is part of FFmpeg.
       8             :  *
       9             :  * FFmpeg is free software; you can redistribute it and/or
      10             :  * modify it under the terms of the GNU Lesser General Public
      11             :  * License as published by the Free Software Foundation; either
      12             :  * version 2.1 of the License, or (at your option) any later version.
      13             :  *
      14             :  * FFmpeg is distributed in the hope that it will be useful,
      15             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      16             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      17             :  * Lesser General Public License for more details.
      18             :  *
      19             :  * You should have received a copy of the GNU Lesser General Public
      20             :  * License along with FFmpeg; if not, write to the Free Software
      21             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      22             :  */
      23             : 
      24             : #include <math.h>
      25             : 
      26             : #include "sipr.h"
      27             : #include "libavutil/attributes.h"
      28             : #include "libavutil/common.h"
      29             : #include "libavutil/float_dsp.h"
      30             : #include "libavutil/mathematics.h"
      31             : #include "lsp.h"
      32             : #include "acelp_vectors.h"
      33             : #include "acelp_pitch_delay.h"
      34             : #include "acelp_filters.h"
      35             : #include "celp_filters.h"
      36             : 
      37             : #include "sipr16kdata.h"
      38             : 
      39             : /**
      40             :  * Convert an lsf vector into an lsp vector.
      41             :  *
      42             :  * @param lsf               input lsf vector
      43             :  * @param lsp               output lsp vector
      44             :  */
      45        3250 : static void lsf2lsp(const float *lsf, double *lsp)
      46             : {
      47             :     int i;
      48             : 
      49       55250 :     for (i = 0; i < LP_FILTER_ORDER_16k; i++)
      50       52000 :         lsp[i] = cosf(lsf[i]);
      51        3250 : }
      52             : 
      53        3250 : static void dequant(float *out, const int *idx, const float * const cbs[])
      54             : {
      55             :     int i;
      56             : 
      57       16250 :     for (i = 0; i < 4; i++)
      58       13000 :         memcpy(out + 3*i, cbs[i] + 3*idx[i], 3*sizeof(float));
      59             : 
      60        3250 :     memcpy(out + 12, cbs[4] + 4*idx[4], 4*sizeof(float));
      61        3250 : }
      62             : 
      63        3250 : static void lsf_decode_fp_16k(float* lsf_history, float* isp_new,
      64             :                               const int* parm, int ma_pred)
      65             : {
      66             :     int i;
      67             :     float isp_q[LP_FILTER_ORDER_16k];
      68             : 
      69        3250 :     dequant(isp_q, parm, lsf_codebooks_16k);
      70             : 
      71       55250 :     for (i = 0; i < LP_FILTER_ORDER_16k; i++) {
      72      156000 :         isp_new[i] = (1 - qu[ma_pred]) * isp_q[i]
      73       52000 :                     +     qu[ma_pred]  * lsf_history[i]
      74      104000 :                     + mean_lsf_16k[i];
      75             :     }
      76             : 
      77        3250 :     memcpy(lsf_history, isp_q, LP_FILTER_ORDER_16k * sizeof(float));
      78        3250 : }
      79             : 
      80        3250 : static int dec_delay3_1st(int index)
      81             : {
      82        3250 :     if (index < 390) {
      83        2237 :         return index + 88;
      84             :     } else
      85        1013 :         return 3 * index - 690;
      86             : }
      87             : 
      88        3250 : static int dec_delay3_2nd(int index, int pit_min, int pit_max,
      89             :                           int pitch_lag_prev)
      90             : {
      91        3250 :     if (index < 62) {
      92        3250 :         int pitch_delay_min = av_clip(pitch_lag_prev - 10,
      93             :                                       pit_min, pit_max - 19);
      94        3250 :         return 3 * pitch_delay_min + index - 2;
      95             :     } else
      96           0 :         return 3 * pitch_lag_prev;
      97             : }
      98             : 
      99        3250 : static void postfilter(float *out_data, float* synth, float* iir_mem,
     100             :                        float* filt_mem[2], float* mem_preemph)
     101             : {
     102             :     float buf[30 + LP_FILTER_ORDER_16k];
     103        3250 :     float *tmpbuf = buf + LP_FILTER_ORDER_16k;
     104             :     float s;
     105             :     int i;
     106             : 
     107       55250 :     for (i = 0; i < LP_FILTER_ORDER_16k; i++)
     108       52000 :         filt_mem[0][i] = iir_mem[i] * ff_pow_0_5[i];
     109             : 
     110        3250 :     memcpy(tmpbuf - LP_FILTER_ORDER_16k, mem_preemph,
     111             :            LP_FILTER_ORDER_16k*sizeof(*buf));
     112             : 
     113        3250 :     ff_celp_lp_synthesis_filterf(tmpbuf, filt_mem[1], synth, 30,
     114             :                                  LP_FILTER_ORDER_16k);
     115             : 
     116        3250 :     memcpy(synth - LP_FILTER_ORDER_16k, mem_preemph,
     117             :            LP_FILTER_ORDER_16k * sizeof(*synth));
     118             : 
     119        3250 :     ff_celp_lp_synthesis_filterf(synth, filt_mem[0], synth, 30,
     120             :                                  LP_FILTER_ORDER_16k);
     121             : 
     122        3250 :     memcpy(out_data + 30 - LP_FILTER_ORDER_16k,
     123        3250 :            synth    + 30 - LP_FILTER_ORDER_16k,
     124             :            LP_FILTER_ORDER_16k * sizeof(*synth));
     125             : 
     126        3250 :     ff_celp_lp_synthesis_filterf(out_data + 30, filt_mem[0],
     127        3250 :                                  synth + 30, 2 * L_SUBFR_16k - 30,
     128             :                                  LP_FILTER_ORDER_16k);
     129             : 
     130             : 
     131        3250 :     memcpy(mem_preemph, out_data + 2*L_SUBFR_16k - LP_FILTER_ORDER_16k,
     132             :            LP_FILTER_ORDER_16k * sizeof(*synth));
     133             : 
     134        3250 :     FFSWAP(float *, filt_mem[0], filt_mem[1]);
     135      100750 :     for (i = 0, s = 0; i < 30; i++, s += 1.0/30)
     136       97500 :         out_data[i] = tmpbuf[i] + s * (synth[i] - tmpbuf[i]);
     137        3250 : }
     138             : 
     139             : /**
     140             :  * Floating point version of ff_acelp_lp_decode().
     141             :  */
     142        3250 : static void acelp_lp_decodef(float *lp_1st, float *lp_2nd,
     143             :                              const double *lsp_2nd, const double *lsp_prev)
     144             : {
     145             :     double lsp_1st[LP_FILTER_ORDER_16k];
     146             :     int i;
     147             : 
     148             :     /* LSP values for first subframe (3.2.5 of G.729, Equation 24) */
     149       55250 :     for (i = 0; i < LP_FILTER_ORDER_16k; i++)
     150       52000 :         lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) * 0.5;
     151             : 
     152        3250 :     ff_acelp_lspd2lpc(lsp_1st, lp_1st, LP_FILTER_ORDER_16k >> 1);
     153             : 
     154             :     /* LSP values for second subframe (3.2.5 of G.729) */
     155        3250 :     ff_acelp_lspd2lpc(lsp_2nd, lp_2nd, LP_FILTER_ORDER_16k >> 1);
     156        3250 : }
     157             : 
     158             : /**
     159             :  * Floating point version of ff_acelp_decode_gain_code().
     160             :  */
     161        6500 : static float acelp_decode_gain_codef(float gain_corr_factor, const float *fc_v,
     162             :                                      float mr_energy, const float *quant_energy,
     163             :                                      const float *ma_prediction_coeff,
     164             :                                      int subframe_size, int ma_pred_order)
     165             : {
     166        6500 :     mr_energy += avpriv_scalarproduct_float_c(quant_energy, ma_prediction_coeff,
     167             :                                               ma_pred_order);
     168             : 
     169       13000 :     mr_energy = gain_corr_factor * exp(M_LN10 / 20. * mr_energy) /
     170        6500 :         sqrt((0.01 + avpriv_scalarproduct_float_c(fc_v, fc_v, subframe_size)));
     171        6500 :     return mr_energy;
     172             : }
     173             : 
     174             : #define DIVIDE_BY_3(x) ((x) * 10923 >> 15)
     175             : 
     176        3250 : void ff_sipr_decode_frame_16k(SiprContext *ctx, SiprParameters *params,
     177             :                               float *out_data)
     178             : {
     179        3250 :     int frame_size = SUBFRAME_COUNT_16k * L_SUBFR_16k;
     180        3250 :     float *synth = ctx->synth_buf + LP_FILTER_ORDER_16k;
     181             :     float lsf_new[LP_FILTER_ORDER_16k];
     182             :     double lsp_new[LP_FILTER_ORDER_16k];
     183             :     float Az[2][LP_FILTER_ORDER_16k];
     184             :     float fixed_vector[L_SUBFR_16k];
     185             :     float pitch_fac, gain_code;
     186             : 
     187             :     int i;
     188             :     int pitch_delay_3x;
     189             : 
     190        3250 :     float *excitation = ctx->excitation + 292;
     191             : 
     192        3250 :     lsf_decode_fp_16k(ctx->lsf_history, lsf_new, params->vq_indexes,
     193             :                       params->ma_pred_switch);
     194             : 
     195        3250 :     ff_set_min_dist_lsf(lsf_new, LSFQ_DIFF_MIN / 2, LP_FILTER_ORDER_16k);
     196             : 
     197        3250 :     lsf2lsp(lsf_new, lsp_new);
     198             : 
     199        3250 :     acelp_lp_decodef(Az[0], Az[1], lsp_new, ctx->lsp_history_16k);
     200             : 
     201        3250 :     memcpy(ctx->lsp_history_16k, lsp_new, LP_FILTER_ORDER_16k * sizeof(double));
     202             : 
     203        3250 :     memcpy(synth - LP_FILTER_ORDER_16k, ctx->synth,
     204             :            LP_FILTER_ORDER_16k * sizeof(*synth));
     205             : 
     206        9750 :     for (i = 0; i < SUBFRAME_COUNT_16k; i++) {
     207        6500 :         int i_subfr = i * L_SUBFR_16k;
     208             :         AMRFixed f;
     209             :         float gain_corr_factor;
     210             :         int pitch_delay_int;
     211             :         int pitch_delay_frac;
     212             : 
     213        6500 :         if (!i) {
     214        3250 :             pitch_delay_3x = dec_delay3_1st(params->pitch_delay[i]);
     215             :         } else
     216        3250 :             pitch_delay_3x = dec_delay3_2nd(params->pitch_delay[i],
     217             :                                             PITCH_MIN, PITCH_MAX,
     218             :                                             ctx->pitch_lag_prev);
     219             : 
     220        6500 :         pitch_fac = gain_pitch_cb_16k[params->gp_index[i]];
     221        6500 :         f.pitch_fac = FFMIN(pitch_fac, 1.0);
     222        6500 :         f.pitch_lag = DIVIDE_BY_3(pitch_delay_3x+1);
     223        6500 :         ctx->pitch_lag_prev = f.pitch_lag;
     224             : 
     225        6500 :         pitch_delay_int  = DIVIDE_BY_3(pitch_delay_3x + 2);
     226        6500 :         pitch_delay_frac = pitch_delay_3x + 2 - 3*pitch_delay_int;
     227             : 
     228       19500 :         ff_acelp_interpolatef(&excitation[i_subfr],
     229       13000 :                               &excitation[i_subfr] - pitch_delay_int + 1,
     230             :                               sinc_win, 3, pitch_delay_frac + 1,
     231             :                               LP_FILTER_ORDER, L_SUBFR_16k);
     232             : 
     233             : 
     234        6500 :         memset(fixed_vector, 0, sizeof(fixed_vector));
     235             : 
     236        6500 :         ff_decode_10_pulses_35bits(params->fc_indexes[i], &f,
     237             :                                    ff_fc_4pulses_8bits_tracks_13, 5, 4);
     238             : 
     239        6500 :         ff_set_fixed_vector(fixed_vector, &f, 1.0, L_SUBFR_16k);
     240             : 
     241        6500 :         gain_corr_factor = gain_cb_16k[params->gc_index[i]];
     242        6500 :         gain_code = gain_corr_factor *
     243        6500 :             acelp_decode_gain_codef(sqrt(L_SUBFR_16k), fixed_vector,
     244             :                                     19.0 - 15.0/(0.05*M_LN10/M_LN2),
     245        6500 :                                     pred_16k, ctx->energy_history,
     246             :                                     L_SUBFR_16k, 2);
     247             : 
     248        6500 :         ctx->energy_history[1] = ctx->energy_history[0];
     249        6500 :         ctx->energy_history[0] = 20.0 * log10f(gain_corr_factor);
     250             : 
     251        6500 :         ff_weighted_vector_sumf(&excitation[i_subfr], &excitation[i_subfr],
     252             :                                 fixed_vector, pitch_fac,
     253             :                                 gain_code, L_SUBFR_16k);
     254             : 
     255        6500 :         ff_celp_lp_synthesis_filterf(synth + i_subfr, Az[i],
     256        6500 :                                      &excitation[i_subfr], L_SUBFR_16k,
     257             :                                      LP_FILTER_ORDER_16k);
     258             : 
     259             :     }
     260        3250 :     memcpy(ctx->synth, synth + frame_size - LP_FILTER_ORDER_16k,
     261             :            LP_FILTER_ORDER_16k * sizeof(*synth));
     262             : 
     263        3250 :     memmove(ctx->excitation, ctx->excitation + 2 * L_SUBFR_16k,
     264             :             (L_INTERPOL+PITCH_MAX) * sizeof(float));
     265             : 
     266        3250 :     postfilter(out_data, synth, ctx->iir_mem, ctx->filt_mem, ctx->mem_preemph);
     267             : 
     268        3250 :     memcpy(ctx->iir_mem, Az[1], LP_FILTER_ORDER_16k * sizeof(float));
     269        3250 : }
     270             : 
     271           2 : av_cold void ff_sipr_init_16k(SiprContext *ctx)
     272             : {
     273             :     int i;
     274             : 
     275          34 :     for (i = 0; i < LP_FILTER_ORDER_16k; i++)
     276          32 :         ctx->lsp_history_16k[i] = cos((i + 1) * M_PI/(LP_FILTER_ORDER_16k + 1));
     277             : 
     278           2 :     ctx->filt_mem[0] = ctx->filt_buf[0];
     279           2 :     ctx->filt_mem[1] = ctx->filt_buf[1];
     280             : 
     281           2 :     ctx->pitch_lag_prev = 180;
     282           2 : }

Generated by: LCOV version 1.13