• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/sipr16k.c

Go to the documentation of this file.
00001 /*
00002  * SIPR decoder for the 16k mode
00003  *
00004  * Copyright (c) 2008 Vladimir Voroshilov
00005  * Copyright (c) 2009 Vitor Sessak
00006  *
00007  * This file is part of FFmpeg.
00008  *
00009  * FFmpeg is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU Lesser General Public
00011  * License as published by the Free Software Foundation; either
00012  * version 2.1 of the License, or (at your option) any later version.
00013  *
00014  * FFmpeg is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017  * Lesser General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU Lesser General Public
00020  * License along with FFmpeg; if not, write to the Free Software
00021  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00022  */
00023 
00024 #include <math.h>
00025 
00026 #include "sipr.h"
00027 #include "libavutil/mathematics.h"
00028 #include "lsp.h"
00029 #include "celp_math.h"
00030 #include "acelp_vectors.h"
00031 #include "acelp_pitch_delay.h"
00032 #include "acelp_filters.h"
00033 #include "celp_filters.h"
00034 
00035 #include "sipr16kdata.h"
00036 
00043 static void lsf2lsp(const float *lsf, double *lsp)
00044 {
00045     int i;
00046 
00047     for (i = 0; i < LP_FILTER_ORDER_16k; i++)
00048         lsp[i] = cosf(lsf[i]);
00049 }
00050 
00051 static void dequant(float *out, const int *idx, const float *cbs[])
00052 {
00053     int i;
00054 
00055     for (i = 0; i < 4; i++)
00056         memcpy(out + 3*i, cbs[i] + 3*idx[i], 3*sizeof(float));
00057 
00058     memcpy(out + 12, cbs[4] + 4*idx[4], 4*sizeof(float));
00059 }
00060 
00061 static void lsf_decode_fp_16k(float* lsf_history, float* isp_new,
00062                               const int* parm, int ma_pred)
00063 {
00064     int i;
00065     float isp_q[LP_FILTER_ORDER_16k];
00066 
00067     dequant(isp_q, parm, lsf_codebooks_16k);
00068 
00069     for (i = 0; i < LP_FILTER_ORDER_16k; i++) {
00070         isp_new[i] = (1 - qu[ma_pred]) * isp_q[i]
00071                     +     qu[ma_pred]  * lsf_history[i]
00072                     + mean_lsf_16k[i];
00073     }
00074 
00075     memcpy(lsf_history, isp_q, LP_FILTER_ORDER_16k * sizeof(float));
00076 }
00077 
00078 static int dec_delay3_1st(int index)
00079 {
00080     if (index < 390) {
00081         return index + 88;
00082     } else
00083         return 3 * index - 690;
00084 }
00085 
00086 static int dec_delay3_2nd(int index, int pit_min, int pit_max,
00087                           int pitch_lag_prev)
00088 {
00089     if (index < 62) {
00090         int pitch_delay_min = av_clip(pitch_lag_prev - 10,
00091                                       pit_min, pit_max - 19);
00092         return 3 * pitch_delay_min + index - 2;
00093     } else
00094         return 3 * pitch_lag_prev;
00095 }
00096 
00097 static void postfilter(float *out_data, float* synth, float* iir_mem,
00098                        float* filt_mem[2], float* mem_preemph)
00099 {
00100     float buf[30 + LP_FILTER_ORDER_16k];
00101     float *tmpbuf = buf + LP_FILTER_ORDER_16k;
00102     float s;
00103     int i;
00104 
00105     for (i = 0; i < LP_FILTER_ORDER_16k; i++)
00106         filt_mem[0][i] = iir_mem[i] * ff_pow_0_5[i];
00107 
00108     memcpy(tmpbuf - LP_FILTER_ORDER_16k, mem_preemph,
00109            LP_FILTER_ORDER_16k*sizeof(*buf));
00110 
00111     ff_celp_lp_synthesis_filterf(tmpbuf, filt_mem[1], synth, 30,
00112                                  LP_FILTER_ORDER_16k);
00113 
00114     memcpy(synth - LP_FILTER_ORDER_16k, mem_preemph,
00115            LP_FILTER_ORDER_16k * sizeof(*synth));
00116 
00117     ff_celp_lp_synthesis_filterf(synth, filt_mem[0], synth, 30,
00118                                  LP_FILTER_ORDER_16k);
00119 
00120     memcpy(out_data + 30 - LP_FILTER_ORDER_16k,
00121            synth    + 30 - LP_FILTER_ORDER_16k,
00122            LP_FILTER_ORDER_16k * sizeof(*synth));
00123 
00124     ff_celp_lp_synthesis_filterf(out_data + 30, filt_mem[0],
00125                                  synth + 30, 2 * L_SUBFR_16k - 30,
00126                                  LP_FILTER_ORDER_16k);
00127 
00128 
00129     memcpy(mem_preemph, out_data + 2*L_SUBFR_16k - LP_FILTER_ORDER_16k,
00130            LP_FILTER_ORDER_16k * sizeof(*synth));
00131 
00132     FFSWAP(float *, filt_mem[0], filt_mem[1]);
00133     for (i = 0, s = 0; i < 30; i++, s += 1.0/30)
00134         out_data[i] = tmpbuf[i] + s * (synth[i] - tmpbuf[i]);
00135 }
00136 
00140 static void acelp_lp_decodef(float *lp_1st, float *lp_2nd,
00141                              const double *lsp_2nd, const double *lsp_prev)
00142 {
00143     double lsp_1st[LP_FILTER_ORDER_16k];
00144     int i;
00145 
00146     /* LSP values for first subframe (3.2.5 of G.729, Equation 24) */
00147     for (i = 0; i < LP_FILTER_ORDER_16k; i++)
00148         lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) * 0.5;
00149 
00150     ff_acelp_lspd2lpc(lsp_1st, lp_1st, LP_FILTER_ORDER_16k >> 1);
00151 
00152     /* LSP values for second subframe (3.2.5 of G.729) */
00153     ff_acelp_lspd2lpc(lsp_2nd, lp_2nd, LP_FILTER_ORDER_16k >> 1);
00154 }
00155 
00159 static float acelp_decode_gain_codef(float gain_corr_factor, const float *fc_v,
00160                                      float mr_energy, const float *quant_energy,
00161                                      const float *ma_prediction_coeff,
00162                                      int subframe_size, int ma_pred_order)
00163 {
00164     mr_energy +=
00165         ff_dot_productf(quant_energy, ma_prediction_coeff, ma_pred_order);
00166 
00167     mr_energy = gain_corr_factor * exp(M_LN10 / 20. * mr_energy) /
00168         sqrt((0.01 + ff_dot_productf(fc_v, fc_v, subframe_size)));
00169     return mr_energy;
00170 }
00171 
00172 #define DIVIDE_BY_3(x) ((x) * 10923 >> 15)
00173 
00174 void ff_sipr_decode_frame_16k(SiprContext *ctx, SiprParameters *params,
00175                               float *out_data)
00176 {
00177     int frame_size = SUBFRAME_COUNT_16k * L_SUBFR_16k;
00178     float *synth = ctx->synth_buf + LP_FILTER_ORDER_16k;
00179     float lsf_new[LP_FILTER_ORDER_16k];
00180     double lsp_new[LP_FILTER_ORDER_16k];
00181     float Az[2][LP_FILTER_ORDER_16k];
00182     float fixed_vector[L_SUBFR_16k];
00183     float pitch_fac, gain_code;
00184 
00185     int i;
00186     int pitch_delay_3x;
00187 
00188     float *excitation = ctx->excitation + 292;
00189 
00190     lsf_decode_fp_16k(ctx->lsf_history, lsf_new, params->vq_indexes,
00191                       params->ma_pred_switch);
00192 
00193     ff_set_min_dist_lsf(lsf_new, LSFQ_DIFF_MIN / 2, LP_FILTER_ORDER_16k);
00194 
00195     lsf2lsp(lsf_new, lsp_new);
00196 
00197     acelp_lp_decodef(Az[0], Az[1], lsp_new, ctx->lsp_history_16k);
00198 
00199     memcpy(ctx->lsp_history_16k, lsp_new, LP_FILTER_ORDER_16k * sizeof(double));
00200 
00201     memcpy(synth - LP_FILTER_ORDER_16k, ctx->synth,
00202            LP_FILTER_ORDER_16k * sizeof(*synth));
00203 
00204     for (i = 0; i < SUBFRAME_COUNT_16k; i++) {
00205         int i_subfr = i * L_SUBFR_16k;
00206         AMRFixed f;
00207         float gain_corr_factor;
00208         int pitch_delay_int;
00209         int pitch_delay_frac;
00210 
00211         if (!i) {
00212             pitch_delay_3x = dec_delay3_1st(params->pitch_delay[i]);
00213         } else
00214             pitch_delay_3x = dec_delay3_2nd(params->pitch_delay[i],
00215                                             PITCH_MIN, PITCH_MAX,
00216                                             ctx->pitch_lag_prev);
00217 
00218         pitch_fac = gain_pitch_cb_16k[params->gp_index[i]];
00219         f.pitch_fac = FFMIN(pitch_fac, 1.0);
00220         f.pitch_lag = DIVIDE_BY_3(pitch_delay_3x+1);
00221         ctx->pitch_lag_prev = f.pitch_lag;
00222 
00223         pitch_delay_int  = DIVIDE_BY_3(pitch_delay_3x + 2);
00224         pitch_delay_frac = pitch_delay_3x + 2 - 3*pitch_delay_int;
00225 
00226         ff_acelp_interpolatef(&excitation[i_subfr],
00227                               &excitation[i_subfr] - pitch_delay_int + 1,
00228                               sinc_win, 3, pitch_delay_frac + 1,
00229                               LP_FILTER_ORDER, L_SUBFR_16k);
00230 
00231 
00232         memset(fixed_vector, 0, sizeof(fixed_vector));
00233 
00234         ff_decode_10_pulses_35bits(params->fc_indexes[i], &f,
00235                                    ff_fc_4pulses_8bits_tracks_13, 5, 4);
00236 
00237         ff_set_fixed_vector(fixed_vector, &f, 1.0, L_SUBFR_16k);
00238 
00239         gain_corr_factor = gain_cb_16k[params->gc_index[i]];
00240         gain_code = gain_corr_factor *
00241             acelp_decode_gain_codef(sqrt(L_SUBFR_16k), fixed_vector,
00242                                     19.0 - 15.0/(0.05*M_LN10/M_LN2),
00243                                     pred_16k, ctx->energy_history,
00244                                     L_SUBFR_16k, 2);
00245 
00246         ctx->energy_history[1] = ctx->energy_history[0];
00247         ctx->energy_history[0] = 20.0 * log10f(gain_corr_factor);
00248 
00249         ff_weighted_vector_sumf(&excitation[i_subfr], &excitation[i_subfr],
00250                                 fixed_vector, pitch_fac,
00251                                 gain_code, L_SUBFR_16k);
00252 
00253         ff_celp_lp_synthesis_filterf(synth + i_subfr, Az[i],
00254                                      &excitation[i_subfr], L_SUBFR_16k,
00255                                      LP_FILTER_ORDER_16k);
00256 
00257     }
00258     memcpy(ctx->synth, synth + frame_size - LP_FILTER_ORDER_16k,
00259            LP_FILTER_ORDER_16k * sizeof(*synth));
00260 
00261     memmove(ctx->excitation, ctx->excitation + 2 * L_SUBFR_16k,
00262             (L_INTERPOL+PITCH_MAX) * sizeof(float));
00263 
00264     postfilter(out_data, synth, ctx->iir_mem, ctx->filt_mem, ctx->mem_preemph);
00265 
00266     memcpy(ctx->iir_mem, Az[1], LP_FILTER_ORDER_16k * sizeof(float));
00267 }
00268 
00269 void ff_sipr_init_16k(SiprContext *ctx)
00270 {
00271     int i;
00272 
00273     for (i = 0; i < LP_FILTER_ORDER_16k; i++)
00274         ctx->lsp_history_16k[i] = cos((i + 1) * M_PI/(LP_FILTER_ORDER_16k + 1));
00275 
00276     ctx->filt_mem[0] = ctx->filt_buf[0];
00277     ctx->filt_mem[1] = ctx->filt_buf[1];
00278 
00279     ctx->pitch_lag_prev = 180;
00280 }

Generated on Fri Sep 16 2011 17:17:43 for FFmpeg by  doxygen 1.7.1