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 */ 45static void lsf2lsp(const float *lsf, double *lsp) 46{ 47 int i; 48 49 for (i = 0; i < LP_FILTER_ORDER_16k; i++) 50 lsp[i] = cosf(lsf[i]); 51} 52 53static void dequant(float *out, const int *idx, const float * const cbs[]) 54{ 55 int i; 56 57 for (i = 0; i < 4; i++) 58 memcpy(out + 3*i, cbs[i] + 3*idx[i], 3*sizeof(float)); 59 60 memcpy(out + 12, cbs[4] + 4*idx[4], 4*sizeof(float)); 61} 62 63static 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 dequant(isp_q, parm, lsf_codebooks_16k); 70 71 for (i = 0; i < LP_FILTER_ORDER_16k; i++) { 72 isp_new[i] = (1 - qu[ma_pred]) * isp_q[i] 73 + qu[ma_pred] * lsf_history[i] 74 + mean_lsf_16k[i]; 75 } 76 77 memcpy(lsf_history, isp_q, LP_FILTER_ORDER_16k * sizeof(float)); 78} 79 80static int dec_delay3_1st(int index) 81{ 82 if (index < 390) { 83 return index + 88; 84 } else 85 return 3 * index - 690; 86} 87 88static int dec_delay3_2nd(int index, int pit_min, int pit_max, 89 int pitch_lag_prev) 90{ 91 if (index < 62) { 92 int pitch_delay_min = av_clip(pitch_lag_prev - 10, 93 pit_min, pit_max - 19); 94 return 3 * pitch_delay_min + index - 2; 95 } else 96 return 3 * pitch_lag_prev; 97} 98 99static 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 float *tmpbuf = buf + LP_FILTER_ORDER_16k; 104 float s; 105 int i; 106 107 for (i = 0; i < LP_FILTER_ORDER_16k; i++) 108 filt_mem[0][i] = iir_mem[i] * ff_pow_0_5[i]; 109 110 memcpy(tmpbuf - LP_FILTER_ORDER_16k, mem_preemph, 111 LP_FILTER_ORDER_16k*sizeof(*buf)); 112 113 ff_celp_lp_synthesis_filterf(tmpbuf, filt_mem[1], synth, 30, 114 LP_FILTER_ORDER_16k); 115 116 memcpy(synth - LP_FILTER_ORDER_16k, mem_preemph, 117 LP_FILTER_ORDER_16k * sizeof(*synth)); 118 119 ff_celp_lp_synthesis_filterf(synth, filt_mem[0], synth, 30, 120 LP_FILTER_ORDER_16k); 121 122 memcpy(out_data + 30 - LP_FILTER_ORDER_16k, 123 synth + 30 - LP_FILTER_ORDER_16k, 124 LP_FILTER_ORDER_16k * sizeof(*synth)); 125 126 ff_celp_lp_synthesis_filterf(out_data + 30, filt_mem[0], 127 synth + 30, 2 * L_SUBFR_16k - 30, 128 LP_FILTER_ORDER_16k); 129 130 131 memcpy(mem_preemph, out_data + 2*L_SUBFR_16k - LP_FILTER_ORDER_16k, 132 LP_FILTER_ORDER_16k * sizeof(*synth)); 133 134 FFSWAP(float *, filt_mem[0], filt_mem[1]); 135 for (i = 0, s = 0; i < 30; i++, s += 1.0/30) 136 out_data[i] = tmpbuf[i] + s * (synth[i] - tmpbuf[i]); 137} 138 139/** 140 * Floating point version of ff_acelp_lp_decode(). 141 */ 142static 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 for (i = 0; i < LP_FILTER_ORDER_16k; i++) 150 lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) * 0.5; 151 152 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 ff_acelp_lspd2lpc(lsp_2nd, lp_2nd, LP_FILTER_ORDER_16k >> 1); 156} 157 158/** 159 * Floating point version of ff_acelp_decode_gain_code(). 160 */ 161static 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 mr_energy += avpriv_scalarproduct_float_c(quant_energy, ma_prediction_coeff, 167 ma_pred_order); 168 169 mr_energy = gain_corr_factor * exp(M_LN10 / 20. * mr_energy) / 170 sqrt((0.01 + avpriv_scalarproduct_float_c(fc_v, fc_v, subframe_size))); 171 return mr_energy; 172} 173 174#define DIVIDE_BY_3(x) ((x) * 10923 >> 15) 175 176void ff_sipr_decode_frame_16k(SiprContext *ctx, SiprParameters *params, 177 float *out_data) 178{ 179 int frame_size = SUBFRAME_COUNT_16k * L_SUBFR_16k; 180 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 float *excitation = ctx->excitation + 292; 191 192 lsf_decode_fp_16k(ctx->lsf_history, lsf_new, params->vq_indexes, 193 params->ma_pred_switch); 194 195 ff_set_min_dist_lsf(lsf_new, LSFQ_DIFF_MIN / 2, LP_FILTER_ORDER_16k); 196 197 lsf2lsp(lsf_new, lsp_new); 198 199 acelp_lp_decodef(Az[0], Az[1], lsp_new, ctx->lsp_history_16k); 200 201 memcpy(ctx->lsp_history_16k, lsp_new, LP_FILTER_ORDER_16k * sizeof(double)); 202 203 memcpy(synth - LP_FILTER_ORDER_16k, ctx->synth, 204 LP_FILTER_ORDER_16k * sizeof(*synth)); 205 206 for (i = 0; i < SUBFRAME_COUNT_16k; i++) { 207 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 if (!i) { 214 pitch_delay_3x = dec_delay3_1st(params->pitch_delay[i]); 215 } else 216 pitch_delay_3x = dec_delay3_2nd(params->pitch_delay[i], 217 PITCH_MIN, PITCH_MAX, 218 ctx->pitch_lag_prev); 219 220 pitch_fac = gain_pitch_cb_16k[params->gp_index[i]]; 221 f.pitch_fac = FFMIN(pitch_fac, 1.0); 222 f.pitch_lag = DIVIDE_BY_3(pitch_delay_3x+1); 223 ctx->pitch_lag_prev = f.pitch_lag; 224 225 pitch_delay_int = DIVIDE_BY_3(pitch_delay_3x + 2); 226 pitch_delay_frac = pitch_delay_3x + 2 - 3*pitch_delay_int; 227 228 ff_acelp_interpolatef(&excitation[i_subfr], 229 &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 memset(fixed_vector, 0, sizeof(fixed_vector)); 235 236 ff_decode_10_pulses_35bits(params->fc_indexes[i], &f, 237 ff_fc_4pulses_8bits_tracks_13, 5, 4); 238 239 ff_set_fixed_vector(fixed_vector, &f, 1.0, L_SUBFR_16k); 240 241 gain_corr_factor = gain_cb_16k[params->gc_index[i]]; 242 gain_code = gain_corr_factor * 243 acelp_decode_gain_codef(sqrt(L_SUBFR_16k), fixed_vector, 244 19.0 - 15.0/(0.05*M_LN10/M_LN2), 245 pred_16k, ctx->energy_history, 246 L_SUBFR_16k, 2); 247 248 ctx->energy_history[1] = ctx->energy_history[0]; 249 ctx->energy_history[0] = 20.0 * log10f(gain_corr_factor); 250 251 ff_weighted_vector_sumf(&excitation[i_subfr], &excitation[i_subfr], 252 fixed_vector, pitch_fac, 253 gain_code, L_SUBFR_16k); 254 255 ff_celp_lp_synthesis_filterf(synth + i_subfr, Az[i], 256 &excitation[i_subfr], L_SUBFR_16k, 257 LP_FILTER_ORDER_16k); 258 259 } 260 memcpy(ctx->synth, synth + frame_size - LP_FILTER_ORDER_16k, 261 LP_FILTER_ORDER_16k * sizeof(*synth)); 262 263 memmove(ctx->excitation, ctx->excitation + 2 * L_SUBFR_16k, 264 (L_INTERPOL+PITCH_MAX) * sizeof(float)); 265 266 postfilter(out_data, synth, ctx->iir_mem, ctx->filt_mem, ctx->mem_preemph); 267 268 memcpy(ctx->iir_mem, Az[1], LP_FILTER_ORDER_16k * sizeof(float)); 269} 270 271av_cold void ff_sipr_init_16k(SiprContext *ctx) 272{ 273 int i; 274 275 for (i = 0; i < LP_FILTER_ORDER_16k; i++) 276 ctx->lsp_history_16k[i] = cos((i + 1) * M_PI/(LP_FILTER_ORDER_16k + 1)); 277 278 ctx->filt_mem[0] = ctx->filt_buf[0]; 279 ctx->filt_mem[1] = ctx->filt_buf[1]; 280 281 ctx->pitch_lag_prev = 180; 282} 283