Mercurial > libavcodec.hg
comparison acelp_pitch_delay.h @ 7170:04da42c2b7b4 libavcodec
gain code, gain pitch and pitch delay decoding for ACELP based codecs
author | voroshil |
---|---|
date | Mon, 30 Jun 2008 18:03:38 +0000 |
parents | |
children | c4a4495715dd |
comparison
equal
deleted
inserted
replaced
7169:f12513065d85 | 7170:04da42c2b7b4 |
---|---|
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 FFMPEG_ACELP_PITCH_DELAY_H | |
24 #define FFMPEG_ACELP_PITCH_DELAY_H | |
25 | |
26 #include <stdint.h> | |
27 | |
28 #define PITCH_DELAY_MIN 20 | |
29 #define PITCH_DELAY_MAX 143 | |
30 | |
31 /** | |
32 * \brief Decode pitch delay of the first subframe encoded by 8 bits with 1/3 | |
33 * resolution. | |
34 * \param ac_index adaptive codebook index (8 bits) | |
35 * | |
36 * \return pitch delay in 1/3 units | |
37 * | |
38 * Pitch delay is coded: | |
39 * with 1/3 resolution, 19 < pitch_delay < 85 | |
40 * integers only, 85 <= pitch_delay <= 143 | |
41 */ | |
42 int ff_acelp_decode_8bit_to_1st_delay3(int ac_index); | |
43 | |
44 /** | |
45 * \brief Decode pitch delay of the second subframe encoded by 5 or 6 bits | |
46 * with 1/3 precision. | |
47 * \param ac_index adaptive codebook index (5 or 6 bits) | |
48 * \param pitch_delay_min lower bound (integer) of pitch delay interval | |
49 * for second subframe | |
50 * | |
51 * \return pitch delay in 1/3 units | |
52 * | |
53 * Pitch delay is coded: | |
54 * with 1/3 resolution, -6 < pitch_delay - int(prev_pitch_delay) < 5 | |
55 * | |
56 * \remark The routine is used in G.729 @8k, AMR @10.2k, AMR @7.95k, | |
57 * AMR @7.4k for the second subframe. | |
58 */ | |
59 int ff_acelp_decode_5_6_bit_to_2nd_delay3( | |
60 int ac_index, | |
61 int pitch_delay_min); | |
62 | |
63 /** | |
64 * \brief Decode pitch delay with 1/3 precision. | |
65 * \param ac_index adaptive codebook index (4 bits) | |
66 * \param pitch_delay_min lower bound (integer) of pitch delay interval for | |
67 * second subframe | |
68 * | |
69 * \return pitch delay in 1/3 units | |
70 * | |
71 * Pitch delay is coded: | |
72 * integers only, -6 < pitch_delay - int(prev_pitch_delay) <= -2 | |
73 * with 1/3 resolution, -2 < pitch_delay - int(prev_pitch_delay) < 1 | |
74 * integers only, 1 <= pitch_delay - int(prev_pitch_delay) < 5 | |
75 * | |
76 * \remark The routine is used in G.729 @6.4k, AMR @6.7k, AMR @5.9k, | |
77 * AMR @5.15k, AMR @4.75k for the second subframe. | |
78 */ | |
79 int ff_acelp_decode_4bit_to_2nd_delay3( | |
80 int ac_index, | |
81 int pitch_delay_min); | |
82 | |
83 /** | |
84 * \brief Decode pitch delay of the first subframe encoded by 9 bits | |
85 * with 1/6 precision. | |
86 * \param ac_index adaptive codebook index (9 bits) | |
87 * \param pitch_delay_min lower bound (integer) of pitch delay interval for | |
88 * second subframe | |
89 * | |
90 * \return pitch delay in 1/6 units | |
91 * | |
92 * Pitch delay is coded: | |
93 * with 1/6 resolution, 17 < pitch_delay < 95 | |
94 * integers only, 95 <= pitch_delay <= 143 | |
95 * | |
96 * \remark The routine is used in AMR @12.2k for the first and third subframes. | |
97 */ | |
98 int ff_acelp_decode_9bit_to_1st_delay6(int ac_index); | |
99 | |
100 /** | |
101 * \brief Decode pitch delay of the second subframe encoded by 6 bits | |
102 * with 1/6 precision. | |
103 * \param ac_index adaptive codebook index (6 bits) | |
104 * \param pitch_delay_min lower bound (integer) of pitch delay interval for | |
105 * second subframe | |
106 * | |
107 * \return pitch delay in 1/6 units | |
108 * | |
109 * Pitch delay is coded: | |
110 * with 1/6 resolution, -6 < pitch_delay - int(prev_pitch_delay) < 5 | |
111 * | |
112 * \remark The routine is used in AMR @12.2k for the second and fourth subframes. | |
113 */ | |
114 int ff_acelp_decode_6bit_to_2nd_delay6( | |
115 int ac_index, | |
116 int pitch_delay_min); | |
117 | |
118 /** | |
119 * \brief Update past quantized energies | |
120 * \param quant_energy [in/out] past quantized energies (5.10) | |
121 * \param gain_corr_factor gain correction factor | |
122 * \param log2_ma_pred_order log2() of MA prediction order | |
123 * \param erasure frame erasure flag | |
124 * | |
125 * If frame erasure flag is not equal to zero, memory is updated with | |
126 * averaged energy, attenuated by 4dB: | |
127 * max(avg(quant_energy[i])-4, -14), i=0,ma_pred_order | |
128 * | |
129 * In normal mode memory is updated with | |
130 * Er - Ep = 20 * log10(gain_corr_factor) | |
131 * | |
132 * \remark The routine is used in G.729 and AMR (all modes). | |
133 */ | |
134 void ff_acelp_update_past_gain( | |
135 int16_t* quant_energy, | |
136 int gain_corr_factor, | |
137 int log2_ma_pred_order, | |
138 int erasure); | |
139 | |
140 /** | |
141 * \brief Decode the adaptive codebook gain and add | |
142 * correction (4.1.5 and 3.9.1 of G.729). | |
143 * \param gain_corr_factor gain correction factor (2.13) | |
144 * \param fc_v fixed-codebook vector (2.13) | |
145 * \param mr_energy mean innovation energy and fixed-point correction (7.13) | |
146 * \param quant_energy [in/out] past quantized energies (5.10) | |
147 * \param subframe_size length of subframe | |
148 * \param ma_pred_order MA prediction order | |
149 * | |
150 * \return quantized fixed-codebook gain (14.1) | |
151 * | |
152 * The routine implements equations 69, 66 and 71 of the G.729 specification (3.9.1) | |
153 * | |
154 * Em - mean innovation energy (dB, constant, depends on decoding algorithm) | |
155 * Ep - mean-removed predicted energy (dB) | |
156 * Er - mean-removed innovation energy (dB) | |
157 * Ei - mean energy of the fixed-codebook contribution (dB) | |
158 * N - subframe_size | |
159 * M - MA (Moving Average) prediction order | |
160 * gc - fixed-codebook gain | |
161 * gc_p - predicted fixed-codebook gain | |
162 * | |
163 * Fixed codebook gain is computed using predicted gain gc_p and | |
164 * correction factor gain_corr_factor as shown below: | |
165 * | |
166 * gc = gc_p * gain_corr_factor | |
167 * | |
168 * The predicted fixed codebook gain gc_p is found by predicting | |
169 * the energy of the fixed-codebook contribution from the energy | |
170 * of previous fixed-codebook contributions. | |
171 * | |
172 * mean = 1/N * sum(i,0,N){ fc_v[i] * fc_v[i] } | |
173 * | |
174 * Ei = 10log(mean) | |
175 * | |
176 * Er = 10log(1/N * gc^2 * mean) - Em = 20log(gc) + Ei - Em | |
177 * | |
178 * Replacing Er with Ep and gc with gc_p we will receive: | |
179 * | |
180 * Ep = 10log(1/N * gc_p^2 * mean) - Em = 20log(gc_p) + Ei - Em | |
181 * | |
182 * and from above: | |
183 * | |
184 * gc_p = 10^((Ep - Ei + Em) / 20) | |
185 * | |
186 * Ep is predicted using past energies and prediction coefficients: | |
187 * | |
188 * Ep = sum(i,0,M){ ma_prediction_coeff[i] * quant_energy[i] } | |
189 * | |
190 * gc_p in fixed-point arithmetic is calculated as following: | |
191 * | |
192 * mean = 1/N * sum(i,0,N){ (fc_v[i] / 2^13) * (fc_v[i] / 2^13) } = | |
193 * = 1/N * sum(i,0,N) { fc_v[i] * fc_v[i] } / 2^26 | |
194 * | |
195 * Ei = 10log(mean) = -10log(N) - 10log(2^26) + | |
196 * + 10log(sum(i,0,N) { fc_v[i] * fc_v[i] }) | |
197 * | |
198 * Ep - Ei + Em = Ep + Em + 10log(N) + 10log(2^26) - | |
199 * - 10log(sum(i,0,N) { fc_v[i] * fc_v[i] }) = | |
200 * = Ep + mr_energy - 10log(sum(i,0,N) { fc_v[i] * fc_v[i] }) | |
201 * | |
202 * gc_p = 10 ^ ((Ep - Ei + Em) / 20) = | |
203 * = 2 ^ (3.3219 * (Ep - Ei + Em) / 20) = 2 ^ (0.166 * (Ep - Ei + Em)) | |
204 * | |
205 * where | |
206 * | |
207 * mr_energy = Em + 10log(N) + 10log(2^26) | |
208 * | |
209 * \remark The routine is used in G.729 and AMR (all modes). | |
210 */ | |
211 int16_t ff_acelp_decode_gain_code( | |
212 int gain_corr_factor, | |
213 const int16_t* fc_v, | |
214 int mr_energy, | |
215 const int16_t* quant_energy, | |
216 const int16_t* ma_prediction_coeff, | |
217 int subframe_size, | |
218 int max_pred_order); | |
219 | |
220 #endif /* FFMPEG_ACELP_PITCH_DELAY_H */ |