| 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 |