ffmpeg / libavcodec / acelp_pitch_delay.c @ e4a35244
History  View  Annotate  Download (5.95 KB)
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 021101301 USA

21 
*/

22  
23 
#include "avcodec.h" 
24 
#include "dsputil.h" 
25 
#include "acelp_pitch_delay.h" 
26 
#include "celp_math.h" 
27  
28 
int ff_acelp_decode_8bit_to_1st_delay3(int ac_index) 
29 
{ 
30 
ac_index += 58;

31 
if(ac_index > 254) 
32 
ac_index = 3 * ac_index  510; 
33 
return ac_index;

34 
} 
35  
36 
int ff_acelp_decode_4bit_to_2nd_delay3(

37 
int ac_index,

38 
int pitch_delay_min)

39 
{ 
40 
if(ac_index < 4) 
41 
return 3 * (ac_index + pitch_delay_min); 
42 
else if(ac_index < 12) 
43 
return 3 * pitch_delay_min + ac_index + 6; 
44 
else

45 
return 3 * (ac_index + pitch_delay_min)  18; 
46 
} 
47  
48 
int ff_acelp_decode_5_6_bit_to_2nd_delay3(

49 
int ac_index,

50 
int pitch_delay_min)

51 
{ 
52 
return 3 * pitch_delay_min + ac_index  2; 
53 
} 
54  
55 
int ff_acelp_decode_9bit_to_1st_delay6(int ac_index) 
56 
{ 
57 
if(ac_index < 463) 
58 
return ac_index + 105; 
59 
else

60 
return 6 * (ac_index  368); 
61 
} 
62 
int ff_acelp_decode_6bit_to_2nd_delay6(

63 
int ac_index,

64 
int pitch_delay_min)

65 
{ 
66 
return 6 * pitch_delay_min + ac_index  3; 
67 
} 
68  
69 
void ff_acelp_update_past_gain(

70 
int16_t* quant_energy, 
71 
int gain_corr_factor,

72 
int log2_ma_pred_order,

73 
int erasure)

74 
{ 
75 
int i;

76 
int avg_gain=quant_energy[(1 << log2_ma_pred_order)  1]; // (5.10) 
77  
78 
for(i=(1 << log2_ma_pred_order)  1; i>0; i) 
79 
{ 
80 
avg_gain += quant_energy[i1];

81 
quant_energy[i] = quant_energy[i1];

82 
} 
83  
84 
if(erasure)

85 
quant_energy[0] = FFMAX(avg_gain >> log2_ma_pred_order, 10240)  4096; // 10 and 4 in (5.10) 
86 
else

87 
quant_energy[0] = (6165 * ((ff_log2(gain_corr_factor) >> 2)  (13 << 13))) >> 13; 
88 
} 
89  
90 
int16_t ff_acelp_decode_gain_code( 
91 
DSPContext *dsp, 
92 
int gain_corr_factor,

93 
const int16_t* fc_v,

94 
int mr_energy,

95 
const int16_t* quant_energy,

96 
const int16_t* ma_prediction_coeff,

97 
int subframe_size,

98 
int ma_pred_order)

99 
{ 
100 
int i;

101  
102 
mr_energy <<= 10;

103  
104 
for(i=0; i<ma_pred_order; i++) 
105 
mr_energy += quant_energy[i] * ma_prediction_coeff[i]; 
106  
107 
#ifdef G729_BITEXACT

108 
mr_energy += (((6165LL * ff_log2(dsp>scalarproduct_int16(fc_v, fc_v, subframe_size, 0))) >> 3) & ~0x3ff); 
109  
110 
mr_energy = (5439 * (mr_energy >> 15)) >> 8; // (0.15) = (0.15) * (7.23) 
111  
112 
return bidir_sal(

113 
((ff_exp2(mr_energy & 0x7fff) + 16) >> 5) * (gain_corr_factor >> 1), 
114 
(mr_energy >> 15)  25 
115 
); 
116 
#else

117 
mr_energy = gain_corr_factor * exp(M_LN10 / (20 << 23) * mr_energy) / 
118 
sqrt(dsp>scalarproduct_int16(fc_v, fc_v, subframe_size, 0));

119 
return mr_energy >> 12; 
120 
#endif

121 
} 
122  
123 
float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy, 
124 
float *prediction_error, float energy_mean, 
125 
const float *pred_table) 
126 
{ 
127 
// Equations 6669:

128 
// ^g_c = ^gamma_gc * 100.05 (predicted dB + mean dB  dB of fixed vector)

129 
// Note 10^(0.05 * 10log(average x2)) = 1/sqrt((average x2)).

130 
float val = fixed_gain_factor *

131 
exp2f(M_LOG2_10 * 0.05 * 
132 
(ff_dot_productf(pred_table, prediction_error, 4) +

133 
energy_mean)) / 
134 
sqrtf(fixed_mean_energy); 
135  
136 
// update quantified prediction error energy history

137 
memmove(&prediction_error[0], &prediction_error[1], 
138 
3 * sizeof(prediction_error[0])); 
139 
prediction_error[3] = 20.0 * log10f(fixed_gain_factor); 
140  
141 
return val;

142 
} 
143  
144 
void ff_decode_pitch_lag(int *lag_int, int *lag_frac, int pitch_index, 
145 
const int prev_lag_int, const int subframe, 
146 
int third_as_first, int resolution) 
147 
{ 
148 
/* Note n * 10923 >> 15 is floor(x/3) for 0 <= n <= 32767 */

149 
if (subframe == 0  (subframe == 2 && third_as_first)) { 
150  
151 
if (pitch_index < 197) 
152 
pitch_index += 59;

153 
else

154 
pitch_index = 3 * pitch_index  335; 
155  
156 
} else {

157 
if (resolution == 4) { 
158 
int search_range_min = av_clip(prev_lag_int  5, PITCH_DELAY_MIN, 
159 
PITCH_DELAY_MAX  9);

160  
161 
// decoding with 4bit resolution

162 
if (pitch_index < 4) { 
163 
// integer only precision for [search_range_min, search_range_min+3]

164 
pitch_index = 3 * (pitch_index + search_range_min) + 1; 
165 
} else if (pitch_index < 12) { 
166 
// 1/3 fractional precision for [search_range_min+3 1/3, search_range_min+5 2/3]

167 
pitch_index += 3 * search_range_min + 7; 
168 
} else {

169 
// integer only precision for [search_range_min+6, search_range_min+9]

170 
pitch_index = 3 * (pitch_index + search_range_min  6) + 1; 
171 
} 
172 
} else {

173 
// decoding with 5 or 6 bit resolution, 1/3 fractional precision

174 
pitch_index; 
175  
176 
if (resolution == 5) { 
177 
pitch_index += 3 * av_clip(prev_lag_int  10, PITCH_DELAY_MIN, 
178 
PITCH_DELAY_MAX  19);

179 
} else

180 
pitch_index += 3 * av_clip(prev_lag_int  5, PITCH_DELAY_MIN, 
181 
PITCH_DELAY_MAX  9);

182 
} 
183 
} 
184 
*lag_int = pitch_index * 10923 >> 15; 
185 
*lag_frac = pitch_index  3 * *lag_int  1; 
186 
} 