Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * AMR wideband decoder | ||
3 | * Copyright (c) 2010 Marcelo Galvao Povoa | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A particular PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | /** | ||
23 | * @file | ||
24 | * AMR wideband decoder | ||
25 | */ | ||
26 | |||
27 | #include "config.h" | ||
28 | |||
29 | #include "libavutil/channel_layout.h" | ||
30 | #include "libavutil/common.h" | ||
31 | #include "libavutil/lfg.h" | ||
32 | |||
33 | #include "avcodec.h" | ||
34 | #include "lsp.h" | ||
35 | #include "celp_filters.h" | ||
36 | #include "celp_math.h" | ||
37 | #include "acelp_filters.h" | ||
38 | #include "acelp_vectors.h" | ||
39 | #include "acelp_pitch_delay.h" | ||
40 | #include "codec_internal.h" | ||
41 | #include "decode.h" | ||
42 | |||
43 | #define AMR_USE_16BIT_TABLES | ||
44 | #include "amr.h" | ||
45 | |||
46 | #include "amrwbdata.h" | ||
47 | #if ARCH_MIPS | ||
48 | #include "mips/amrwbdec_mips.h" | ||
49 | #endif /* ARCH_MIPS */ | ||
50 | |||
51 | typedef struct AMRWBContext { | ||
52 | AMRWBFrame frame; ///< AMRWB parameters decoded from bitstream | ||
53 | enum Mode fr_cur_mode; ///< mode index of current frame | ||
54 | uint8_t fr_quality; ///< frame quality index (FQI) | ||
55 | float isf_cur[LP_ORDER]; ///< working ISF vector from current frame | ||
56 | float isf_q_past[LP_ORDER]; ///< quantized ISF vector of the previous frame | ||
57 | float isf_past_final[LP_ORDER]; ///< final processed ISF vector of the previous frame | ||
58 | double isp[4][LP_ORDER]; ///< ISP vectors from current frame | ||
59 | double isp_sub4_past[LP_ORDER]; ///< ISP vector for the 4th subframe of the previous frame | ||
60 | |||
61 | float lp_coef[4][LP_ORDER]; ///< Linear Prediction Coefficients from ISP vector | ||
62 | |||
63 | uint8_t base_pitch_lag; ///< integer part of pitch lag for the next relative subframe | ||
64 | uint8_t pitch_lag_int; ///< integer part of pitch lag of the previous subframe | ||
65 | |||
66 | float excitation_buf[AMRWB_P_DELAY_MAX + LP_ORDER + 2 + AMRWB_SFR_SIZE]; ///< current excitation and all necessary excitation history | ||
67 | float *excitation; ///< points to current excitation in excitation_buf[] | ||
68 | |||
69 | float pitch_vector[AMRWB_SFR_SIZE]; ///< adaptive codebook (pitch) vector for current subframe | ||
70 | float fixed_vector[AMRWB_SFR_SIZE]; ///< algebraic codebook (fixed) vector for current subframe | ||
71 | |||
72 | float prediction_error[4]; ///< quantified prediction errors {20log10(^gamma_gc)} for previous four subframes | ||
73 | float pitch_gain[6]; ///< quantified pitch gains for the current and previous five subframes | ||
74 | float fixed_gain[2]; ///< quantified fixed gains for the current and previous subframes | ||
75 | |||
76 | float tilt_coef; ///< {beta_1} related to the voicing of the previous subframe | ||
77 | |||
78 | float prev_sparse_fixed_gain; ///< previous fixed gain; used by anti-sparseness to determine "onset" | ||
79 | uint8_t prev_ir_filter_nr; ///< previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none | ||
80 | float prev_tr_gain; ///< previous initial gain used by noise enhancer for threshold | ||
81 | |||
82 | float samples_az[LP_ORDER + AMRWB_SFR_SIZE]; ///< low-band samples and memory from synthesis at 12.8kHz | ||
83 | float samples_up[UPS_MEM_SIZE + AMRWB_SFR_SIZE]; ///< low-band samples and memory processed for upsampling | ||
84 | float samples_hb[LP_ORDER_16k + AMRWB_SFR_SIZE_16k]; ///< high-band samples and memory from synthesis at 16kHz | ||
85 | |||
86 | float hpf_31_mem[2], hpf_400_mem[2]; ///< previous values in the high pass filters | ||
87 | float demph_mem[1]; ///< previous value in the de-emphasis filter | ||
88 | float bpf_6_7_mem[HB_FIR_SIZE]; ///< previous values in the high-band band pass filter | ||
89 | float lpf_7_mem[HB_FIR_SIZE]; ///< previous values in the high-band low pass filter | ||
90 | |||
91 | AVLFG prng; ///< random number generator for white noise excitation | ||
92 | uint8_t first_frame; ///< flag active during decoding of the first frame | ||
93 | ACELPFContext acelpf_ctx; ///< context for filters for ACELP-based codecs | ||
94 | ACELPVContext acelpv_ctx; ///< context for vector operations for ACELP-based codecs | ||
95 | CELPFContext celpf_ctx; ///< context for filters for CELP-based codecs | ||
96 | CELPMContext celpm_ctx; ///< context for fixed point math operations | ||
97 | |||
98 | } AMRWBContext; | ||
99 | |||
100 | typedef struct AMRWBChannelsContext { | ||
101 | AMRWBContext ch[2]; | ||
102 | } AMRWBChannelsContext; | ||
103 | |||
104 | 22 | static av_cold int amrwb_decode_init(AVCodecContext *avctx) | |
105 | { | ||
106 | 22 | AMRWBChannelsContext *s = avctx->priv_data; | |
107 | int i; | ||
108 | |||
109 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if (avctx->ch_layout.nb_channels > 2) { |
110 | ✗ | avpriv_report_missing_feature(avctx, ">2 channel AMR"); | |
111 | ✗ | return AVERROR_PATCHWELCOME; | |
112 | } | ||
113 | |||
114 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if (!avctx->ch_layout.nb_channels) { |
115 | ✗ | av_channel_layout_uninit(&avctx->ch_layout); | |
116 | ✗ | avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO; | |
117 | } | ||
118 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if (!avctx->sample_rate) |
119 | ✗ | avctx->sample_rate = 16000; | |
120 | 22 | avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; | |
121 | |||
122 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 22 times.
|
44 | for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) { |
123 | 22 | AMRWBContext *ctx = &s->ch[ch]; | |
124 | |||
125 | 22 | av_lfg_init(&ctx->prng, 1); | |
126 | |||
127 | 22 | ctx->excitation = &ctx->excitation_buf[AMRWB_P_DELAY_MAX + LP_ORDER + 1]; | |
128 | 22 | ctx->first_frame = 1; | |
129 | |||
130 |
2/2✓ Branch 0 taken 352 times.
✓ Branch 1 taken 22 times.
|
374 | for (i = 0; i < LP_ORDER; i++) |
131 | 352 | ctx->isf_past_final[i] = isf_init[i] * (1.0f / (1 << 15)); | |
132 | |||
133 |
2/2✓ Branch 0 taken 88 times.
✓ Branch 1 taken 22 times.
|
110 | for (i = 0; i < 4; i++) |
134 | 88 | ctx->prediction_error[i] = MIN_ENERGY; | |
135 | |||
136 | 22 | ff_acelp_filter_init(&ctx->acelpf_ctx); | |
137 | 22 | ff_acelp_vectors_init(&ctx->acelpv_ctx); | |
138 | 22 | ff_celp_filter_init(&ctx->celpf_ctx); | |
139 | 22 | ff_celp_math_init(&ctx->celpm_ctx); | |
140 | } | ||
141 | |||
142 | 22 | return 0; | |
143 | } | ||
144 | |||
145 | /** | ||
146 | * Decode the frame header in the "MIME/storage" format. This format | ||
147 | * is simpler and does not carry the auxiliary frame information. | ||
148 | * | ||
149 | * @param[in] ctx The Context | ||
150 | * @param[in] buf Pointer to the input buffer | ||
151 | * | ||
152 | * @return The decoded header length in bytes | ||
153 | */ | ||
154 | 6268 | static int decode_mime_header(AMRWBContext *ctx, const uint8_t *buf) | |
155 | { | ||
156 | /* Decode frame header (1st octet) */ | ||
157 | 6268 | ctx->fr_cur_mode = buf[0] >> 3 & 0x0F; | |
158 | 6268 | ctx->fr_quality = (buf[0] & 0x4) == 0x4; | |
159 | |||
160 | 6268 | return 1; | |
161 | } | ||
162 | |||
163 | /** | ||
164 | * Decode quantized ISF vectors using 36-bit indexes (6K60 mode only). | ||
165 | * | ||
166 | * @param[in] ind Array of 5 indexes | ||
167 | * @param[out] isf_q Buffer for isf_q[LP_ORDER] | ||
168 | */ | ||
169 | 513 | static void decode_isf_indices_36b(uint16_t *ind, float *isf_q) | |
170 | { | ||
171 | int i; | ||
172 | |||
173 |
2/2✓ Branch 0 taken 4617 times.
✓ Branch 1 taken 513 times.
|
5130 | for (i = 0; i < 9; i++) |
174 | 4617 | isf_q[i] = dico1_isf[ind[0]][i] * (1.0f / (1 << 15)); | |
175 | |||
176 |
2/2✓ Branch 0 taken 3591 times.
✓ Branch 1 taken 513 times.
|
4104 | for (i = 0; i < 7; i++) |
177 | 3591 | isf_q[i + 9] = dico2_isf[ind[1]][i] * (1.0f / (1 << 15)); | |
178 | |||
179 |
2/2✓ Branch 0 taken 2565 times.
✓ Branch 1 taken 513 times.
|
3078 | for (i = 0; i < 5; i++) |
180 | 2565 | isf_q[i] += dico21_isf_36b[ind[2]][i] * (1.0f / (1 << 15)); | |
181 | |||
182 |
2/2✓ Branch 0 taken 2052 times.
✓ Branch 1 taken 513 times.
|
2565 | for (i = 0; i < 4; i++) |
183 | 2052 | isf_q[i + 5] += dico22_isf_36b[ind[3]][i] * (1.0f / (1 << 15)); | |
184 | |||
185 |
2/2✓ Branch 0 taken 3591 times.
✓ Branch 1 taken 513 times.
|
4104 | for (i = 0; i < 7; i++) |
186 | 3591 | isf_q[i + 9] += dico23_isf_36b[ind[4]][i] * (1.0f / (1 << 15)); | |
187 | 513 | } | |
188 | |||
189 | /** | ||
190 | * Decode quantized ISF vectors using 46-bit indexes (except 6K60 mode). | ||
191 | * | ||
192 | * @param[in] ind Array of 7 indexes | ||
193 | * @param[out] isf_q Buffer for isf_q[LP_ORDER] | ||
194 | */ | ||
195 | 5755 | static void decode_isf_indices_46b(uint16_t *ind, float *isf_q) | |
196 | { | ||
197 | int i; | ||
198 | |||
199 |
2/2✓ Branch 0 taken 51795 times.
✓ Branch 1 taken 5755 times.
|
57550 | for (i = 0; i < 9; i++) |
200 | 51795 | isf_q[i] = dico1_isf[ind[0]][i] * (1.0f / (1 << 15)); | |
201 | |||
202 |
2/2✓ Branch 0 taken 40285 times.
✓ Branch 1 taken 5755 times.
|
46040 | for (i = 0; i < 7; i++) |
203 | 40285 | isf_q[i + 9] = dico2_isf[ind[1]][i] * (1.0f / (1 << 15)); | |
204 | |||
205 |
2/2✓ Branch 0 taken 17265 times.
✓ Branch 1 taken 5755 times.
|
23020 | for (i = 0; i < 3; i++) |
206 | 17265 | isf_q[i] += dico21_isf[ind[2]][i] * (1.0f / (1 << 15)); | |
207 | |||
208 |
2/2✓ Branch 0 taken 17265 times.
✓ Branch 1 taken 5755 times.
|
23020 | for (i = 0; i < 3; i++) |
209 | 17265 | isf_q[i + 3] += dico22_isf[ind[3]][i] * (1.0f / (1 << 15)); | |
210 | |||
211 |
2/2✓ Branch 0 taken 17265 times.
✓ Branch 1 taken 5755 times.
|
23020 | for (i = 0; i < 3; i++) |
212 | 17265 | isf_q[i + 6] += dico23_isf[ind[4]][i] * (1.0f / (1 << 15)); | |
213 | |||
214 |
2/2✓ Branch 0 taken 17265 times.
✓ Branch 1 taken 5755 times.
|
23020 | for (i = 0; i < 3; i++) |
215 | 17265 | isf_q[i + 9] += dico24_isf[ind[5]][i] * (1.0f / (1 << 15)); | |
216 | |||
217 |
2/2✓ Branch 0 taken 23020 times.
✓ Branch 1 taken 5755 times.
|
28775 | for (i = 0; i < 4; i++) |
218 | 23020 | isf_q[i + 12] += dico25_isf[ind[6]][i] * (1.0f / (1 << 15)); | |
219 | 5755 | } | |
220 | |||
221 | /** | ||
222 | * Apply mean and past ISF values using the prediction factor. | ||
223 | * Updates past ISF vector. | ||
224 | * | ||
225 | * @param[in,out] isf_q Current quantized ISF | ||
226 | * @param[in,out] isf_past Past quantized ISF | ||
227 | */ | ||
228 | 6268 | static void isf_add_mean_and_past(float *isf_q, float *isf_past) | |
229 | { | ||
230 | int i; | ||
231 | float tmp; | ||
232 | |||
233 |
2/2✓ Branch 0 taken 100288 times.
✓ Branch 1 taken 6268 times.
|
106556 | for (i = 0; i < LP_ORDER; i++) { |
234 | 100288 | tmp = isf_q[i]; | |
235 | 100288 | isf_q[i] += isf_mean[i] * (1.0f / (1 << 15)); | |
236 | 100288 | isf_q[i] += PRED_FACTOR * isf_past[i]; | |
237 | 100288 | isf_past[i] = tmp; | |
238 | } | ||
239 | 6268 | } | |
240 | |||
241 | /** | ||
242 | * Interpolate the fourth ISP vector from current and past frames | ||
243 | * to obtain an ISP vector for each subframe. | ||
244 | * | ||
245 | * @param[in,out] isp_q ISPs for each subframe | ||
246 | * @param[in] isp4_past Past ISP for subframe 4 | ||
247 | */ | ||
248 | 6268 | static void interpolate_isp(double isp_q[4][LP_ORDER], const double *isp4_past) | |
249 | { | ||
250 | int i, k; | ||
251 | |||
252 |
2/2✓ Branch 0 taken 18804 times.
✓ Branch 1 taken 6268 times.
|
25072 | for (k = 0; k < 3; k++) { |
253 | 18804 | float c = isfp_inter[k]; | |
254 |
2/2✓ Branch 0 taken 300864 times.
✓ Branch 1 taken 18804 times.
|
319668 | for (i = 0; i < LP_ORDER; i++) |
255 | 300864 | isp_q[k][i] = (1.0 - c) * isp4_past[i] + c * isp_q[3][i]; | |
256 | } | ||
257 | 6268 | } | |
258 | |||
259 | /** | ||
260 | * Decode an adaptive codebook index into pitch lag (except 6k60, 8k85 modes). | ||
261 | * Calculate integer lag and fractional lag always using 1/4 resolution. | ||
262 | * In 1st and 3rd subframes the index is relative to last subframe integer lag. | ||
263 | * | ||
264 | * @param[out] lag_int Decoded integer pitch lag | ||
265 | * @param[out] lag_frac Decoded fractional pitch lag | ||
266 | * @param[in] pitch_index Adaptive codebook pitch index | ||
267 | * @param[in,out] base_lag_int Base integer lag used in relative subframes | ||
268 | * @param[in] subframe Current subframe index (0 to 3) | ||
269 | */ | ||
270 | 20968 | static void decode_pitch_lag_high(int *lag_int, int *lag_frac, int pitch_index, | |
271 | uint8_t *base_lag_int, int subframe) | ||
272 | { | ||
273 |
4/4✓ Branch 0 taken 15726 times.
✓ Branch 1 taken 5242 times.
✓ Branch 2 taken 5242 times.
✓ Branch 3 taken 10484 times.
|
20968 | if (subframe == 0 || subframe == 2) { |
274 |
2/2✓ Branch 0 taken 7630 times.
✓ Branch 1 taken 2854 times.
|
10484 | if (pitch_index < 376) { |
275 | 7630 | *lag_int = (pitch_index + 137) >> 2; | |
276 | 7630 | *lag_frac = pitch_index - (*lag_int << 2) + 136; | |
277 |
2/2✓ Branch 0 taken 1248 times.
✓ Branch 1 taken 1606 times.
|
2854 | } else if (pitch_index < 440) { |
278 | 1248 | *lag_int = (pitch_index + 257 - 376) >> 1; | |
279 | 1248 | *lag_frac = (pitch_index - (*lag_int << 1) + 256 - 376) * 2; | |
280 | /* the actual resolution is 1/2 but expressed as 1/4 */ | ||
281 | } else { | ||
282 | 1606 | *lag_int = pitch_index - 280; | |
283 | 1606 | *lag_frac = 0; | |
284 | } | ||
285 | /* minimum lag for next subframe */ | ||
286 | 10484 | *base_lag_int = av_clip(*lag_int - 8 - (*lag_frac < 0), | |
287 | AMRWB_P_DELAY_MIN, AMRWB_P_DELAY_MAX - 15); | ||
288 | // XXX: the spec states clearly that *base_lag_int should be | ||
289 | // the nearest integer to *lag_int (minus 8), but the ref code | ||
290 | // actually always uses its floor, I'm following the latter | ||
291 | } else { | ||
292 | 10484 | *lag_int = (pitch_index + 1) >> 2; | |
293 | 10484 | *lag_frac = pitch_index - (*lag_int << 2); | |
294 | 10484 | *lag_int += *base_lag_int; | |
295 | } | ||
296 | 20968 | } | |
297 | |||
298 | /** | ||
299 | * Decode an adaptive codebook index into pitch lag for 8k85 and 6k60 modes. | ||
300 | * The description is analogous to decode_pitch_lag_high, but in 6k60 the | ||
301 | * relative index is used for all subframes except the first. | ||
302 | */ | ||
303 | 4104 | static void decode_pitch_lag_low(int *lag_int, int *lag_frac, int pitch_index, | |
304 | uint8_t *base_lag_int, int subframe, enum Mode mode) | ||
305 | { | ||
306 |
6/6✓ Branch 0 taken 3078 times.
✓ Branch 1 taken 1026 times.
✓ Branch 2 taken 1026 times.
✓ Branch 3 taken 2052 times.
✓ Branch 4 taken 513 times.
✓ Branch 5 taken 513 times.
|
4104 | if (subframe == 0 || (subframe == 2 && mode != MODE_6k60)) { |
307 |
2/2✓ Branch 0 taken 850 times.
✓ Branch 1 taken 689 times.
|
1539 | if (pitch_index < 116) { |
308 | 850 | *lag_int = (pitch_index + 69) >> 1; | |
309 | 850 | *lag_frac = (pitch_index - (*lag_int << 1) + 68) * 2; | |
310 | } else { | ||
311 | 689 | *lag_int = pitch_index - 24; | |
312 | 689 | *lag_frac = 0; | |
313 | } | ||
314 | // XXX: same problem as before | ||
315 | 1539 | *base_lag_int = av_clip(*lag_int - 8 - (*lag_frac < 0), | |
316 | AMRWB_P_DELAY_MIN, AMRWB_P_DELAY_MAX - 15); | ||
317 | } else { | ||
318 | 2565 | *lag_int = (pitch_index + 1) >> 1; | |
319 | 2565 | *lag_frac = (pitch_index - (*lag_int << 1)) * 2; | |
320 | 2565 | *lag_int += *base_lag_int; | |
321 | } | ||
322 | 4104 | } | |
323 | |||
324 | /** | ||
325 | * Find the pitch vector by interpolating the past excitation at the | ||
326 | * pitch delay, which is obtained in this function. | ||
327 | * | ||
328 | * @param[in,out] ctx The context | ||
329 | * @param[in] amr_subframe Current subframe data | ||
330 | * @param[in] subframe Current subframe index (0 to 3) | ||
331 | */ | ||
332 | 25072 | static void decode_pitch_vector(AMRWBContext *ctx, | |
333 | const AMRWBSubFrame *amr_subframe, | ||
334 | const int subframe) | ||
335 | { | ||
336 | int pitch_lag_int, pitch_lag_frac; | ||
337 | int i; | ||
338 | 25072 | float *exc = ctx->excitation; | |
339 | 25072 | enum Mode mode = ctx->fr_cur_mode; | |
340 | |||
341 |
2/2✓ Branch 0 taken 4104 times.
✓ Branch 1 taken 20968 times.
|
25072 | if (mode <= MODE_8k85) { |
342 | 4104 | decode_pitch_lag_low(&pitch_lag_int, &pitch_lag_frac, amr_subframe->adap, | |
343 | &ctx->base_pitch_lag, subframe, mode); | ||
344 | } else | ||
345 | 20968 | decode_pitch_lag_high(&pitch_lag_int, &pitch_lag_frac, amr_subframe->adap, | |
346 | &ctx->base_pitch_lag, subframe); | ||
347 | |||
348 | 25072 | ctx->pitch_lag_int = pitch_lag_int; | |
349 | 25072 | pitch_lag_int += pitch_lag_frac > 0; | |
350 | |||
351 | /* Calculate the pitch vector by interpolating the past excitation at the | ||
352 | pitch lag using a hamming windowed sinc function */ | ||
353 | 50144 | ctx->acelpf_ctx.acelp_interpolatef(exc, | |
354 | 25072 | exc + 1 - pitch_lag_int, | |
355 | ac_inter, 4, | ||
356 |
2/2✓ Branch 0 taken 8454 times.
✓ Branch 1 taken 16618 times.
|
25072 | pitch_lag_frac + (pitch_lag_frac > 0 ? 0 : 4), |
357 | LP_ORDER, AMRWB_SFR_SIZE + 1); | ||
358 | |||
359 | /* Check which pitch signal path should be used | ||
360 | * 6k60 and 8k85 modes have the ltp flag set to 0 */ | ||
361 |
2/2✓ Branch 0 taken 7140 times.
✓ Branch 1 taken 17932 times.
|
25072 | if (amr_subframe->ltp) { |
362 | 7140 | memcpy(ctx->pitch_vector, exc, AMRWB_SFR_SIZE * sizeof(float)); | |
363 | } else { | ||
364 |
2/2✓ Branch 0 taken 1147648 times.
✓ Branch 1 taken 17932 times.
|
1165580 | for (i = 0; i < AMRWB_SFR_SIZE; i++) |
365 | 1147648 | ctx->pitch_vector[i] = 0.18 * exc[i - 1] + 0.64 * exc[i] + | |
366 | 1147648 | 0.18 * exc[i + 1]; | |
367 | 17932 | memcpy(exc, ctx->pitch_vector, AMRWB_SFR_SIZE * sizeof(float)); | |
368 | } | ||
369 | 25072 | } | |
370 | |||
371 | /** Get x bits in the index interval [lsb,lsb+len-1] inclusive */ | ||
372 | #define BIT_STR(x,lsb,len) av_mod_uintp2((x) >> (lsb), (len)) | ||
373 | |||
374 | /** Get the bit at specified position */ | ||
375 | #define BIT_POS(x, p) (((x) >> (p)) & 1) | ||
376 | |||
377 | /** | ||
378 | * The next six functions decode_[i]p_track decode exactly i pulses | ||
379 | * positions and amplitudes (-1 or 1) in a subframe track using | ||
380 | * an encoded pulse indexing (TS 26.190 section 5.8.2). | ||
381 | * | ||
382 | * The results are given in out[], in which a negative number means | ||
383 | * amplitude -1 and vice versa (i.e., ampl(x) = x / abs(x) ). | ||
384 | * | ||
385 | * @param[out] out Output buffer (writes i elements) | ||
386 | * @param[in] code Pulse index (no. of bits varies, see below) | ||
387 | * @param[in] m (log2) Number of potential positions | ||
388 | * @param[in] off Offset for decoded positions | ||
389 | */ | ||
390 | 106180 | static inline void decode_1p_track(int *out, int code, int m, int off) | |
391 | { | ||
392 | 106180 | int pos = BIT_STR(code, 0, m) + off; ///code: m+1 bits | |
393 | |||
394 |
2/2✓ Branch 0 taken 53239 times.
✓ Branch 1 taken 52941 times.
|
106180 | out[0] = BIT_POS(code, m) ? -pos : pos; |
395 | 106180 | } | |
396 | |||
397 | 147226 | static inline void decode_2p_track(int *out, int code, int m, int off) ///code: 2m+1 bits | |
398 | { | ||
399 | 147226 | int pos0 = BIT_STR(code, m, m) + off; | |
400 | 147226 | int pos1 = BIT_STR(code, 0, m) + off; | |
401 | |||
402 |
2/2✓ Branch 0 taken 74035 times.
✓ Branch 1 taken 73191 times.
|
147226 | out[0] = BIT_POS(code, 2*m) ? -pos0 : pos0; |
403 |
2/2✓ Branch 0 taken 74035 times.
✓ Branch 1 taken 73191 times.
|
147226 | out[1] = BIT_POS(code, 2*m) ? -pos1 : pos1; |
404 |
2/2✓ Branch 0 taken 66336 times.
✓ Branch 1 taken 80890 times.
|
147226 | out[1] = pos0 > pos1 ? -out[1] : out[1]; |
405 | 147226 | } | |
406 | |||
407 | 68748 | static void decode_3p_track(int *out, int code, int m, int off) ///code: 3m+1 bits | |
408 | { | ||
409 | 68748 | int half_2p = BIT_POS(code, 2*m - 1) << (m - 1); | |
410 | |||
411 | 68748 | decode_2p_track(out, BIT_STR(code, 0, 2*m - 1), | |
412 | m - 1, off + half_2p); | ||
413 | 68748 | decode_1p_track(out + 2, BIT_STR(code, 2*m, m + 1), m, off); | |
414 | 68748 | } | |
415 | |||
416 | 32563 | static void decode_4p_track(int *out, int code, int m, int off) ///code: 4m bits | |
417 | { | ||
418 | int half_4p, subhalf_2p; | ||
419 | 32563 | int b_offset = 1 << (m - 1); | |
420 | |||
421 |
4/5✓ Branch 0 taken 3612 times.
✓ Branch 1 taken 7991 times.
✓ Branch 2 taken 12806 times.
✓ Branch 3 taken 8154 times.
✗ Branch 4 not taken.
|
32563 | switch (BIT_STR(code, 4*m - 2, 2)) { /* case ID (2 bits) */ |
422 | 3612 | case 0: /* 0 pulses in A, 4 pulses in B or vice versa */ | |
423 | 3612 | half_4p = BIT_POS(code, 4*m - 3) << (m - 1); // which has 4 pulses | |
424 | 3612 | subhalf_2p = BIT_POS(code, 2*m - 3) << (m - 2); | |
425 | |||
426 | 3612 | decode_2p_track(out, BIT_STR(code, 0, 2*m - 3), | |
427 | 3612 | m - 2, off + half_4p + subhalf_2p); | |
428 | 3612 | decode_2p_track(out + 2, BIT_STR(code, 2*m - 2, 2*m - 1), | |
429 | m - 1, off + half_4p); | ||
430 | 3612 | break; | |
431 | 7991 | case 1: /* 1 pulse in A, 3 pulses in B */ | |
432 | 7991 | decode_1p_track(out, BIT_STR(code, 3*m - 2, m), | |
433 | m - 1, off); | ||
434 | 7991 | decode_3p_track(out + 1, BIT_STR(code, 0, 3*m - 2), | |
435 | m - 1, off + b_offset); | ||
436 | 7991 | break; | |
437 | 12806 | case 2: /* 2 pulses in each half */ | |
438 | 12806 | decode_2p_track(out, BIT_STR(code, 2*m - 1, 2*m - 1), | |
439 | m - 1, off); | ||
440 | 12806 | decode_2p_track(out + 2, BIT_STR(code, 0, 2*m - 1), | |
441 | m - 1, off + b_offset); | ||
442 | 12806 | break; | |
443 | 8154 | case 3: /* 3 pulses in A, 1 pulse in B */ | |
444 | 8154 | decode_3p_track(out, BIT_STR(code, m, 3*m - 2), | |
445 | m - 1, off); | ||
446 | 8154 | decode_1p_track(out + 3, BIT_STR(code, 0, m), | |
447 | m - 1, off + b_offset); | ||
448 | 8154 | break; | |
449 | } | ||
450 | 32563 | } | |
451 | |||
452 | 13079 | static void decode_5p_track(int *out, int code, int m, int off) ///code: 5m bits | |
453 | { | ||
454 | 13079 | int half_3p = BIT_POS(code, 5*m - 1) << (m - 1); | |
455 | |||
456 | 13079 | decode_3p_track(out, BIT_STR(code, 2*m + 1, 3*m - 2), | |
457 | m - 1, off + half_3p); | ||
458 | |||
459 | 13079 | decode_2p_track(out + 3, BIT_STR(code, 0, 2*m + 1), m, off); | |
460 | 13079 | } | |
461 | |||
462 | 42832 | static void decode_6p_track(int *out, int code, int m, int off) ///code: 6m-2 bits | |
463 | { | ||
464 | 42832 | int b_offset = 1 << (m - 1); | |
465 | /* which half has more pulses in cases 0 to 2 */ | ||
466 | 42832 | int half_more = BIT_POS(code, 6*m - 5) << (m - 1); | |
467 | 42832 | int half_other = b_offset - half_more; | |
468 | |||
469 |
4/5✓ Branch 0 taken 1297 times.
✓ Branch 1 taken 7678 times.
✓ Branch 2 taken 20251 times.
✓ Branch 3 taken 13606 times.
✗ Branch 4 not taken.
|
42832 | switch (BIT_STR(code, 6*m - 4, 2)) { /* case ID (2 bits) */ |
470 | 1297 | case 0: /* 0 pulses in A, 6 pulses in B or vice versa */ | |
471 | 1297 | decode_1p_track(out, BIT_STR(code, 0, m), | |
472 | m - 1, off + half_more); | ||
473 | 1297 | decode_5p_track(out + 1, BIT_STR(code, m, 5*m - 5), | |
474 | m - 1, off + half_more); | ||
475 | 1297 | break; | |
476 | 7678 | case 1: /* 1 pulse in A, 5 pulses in B or vice versa */ | |
477 | 7678 | decode_1p_track(out, BIT_STR(code, 0, m), | |
478 | m - 1, off + half_other); | ||
479 | 7678 | decode_5p_track(out + 1, BIT_STR(code, m, 5*m - 5), | |
480 | m - 1, off + half_more); | ||
481 | 7678 | break; | |
482 | 20251 | case 2: /* 2 pulses in A, 4 pulses in B or vice versa */ | |
483 | 20251 | decode_2p_track(out, BIT_STR(code, 0, 2*m - 1), | |
484 | m - 1, off + half_other); | ||
485 | 20251 | decode_4p_track(out + 2, BIT_STR(code, 2*m - 1, 4*m - 4), | |
486 | m - 1, off + half_more); | ||
487 | 20251 | break; | |
488 | 13606 | case 3: /* 3 pulses in A, 3 pulses in B */ | |
489 | 13606 | decode_3p_track(out, BIT_STR(code, 3*m - 2, 3*m - 2), | |
490 | m - 1, off); | ||
491 | 13606 | decode_3p_track(out + 3, BIT_STR(code, 0, 3*m - 2), | |
492 | m - 1, off + b_offset); | ||
493 | 13606 | break; | |
494 | } | ||
495 | 42832 | } | |
496 | |||
497 | /** | ||
498 | * Decode the algebraic codebook index to pulse positions and signs, | ||
499 | * then construct the algebraic codebook vector. | ||
500 | * | ||
501 | * @param[out] fixed_vector Buffer for the fixed codebook excitation | ||
502 | * @param[in] pulse_hi MSBs part of the pulse index array (higher modes only) | ||
503 | * @param[in] pulse_lo LSBs part of the pulse index array | ||
504 | * @param[in] mode Mode of the current frame | ||
505 | */ | ||
506 | 25072 | static void decode_fixed_vector(float *fixed_vector, const uint16_t *pulse_hi, | |
507 | const uint16_t *pulse_lo, const enum Mode mode) | ||
508 | { | ||
509 | /* sig_pos stores for each track the decoded pulse position indexes | ||
510 | * (1-based) multiplied by its corresponding amplitude (+1 or -1) */ | ||
511 | int sig_pos[4][6]; | ||
512 |
2/2✓ Branch 0 taken 2052 times.
✓ Branch 1 taken 23020 times.
|
25072 | int spacing = (mode == MODE_6k60) ? 2 : 4; |
513 | int i, j; | ||
514 | |||
515 |
8/9✓ Branch 0 taken 2052 times.
✓ Branch 1 taken 2052 times.
✓ Branch 2 taken 2052 times.
✓ Branch 3 taken 2052 times.
✓ Branch 4 taken 2052 times.
✓ Branch 5 taken 2052 times.
✓ Branch 6 taken 2052 times.
✓ Branch 7 taken 10708 times.
✗ Branch 8 not taken.
|
25072 | switch (mode) { |
516 | 2052 | case MODE_6k60: | |
517 |
2/2✓ Branch 0 taken 4104 times.
✓ Branch 1 taken 2052 times.
|
6156 | for (i = 0; i < 2; i++) |
518 | 4104 | decode_1p_track(sig_pos[i], pulse_lo[i], 5, 1); | |
519 | 2052 | break; | |
520 | 2052 | case MODE_8k85: | |
521 |
2/2✓ Branch 0 taken 8208 times.
✓ Branch 1 taken 2052 times.
|
10260 | for (i = 0; i < 4; i++) |
522 | 8208 | decode_1p_track(sig_pos[i], pulse_lo[i], 4, 1); | |
523 | 2052 | break; | |
524 | 2052 | case MODE_12k65: | |
525 |
2/2✓ Branch 0 taken 8208 times.
✓ Branch 1 taken 2052 times.
|
10260 | for (i = 0; i < 4; i++) |
526 | 8208 | decode_2p_track(sig_pos[i], pulse_lo[i], 4, 1); | |
527 | 2052 | break; | |
528 | 2052 | case MODE_14k25: | |
529 |
2/2✓ Branch 0 taken 4104 times.
✓ Branch 1 taken 2052 times.
|
6156 | for (i = 0; i < 2; i++) |
530 | 4104 | decode_3p_track(sig_pos[i], pulse_lo[i], 4, 1); | |
531 |
2/2✓ Branch 0 taken 4104 times.
✓ Branch 1 taken 2052 times.
|
6156 | for (i = 2; i < 4; i++) |
532 | 4104 | decode_2p_track(sig_pos[i], pulse_lo[i], 4, 1); | |
533 | 2052 | break; | |
534 | 2052 | case MODE_15k85: | |
535 |
2/2✓ Branch 0 taken 8208 times.
✓ Branch 1 taken 2052 times.
|
10260 | for (i = 0; i < 4; i++) |
536 | 8208 | decode_3p_track(sig_pos[i], pulse_lo[i], 4, 1); | |
537 | 2052 | break; | |
538 | 2052 | case MODE_18k25: | |
539 |
2/2✓ Branch 0 taken 8208 times.
✓ Branch 1 taken 2052 times.
|
10260 | for (i = 0; i < 4; i++) |
540 | 8208 | decode_4p_track(sig_pos[i], (int) pulse_lo[i] + | |
541 | 8208 | ((int) pulse_hi[i] << 14), 4, 1); | |
542 | 2052 | break; | |
543 | 2052 | case MODE_19k85: | |
544 |
2/2✓ Branch 0 taken 4104 times.
✓ Branch 1 taken 2052 times.
|
6156 | for (i = 0; i < 2; i++) |
545 | 4104 | decode_5p_track(sig_pos[i], (int) pulse_lo[i] + | |
546 | 4104 | ((int) pulse_hi[i] << 10), 4, 1); | |
547 |
2/2✓ Branch 0 taken 4104 times.
✓ Branch 1 taken 2052 times.
|
6156 | for (i = 2; i < 4; i++) |
548 | 4104 | decode_4p_track(sig_pos[i], (int) pulse_lo[i] + | |
549 | 4104 | ((int) pulse_hi[i] << 14), 4, 1); | |
550 | 2052 | break; | |
551 | 10708 | case MODE_23k05: | |
552 | case MODE_23k85: | ||
553 |
2/2✓ Branch 0 taken 42832 times.
✓ Branch 1 taken 10708 times.
|
53540 | for (i = 0; i < 4; i++) |
554 | 42832 | decode_6p_track(sig_pos[i], (int) pulse_lo[i] + | |
555 | 42832 | ((int) pulse_hi[i] << 11), 4, 1); | |
556 | 10708 | break; | |
557 | } | ||
558 | |||
559 | 25072 | memset(fixed_vector, 0, sizeof(float) * AMRWB_SFR_SIZE); | |
560 | |||
561 |
2/2✓ Branch 0 taken 100288 times.
✓ Branch 1 taken 25072 times.
|
125360 | for (i = 0; i < 4; i++) |
562 |
2/2✓ Branch 0 taken 400632 times.
✓ Branch 1 taken 100288 times.
|
500920 | for (j = 0; j < pulses_nb_per_mode_tr[mode][i]; j++) { |
563 | 400632 | int pos = (FFABS(sig_pos[i][j]) - 1) * spacing + i; | |
564 | |||
565 |
2/2✓ Branch 0 taken 201133 times.
✓ Branch 1 taken 199499 times.
|
400632 | fixed_vector[pos] += sig_pos[i][j] < 0 ? -1.0 : 1.0; |
566 | } | ||
567 | 25072 | } | |
568 | |||
569 | /** | ||
570 | * Decode pitch gain and fixed gain correction factor. | ||
571 | * | ||
572 | * @param[in] vq_gain Vector-quantized index for gains | ||
573 | * @param[in] mode Mode of the current frame | ||
574 | * @param[out] fixed_gain_factor Decoded fixed gain correction factor | ||
575 | * @param[out] pitch_gain Decoded pitch gain | ||
576 | */ | ||
577 | 25072 | static void decode_gains(const uint8_t vq_gain, const enum Mode mode, | |
578 | float *fixed_gain_factor, float *pitch_gain) | ||
579 | { | ||
580 |
2/2✓ Branch 0 taken 4104 times.
✓ Branch 1 taken 20968 times.
|
25072 | const int16_t *gains = (mode <= MODE_8k85 ? qua_gain_6b[vq_gain] : |
581 | 20968 | qua_gain_7b[vq_gain]); | |
582 | |||
583 | 25072 | *pitch_gain = gains[0] * (1.0f / (1 << 14)); | |
584 | 25072 | *fixed_gain_factor = gains[1] * (1.0f / (1 << 11)); | |
585 | 25072 | } | |
586 | |||
587 | /** | ||
588 | * Apply pitch sharpening filters to the fixed codebook vector. | ||
589 | * | ||
590 | * @param[in] ctx The context | ||
591 | * @param[in,out] fixed_vector Fixed codebook excitation | ||
592 | */ | ||
593 | // XXX: Spec states this procedure should be applied when the pitch | ||
594 | // lag is less than 64, but this checking seems absent in reference and AMR-NB | ||
595 | 25072 | static void pitch_sharpening(AMRWBContext *ctx, float *fixed_vector) | |
596 | { | ||
597 | int i; | ||
598 | |||
599 | /* Tilt part */ | ||
600 |
2/2✓ Branch 0 taken 1579536 times.
✓ Branch 1 taken 25072 times.
|
1604608 | for (i = AMRWB_SFR_SIZE - 1; i != 0; i--) |
601 | 1579536 | fixed_vector[i] -= fixed_vector[i - 1] * ctx->tilt_coef; | |
602 | |||
603 | /* Periodicity enhancement part */ | ||
604 |
2/2✓ Branch 0 taken 161953 times.
✓ Branch 1 taken 25072 times.
|
187025 | for (i = ctx->pitch_lag_int; i < AMRWB_SFR_SIZE; i++) |
605 | 161953 | fixed_vector[i] += fixed_vector[i - ctx->pitch_lag_int] * 0.85; | |
606 | 25072 | } | |
607 | |||
608 | /** | ||
609 | * Calculate the voicing factor (-1.0 = unvoiced to 1.0 = voiced). | ||
610 | * | ||
611 | * @param[in] p_vector, f_vector Pitch and fixed excitation vectors | ||
612 | * @param[in] p_gain, f_gain Pitch and fixed gains | ||
613 | * @param[in] ctx The context | ||
614 | */ | ||
615 | // XXX: There is something wrong with the precision here! The magnitudes | ||
616 | // of the energies are not correct. Please check the reference code carefully | ||
617 | 25072 | static float voice_factor(float *p_vector, float p_gain, | |
618 | float *f_vector, float f_gain, | ||
619 | CELPMContext *ctx) | ||
620 | { | ||
621 | 25072 | double p_ener = (double) ctx->dot_productf(p_vector, p_vector, | |
622 | 25072 | AMRWB_SFR_SIZE) * | |
623 | 25072 | p_gain * p_gain; | |
624 | 25072 | double f_ener = (double) ctx->dot_productf(f_vector, f_vector, | |
625 | 25072 | AMRWB_SFR_SIZE) * | |
626 | 25072 | f_gain * f_gain; | |
627 | |||
628 | 25072 | return (p_ener - f_ener) / (p_ener + f_ener + 0.01); | |
629 | } | ||
630 | |||
631 | /** | ||
632 | * Reduce fixed vector sparseness by smoothing with one of three IR filters, | ||
633 | * also known as "adaptive phase dispersion". | ||
634 | * | ||
635 | * @param[in] ctx The context | ||
636 | * @param[in,out] fixed_vector Unfiltered fixed vector | ||
637 | * @param[out] buf Space for modified vector if necessary | ||
638 | * | ||
639 | * @return The potentially overwritten filtered fixed vector address | ||
640 | */ | ||
641 | 25072 | static float *anti_sparseness(AMRWBContext *ctx, | |
642 | float *fixed_vector, float *buf) | ||
643 | { | ||
644 | int ir_filter_nr; | ||
645 | |||
646 |
2/2✓ Branch 0 taken 20968 times.
✓ Branch 1 taken 4104 times.
|
25072 | if (ctx->fr_cur_mode > MODE_8k85) // no filtering in higher modes |
647 | 20968 | return fixed_vector; | |
648 | |||
649 |
2/2✓ Branch 0 taken 2261 times.
✓ Branch 1 taken 1843 times.
|
4104 | if (ctx->pitch_gain[0] < 0.6) { |
650 | 2261 | ir_filter_nr = 0; // strong filtering | |
651 |
2/2✓ Branch 0 taken 712 times.
✓ Branch 1 taken 1131 times.
|
1843 | } else if (ctx->pitch_gain[0] < 0.9) { |
652 | 712 | ir_filter_nr = 1; // medium filtering | |
653 | } else | ||
654 | 1131 | ir_filter_nr = 2; // no filtering | |
655 | |||
656 | /* detect 'onset' */ | ||
657 |
2/2✓ Branch 0 taken 61 times.
✓ Branch 1 taken 4043 times.
|
4104 | if (ctx->fixed_gain[0] > 3.0 * ctx->fixed_gain[1]) { |
658 |
2/2✓ Branch 0 taken 39 times.
✓ Branch 1 taken 22 times.
|
61 | if (ir_filter_nr < 2) |
659 | 39 | ir_filter_nr++; | |
660 | } else { | ||
661 | 4043 | int i, count = 0; | |
662 | |||
663 |
2/2✓ Branch 0 taken 24258 times.
✓ Branch 1 taken 4043 times.
|
28301 | for (i = 0; i < 6; i++) |
664 |
2/2✓ Branch 0 taken 13373 times.
✓ Branch 1 taken 10885 times.
|
24258 | if (ctx->pitch_gain[i] < 0.6) |
665 | 13373 | count++; | |
666 | |||
667 |
2/2✓ Branch 0 taken 2724 times.
✓ Branch 1 taken 1319 times.
|
4043 | if (count > 2) |
668 | 2724 | ir_filter_nr = 0; | |
669 | |||
670 |
2/2✓ Branch 0 taken 83 times.
✓ Branch 1 taken 3960 times.
|
4043 | if (ir_filter_nr > ctx->prev_ir_filter_nr + 1) |
671 | 83 | ir_filter_nr--; | |
672 | } | ||
673 | |||
674 | /* update ir filter strength history */ | ||
675 | 4104 | ctx->prev_ir_filter_nr = ir_filter_nr; | |
676 | |||
677 | 4104 | ir_filter_nr += (ctx->fr_cur_mode == MODE_8k85); | |
678 | |||
679 |
2/2✓ Branch 0 taken 3197 times.
✓ Branch 1 taken 907 times.
|
4104 | if (ir_filter_nr < 2) { |
680 | int i; | ||
681 | 3197 | const float *coef = ir_filters_lookup[ir_filter_nr]; | |
682 | |||
683 | /* Circular convolution code in the reference | ||
684 | * decoder was modified to avoid using one | ||
685 | * extra array. The filtered vector is given by: | ||
686 | * | ||
687 | * c2(n) = sum(i,0,len-1){ c(i) * coef( (n - i + len) % len ) } | ||
688 | */ | ||
689 | |||
690 | 3197 | memset(buf, 0, sizeof(float) * AMRWB_SFR_SIZE); | |
691 |
2/2✓ Branch 0 taken 204608 times.
✓ Branch 1 taken 3197 times.
|
207805 | for (i = 0; i < AMRWB_SFR_SIZE; i++) |
692 |
2/2✓ Branch 0 taken 21471 times.
✓ Branch 1 taken 183137 times.
|
204608 | if (fixed_vector[i]) |
693 | 21471 | ff_celp_circ_addf(buf, buf, coef, i, fixed_vector[i], | |
694 | AMRWB_SFR_SIZE); | ||
695 | 3197 | fixed_vector = buf; | |
696 | } | ||
697 | |||
698 | 4104 | return fixed_vector; | |
699 | } | ||
700 | |||
701 | /** | ||
702 | * Calculate a stability factor {teta} based on distance between | ||
703 | * current and past isf. A value of 1 shows maximum signal stability. | ||
704 | */ | ||
705 | 6268 | static float stability_factor(const float *isf, const float *isf_past) | |
706 | { | ||
707 | int i; | ||
708 | 6268 | float acc = 0.0; | |
709 | |||
710 |
2/2✓ Branch 0 taken 94020 times.
✓ Branch 1 taken 6268 times.
|
100288 | for (i = 0; i < LP_ORDER - 1; i++) |
711 | 94020 | acc += (isf[i] - isf_past[i]) * (isf[i] - isf_past[i]); | |
712 | |||
713 | // XXX: This part is not so clear from the reference code | ||
714 | // the result is more accurate changing the "/ 256" to "* 512" | ||
715 |
2/2✓ Branch 0 taken 511 times.
✓ Branch 1 taken 5757 times.
|
6268 | return FFMAX(0.0, 1.25 - acc * 0.8 * 512); |
716 | } | ||
717 | |||
718 | /** | ||
719 | * Apply a non-linear fixed gain smoothing in order to reduce | ||
720 | * fluctuation in the energy of excitation. | ||
721 | * | ||
722 | * @param[in] fixed_gain Unsmoothed fixed gain | ||
723 | * @param[in,out] prev_tr_gain Previous threshold gain (updated) | ||
724 | * @param[in] voice_fac Frame voicing factor | ||
725 | * @param[in] stab_fac Frame stability factor | ||
726 | * | ||
727 | * @return The smoothed gain | ||
728 | */ | ||
729 | 25072 | static float noise_enhancer(float fixed_gain, float *prev_tr_gain, | |
730 | float voice_fac, float stab_fac) | ||
731 | { | ||
732 | 25072 | float sm_fac = 0.5 * (1 - voice_fac) * stab_fac; | |
733 | float g0; | ||
734 | |||
735 | // XXX: the following fixed-point constants used to in(de)crement | ||
736 | // gain by 1.5dB were taken from the reference code, maybe it could | ||
737 | // be simpler | ||
738 |
2/2✓ Branch 0 taken 13115 times.
✓ Branch 1 taken 11957 times.
|
25072 | if (fixed_gain < *prev_tr_gain) { |
739 |
2/2✓ Branch 0 taken 7438 times.
✓ Branch 1 taken 5677 times.
|
13115 | g0 = FFMIN(*prev_tr_gain, fixed_gain + fixed_gain * |
740 | (6226 * (1.0f / (1 << 15)))); // +1.5 dB | ||
741 | } else | ||
742 |
2/2✓ Branch 0 taken 5835 times.
✓ Branch 1 taken 6122 times.
|
11957 | g0 = FFMAX(*prev_tr_gain, fixed_gain * |
743 | (27536 * (1.0f / (1 << 15)))); // -1.5 dB | ||
744 | |||
745 | 25072 | *prev_tr_gain = g0; // update next frame threshold | |
746 | |||
747 | 25072 | return sm_fac * g0 + (1 - sm_fac) * fixed_gain; | |
748 | } | ||
749 | |||
750 | /** | ||
751 | * Filter the fixed_vector to emphasize the higher frequencies. | ||
752 | * | ||
753 | * @param[in,out] fixed_vector Fixed codebook vector | ||
754 | * @param[in] voice_fac Frame voicing factor | ||
755 | */ | ||
756 | 25072 | static void pitch_enhancer(float *fixed_vector, float voice_fac) | |
757 | { | ||
758 | int i; | ||
759 | 25072 | float cpe = 0.125 * (1 + voice_fac); | |
760 | 25072 | float last = fixed_vector[0]; // holds c(i - 1) | |
761 | |||
762 | 25072 | fixed_vector[0] -= cpe * fixed_vector[1]; | |
763 | |||
764 |
2/2✓ Branch 0 taken 1554464 times.
✓ Branch 1 taken 25072 times.
|
1579536 | for (i = 1; i < AMRWB_SFR_SIZE - 1; i++) { |
765 | 1554464 | float cur = fixed_vector[i]; | |
766 | |||
767 | 1554464 | fixed_vector[i] -= cpe * (last + fixed_vector[i + 1]); | |
768 | 1554464 | last = cur; | |
769 | } | ||
770 | |||
771 | 25072 | fixed_vector[AMRWB_SFR_SIZE - 1] -= cpe * last; | |
772 | 25072 | } | |
773 | |||
774 | /** | ||
775 | * Conduct 16th order linear predictive coding synthesis from excitation. | ||
776 | * | ||
777 | * @param[in] ctx Pointer to the AMRWBContext | ||
778 | * @param[in] lpc Pointer to the LPC coefficients | ||
779 | * @param[out] excitation Buffer for synthesis final excitation | ||
780 | * @param[in] fixed_gain Fixed codebook gain for synthesis | ||
781 | * @param[in] fixed_vector Algebraic codebook vector | ||
782 | * @param[in,out] samples Pointer to the output samples and memory | ||
783 | */ | ||
784 | 25072 | static void synthesis(AMRWBContext *ctx, float *lpc, float *excitation, | |
785 | float fixed_gain, const float *fixed_vector, | ||
786 | float *samples) | ||
787 | { | ||
788 | 25072 | ctx->acelpv_ctx.weighted_vector_sumf(excitation, ctx->pitch_vector, fixed_vector, | |
789 | ctx->pitch_gain[0], fixed_gain, AMRWB_SFR_SIZE); | ||
790 | |||
791 | /* emphasize pitch vector contribution in low bitrate modes */ | ||
792 |
4/4✓ Branch 0 taken 14894 times.
✓ Branch 1 taken 10178 times.
✓ Branch 2 taken 1897 times.
✓ Branch 3 taken 12997 times.
|
25072 | if (ctx->pitch_gain[0] > 0.5 && ctx->fr_cur_mode <= MODE_8k85) { |
793 | int i; | ||
794 | 1897 | float energy = ctx->celpm_ctx.dot_productf(excitation, excitation, | |
795 | AMRWB_SFR_SIZE); | ||
796 | |||
797 | // XXX: Weird part in both ref code and spec. A unknown parameter | ||
798 | // {beta} seems to be identical to the current pitch gain | ||
799 | 1897 | float pitch_factor = 0.25 * ctx->pitch_gain[0] * ctx->pitch_gain[0]; | |
800 | |||
801 |
2/2✓ Branch 0 taken 121408 times.
✓ Branch 1 taken 1897 times.
|
123305 | for (i = 0; i < AMRWB_SFR_SIZE; i++) |
802 | 121408 | excitation[i] += pitch_factor * ctx->pitch_vector[i]; | |
803 | |||
804 | 1897 | ff_scale_vector_to_given_sum_of_squares(excitation, excitation, | |
805 | energy, AMRWB_SFR_SIZE); | ||
806 | } | ||
807 | |||
808 | 25072 | ctx->celpf_ctx.celp_lp_synthesis_filterf(samples, lpc, excitation, | |
809 | AMRWB_SFR_SIZE, LP_ORDER); | ||
810 | 25072 | } | |
811 | |||
812 | /** | ||
813 | * Apply to synthesis a de-emphasis filter of the form: | ||
814 | * H(z) = 1 / (1 - m * z^-1) | ||
815 | * | ||
816 | * @param[out] out Output buffer | ||
817 | * @param[in] in Input samples array with in[-1] | ||
818 | * @param[in] m Filter coefficient | ||
819 | * @param[in,out] mem State from last filtering | ||
820 | */ | ||
821 | 25072 | static void de_emphasis(float *out, float *in, float m, float mem[1]) | |
822 | { | ||
823 | int i; | ||
824 | |||
825 | 25072 | out[0] = in[0] + m * mem[0]; | |
826 | |||
827 |
2/2✓ Branch 0 taken 1579536 times.
✓ Branch 1 taken 25072 times.
|
1604608 | for (i = 1; i < AMRWB_SFR_SIZE; i++) |
828 | 1579536 | out[i] = in[i] + out[i - 1] * m; | |
829 | |||
830 | 25072 | mem[0] = out[AMRWB_SFR_SIZE - 1]; | |
831 | 25072 | } | |
832 | |||
833 | /** | ||
834 | * Upsample a signal by 5/4 ratio (from 12.8kHz to 16kHz) using | ||
835 | * a FIR interpolation filter. Uses past data from before *in address. | ||
836 | * | ||
837 | * @param[out] out Buffer for interpolated signal | ||
838 | * @param[in] in Current signal data (length 0.8*o_size) | ||
839 | * @param[in] o_size Output signal length | ||
840 | * @param[in] ctx The context | ||
841 | */ | ||
842 | 25072 | static void upsample_5_4(float *out, const float *in, int o_size, CELPMContext *ctx) | |
843 | { | ||
844 | 25072 | const float *in0 = in - UPS_FIR_SIZE + 1; | |
845 | int i, j, k; | ||
846 | 25072 | int int_part = 0, frac_part; | |
847 | |||
848 | 25072 | i = 0; | |
849 |
2/2✓ Branch 0 taken 401152 times.
✓ Branch 1 taken 25072 times.
|
426224 | for (j = 0; j < o_size / 5; j++) { |
850 | 401152 | out[i] = in[int_part]; | |
851 | 401152 | frac_part = 4; | |
852 | 401152 | i++; | |
853 | |||
854 |
2/2✓ Branch 0 taken 1604608 times.
✓ Branch 1 taken 401152 times.
|
2005760 | for (k = 1; k < 5; k++) { |
855 | 3209216 | out[i] = ctx->dot_productf(in0 + int_part, | |
856 | 1604608 | upsample_fir[4 - frac_part], | |
857 | UPS_MEM_SIZE); | ||
858 | 1604608 | int_part++; | |
859 | 1604608 | frac_part--; | |
860 | 1604608 | i++; | |
861 | } | ||
862 | } | ||
863 | 25072 | } | |
864 | |||
865 | /** | ||
866 | * Calculate the high-band gain based on encoded index (23k85 mode) or | ||
867 | * on the low-band speech signal and the Voice Activity Detection flag. | ||
868 | * | ||
869 | * @param[in] ctx The context | ||
870 | * @param[in] synth LB speech synthesis at 12.8k | ||
871 | * @param[in] hb_idx Gain index for mode 23k85 only | ||
872 | * @param[in] vad VAD flag for the frame | ||
873 | */ | ||
874 | 25072 | static float find_hb_gain(AMRWBContext *ctx, const float *synth, | |
875 | uint16_t hb_idx, uint8_t vad) | ||
876 | { | ||
877 | 25072 | int wsp = (vad > 0); | |
878 | float tilt; | ||
879 | float tmp; | ||
880 | |||
881 |
2/2✓ Branch 0 taken 8656 times.
✓ Branch 1 taken 16416 times.
|
25072 | if (ctx->fr_cur_mode == MODE_23k85) |
882 | 8656 | return qua_hb_gain[hb_idx] * (1.0f / (1 << 14)); | |
883 | |||
884 | 16416 | tmp = ctx->celpm_ctx.dot_productf(synth, synth + 1, AMRWB_SFR_SIZE - 1); | |
885 | |||
886 |
2/2✓ Branch 0 taken 15653 times.
✓ Branch 1 taken 763 times.
|
16416 | if (tmp > 0) { |
887 | 15653 | tilt = tmp / ctx->celpm_ctx.dot_productf(synth, synth, AMRWB_SFR_SIZE); | |
888 | } else | ||
889 | 763 | tilt = 0; | |
890 | |||
891 | /* return gain bounded by [0.1, 1.0] */ | ||
892 | 16416 | return av_clipf((1.0 - tilt) * (1.25 - 0.25 * wsp), 0.1, 1.0); | |
893 | } | ||
894 | |||
895 | /** | ||
896 | * Generate the high-band excitation with the same energy from the lower | ||
897 | * one and scaled by the given gain. | ||
898 | * | ||
899 | * @param[in] ctx The context | ||
900 | * @param[out] hb_exc Buffer for the excitation | ||
901 | * @param[in] synth_exc Low-band excitation used for synthesis | ||
902 | * @param[in] hb_gain Wanted excitation gain | ||
903 | */ | ||
904 | 25072 | static void scaled_hb_excitation(AMRWBContext *ctx, float *hb_exc, | |
905 | const float *synth_exc, float hb_gain) | ||
906 | { | ||
907 | int i; | ||
908 | 25072 | float energy = ctx->celpm_ctx.dot_productf(synth_exc, synth_exc, | |
909 | AMRWB_SFR_SIZE); | ||
910 | |||
911 | /* Generate a white-noise excitation */ | ||
912 |
2/2✓ Branch 0 taken 2005760 times.
✓ Branch 1 taken 25072 times.
|
2030832 | for (i = 0; i < AMRWB_SFR_SIZE_16k; i++) |
913 | 2005760 | hb_exc[i] = 32768.0 - (uint16_t) av_lfg_get(&ctx->prng); | |
914 | |||
915 | 25072 | ff_scale_vector_to_given_sum_of_squares(hb_exc, hb_exc, | |
916 | 25072 | energy * hb_gain * hb_gain, | |
917 | AMRWB_SFR_SIZE_16k); | ||
918 | 25072 | } | |
919 | |||
920 | /** | ||
921 | * Calculate the auto-correlation for the ISF difference vector. | ||
922 | */ | ||
923 | 6156 | static float auto_correlation(float *diff_isf, float mean, int lag) | |
924 | { | ||
925 | int i; | ||
926 | 6156 | float sum = 0.0; | |
927 | |||
928 |
2/2✓ Branch 0 taken 43092 times.
✓ Branch 1 taken 6156 times.
|
49248 | for (i = 7; i < LP_ORDER - 2; i++) { |
929 | 43092 | float prod = (diff_isf[i] - mean) * (diff_isf[i - lag] - mean); | |
930 | 43092 | sum += prod * prod; | |
931 | } | ||
932 | 6156 | return sum; | |
933 | } | ||
934 | |||
935 | /** | ||
936 | * Extrapolate a ISF vector to the 16kHz range (20th order LP) | ||
937 | * used at mode 6k60 LP filter for the high frequency band. | ||
938 | * | ||
939 | * @param[out] isf Buffer for extrapolated isf; contains LP_ORDER | ||
940 | * values on input | ||
941 | */ | ||
942 | 2052 | static void extrapolate_isf(float isf[LP_ORDER_16k]) | |
943 | { | ||
944 | float diff_isf[LP_ORDER - 2], diff_mean; | ||
945 | float corr_lag[3]; | ||
946 | float est, scale; | ||
947 | int i, j, i_max_corr; | ||
948 | |||
949 | 2052 | isf[LP_ORDER_16k - 1] = isf[LP_ORDER - 1]; | |
950 | |||
951 | /* Calculate the difference vector */ | ||
952 |
2/2✓ Branch 0 taken 28728 times.
✓ Branch 1 taken 2052 times.
|
30780 | for (i = 0; i < LP_ORDER - 2; i++) |
953 | 28728 | diff_isf[i] = isf[i + 1] - isf[i]; | |
954 | |||
955 | 2052 | diff_mean = 0.0; | |
956 |
2/2✓ Branch 0 taken 24624 times.
✓ Branch 1 taken 2052 times.
|
26676 | for (i = 2; i < LP_ORDER - 2; i++) |
957 | 24624 | diff_mean += diff_isf[i] * (1.0f / (LP_ORDER - 4)); | |
958 | |||
959 | /* Find which is the maximum autocorrelation */ | ||
960 | 2052 | i_max_corr = 0; | |
961 |
2/2✓ Branch 0 taken 6156 times.
✓ Branch 1 taken 2052 times.
|
8208 | for (i = 0; i < 3; i++) { |
962 | 6156 | corr_lag[i] = auto_correlation(diff_isf, diff_mean, i + 2); | |
963 | |||
964 |
2/2✓ Branch 0 taken 2154 times.
✓ Branch 1 taken 4002 times.
|
6156 | if (corr_lag[i] > corr_lag[i_max_corr]) |
965 | 2154 | i_max_corr = i; | |
966 | } | ||
967 | 2052 | i_max_corr++; | |
968 | |||
969 |
2/2✓ Branch 0 taken 8208 times.
✓ Branch 1 taken 2052 times.
|
10260 | for (i = LP_ORDER - 1; i < LP_ORDER_16k - 1; i++) |
970 | 8208 | isf[i] = isf[i - 1] + isf[i - 1 - i_max_corr] | |
971 | 8208 | - isf[i - 2 - i_max_corr]; | |
972 | |||
973 | /* Calculate an estimate for ISF(18) and scale ISF based on the error */ | ||
974 | 2052 | est = 7965 + (isf[2] - isf[3] - isf[4]) / 6.0; | |
975 |
1/2✓ Branch 0 taken 2052 times.
✗ Branch 1 not taken.
|
2052 | scale = 0.5 * (FFMIN(est, 7600) - isf[LP_ORDER - 2]) / |
976 | 2052 | (isf[LP_ORDER_16k - 2] - isf[LP_ORDER - 2]); | |
977 | |||
978 |
2/2✓ Branch 0 taken 8208 times.
✓ Branch 1 taken 2052 times.
|
10260 | for (i = LP_ORDER - 1, j = 0; i < LP_ORDER_16k - 1; i++, j++) |
979 | 8208 | diff_isf[j] = scale * (isf[i] - isf[i - 1]); | |
980 | |||
981 | /* Stability insurance */ | ||
982 |
2/2✓ Branch 0 taken 6156 times.
✓ Branch 1 taken 2052 times.
|
8208 | for (i = 1; i < LP_ORDER_16k - LP_ORDER; i++) |
983 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6156 times.
|
6156 | if (diff_isf[i] + diff_isf[i - 1] < 5.0) { |
984 | ✗ | if (diff_isf[i] > diff_isf[i - 1]) { | |
985 | ✗ | diff_isf[i - 1] = 5.0 - diff_isf[i]; | |
986 | } else | ||
987 | ✗ | diff_isf[i] = 5.0 - diff_isf[i - 1]; | |
988 | } | ||
989 | |||
990 |
2/2✓ Branch 0 taken 8208 times.
✓ Branch 1 taken 2052 times.
|
10260 | for (i = LP_ORDER - 1, j = 0; i < LP_ORDER_16k - 1; i++, j++) |
991 | 8208 | isf[i] = isf[i - 1] + diff_isf[j] * (1.0f / (1 << 15)); | |
992 | |||
993 | /* Scale the ISF vector for 16000 Hz */ | ||
994 |
2/2✓ Branch 0 taken 38988 times.
✓ Branch 1 taken 2052 times.
|
41040 | for (i = 0; i < LP_ORDER_16k - 1; i++) |
995 | 38988 | isf[i] *= 0.8; | |
996 | 2052 | } | |
997 | |||
998 | /** | ||
999 | * Spectral expand the LP coefficients using the equation: | ||
1000 | * y[i] = x[i] * (gamma ** i) | ||
1001 | * | ||
1002 | * @param[out] out Output buffer (may use input array) | ||
1003 | * @param[in] lpc LP coefficients array | ||
1004 | * @param[in] gamma Weighting factor | ||
1005 | * @param[in] size LP array size | ||
1006 | */ | ||
1007 | 25072 | static void lpc_weighting(float *out, const float *lpc, float gamma, int size) | |
1008 | { | ||
1009 | int i; | ||
1010 | 25072 | float fac = gamma; | |
1011 | |||
1012 |
2/2✓ Branch 0 taken 409360 times.
✓ Branch 1 taken 25072 times.
|
434432 | for (i = 0; i < size; i++) { |
1013 | 409360 | out[i] = lpc[i] * fac; | |
1014 | 409360 | fac *= gamma; | |
1015 | } | ||
1016 | 25072 | } | |
1017 | |||
1018 | /** | ||
1019 | * Conduct 20th order linear predictive coding synthesis for the high | ||
1020 | * frequency band excitation at 16kHz. | ||
1021 | * | ||
1022 | * @param[in] ctx The context | ||
1023 | * @param[in] subframe Current subframe index (0 to 3) | ||
1024 | * @param[in,out] samples Pointer to the output speech samples | ||
1025 | * @param[in] exc Generated white-noise scaled excitation | ||
1026 | * @param[in] isf Current frame isf vector | ||
1027 | * @param[in] isf_past Past frame final isf vector | ||
1028 | */ | ||
1029 | 25072 | static void hb_synthesis(AMRWBContext *ctx, int subframe, float *samples, | |
1030 | const float *exc, const float *isf, const float *isf_past) | ||
1031 | { | ||
1032 | float hb_lpc[LP_ORDER_16k]; | ||
1033 | 25072 | enum Mode mode = ctx->fr_cur_mode; | |
1034 | |||
1035 |
2/2✓ Branch 0 taken 2052 times.
✓ Branch 1 taken 23020 times.
|
25072 | if (mode == MODE_6k60) { |
1036 | float e_isf[LP_ORDER_16k]; // ISF vector for extrapolation | ||
1037 | double e_isp[LP_ORDER_16k]; | ||
1038 | |||
1039 | 2052 | ctx->acelpv_ctx.weighted_vector_sumf(e_isf, isf_past, isf, isfp_inter[subframe], | |
1040 | 2052 | 1.0 - isfp_inter[subframe], LP_ORDER); | |
1041 | |||
1042 | 2052 | extrapolate_isf(e_isf); | |
1043 | |||
1044 | 2052 | e_isf[LP_ORDER_16k - 1] *= 2.0; | |
1045 | 2052 | ff_acelp_lsf2lspd(e_isp, e_isf, LP_ORDER_16k); | |
1046 | 2052 | ff_amrwb_lsp2lpc(e_isp, hb_lpc, LP_ORDER_16k); | |
1047 | |||
1048 | 2052 | lpc_weighting(hb_lpc, hb_lpc, 0.9, LP_ORDER_16k); | |
1049 | } else { | ||
1050 | 23020 | lpc_weighting(hb_lpc, ctx->lp_coef[subframe], 0.6, LP_ORDER); | |
1051 | } | ||
1052 | |||
1053 |
2/2✓ Branch 0 taken 2052 times.
✓ Branch 1 taken 23020 times.
|
25072 | ctx->celpf_ctx.celp_lp_synthesis_filterf(samples, hb_lpc, exc, AMRWB_SFR_SIZE_16k, |
1054 | (mode == MODE_6k60) ? LP_ORDER_16k : LP_ORDER); | ||
1055 | 25072 | } | |
1056 | |||
1057 | /** | ||
1058 | * Apply a 15th order filter to high-band samples. | ||
1059 | * The filter characteristic depends on the given coefficients. | ||
1060 | * | ||
1061 | * @param[out] out Buffer for filtered output | ||
1062 | * @param[in] fir_coef Filter coefficients | ||
1063 | * @param[in,out] mem State from last filtering (updated) | ||
1064 | * @param[in] in Input speech data (high-band) | ||
1065 | * | ||
1066 | * @remark It is safe to pass the same array in in and out parameters | ||
1067 | */ | ||
1068 | |||
1069 | #ifndef hb_fir_filter | ||
1070 | 33728 | static void hb_fir_filter(float *out, const float fir_coef[HB_FIR_SIZE + 1], | |
1071 | float mem[HB_FIR_SIZE], const float *in) | ||
1072 | { | ||
1073 | int i, j; | ||
1074 | float data[AMRWB_SFR_SIZE_16k + HB_FIR_SIZE]; // past and current samples | ||
1075 | |||
1076 | 33728 | memcpy(data, mem, HB_FIR_SIZE * sizeof(float)); | |
1077 | 33728 | memcpy(data + HB_FIR_SIZE, in, AMRWB_SFR_SIZE_16k * sizeof(float)); | |
1078 | |||
1079 |
2/2✓ Branch 0 taken 2698240 times.
✓ Branch 1 taken 33728 times.
|
2731968 | for (i = 0; i < AMRWB_SFR_SIZE_16k; i++) { |
1080 | 2698240 | out[i] = 0.0; | |
1081 |
2/2✓ Branch 0 taken 83645440 times.
✓ Branch 1 taken 2698240 times.
|
86343680 | for (j = 0; j <= HB_FIR_SIZE; j++) |
1082 | 83645440 | out[i] += data[i + j] * fir_coef[j]; | |
1083 | } | ||
1084 | |||
1085 | 33728 | memcpy(mem, data + AMRWB_SFR_SIZE_16k, HB_FIR_SIZE * sizeof(float)); | |
1086 | 33728 | } | |
1087 | #endif /* hb_fir_filter */ | ||
1088 | |||
1089 | /** | ||
1090 | * Update context state before the next subframe. | ||
1091 | */ | ||
1092 | 25072 | static void update_sub_state(AMRWBContext *ctx) | |
1093 | { | ||
1094 | 25072 | memmove(&ctx->excitation_buf[0], &ctx->excitation_buf[AMRWB_SFR_SIZE], | |
1095 | (AMRWB_P_DELAY_MAX + LP_ORDER + 1) * sizeof(float)); | ||
1096 | |||
1097 | 25072 | memmove(&ctx->pitch_gain[1], &ctx->pitch_gain[0], 5 * sizeof(float)); | |
1098 | 25072 | memmove(&ctx->fixed_gain[1], &ctx->fixed_gain[0], 1 * sizeof(float)); | |
1099 | |||
1100 | 25072 | memmove(&ctx->samples_az[0], &ctx->samples_az[AMRWB_SFR_SIZE], | |
1101 | LP_ORDER * sizeof(float)); | ||
1102 | 25072 | memmove(&ctx->samples_up[0], &ctx->samples_up[AMRWB_SFR_SIZE], | |
1103 | UPS_MEM_SIZE * sizeof(float)); | ||
1104 | 25072 | memmove(&ctx->samples_hb[0], &ctx->samples_hb[AMRWB_SFR_SIZE_16k], | |
1105 | LP_ORDER_16k * sizeof(float)); | ||
1106 | 25072 | } | |
1107 | |||
1108 | 6268 | static int amrwb_decode_frame(AVCodecContext *avctx, AVFrame *frame, | |
1109 | int *got_frame_ptr, AVPacket *avpkt) | ||
1110 | { | ||
1111 | 6268 | AMRWBChannelsContext *s = avctx->priv_data; | |
1112 | 6268 | const uint8_t *buf = avpkt->data; | |
1113 | 6268 | int buf_size = avpkt->size; | |
1114 | int sub, i, ret; | ||
1115 | |||
1116 | /* get output buffer */ | ||
1117 | 6268 | frame->nb_samples = 4 * AMRWB_SFR_SIZE_16k; | |
1118 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 6268 times.
|
6268 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
1119 | ✗ | return ret; | |
1120 | |||
1121 |
2/2✓ Branch 0 taken 6268 times.
✓ Branch 1 taken 6268 times.
|
12536 | for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) { |
1122 | 6268 | AMRWBContext *ctx = &s->ch[ch]; | |
1123 | 6268 | AMRWBFrame *cf = &ctx->frame; | |
1124 | int expected_fr_size, header_size; | ||
1125 | float spare_vector[AMRWB_SFR_SIZE]; // extra stack space to hold result from anti-sparseness processing | ||
1126 | float fixed_gain_factor; // fixed gain correction factor (gamma) | ||
1127 | float *synth_fixed_vector; // pointer to the fixed vector that synthesis should use | ||
1128 | float synth_fixed_gain; // the fixed gain that synthesis should use | ||
1129 | float voice_fac, stab_fac; // parameters used for gain smoothing | ||
1130 | float synth_exc[AMRWB_SFR_SIZE]; // post-processed excitation for synthesis | ||
1131 | float hb_exc[AMRWB_SFR_SIZE_16k]; // excitation for the high frequency band | ||
1132 | float hb_samples[AMRWB_SFR_SIZE_16k]; // filtered high-band samples from synthesis | ||
1133 | float hb_gain; | ||
1134 | 6268 | float *buf_out = (float *)frame->extended_data[ch]; | |
1135 | |||
1136 | 6268 | header_size = decode_mime_header(ctx, buf); | |
1137 | 6268 | expected_fr_size = ((cf_sizes_wb[ctx->fr_cur_mode] + 7) >> 3) + 1; | |
1138 | |||
1139 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6268 times.
|
6268 | if (!ctx->fr_quality) |
1140 | ✗ | av_log(avctx, AV_LOG_ERROR, "Encountered a bad or corrupted frame\n"); | |
1141 | |||
1142 |
2/4✓ Branch 0 taken 6268 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6268 times.
|
6268 | if (ctx->fr_cur_mode == NO_DATA || !ctx->fr_quality) { |
1143 | /* The specification suggests a "random signal" and | ||
1144 | "a muting technique" to "gradually decrease the output level". */ | ||
1145 | ✗ | av_samples_set_silence(&frame->extended_data[ch], 0, frame->nb_samples, 1, AV_SAMPLE_FMT_FLT); | |
1146 | ✗ | buf += expected_fr_size; | |
1147 | ✗ | buf_size -= expected_fr_size; | |
1148 | ✗ | continue; | |
1149 | } | ||
1150 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6268 times.
|
6268 | if (ctx->fr_cur_mode > MODE_SID) { |
1151 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
1152 | ✗ | "Invalid mode %d\n", ctx->fr_cur_mode); | |
1153 | ✗ | return AVERROR_INVALIDDATA; | |
1154 | } | ||
1155 | |||
1156 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6268 times.
|
6268 | if (buf_size < expected_fr_size) { |
1157 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
1158 | "Frame too small (%d bytes). Truncated file?\n", buf_size); | ||
1159 | ✗ | *got_frame_ptr = 0; | |
1160 | ✗ | return AVERROR_INVALIDDATA; | |
1161 | } | ||
1162 | |||
1163 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6268 times.
|
6268 | if (ctx->fr_cur_mode == MODE_SID) { /* Comfort noise frame */ |
1164 | ✗ | avpriv_request_sample(avctx, "SID mode"); | |
1165 | ✗ | return AVERROR_PATCHWELCOME; | |
1166 | } | ||
1167 | |||
1168 | 6268 | ff_amr_bit_reorder((uint16_t *) &ctx->frame, sizeof(AMRWBFrame), | |
1169 | 6268 | buf + header_size, amr_bit_orderings_by_mode[ctx->fr_cur_mode]); | |
1170 | |||
1171 | /* Decode the quantized ISF vector */ | ||
1172 |
2/2✓ Branch 0 taken 513 times.
✓ Branch 1 taken 5755 times.
|
6268 | if (ctx->fr_cur_mode == MODE_6k60) { |
1173 | 513 | decode_isf_indices_36b(cf->isp_id, ctx->isf_cur); | |
1174 | } else { | ||
1175 | 5755 | decode_isf_indices_46b(cf->isp_id, ctx->isf_cur); | |
1176 | } | ||
1177 | |||
1178 | 6268 | isf_add_mean_and_past(ctx->isf_cur, ctx->isf_q_past); | |
1179 | 6268 | ff_set_min_dist_lsf(ctx->isf_cur, MIN_ISF_SPACING, LP_ORDER - 1); | |
1180 | |||
1181 | 6268 | stab_fac = stability_factor(ctx->isf_cur, ctx->isf_past_final); | |
1182 | |||
1183 | 6268 | ctx->isf_cur[LP_ORDER - 1] *= 2.0; | |
1184 | 6268 | ff_acelp_lsf2lspd(ctx->isp[3], ctx->isf_cur, LP_ORDER); | |
1185 | |||
1186 | /* Generate a ISP vector for each subframe */ | ||
1187 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 6246 times.
|
6268 | if (ctx->first_frame) { |
1188 | 22 | ctx->first_frame = 0; | |
1189 | 22 | memcpy(ctx->isp_sub4_past, ctx->isp[3], LP_ORDER * sizeof(double)); | |
1190 | } | ||
1191 | 6268 | interpolate_isp(ctx->isp, ctx->isp_sub4_past); | |
1192 | |||
1193 |
2/2✓ Branch 0 taken 25072 times.
✓ Branch 1 taken 6268 times.
|
31340 | for (sub = 0; sub < 4; sub++) |
1194 | 25072 | ff_amrwb_lsp2lpc(ctx->isp[sub], ctx->lp_coef[sub], LP_ORDER); | |
1195 | |||
1196 |
2/2✓ Branch 0 taken 25072 times.
✓ Branch 1 taken 6268 times.
|
31340 | for (sub = 0; sub < 4; sub++) { |
1197 | 25072 | const AMRWBSubFrame *cur_subframe = &cf->subframe[sub]; | |
1198 | 25072 | float *sub_buf = buf_out + sub * AMRWB_SFR_SIZE_16k; | |
1199 | |||
1200 | /* Decode adaptive codebook (pitch vector) */ | ||
1201 | 25072 | decode_pitch_vector(ctx, cur_subframe, sub); | |
1202 | /* Decode innovative codebook (fixed vector) */ | ||
1203 | 25072 | decode_fixed_vector(ctx->fixed_vector, cur_subframe->pul_ih, | |
1204 | 25072 | cur_subframe->pul_il, ctx->fr_cur_mode); | |
1205 | |||
1206 | 25072 | pitch_sharpening(ctx, ctx->fixed_vector); | |
1207 | |||
1208 | 25072 | decode_gains(cur_subframe->vq_gain, ctx->fr_cur_mode, | |
1209 | &fixed_gain_factor, &ctx->pitch_gain[0]); | ||
1210 | |||
1211 | 25072 | ctx->fixed_gain[0] = | |
1212 | 25072 | ff_amr_set_fixed_gain(fixed_gain_factor, | |
1213 | 25072 | ctx->celpm_ctx.dot_productf(ctx->fixed_vector, | |
1214 | 25072 | ctx->fixed_vector, | |
1215 | AMRWB_SFR_SIZE) / | ||
1216 | AMRWB_SFR_SIZE, | ||
1217 | 25072 | ctx->prediction_error, | |
1218 | ENERGY_MEAN, energy_pred_fac); | ||
1219 | |||
1220 | /* Calculate voice factor and store tilt for next subframe */ | ||
1221 | 25072 | voice_fac = voice_factor(ctx->pitch_vector, ctx->pitch_gain[0], | |
1222 | 25072 | ctx->fixed_vector, ctx->fixed_gain[0], | |
1223 | &ctx->celpm_ctx); | ||
1224 | 25072 | ctx->tilt_coef = voice_fac * 0.25 + 0.25; | |
1225 | |||
1226 | /* Construct current excitation */ | ||
1227 |
2/2✓ Branch 0 taken 1604608 times.
✓ Branch 1 taken 25072 times.
|
1629680 | for (i = 0; i < AMRWB_SFR_SIZE; i++) { |
1228 | 1604608 | ctx->excitation[i] *= ctx->pitch_gain[0]; | |
1229 | 1604608 | ctx->excitation[i] += ctx->fixed_gain[0] * ctx->fixed_vector[i]; | |
1230 | 1604608 | ctx->excitation[i] = truncf(ctx->excitation[i]); | |
1231 | } | ||
1232 | |||
1233 | /* Post-processing of excitation elements */ | ||
1234 | 25072 | synth_fixed_gain = noise_enhancer(ctx->fixed_gain[0], &ctx->prev_tr_gain, | |
1235 | voice_fac, stab_fac); | ||
1236 | |||
1237 | 25072 | synth_fixed_vector = anti_sparseness(ctx, ctx->fixed_vector, | |
1238 | spare_vector); | ||
1239 | |||
1240 | 25072 | pitch_enhancer(synth_fixed_vector, voice_fac); | |
1241 | |||
1242 | 25072 | synthesis(ctx, ctx->lp_coef[sub], synth_exc, synth_fixed_gain, | |
1243 | synth_fixed_vector, &ctx->samples_az[LP_ORDER]); | ||
1244 | |||
1245 | /* Synthesis speech post-processing */ | ||
1246 | 25072 | de_emphasis(&ctx->samples_up[UPS_MEM_SIZE], | |
1247 | 25072 | &ctx->samples_az[LP_ORDER], PREEMPH_FAC, ctx->demph_mem); | |
1248 | |||
1249 | 25072 | ctx->acelpf_ctx.acelp_apply_order_2_transfer_function(&ctx->samples_up[UPS_MEM_SIZE], | |
1250 | 25072 | &ctx->samples_up[UPS_MEM_SIZE], hpf_zeros, hpf_31_poles, | |
1251 | 25072 | hpf_31_gain, ctx->hpf_31_mem, AMRWB_SFR_SIZE); | |
1252 | |||
1253 | 25072 | upsample_5_4(sub_buf, &ctx->samples_up[UPS_FIR_SIZE], | |
1254 | AMRWB_SFR_SIZE_16k, &ctx->celpm_ctx); | ||
1255 | |||
1256 | /* High frequency band (6.4 - 7.0 kHz) generation part */ | ||
1257 | 25072 | ctx->acelpf_ctx.acelp_apply_order_2_transfer_function(hb_samples, | |
1258 | 25072 | &ctx->samples_up[UPS_MEM_SIZE], hpf_zeros, hpf_400_poles, | |
1259 | 25072 | hpf_400_gain, ctx->hpf_400_mem, AMRWB_SFR_SIZE); | |
1260 | |||
1261 | 25072 | hb_gain = find_hb_gain(ctx, hb_samples, | |
1262 | 25072 | cur_subframe->hb_gain, cf->vad); | |
1263 | |||
1264 | 25072 | scaled_hb_excitation(ctx, hb_exc, synth_exc, hb_gain); | |
1265 | |||
1266 | 25072 | hb_synthesis(ctx, sub, &ctx->samples_hb[LP_ORDER_16k], | |
1267 | 25072 | hb_exc, ctx->isf_cur, ctx->isf_past_final); | |
1268 | |||
1269 | /* High-band post-processing filters */ | ||
1270 | 25072 | hb_fir_filter(hb_samples, bpf_6_7_coef, ctx->bpf_6_7_mem, | |
1271 | 25072 | &ctx->samples_hb[LP_ORDER_16k]); | |
1272 | |||
1273 |
2/2✓ Branch 0 taken 8656 times.
✓ Branch 1 taken 16416 times.
|
25072 | if (ctx->fr_cur_mode == MODE_23k85) |
1274 | 8656 | hb_fir_filter(hb_samples, lpf_7_coef, ctx->lpf_7_mem, | |
1275 | hb_samples); | ||
1276 | |||
1277 | /* Add the low and high frequency bands */ | ||
1278 |
2/2✓ Branch 0 taken 2005760 times.
✓ Branch 1 taken 25072 times.
|
2030832 | for (i = 0; i < AMRWB_SFR_SIZE_16k; i++) |
1279 | 2005760 | sub_buf[i] = (sub_buf[i] + hb_samples[i]) * (1.0f / (1 << 15)); | |
1280 | |||
1281 | /* Update buffers and history */ | ||
1282 | 25072 | update_sub_state(ctx); | |
1283 | } | ||
1284 | |||
1285 | /* update state for next frame */ | ||
1286 | 6268 | memcpy(ctx->isp_sub4_past, ctx->isp[3], LP_ORDER * sizeof(ctx->isp[3][0])); | |
1287 | 6268 | memcpy(ctx->isf_past_final, ctx->isf_cur, LP_ORDER * sizeof(float)); | |
1288 | |||
1289 | 6268 | buf += expected_fr_size; | |
1290 | 6268 | buf_size -= expected_fr_size; | |
1291 | } | ||
1292 | |||
1293 | 6268 | *got_frame_ptr = 1; | |
1294 | |||
1295 | 6268 | return buf - avpkt->data; | |
1296 | } | ||
1297 | |||
1298 | const FFCodec ff_amrwb_decoder = { | ||
1299 | .p.name = "amrwb", | ||
1300 | CODEC_LONG_NAME("AMR-WB (Adaptive Multi-Rate WideBand)"), | ||
1301 | .p.type = AVMEDIA_TYPE_AUDIO, | ||
1302 | .p.id = AV_CODEC_ID_AMR_WB, | ||
1303 | .priv_data_size = sizeof(AMRWBChannelsContext), | ||
1304 | .init = amrwb_decode_init, | ||
1305 | FF_CODEC_DECODE_CB(amrwb_decode_frame), | ||
1306 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF, | ||
1307 | .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP, | ||
1308 | AV_SAMPLE_FMT_NONE }, | ||
1309 | }; | ||
1310 |