FFmpeg
acelp_pitch_delay.c
Go to the documentation of this file.
1 /*
2  * gain code, gain pitch and pitch delay decoding
3  *
4  * Copyright (c) 2008 Vladimir Voroshilov
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "libavutil/common.h"
24 #include "libavutil/ffmath.h"
25 #include "libavutil/float_dsp.h"
26 #include "libavutil/mathematics.h"
27 #include "avcodec.h"
28 #include "acelp_pitch_delay.h"
29 #include "celp_math.h"
30 #include "audiodsp.h"
31 
33 {
34  ac_index += 58;
35  if(ac_index > 254)
36  ac_index = 3 * ac_index - 510;
37  return ac_index;
38 }
39 
41  int ac_index,
42  int pitch_delay_min)
43 {
44  if(ac_index < 4)
45  return 3 * (ac_index + pitch_delay_min);
46  else if(ac_index < 12)
47  return 3 * pitch_delay_min + ac_index + 6;
48  else
49  return 3 * (ac_index + pitch_delay_min) - 18;
50 }
51 
53  int ac_index,
54  int pitch_delay_min)
55 {
56  return 3 * pitch_delay_min + ac_index - 2;
57 }
58 
60 {
61  if(ac_index < 463)
62  return ac_index + 105;
63  else
64  return 6 * (ac_index - 368);
65 }
67  int ac_index,
68  int pitch_delay_min)
69 {
70  return 6 * pitch_delay_min + ac_index - 3;
71 }
72 
74  int16_t* quant_energy,
75  int gain_corr_factor,
76  int log2_ma_pred_order,
77  int erasure)
78 {
79  int i;
80  int avg_gain=quant_energy[(1 << log2_ma_pred_order) - 1]; // (5.10)
81 
82  for(i=(1 << log2_ma_pred_order) - 1; i>0; i--)
83  {
84  avg_gain += quant_energy[i-1];
85  quant_energy[i] = quant_energy[i-1];
86  }
87 
88  if(erasure)
89  quant_energy[0] = FFMAX(avg_gain >> log2_ma_pred_order, -10240) - 4096; // -10 and -4 in (5.10)
90  else
91  quant_energy[0] = (6165 * ((ff_log2_q15(gain_corr_factor) >> 2) - (13 << 13))) >> 13;
92 }
93 
95  AudioDSPContext *adsp,
96  int gain_corr_factor,
97  const int16_t* fc_v,
98  int mr_energy,
99  const int16_t* quant_energy,
100  const int16_t* ma_prediction_coeff,
101  int subframe_size,
102  int ma_pred_order)
103 {
104  int i;
105 
106  mr_energy <<= 10;
107 
108  for(i=0; i<ma_pred_order; i++)
109  mr_energy += quant_energy[i] * ma_prediction_coeff[i];
110 
111 #ifdef G729_BITEXACT
112  mr_energy += (((-6165LL * ff_log2(dsp->scalarproduct_int16(fc_v, fc_v, subframe_size, 0))) >> 3) & ~0x3ff);
113 
114  mr_energy = (5439 * (mr_energy >> 15)) >> 8; // (0.15) = (0.15) * (7.23)
115 
116  return bidir_sal(
117  ((ff_exp2(mr_energy & 0x7fff) + 16) >> 5) * (gain_corr_factor >> 1),
118  (mr_energy >> 15) - 25
119  );
120 #else
121  mr_energy = gain_corr_factor * ff_exp10((double)mr_energy / (20 << 23)) /
122  sqrt(adsp->scalarproduct_int16(fc_v, fc_v, subframe_size));
123  return mr_energy >> 12;
124 #endif
125 }
126 
127 float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy,
128  float *prediction_error, float energy_mean,
129  const float *pred_table)
130 {
131  // Equations 66-69:
132  // ^g_c = ^gamma_gc * 100.05 (predicted dB + mean dB - dB of fixed vector)
133  // Note 10^(0.05 * -10log(average x2)) = 1/sqrt((average x2)).
134  float val = fixed_gain_factor *
135  ff_exp10(0.05 *
136  (avpriv_scalarproduct_float_c(pred_table, prediction_error, 4) +
137  energy_mean)) /
138  sqrtf(fixed_mean_energy ? fixed_mean_energy : 1.0);
139 
140  // update quantified prediction error energy history
141  memmove(&prediction_error[0], &prediction_error[1],
142  3 * sizeof(prediction_error[0]));
143  prediction_error[3] = 20.0 * log10f(fixed_gain_factor);
144 
145  return val;
146 }
147 
148 void ff_decode_pitch_lag(int *lag_int, int *lag_frac, int pitch_index,
149  const int prev_lag_int, const int subframe,
150  int third_as_first, int resolution)
151 {
152  /* Note n * 10923 >> 15 is floor(x/3) for 0 <= n <= 32767 */
153  if (subframe == 0 || (subframe == 2 && third_as_first)) {
154 
155  if (pitch_index < 197)
156  pitch_index += 59;
157  else
158  pitch_index = 3 * pitch_index - 335;
159 
160  } else {
161  if (resolution == 4) {
162  int search_range_min = av_clip(prev_lag_int - 5, PITCH_DELAY_MIN,
163  PITCH_DELAY_MAX - 9);
164 
165  // decoding with 4-bit resolution
166  if (pitch_index < 4) {
167  // integer only precision for [search_range_min, search_range_min+3]
168  pitch_index = 3 * (pitch_index + search_range_min) + 1;
169  } else if (pitch_index < 12) {
170  // 1/3 fractional precision for [search_range_min+3 1/3, search_range_min+5 2/3]
171  pitch_index += 3 * search_range_min + 7;
172  } else {
173  // integer only precision for [search_range_min+6, search_range_min+9]
174  pitch_index = 3 * (pitch_index + search_range_min - 6) + 1;
175  }
176  } else {
177  // decoding with 5 or 6 bit resolution, 1/3 fractional precision
178  pitch_index--;
179 
180  if (resolution == 5) {
181  pitch_index += 3 * av_clip(prev_lag_int - 10, PITCH_DELAY_MIN,
182  PITCH_DELAY_MAX - 19);
183  } else
184  pitch_index += 3 * av_clip(prev_lag_int - 5, PITCH_DELAY_MIN,
185  PITCH_DELAY_MAX - 9);
186  }
187  }
188  *lag_int = pitch_index * 10923 >> 15;
189  *lag_frac = pitch_index - 3 * *lag_int - 1;
190 }
void ff_decode_pitch_lag(int *lag_int, int *lag_frac, int pitch_index, const int prev_lag_int, const int subframe, int third_as_first, int resolution)
Decode the adaptive codebook index to the integer and fractional parts of the pitch lag for one subfr...
const char const char void * val
Definition: avisynth_c.h:771
static const uint16_t ma_prediction_coeff[4]
MA prediction coefficients (3.9.1 of G.729, near Equation 69)
Definition: g729data.h:343
int ff_exp2(uint16_t power)
fixed-point implementation of exp2(x) in [0; 1] domain.
Definition: celp_math.c:48
int ff_acelp_decode_6bit_to_2nd_delay6(int ac_index, int pitch_delay_min)
Decode pitch delay of the second subframe encoded by 6 bits with 1/6 precision.
int ff_acelp_decode_4bit_to_2nd_delay3(int ac_index, int pitch_delay_min)
Decode pitch delay with 1/3 precision.
int ff_acelp_decode_8bit_to_1st_delay3(int ac_index)
Decode pitch delay of the first subframe encoded by 8 bits with 1/3 resolution.
int ff_acelp_decode_9bit_to_1st_delay6(int ac_index)
Decode pitch delay of the first subframe encoded by 9 bits with 1/6 precision.
#define PITCH_DELAY_MAX
int ff_acelp_decode_5_6_bit_to_2nd_delay3(int ac_index, int pitch_delay_min)
Decode pitch delay of the second subframe encoded by 5 or 6 bits with 1/3 precision.
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
int ff_log2_q15(uint32_t value)
Calculate log2(x).
Definition: celp_math.c:78
#define FFMAX(a, b)
Definition: common.h:94
void ff_acelp_update_past_gain(int16_t *quant_energy, int gain_corr_factor, int log2_ma_pred_order, int erasure)
Update past quantized energies.
Libavcodec external API header.
int32_t(* scalarproduct_int16)(const int16_t *v1, const int16_t *v2, int len)
Calculate scalar product of two vectors.
Definition: audiodsp.h:29
#define ff_log2
Definition: intmath.h:50
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted then it is pulled from the input slice through the input converter and horizontal scaler The result is also stored in the ring buffer to serve future vertical scaler requests When no more output can be generated because lines from a future slice would be then all remaining lines in the current slice are horizontally scaled and put in the ring buffer[This is done for luma and chroma, each with possibly different numbers of lines per picture.] Input to YUV Converter When the input to the main path is not planar bits per component YUV or bit it is converted to planar bit YUV Two sets of converters exist for this the other leaves the full chroma resolution
Definition: swscale.txt:33
float avpriv_scalarproduct_float_c(const float *v1, const float *v2, int len)
Return the scalar product of two vectors.
Definition: float_dsp.c:124
internal math functions header
common internal and external API header
static int bidir_sal(int value, int offset)
Shift value left or right depending on sign of offset parameter.
Definition: celp_math.h:81
static const float energy_mean[8]
desired mean innovation energy, indexed by active mode
Definition: amrnbdata.h:1458
#define PITCH_DELAY_MIN
#define log10f(x)
Definition: libm.h:414
int16_t ff_acelp_decode_gain_code(AudioDSPContext *adsp, int gain_corr_factor, const int16_t *fc_v, int mr_energy, const int16_t *quant_energy, const int16_t *ma_prediction_coeff, int subframe_size, int ma_pred_order)
Decode the adaptive codebook gain and add correction (4.1.5 and 3.9.1 of G.729).
float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy, float *prediction_error, float energy_mean, const float *pred_table)
Calculate fixed gain (part of section 6.1.3 of AMR spec)