Directory: | ../../../ffmpeg/ |
---|---|

File: | src/libavcodec/acelp_pitch_delay.h |

Date: | 2022-01-28 07:56:06 |

Exec | Total | Coverage | |
---|---|---|---|

Lines: | 0 | 13 | 0.0% |

Branches: | 0 | 6 | 0.0% |

Line | Branch | Exec | Source |
---|---|---|---|

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 | #ifndef AVCODEC_ACELP_PITCH_DELAY_H | ||

24 | #define AVCODEC_ACELP_PITCH_DELAY_H | ||

25 | |||

26 | #include <stdint.h> | ||

27 | |||

28 | #include "audiodsp.h" | ||

29 | |||

30 | #define PITCH_DELAY_MIN 20 | ||

31 | #define PITCH_DELAY_MAX 143 | ||

32 | |||

33 | /** | ||

34 | * @brief Decode pitch delay of the first subframe encoded by 8 bits with 1/3 | ||

35 | * resolution. | ||

36 | * @param ac_index adaptive codebook index (8 bits) | ||

37 | * | ||

38 | * @return pitch delay in 1/3 units | ||

39 | * | ||

40 | * Pitch delay is coded: | ||

41 | * with 1/3 resolution, 19 < pitch_delay < 85 | ||

42 | * integers only, 85 <= pitch_delay <= 143 | ||

43 | */ | ||

44 | ✗ | static inline int ff_acelp_decode_8bit_to_1st_delay3(int ac_index) | |

45 | { | ||

46 | ✗ | ac_index += 58; | |

47 | ✗ | if (ac_index > 254) | |

48 | ✗ | ac_index = 3 * ac_index - 510; | |

49 | ✗ | return ac_index; | |

50 | } | ||

51 | |||

52 | /** | ||

53 | * @brief Decode pitch delay of the second subframe encoded by 5 or 6 bits | ||

54 | * with 1/3 precision. | ||

55 | * @param ac_index adaptive codebook index (5 or 6 bits) | ||

56 | * @param pitch_delay_min lower bound (integer) of pitch delay interval | ||

57 | * for second subframe | ||

58 | * | ||

59 | * @return pitch delay in 1/3 units | ||

60 | * | ||

61 | * Pitch delay is coded: | ||

62 | * with 1/3 resolution, -6 < pitch_delay - int(prev_pitch_delay) < 5 | ||

63 | * | ||

64 | * @remark The routine is used in G.729 @@8k, AMR @@10.2k, AMR @@7.95k, | ||

65 | * AMR @@7.4k for the second subframe. | ||

66 | */ | ||

67 | ✗ | static inline int ff_acelp_decode_5_6_bit_to_2nd_delay3(int ac_index, | |

68 | int pitch_delay_min) | ||

69 | { | ||

70 | ✗ | return 3 * pitch_delay_min + ac_index - 2; | |

71 | } | ||

72 | |||

73 | /** | ||

74 | * @brief Decode pitch delay with 1/3 precision. | ||

75 | * @param ac_index adaptive codebook index (4 bits) | ||

76 | * @param pitch_delay_min lower bound (integer) of pitch delay interval for | ||

77 | * second subframe | ||

78 | * | ||

79 | * @return pitch delay in 1/3 units | ||

80 | * | ||

81 | * Pitch delay is coded: | ||

82 | * integers only, -6 < pitch_delay - int(prev_pitch_delay) <= -2 | ||

83 | * with 1/3 resolution, -2 < pitch_delay - int(prev_pitch_delay) < 1 | ||

84 | * integers only, 1 <= pitch_delay - int(prev_pitch_delay) < 5 | ||

85 | * | ||

86 | * @remark The routine is used in G.729 @@6.4k, AMR @@6.7k, AMR @@5.9k, | ||

87 | * AMR @@5.15k, AMR @@4.75k for the second subframe. | ||

88 | */ | ||

89 | ✗ | static inline int ff_acelp_decode_4bit_to_2nd_delay3(int ac_index, | |

90 | int pitch_delay_min) | ||

91 | { | ||

92 | ✗ | if (ac_index < 4) | |

93 | ✗ | return 3 * (ac_index + pitch_delay_min); | |

94 | ✗ | else if (ac_index < 12) | |

95 | ✗ | return 3 * pitch_delay_min + ac_index + 6; | |

96 | else | ||

97 | ✗ | return 3 * (ac_index + pitch_delay_min) - 18; | |

98 | } | ||

99 | |||

100 | /** | ||

101 | * @brief Decode pitch delay of the first subframe encoded by 9 bits | ||

102 | * with 1/6 precision. | ||

103 | * @param ac_index adaptive codebook index (9 bits) | ||

104 | * | ||

105 | * @return pitch delay in 1/6 units | ||

106 | * | ||

107 | * Pitch delay is coded: | ||

108 | * with 1/6 resolution, 17 < pitch_delay < 95 | ||

109 | * integers only, 95 <= pitch_delay <= 143 | ||

110 | * | ||

111 | * @remark The routine is used in AMR @@12.2k for the first and third subframes. | ||

112 | */ | ||

113 | static inline int ff_acelp_decode_9bit_to_1st_delay6(int ac_index) | ||

114 | { | ||

115 | if (ac_index < 463) | ||

116 | return ac_index + 105; | ||

117 | else | ||

118 | return 6 * (ac_index - 368); | ||

119 | } | ||

120 | |||

121 | /** | ||

122 | * @brief Decode pitch delay of the second subframe encoded by 6 bits | ||

123 | * with 1/6 precision. | ||

124 | * @param ac_index adaptive codebook index (6 bits) | ||

125 | * @param pitch_delay_min lower bound (integer) of pitch delay interval for | ||

126 | * second subframe | ||

127 | * | ||

128 | * @return pitch delay in 1/6 units | ||

129 | * | ||

130 | * Pitch delay is coded: | ||

131 | * with 1/6 resolution, -6 < pitch_delay - int(prev_pitch_delay) < 5 | ||

132 | * | ||

133 | * @remark The routine is used in AMR @@12.2k for the second and fourth subframes. | ||

134 | */ | ||

135 | static inline int ff_acelp_decode_6bit_to_2nd_delay6(int ac_index, | ||

136 | int pitch_delay_min) | ||

137 | { | ||

138 | return 6 * pitch_delay_min + ac_index - 3; | ||

139 | } | ||

140 | |||

141 | /** | ||

142 | * @brief Update past quantized energies | ||

143 | * @param[in,out] quant_energy past quantized energies (5.10) | ||

144 | * @param gain_corr_factor gain correction factor | ||

145 | * @param log2_ma_pred_order log2() of MA prediction order | ||

146 | * @param erasure frame erasure flag | ||

147 | * | ||

148 | * If frame erasure flag is not equal to zero, memory is updated with | ||

149 | * averaged energy, attenuated by 4dB: | ||

150 | * max(avg(quant_energy[i])-4, -14), i=0,ma_pred_order | ||

151 | * | ||

152 | * In normal mode memory is updated with | ||

153 | * Er - Ep = 20 * log10(gain_corr_factor) | ||

154 | * | ||

155 | * @remark The routine is used in G.729 and AMR (all modes). | ||

156 | */ | ||

157 | void ff_acelp_update_past_gain( | ||

158 | int16_t* quant_energy, | ||

159 | int gain_corr_factor, | ||

160 | int log2_ma_pred_order, | ||

161 | int erasure); | ||

162 | |||

163 | /** | ||

164 | * @brief Decode the adaptive codebook gain and add | ||

165 | * correction (4.1.5 and 3.9.1 of G.729). | ||

166 | * @param adsp initialized audio DSP context | ||

167 | * @param gain_corr_factor gain correction factor (2.13) | ||

168 | * @param fc_v fixed-codebook vector (2.13) | ||

169 | * @param mr_energy mean innovation energy and fixed-point correction (7.13) | ||

170 | * @param[in,out] quant_energy past quantized energies (5.10) | ||

171 | * @param subframe_size length of subframe | ||

172 | * | ||

173 | * @return quantized fixed-codebook gain (14.1) | ||

174 | * | ||

175 | * The routine implements equations 69, 66 and 71 of the G.729 specification (3.9.1) | ||

176 | * | ||

177 | * Em - mean innovation energy (dB, constant, depends on decoding algorithm) | ||

178 | * Ep - mean-removed predicted energy (dB) | ||

179 | * Er - mean-removed innovation energy (dB) | ||

180 | * Ei - mean energy of the fixed-codebook contribution (dB) | ||

181 | * N - subframe_size | ||

182 | * M - MA (Moving Average) prediction order | ||

183 | * gc - fixed-codebook gain | ||

184 | * gc_p - predicted fixed-codebook gain | ||

185 | * | ||

186 | * Fixed codebook gain is computed using predicted gain gc_p and | ||

187 | * correction factor gain_corr_factor as shown below: | ||

188 | * | ||

189 | * gc = gc_p * gain_corr_factor | ||

190 | * | ||

191 | * The predicted fixed codebook gain gc_p is found by predicting | ||

192 | * the energy of the fixed-codebook contribution from the energy | ||

193 | * of previous fixed-codebook contributions. | ||

194 | * | ||

195 | * mean = 1/N * sum(i,0,N){ fc_v[i] * fc_v[i] } | ||

196 | * | ||

197 | * Ei = 10log(mean) | ||

198 | * | ||

199 | * Er = 10log(1/N * gc^2 * mean) - Em = 20log(gc) + Ei - Em | ||

200 | * | ||

201 | * Replacing Er with Ep and gc with gc_p we will receive: | ||

202 | * | ||

203 | * Ep = 10log(1/N * gc_p^2 * mean) - Em = 20log(gc_p) + Ei - Em | ||

204 | * | ||

205 | * and from above: | ||

206 | * | ||

207 | * gc_p = 10^((Ep - Ei + Em) / 20) | ||

208 | * | ||

209 | * Ep is predicted using past energies and prediction coefficients: | ||

210 | * | ||

211 | * Ep = sum(i,0,M){ ma_prediction_coeff[i] * quant_energy[i] } | ||

212 | * | ||

213 | * gc_p in fixed-point arithmetic is calculated as following: | ||

214 | * | ||

215 | * mean = 1/N * sum(i,0,N){ (fc_v[i] / 2^13) * (fc_v[i] / 2^13) } = | ||

216 | * = 1/N * sum(i,0,N) { fc_v[i] * fc_v[i] } / 2^26 | ||

217 | * | ||

218 | * Ei = 10log(mean) = -10log(N) - 10log(2^26) + | ||

219 | * + 10log(sum(i,0,N) { fc_v[i] * fc_v[i] }) | ||

220 | * | ||

221 | * Ep - Ei + Em = Ep + Em + 10log(N) + 10log(2^26) - | ||

222 | * - 10log(sum(i,0,N) { fc_v[i] * fc_v[i] }) = | ||

223 | * = Ep + mr_energy - 10log(sum(i,0,N) { fc_v[i] * fc_v[i] }) | ||

224 | * | ||

225 | * gc_p = 10 ^ ((Ep - Ei + Em) / 20) = | ||

226 | * = 2 ^ (3.3219 * (Ep - Ei + Em) / 20) = 2 ^ (0.166 * (Ep - Ei + Em)) | ||

227 | * | ||

228 | * where | ||

229 | * | ||

230 | * mr_energy = Em + 10log(N) + 10log(2^26) | ||

231 | * | ||

232 | * @remark The routine is used in G.729 and AMR (all modes). | ||

233 | */ | ||

234 | int16_t ff_acelp_decode_gain_code( | ||

235 | AudioDSPContext *adsp, | ||

236 | int gain_corr_factor, | ||

237 | const int16_t* fc_v, | ||

238 | int mr_energy, | ||

239 | const int16_t* quant_energy, | ||

240 | const int16_t* ma_prediction_coeff, | ||

241 | int subframe_size, | ||

242 | int max_pred_order); | ||

243 | |||

244 | /** | ||

245 | * Calculate fixed gain (part of section 6.1.3 of AMR spec) | ||

246 | * | ||

247 | * @param fixed_gain_factor gain correction factor | ||

248 | * @param fixed_mean_energy mean decoded algebraic codebook vector energy | ||

249 | * @param prediction_error vector of the quantified predictor errors of | ||

250 | * the four previous subframes. It is updated by this function. | ||

251 | * @param energy_mean desired mean innovation energy | ||

252 | * @param pred_table table of four moving average coefficients | ||

253 | */ | ||

254 | float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy, | ||

255 | float *prediction_error, float energy_mean, | ||

256 | const float *pred_table); | ||

257 | |||

258 | |||

259 | /** | ||

260 | * Decode the adaptive codebook index to the integer and fractional parts | ||

261 | * of the pitch lag for one subframe at 1/3 fractional precision. | ||

262 | * | ||

263 | * The choice of pitch lag is described in 3GPP TS 26.090 section 5.6.1. | ||

264 | * | ||

265 | * @param lag_int integer part of pitch lag of the current subframe | ||

266 | * @param lag_frac fractional part of pitch lag of the current subframe | ||

267 | * @param pitch_index parsed adaptive codebook (pitch) index | ||

268 | * @param prev_lag_int integer part of pitch lag for the previous subframe | ||

269 | * @param subframe current subframe number | ||

270 | * @param third_as_first treat the third frame the same way as the first | ||

271 | */ | ||

272 | void ff_decode_pitch_lag(int *lag_int, int *lag_frac, int pitch_index, | ||

273 | const int prev_lag_int, const int subframe, | ||

274 | int third_as_first, int resolution); | ||

275 | |||

276 | #endif /* AVCODEC_ACELP_PITCH_DELAY_H */ | ||

277 |