Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/amrnbdec.c |
Date: | 2022-07-07 01:21:54 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 368 | 388 | 94.8% |
Branches: | 185 | 204 | 90.7% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * AMR narrowband decoder | ||
3 | * Copyright (c) 2006-2007 Robert Swain | ||
4 | * Copyright (c) 2009 Colin McQuillan | ||
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 | |||
24 | /** | ||
25 | * @file | ||
26 | * AMR narrowband decoder | ||
27 | * | ||
28 | * This decoder uses floats for simplicity and so is not bit-exact. One | ||
29 | * difference is that differences in phase can accumulate. The test sequences | ||
30 | * in 3GPP TS 26.074 can still be useful. | ||
31 | * | ||
32 | * - Comparing this file's output to the output of the ref decoder gives a | ||
33 | * PSNR of 30 to 80. Plotting the output samples shows a difference in | ||
34 | * phase in some areas. | ||
35 | * | ||
36 | * - Comparing both decoders against their input, this decoder gives a similar | ||
37 | * PSNR. If the test sequence homing frames are removed (this decoder does | ||
38 | * not detect them), the PSNR is at least as good as the reference on 140 | ||
39 | * out of 169 tests. | ||
40 | */ | ||
41 | |||
42 | |||
43 | #include <string.h> | ||
44 | #include <math.h> | ||
45 | |||
46 | #include "libavutil/channel_layout.h" | ||
47 | #include "libavutil/float_dsp.h" | ||
48 | #include "avcodec.h" | ||
49 | #include "libavutil/common.h" | ||
50 | #include "libavutil/avassert.h" | ||
51 | #include "celp_math.h" | ||
52 | #include "celp_filters.h" | ||
53 | #include "acelp_filters.h" | ||
54 | #include "acelp_vectors.h" | ||
55 | #include "acelp_pitch_delay.h" | ||
56 | #include "lsp.h" | ||
57 | #include "amr.h" | ||
58 | #include "codec_internal.h" | ||
59 | #include "internal.h" | ||
60 | |||
61 | #include "amrnbdata.h" | ||
62 | |||
63 | #define AMR_BLOCK_SIZE 160 ///< samples per frame | ||
64 | #define AMR_SAMPLE_BOUND 32768.0 ///< threshold for synthesis overflow | ||
65 | |||
66 | /** | ||
67 | * Scale from constructed speech to [-1,1] | ||
68 | * | ||
69 | * AMR is designed to produce 16-bit PCM samples (3GPP TS 26.090 4.2) but | ||
70 | * upscales by two (section 6.2.2). | ||
71 | * | ||
72 | * Fundamentally, this scale is determined by energy_mean through | ||
73 | * the fixed vector contribution to the excitation vector. | ||
74 | */ | ||
75 | #define AMR_SAMPLE_SCALE (2.0 / 32768.0) | ||
76 | |||
77 | /** Prediction factor for 12.2kbit/s mode */ | ||
78 | #define PRED_FAC_MODE_12k2 0.65 | ||
79 | |||
80 | #define LSF_R_FAC (8000.0 / 32768.0) ///< LSF residual tables to Hertz | ||
81 | #define MIN_LSF_SPACING (50.0488 / 8000.0) ///< Ensures stability of LPC filter | ||
82 | #define PITCH_LAG_MIN_MODE_12k2 18 ///< Lower bound on decoded lag search in 12.2kbit/s mode | ||
83 | |||
84 | /** Initial energy in dB. Also used for bad frames (unimplemented). */ | ||
85 | #define MIN_ENERGY -14.0 | ||
86 | |||
87 | /** Maximum sharpening factor | ||
88 | * | ||
89 | * The specification says 0.8, which should be 13107, but the reference C code | ||
90 | * uses 13017 instead. (Amusingly the same applies to SHARP_MAX in g729dec.c.) | ||
91 | */ | ||
92 | #define SHARP_MAX 0.79449462890625 | ||
93 | |||
94 | /** Number of impulse response coefficients used for tilt factor */ | ||
95 | #define AMR_TILT_RESPONSE 22 | ||
96 | /** Tilt factor = 1st reflection coefficient * gamma_t */ | ||
97 | #define AMR_TILT_GAMMA_T 0.8 | ||
98 | /** Adaptive gain control factor used in post-filter */ | ||
99 | #define AMR_AGC_ALPHA 0.9 | ||
100 | |||
101 | typedef struct AMRContext { | ||
102 | AMRNBFrame frame; ///< decoded AMR parameters (lsf coefficients, codebook indexes, etc) | ||
103 | uint8_t bad_frame_indicator; ///< bad frame ? 1 : 0 | ||
104 | enum Mode cur_frame_mode; | ||
105 | |||
106 | int16_t prev_lsf_r[LP_FILTER_ORDER]; ///< residual LSF vector from previous subframe | ||
107 | double lsp[4][LP_FILTER_ORDER]; ///< lsp vectors from current frame | ||
108 | double prev_lsp_sub4[LP_FILTER_ORDER]; ///< lsp vector for the 4th subframe of the previous frame | ||
109 | |||
110 | float lsf_q[4][LP_FILTER_ORDER]; ///< Interpolated LSF vector for fixed gain smoothing | ||
111 | float lsf_avg[LP_FILTER_ORDER]; ///< vector of averaged lsf vector | ||
112 | |||
113 | float lpc[4][LP_FILTER_ORDER]; ///< lpc coefficient vectors for 4 subframes | ||
114 | |||
115 | uint8_t pitch_lag_int; ///< integer part of pitch lag from current subframe | ||
116 | |||
117 | float excitation_buf[PITCH_DELAY_MAX + LP_FILTER_ORDER + 1 + AMR_SUBFRAME_SIZE]; ///< current excitation and all necessary excitation history | ||
118 | float *excitation; ///< pointer to the current excitation vector in excitation_buf | ||
119 | |||
120 | float pitch_vector[AMR_SUBFRAME_SIZE]; ///< adaptive code book (pitch) vector | ||
121 | float fixed_vector[AMR_SUBFRAME_SIZE]; ///< algebraic codebook (fixed) vector (must be kept zero between frames) | ||
122 | |||
123 | float prediction_error[4]; ///< quantified prediction errors {20log10(^gamma_gc)} for previous four subframes | ||
124 | float pitch_gain[5]; ///< quantified pitch gains for the current and previous four subframes | ||
125 | float fixed_gain[5]; ///< quantified fixed gains for the current and previous four subframes | ||
126 | |||
127 | float beta; ///< previous pitch_gain, bounded by [0.0,SHARP_MAX] | ||
128 | uint8_t diff_count; ///< the number of subframes for which diff has been above 0.65 | ||
129 | uint8_t hang_count; ///< the number of subframes since a hangover period started | ||
130 | |||
131 | float prev_sparse_fixed_gain; ///< previous fixed gain; used by anti-sparseness processing to determine "onset" | ||
132 | uint8_t prev_ir_filter_nr; ///< previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none | ||
133 | uint8_t ir_filter_onset; ///< flag for impulse response filter strength | ||
134 | |||
135 | float postfilter_mem[10]; ///< previous intermediate values in the formant filter | ||
136 | float tilt_mem; ///< previous input to tilt compensation filter | ||
137 | float postfilter_agc; ///< previous factor used for adaptive gain control | ||
138 | float high_pass_mem[2]; ///< previous intermediate values in the high-pass filter | ||
139 | |||
140 | float samples_in[LP_FILTER_ORDER + AMR_SUBFRAME_SIZE]; ///< floating point samples | ||
141 | |||
142 | ACELPFContext acelpf_ctx; ///< context for filters for ACELP-based codecs | ||
143 | ACELPVContext acelpv_ctx; ///< context for vector operations for ACELP-based codecs | ||
144 | CELPFContext celpf_ctx; ///< context for filters for CELP-based codecs | ||
145 | CELPMContext celpm_ctx; ///< context for fixed point math operations | ||
146 | |||
147 | } AMRContext; | ||
148 | |||
149 | typedef struct AMRChannelsContext { | ||
150 | AMRContext ch[2]; | ||
151 | } AMRChannelsContext; | ||
152 | |||
153 | /** Double version of ff_weighted_vector_sumf() */ | ||
154 | 570 | static void weighted_vector_sumd(double *out, const double *in_a, | |
155 | const double *in_b, double weight_coeff_a, | ||
156 | double weight_coeff_b, int length) | ||
157 | { | ||
158 | int i; | ||
159 | |||
160 |
2/2✓ Branch 0 taken 5700 times.
✓ Branch 1 taken 570 times.
|
6270 | for (i = 0; i < length; i++) |
161 | 5700 | out[i] = weight_coeff_a * in_a[i] | |
162 | 5700 | + weight_coeff_b * in_b[i]; | |
163 | 570 | } | |
164 | |||
165 | 20 | static av_cold int amrnb_decode_init(AVCodecContext *avctx) | |
166 | { | ||
167 | 20 | AMRChannelsContext *s = avctx->priv_data; | |
168 | int i; | ||
169 | |||
170 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.
|
20 | if (avctx->ch_layout.nb_channels > 2) { |
171 | ✗ | avpriv_report_missing_feature(avctx, ">2 channel AMR"); | |
172 | ✗ | return AVERROR_PATCHWELCOME; | |
173 | } | ||
174 | |||
175 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.
|
20 | if (!avctx->ch_layout.nb_channels) { |
176 | ✗ | av_channel_layout_uninit(&avctx->ch_layout); | |
177 | ✗ | avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO; | |
178 | } | ||
179 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.
|
20 | if (!avctx->sample_rate) |
180 | ✗ | avctx->sample_rate = 8000; | |
181 | 20 | avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; | |
182 | |||
183 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 20 times.
|
40 | for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) { |
184 | 20 | AMRContext *p = &s->ch[ch]; | |
185 | // p->excitation always points to the same position in p->excitation_buf | ||
186 | 20 | p->excitation = &p->excitation_buf[PITCH_DELAY_MAX + LP_FILTER_ORDER + 1]; | |
187 | |||
188 |
2/2✓ Branch 0 taken 200 times.
✓ Branch 1 taken 20 times.
|
220 | for (i = 0; i < LP_FILTER_ORDER; i++) { |
189 | 200 | p->prev_lsp_sub4[i] = lsp_sub4_init[i] * 1000 / (float)(1 << 15); | |
190 | 200 | p->lsf_avg[i] = p->lsf_q[3][i] = lsp_avg_init[i] / (float)(1 << 15); | |
191 | } | ||
192 | |||
193 |
2/2✓ Branch 0 taken 80 times.
✓ Branch 1 taken 20 times.
|
100 | for (i = 0; i < 4; i++) |
194 | 80 | p->prediction_error[i] = MIN_ENERGY; | |
195 | |||
196 | 20 | ff_acelp_filter_init(&p->acelpf_ctx); | |
197 | 20 | ff_acelp_vectors_init(&p->acelpv_ctx); | |
198 | 20 | ff_celp_filter_init(&p->celpf_ctx); | |
199 | 20 | ff_celp_math_init(&p->celpm_ctx); | |
200 | } | ||
201 | |||
202 | 20 | return 0; | |
203 | } | ||
204 | |||
205 | |||
206 | /** | ||
207 | * Unpack an RFC4867 speech frame into the AMR frame mode and parameters. | ||
208 | * | ||
209 | * The order of speech bits is specified by 3GPP TS 26.101. | ||
210 | * | ||
211 | * @param p the context | ||
212 | * @param buf pointer to the input buffer | ||
213 | * @param buf_size size of the input buffer | ||
214 | * | ||
215 | * @return the frame mode | ||
216 | */ | ||
217 | 2284 | static enum Mode unpack_bitstream(AMRContext *p, const uint8_t *buf, | |
218 | int buf_size) | ||
219 | { | ||
220 | enum Mode mode; | ||
221 | |||
222 | // Decode the first octet. | ||
223 | 2284 | mode = buf[0] >> 3 & 0x0F; // frame type | |
224 | 2284 | p->bad_frame_indicator = (buf[0] & 0x4) != 0x4; // quality bit | |
225 | |||
226 |
2/4✓ Branch 0 taken 2284 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2284 times.
|
2284 | if (mode >= N_MODES || buf_size < frame_sizes_nb[mode] + 1) { |
227 | ✗ | return NO_DATA; | |
228 | } | ||
229 | |||
230 |
1/2✓ Branch 0 taken 2284 times.
✗ Branch 1 not taken.
|
2284 | if (mode < MODE_DTX) |
231 | 2284 | ff_amr_bit_reorder((uint16_t *) &p->frame, sizeof(AMRNBFrame), buf + 1, | |
232 | 2284 | amr_unpacking_bitmaps_per_mode[mode]); | |
233 | |||
234 | 2284 | return mode; | |
235 | } | ||
236 | |||
237 | |||
238 | /// @name AMR pitch LPC coefficient decoding functions | ||
239 | /// @{ | ||
240 | |||
241 | /** | ||
242 | * Interpolate the LSF vector (used for fixed gain smoothing). | ||
243 | * The interpolation is done over all four subframes even in MODE_12k2. | ||
244 | * | ||
245 | * @param[in] ctx The Context | ||
246 | * @param[in,out] lsf_q LSFs in [0,1] for each subframe | ||
247 | * @param[in] lsf_new New LSFs in [0,1] for subframe 4 | ||
248 | */ | ||
249 | 2284 | static void interpolate_lsf(ACELPVContext *ctx, float lsf_q[4][LP_FILTER_ORDER], float *lsf_new) | |
250 | { | ||
251 | int i; | ||
252 | |||
253 |
2/2✓ Branch 0 taken 9136 times.
✓ Branch 1 taken 2284 times.
|
11420 | for (i = 0; i < 4; i++) |
254 | 9136 | ctx->weighted_vector_sumf(lsf_q[i], lsf_q[3], lsf_new, | |
255 | 9136 | 0.25 * (3 - i), 0.25 * (i + 1), | |
256 | LP_FILTER_ORDER); | ||
257 | 2284 | } | |
258 | |||
259 | /** | ||
260 | * Decode a set of 5 split-matrix quantized lsf indexes into an lsp vector. | ||
261 | * | ||
262 | * @param p the context | ||
263 | * @param lsp output LSP vector | ||
264 | * @param lsf_no_r LSF vector without the residual vector added | ||
265 | * @param lsf_quantizer pointers to LSF dictionary tables | ||
266 | * @param quantizer_offset offset in tables | ||
267 | * @param sign for the 3 dictionary table | ||
268 | * @param update store data for computing the next frame's LSFs | ||
269 | */ | ||
270 | 570 | static void lsf2lsp_for_mode12k2(AMRContext *p, double lsp[LP_FILTER_ORDER], | |
271 | const float lsf_no_r[LP_FILTER_ORDER], | ||
272 | const int16_t *lsf_quantizer[5], | ||
273 | const int quantizer_offset, | ||
274 | const int sign, const int update) | ||
275 | { | ||
276 | int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector | ||
277 | float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector | ||
278 | int i; | ||
279 | |||
280 |
2/2✓ Branch 0 taken 2850 times.
✓ Branch 1 taken 570 times.
|
3420 | for (i = 0; i < LP_FILTER_ORDER >> 1; i++) |
281 | 2850 | memcpy(&lsf_r[i << 1], &lsf_quantizer[i][quantizer_offset], | |
282 | 2 * sizeof(*lsf_r)); | ||
283 | |||
284 |
2/2✓ Branch 0 taken 266 times.
✓ Branch 1 taken 304 times.
|
570 | if (sign) { |
285 | 266 | lsf_r[4] *= -1; | |
286 | 266 | lsf_r[5] *= -1; | |
287 | } | ||
288 | |||
289 |
2/2✓ Branch 0 taken 285 times.
✓ Branch 1 taken 285 times.
|
570 | if (update) |
290 | 285 | memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r)); | |
291 | |||
292 |
2/2✓ Branch 0 taken 5700 times.
✓ Branch 1 taken 570 times.
|
6270 | for (i = 0; i < LP_FILTER_ORDER; i++) |
293 | 5700 | lsf_q[i] = lsf_r[i] * (LSF_R_FAC / 8000.0) + lsf_no_r[i] * (1.0 / 8000.0); | |
294 | |||
295 | 570 | ff_set_min_dist_lsf(lsf_q, MIN_LSF_SPACING, LP_FILTER_ORDER); | |
296 | |||
297 |
2/2✓ Branch 0 taken 285 times.
✓ Branch 1 taken 285 times.
|
570 | if (update) |
298 | 285 | interpolate_lsf(&p->acelpv_ctx, p->lsf_q, lsf_q); | |
299 | |||
300 | 570 | ff_acelp_lsf2lspd(lsp, lsf_q, LP_FILTER_ORDER); | |
301 | 570 | } | |
302 | |||
303 | /** | ||
304 | * Decode a set of 5 split-matrix quantized lsf indexes into 2 lsp vectors. | ||
305 | * | ||
306 | * @param p pointer to the AMRContext | ||
307 | */ | ||
308 | 285 | static void lsf2lsp_5(AMRContext *p) | |
309 | { | ||
310 | 285 | const uint16_t *lsf_param = p->frame.lsf; | |
311 | float lsf_no_r[LP_FILTER_ORDER]; // LSFs without the residual vector | ||
312 | const int16_t *lsf_quantizer[5]; | ||
313 | int i; | ||
314 | |||
315 | 285 | lsf_quantizer[0] = lsf_5_1[lsf_param[0]]; | |
316 | 285 | lsf_quantizer[1] = lsf_5_2[lsf_param[1]]; | |
317 | 285 | lsf_quantizer[2] = lsf_5_3[lsf_param[2] >> 1]; | |
318 | 285 | lsf_quantizer[3] = lsf_5_4[lsf_param[3]]; | |
319 | 285 | lsf_quantizer[4] = lsf_5_5[lsf_param[4]]; | |
320 | |||
321 |
2/2✓ Branch 0 taken 2850 times.
✓ Branch 1 taken 285 times.
|
3135 | for (i = 0; i < LP_FILTER_ORDER; i++) |
322 | 2850 | lsf_no_r[i] = p->prev_lsf_r[i] * LSF_R_FAC * PRED_FAC_MODE_12k2 + lsf_5_mean[i]; | |
323 | |||
324 | 285 | lsf2lsp_for_mode12k2(p, p->lsp[1], lsf_no_r, lsf_quantizer, 0, lsf_param[2] & 1, 0); | |
325 | 285 | lsf2lsp_for_mode12k2(p, p->lsp[3], lsf_no_r, lsf_quantizer, 2, lsf_param[2] & 1, 1); | |
326 | |||
327 | // interpolate LSP vectors at subframes 1 and 3 | ||
328 | 285 | weighted_vector_sumd(p->lsp[0], p->prev_lsp_sub4, p->lsp[1], 0.5, 0.5, LP_FILTER_ORDER); | |
329 | 285 | weighted_vector_sumd(p->lsp[2], p->lsp[1] , p->lsp[3], 0.5, 0.5, LP_FILTER_ORDER); | |
330 | 285 | } | |
331 | |||
332 | /** | ||
333 | * Decode a set of 3 split-matrix quantized lsf indexes into an lsp vector. | ||
334 | * | ||
335 | * @param p pointer to the AMRContext | ||
336 | */ | ||
337 | 1999 | static void lsf2lsp_3(AMRContext *p) | |
338 | { | ||
339 | 1999 | const uint16_t *lsf_param = p->frame.lsf; | |
340 | int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector | ||
341 | float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector | ||
342 | const int16_t *lsf_quantizer; | ||
343 | int i, j; | ||
344 | |||
345 |
2/2✓ Branch 0 taken 285 times.
✓ Branch 1 taken 1714 times.
|
1999 | lsf_quantizer = (p->cur_frame_mode == MODE_7k95 ? lsf_3_1_MODE_7k95 : lsf_3_1)[lsf_param[0]]; |
346 | 1999 | memcpy(lsf_r, lsf_quantizer, 3 * sizeof(*lsf_r)); | |
347 | |||
348 | 1999 | lsf_quantizer = lsf_3_2[lsf_param[1] << (p->cur_frame_mode <= MODE_5k15)]; | |
349 | 1999 | memcpy(lsf_r + 3, lsf_quantizer, 3 * sizeof(*lsf_r)); | |
350 | |||
351 |
2/2✓ Branch 0 taken 572 times.
✓ Branch 1 taken 1427 times.
|
1999 | lsf_quantizer = (p->cur_frame_mode <= MODE_5k15 ? lsf_3_3_MODE_5k15 : lsf_3_3)[lsf_param[2]]; |
352 | 1999 | memcpy(lsf_r + 6, lsf_quantizer, 4 * sizeof(*lsf_r)); | |
353 | |||
354 | // calculate mean-removed LSF vector and add mean | ||
355 |
2/2✓ Branch 0 taken 19990 times.
✓ Branch 1 taken 1999 times.
|
21989 | for (i = 0; i < LP_FILTER_ORDER; i++) |
356 | 19990 | lsf_q[i] = (lsf_r[i] + p->prev_lsf_r[i] * pred_fac[i]) * (LSF_R_FAC / 8000.0) + lsf_3_mean[i] * (1.0 / 8000.0); | |
357 | |||
358 | 1999 | ff_set_min_dist_lsf(lsf_q, MIN_LSF_SPACING, LP_FILTER_ORDER); | |
359 | |||
360 | // store data for computing the next frame's LSFs | ||
361 | 1999 | interpolate_lsf(&p->acelpv_ctx, p->lsf_q, lsf_q); | |
362 | 1999 | memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r)); | |
363 | |||
364 | 1999 | ff_acelp_lsf2lspd(p->lsp[3], lsf_q, LP_FILTER_ORDER); | |
365 | |||
366 | // interpolate LSP vectors at subframes 1, 2 and 3 | ||
367 |
2/2✓ Branch 0 taken 5997 times.
✓ Branch 1 taken 1999 times.
|
7996 | for (i = 1; i <= 3; i++) |
368 |
2/2✓ Branch 0 taken 59970 times.
✓ Branch 1 taken 5997 times.
|
65967 | for(j = 0; j < LP_FILTER_ORDER; j++) |
369 | 59970 | p->lsp[i-1][j] = p->prev_lsp_sub4[j] + | |
370 | 59970 | (p->lsp[3][j] - p->prev_lsp_sub4[j]) * 0.25 * i; | |
371 | 1999 | } | |
372 | |||
373 | /// @} | ||
374 | |||
375 | |||
376 | /// @name AMR pitch vector decoding functions | ||
377 | /// @{ | ||
378 | |||
379 | /** | ||
380 | * Like ff_decode_pitch_lag(), but with 1/6 resolution | ||
381 | */ | ||
382 | 1140 | static void decode_pitch_lag_1_6(int *lag_int, int *lag_frac, int pitch_index, | |
383 | const int prev_lag_int, const int subframe) | ||
384 | { | ||
385 |
4/4✓ Branch 0 taken 855 times.
✓ Branch 1 taken 285 times.
✓ Branch 2 taken 285 times.
✓ Branch 3 taken 570 times.
|
1140 | if (subframe == 0 || subframe == 2) { |
386 |
2/2✓ Branch 0 taken 459 times.
✓ Branch 1 taken 111 times.
|
570 | if (pitch_index < 463) { |
387 | 459 | *lag_int = (pitch_index + 107) * 10923 >> 16; | |
388 | 459 | *lag_frac = pitch_index - *lag_int * 6 + 105; | |
389 | } else { | ||
390 | 111 | *lag_int = pitch_index - 368; | |
391 | 111 | *lag_frac = 0; | |
392 | } | ||
393 | } else { | ||
394 | 570 | *lag_int = ((pitch_index + 5) * 10923 >> 16) - 1; | |
395 | 570 | *lag_frac = pitch_index - *lag_int * 6 - 3; | |
396 | 570 | *lag_int += av_clip(prev_lag_int - 5, PITCH_LAG_MIN_MODE_12k2, | |
397 | PITCH_DELAY_MAX - 9); | ||
398 | } | ||
399 | 1140 | } | |
400 | |||
401 | 9136 | static void decode_pitch_vector(AMRContext *p, | |
402 | const AMRNBSubframe *amr_subframe, | ||
403 | const int subframe) | ||
404 | { | ||
405 | int pitch_lag_int, pitch_lag_frac; | ||
406 | 9136 | enum Mode mode = p->cur_frame_mode; | |
407 | |||
408 |
2/2✓ Branch 0 taken 1140 times.
✓ Branch 1 taken 7996 times.
|
9136 | if (p->cur_frame_mode == MODE_12k2) { |
409 | 1140 | decode_pitch_lag_1_6(&pitch_lag_int, &pitch_lag_frac, | |
410 | 1140 | amr_subframe->p_lag, p->pitch_lag_int, | |
411 | subframe); | ||
412 | } else { | ||
413 |
6/6✓ Branch 0 taken 3428 times.
✓ Branch 1 taken 4568 times.
✓ Branch 2 taken 6848 times.
✓ Branch 3 taken 1148 times.
✓ Branch 4 taken 5708 times.
✓ Branch 5 taken 1140 times.
|
11424 | ff_decode_pitch_lag(&pitch_lag_int, &pitch_lag_frac, |
414 | 7996 | amr_subframe->p_lag, | |
415 | 7996 | p->pitch_lag_int, subframe, | |
416 | mode != MODE_4k75 && mode != MODE_5k15, | ||
417 |
2/2✓ Branch 0 taken 1140 times.
✓ Branch 1 taken 2288 times.
|
3428 | mode <= MODE_6k7 ? 4 : (mode == MODE_7k95 ? 5 : 6)); |
418 | 7996 | pitch_lag_frac *= 2; | |
419 | } | ||
420 | |||
421 | 9136 | p->pitch_lag_int = pitch_lag_int; // store previous lag in a uint8_t | |
422 | |||
423 | 9136 | pitch_lag_int += pitch_lag_frac > 0; | |
424 | |||
425 | /* Calculate the pitch vector by interpolating the past excitation at the | ||
426 | pitch lag using a b60 hamming windowed sinc function. */ | ||
427 | 18272 | p->acelpf_ctx.acelp_interpolatef(p->excitation, | |
428 | 9136 | p->excitation + 1 - pitch_lag_int, | |
429 | ff_b60_sinc, 6, | ||
430 |
2/2✓ Branch 0 taken 2124 times.
✓ Branch 1 taken 7012 times.
|
9136 | pitch_lag_frac + 6 - 6*(pitch_lag_frac > 0), |
431 | 10, AMR_SUBFRAME_SIZE); | ||
432 | |||
433 | 9136 | memcpy(p->pitch_vector, p->excitation, AMR_SUBFRAME_SIZE * sizeof(float)); | |
434 | 9136 | } | |
435 | |||
436 | /// @} | ||
437 | |||
438 | |||
439 | /// @name AMR algebraic code book (fixed) vector decoding functions | ||
440 | /// @{ | ||
441 | |||
442 | /** | ||
443 | * Decode a 10-bit algebraic codebook index from a 10.2 kbit/s frame. | ||
444 | */ | ||
445 | 2296 | static void decode_10bit_pulse(int code, int pulse_position[8], | |
446 | int i1, int i2, int i3) | ||
447 | { | ||
448 | // coded using 7+3 bits with the 3 LSBs being, individually, the LSB of 1 of | ||
449 | // the 3 pulses and the upper 7 bits being coded in base 5 | ||
450 | 2296 | const uint8_t *positions = base_five_table[code >> 3]; | |
451 | 2296 | pulse_position[i1] = (positions[2] << 1) + ( code & 1); | |
452 | 2296 | pulse_position[i2] = (positions[1] << 1) + ((code >> 1) & 1); | |
453 | 2296 | pulse_position[i3] = (positions[0] << 1) + ((code >> 2) & 1); | |
454 | 2296 | } | |
455 | |||
456 | /** | ||
457 | * Decode the algebraic codebook index to pulse positions and signs and | ||
458 | * construct the algebraic codebook vector for MODE_10k2. | ||
459 | * | ||
460 | * @param fixed_index positions of the eight pulses | ||
461 | * @param fixed_sparse pointer to the algebraic codebook vector | ||
462 | */ | ||
463 | 1148 | static void decode_8_pulses_31bits(const int16_t *fixed_index, | |
464 | AMRFixed *fixed_sparse) | ||
465 | { | ||
466 | int pulse_position[8]; | ||
467 | int i, temp; | ||
468 | |||
469 | 1148 | decode_10bit_pulse(fixed_index[4], pulse_position, 0, 4, 1); | |
470 | 1148 | decode_10bit_pulse(fixed_index[5], pulse_position, 2, 6, 5); | |
471 | |||
472 | // coded using 5+2 bits with the 2 LSBs being, individually, the LSB of 1 of | ||
473 | // the 2 pulses and the upper 5 bits being coded in base 5 | ||
474 | 1148 | temp = ((fixed_index[6] >> 2) * 25 + 12) >> 5; | |
475 | 1148 | pulse_position[3] = temp % 5; | |
476 | 1148 | pulse_position[7] = temp / 5; | |
477 |
2/2✓ Branch 0 taken 480 times.
✓ Branch 1 taken 668 times.
|
1148 | if (pulse_position[7] & 1) |
478 | 480 | pulse_position[3] = 4 - pulse_position[3]; | |
479 | 1148 | pulse_position[3] = (pulse_position[3] << 1) + ( fixed_index[6] & 1); | |
480 | 1148 | pulse_position[7] = (pulse_position[7] << 1) + ((fixed_index[6] >> 1) & 1); | |
481 | |||
482 | 1148 | fixed_sparse->n = 8; | |
483 |
2/2✓ Branch 0 taken 4592 times.
✓ Branch 1 taken 1148 times.
|
5740 | for (i = 0; i < 4; i++) { |
484 | 4592 | const int pos1 = (pulse_position[i] << 2) + i; | |
485 | 4592 | const int pos2 = (pulse_position[i + 4] << 2) + i; | |
486 |
2/2✓ Branch 0 taken 2267 times.
✓ Branch 1 taken 2325 times.
|
4592 | const float sign = fixed_index[i] ? -1.0 : 1.0; |
487 | 4592 | fixed_sparse->x[i ] = pos1; | |
488 | 4592 | fixed_sparse->x[i + 4] = pos2; | |
489 | 4592 | fixed_sparse->y[i ] = sign; | |
490 |
2/2✓ Branch 0 taken 2154 times.
✓ Branch 1 taken 2438 times.
|
4592 | fixed_sparse->y[i + 4] = pos2 < pos1 ? -sign : sign; |
491 | } | ||
492 | 1148 | } | |
493 | |||
494 | /** | ||
495 | * Decode the algebraic codebook index to pulse positions and signs, | ||
496 | * then construct the algebraic codebook vector. | ||
497 | * | ||
498 | * nb of pulses | bits encoding pulses | ||
499 | * For MODE_4k75 or MODE_5k15, 2 | 1-3, 4-6, 7 | ||
500 | * MODE_5k9, 2 | 1, 2-4, 5-6, 7-9 | ||
501 | * MODE_6k7, 3 | 1-3, 4, 5-7, 8, 9-11 | ||
502 | * MODE_7k4 or MODE_7k95, 4 | 1-3, 4-6, 7-9, 10, 11-13 | ||
503 | * | ||
504 | * @param fixed_sparse pointer to the algebraic codebook vector | ||
505 | * @param pulses algebraic codebook indexes | ||
506 | * @param mode mode of the current frame | ||
507 | * @param subframe current subframe number | ||
508 | */ | ||
509 | 9136 | static void decode_fixed_sparse(AMRFixed *fixed_sparse, const uint16_t *pulses, | |
510 | const enum Mode mode, const int subframe) | ||
511 | { | ||
512 | av_assert1(MODE_4k75 <= (signed)mode && mode <= MODE_12k2); | ||
513 | |||
514 |
2/2✓ Branch 0 taken 1140 times.
✓ Branch 1 taken 7996 times.
|
9136 | if (mode == MODE_12k2) { |
515 | 1140 | ff_decode_10_pulses_35bits(pulses, fixed_sparse, gray_decode, 5, 3); | |
516 |
2/2✓ Branch 0 taken 1148 times.
✓ Branch 1 taken 6848 times.
|
7996 | } else if (mode == MODE_10k2) { |
517 | 1148 | decode_8_pulses_31bits(pulses, fixed_sparse); | |
518 | } else { | ||
519 | 6848 | int *pulse_position = fixed_sparse->x; | |
520 | int i, pulse_subset; | ||
521 | 6848 | const int fixed_index = pulses[0]; | |
522 | |||
523 |
2/2✓ Branch 0 taken 2288 times.
✓ Branch 1 taken 4560 times.
|
6848 | if (mode <= MODE_5k15) { |
524 | 2288 | pulse_subset = ((fixed_index >> 3) & 8) + (subframe << 1); | |
525 | 2288 | pulse_position[0] = ( fixed_index & 7) * 5 + track_position[pulse_subset]; | |
526 | 2288 | pulse_position[1] = ((fixed_index >> 3) & 7) * 5 + track_position[pulse_subset + 1]; | |
527 | 2288 | fixed_sparse->n = 2; | |
528 |
2/2✓ Branch 0 taken 1140 times.
✓ Branch 1 taken 3420 times.
|
4560 | } else if (mode == MODE_5k9) { |
529 | 1140 | pulse_subset = ((fixed_index & 1) << 1) + 1; | |
530 | 1140 | pulse_position[0] = ((fixed_index >> 1) & 7) * 5 + pulse_subset; | |
531 | 1140 | pulse_subset = (fixed_index >> 4) & 3; | |
532 | 1140 | pulse_position[1] = ((fixed_index >> 6) & 7) * 5 + pulse_subset + (pulse_subset == 3 ? 1 : 0); | |
533 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1139 times.
|
1140 | fixed_sparse->n = pulse_position[0] == pulse_position[1] ? 1 : 2; |
534 |
2/2✓ Branch 0 taken 1140 times.
✓ Branch 1 taken 2280 times.
|
3420 | } else if (mode == MODE_6k7) { |
535 | 1140 | pulse_position[0] = (fixed_index & 7) * 5; | |
536 | 1140 | pulse_subset = (fixed_index >> 2) & 2; | |
537 | 1140 | pulse_position[1] = ((fixed_index >> 4) & 7) * 5 + pulse_subset + 1; | |
538 | 1140 | pulse_subset = (fixed_index >> 6) & 2; | |
539 | 1140 | pulse_position[2] = ((fixed_index >> 8) & 7) * 5 + pulse_subset + 2; | |
540 | 1140 | fixed_sparse->n = 3; | |
541 | } else { // mode <= MODE_7k95 | ||
542 | 2280 | pulse_position[0] = gray_decode[ fixed_index & 7]; | |
543 | 2280 | pulse_position[1] = gray_decode[(fixed_index >> 3) & 7] + 1; | |
544 | 2280 | pulse_position[2] = gray_decode[(fixed_index >> 6) & 7] + 2; | |
545 | 2280 | pulse_subset = (fixed_index >> 9) & 1; | |
546 | 2280 | pulse_position[3] = gray_decode[(fixed_index >> 10) & 7] + pulse_subset + 3; | |
547 | 2280 | fixed_sparse->n = 4; | |
548 | } | ||
549 |
2/2✓ Branch 0 taken 19395 times.
✓ Branch 1 taken 6848 times.
|
26243 | for (i = 0; i < fixed_sparse->n; i++) |
550 |
2/2✓ Branch 0 taken 9758 times.
✓ Branch 1 taken 9637 times.
|
19395 | fixed_sparse->y[i] = (pulses[1] >> i) & 1 ? 1.0 : -1.0; |
551 | } | ||
552 | 9136 | } | |
553 | |||
554 | /** | ||
555 | * Apply pitch lag to obtain the sharpened fixed vector (section 6.1.2) | ||
556 | * | ||
557 | * @param p the context | ||
558 | * @param subframe unpacked amr subframe | ||
559 | * @param mode mode of the current frame | ||
560 | * @param fixed_sparse sparse representation of the fixed vector | ||
561 | */ | ||
562 | 9136 | static void pitch_sharpening(AMRContext *p, int subframe, enum Mode mode, | |
563 | AMRFixed *fixed_sparse) | ||
564 | { | ||
565 | // The spec suggests the current pitch gain is always used, but in other | ||
566 | // modes the pitch and codebook gains are jointly quantized (sec 5.8.2) | ||
567 | // so the codebook gain cannot depend on the quantized pitch gain. | ||
568 |
2/2✓ Branch 0 taken 1140 times.
✓ Branch 1 taken 7996 times.
|
9136 | if (mode == MODE_12k2) |
569 |
2/2✓ Branch 0 taken 106 times.
✓ Branch 1 taken 1034 times.
|
1140 | p->beta = FFMIN(p->pitch_gain[4], 1.0); |
570 | |||
571 | 9136 | fixed_sparse->pitch_lag = p->pitch_lag_int; | |
572 | 9136 | fixed_sparse->pitch_fac = p->beta; | |
573 | |||
574 | // Save pitch sharpening factor for the next subframe | ||
575 | // MODE_4k75 only updates on the 2nd and 4th subframes - this follows from | ||
576 | // the fact that the gains for two subframes are jointly quantized. | ||
577 |
4/4✓ Branch 0 taken 1148 times.
✓ Branch 1 taken 7988 times.
✓ Branch 2 taken 574 times.
✓ Branch 3 taken 574 times.
|
9136 | if (mode != MODE_4k75 || subframe & 1) |
578 | 8562 | p->beta = av_clipf(p->pitch_gain[4], 0.0, SHARP_MAX); | |
579 | 9136 | } | |
580 | /// @} | ||
581 | |||
582 | |||
583 | /// @name AMR gain decoding functions | ||
584 | /// @{ | ||
585 | |||
586 | /** | ||
587 | * fixed gain smoothing | ||
588 | * Note that where the spec specifies the "spectrum in the q domain" | ||
589 | * in section 6.1.4, in fact frequencies should be used. | ||
590 | * | ||
591 | * @param p the context | ||
592 | * @param lsf LSFs for the current subframe, in the range [0,1] | ||
593 | * @param lsf_avg averaged LSFs | ||
594 | * @param mode mode of the current frame | ||
595 | * | ||
596 | * @return fixed gain smoothed | ||
597 | */ | ||
598 | 9136 | static float fixed_gain_smooth(AMRContext *p , const float *lsf, | |
599 | const float *lsf_avg, const enum Mode mode) | ||
600 | { | ||
601 | 9136 | float diff = 0.0; | |
602 | int i; | ||
603 | |||
604 |
2/2✓ Branch 0 taken 91360 times.
✓ Branch 1 taken 9136 times.
|
100496 | for (i = 0; i < LP_FILTER_ORDER; i++) |
605 | 91360 | diff += fabs(lsf_avg[i] - lsf[i]) / lsf_avg[i]; | |
606 | |||
607 | // If diff is large for ten subframes, disable smoothing for a 40-subframe | ||
608 | // hangover period. | ||
609 | 9136 | p->diff_count++; | |
610 |
2/2✓ Branch 0 taken 6733 times.
✓ Branch 1 taken 2403 times.
|
9136 | if (diff <= 0.65) |
611 | 6733 | p->diff_count = 0; | |
612 | |||
613 |
2/2✓ Branch 0 taken 687 times.
✓ Branch 1 taken 8449 times.
|
9136 | if (p->diff_count > 10) { |
614 | 687 | p->hang_count = 0; | |
615 | 687 | p->diff_count--; // don't let diff_count overflow | |
616 | } | ||
617 | |||
618 |
2/2✓ Branch 0 taken 3851 times.
✓ Branch 1 taken 5285 times.
|
9136 | if (p->hang_count < 40) { |
619 | 3851 | p->hang_count++; | |
620 |
4/4✓ Branch 0 taken 2539 times.
✓ Branch 1 taken 2746 times.
✓ Branch 2 taken 667 times.
✓ Branch 3 taken 1872 times.
|
5285 | } else if (mode < MODE_7k4 || mode == MODE_10k2) { |
621 | 3413 | const float smoothing_factor = av_clipf(4.0 * diff - 1.6, 0.0, 1.0); | |
622 | 3413 | const float fixed_gain_mean = (p->fixed_gain[0] + p->fixed_gain[1] + | |
623 | 3413 | p->fixed_gain[2] + p->fixed_gain[3] + | |
624 | 3413 | p->fixed_gain[4]) * 0.2; | |
625 | 3413 | return smoothing_factor * p->fixed_gain[4] + | |
626 | 3413 | (1.0 - smoothing_factor) * fixed_gain_mean; | |
627 | } | ||
628 | 5723 | return p->fixed_gain[4]; | |
629 | } | ||
630 | |||
631 | /** | ||
632 | * Decode pitch gain and fixed gain factor (part of section 6.1.3). | ||
633 | * | ||
634 | * @param p the context | ||
635 | * @param amr_subframe unpacked amr subframe | ||
636 | * @param mode mode of the current frame | ||
637 | * @param subframe current subframe number | ||
638 | * @param fixed_gain_factor decoded gain correction factor | ||
639 | */ | ||
640 | 9136 | static void decode_gains(AMRContext *p, const AMRNBSubframe *amr_subframe, | |
641 | const enum Mode mode, const int subframe, | ||
642 | float *fixed_gain_factor) | ||
643 | { | ||
644 |
4/4✓ Branch 0 taken 7996 times.
✓ Branch 1 taken 1140 times.
✓ Branch 2 taken 1140 times.
✓ Branch 3 taken 6856 times.
|
9136 | if (mode == MODE_12k2 || mode == MODE_7k95) { |
645 | 2280 | p->pitch_gain[4] = qua_gain_pit [amr_subframe->p_gain ] | |
646 | 2280 | * (1.0 / 16384.0); | |
647 | 2280 | *fixed_gain_factor = qua_gain_code[amr_subframe->fixed_gain] | |
648 | 2280 | * (1.0 / 2048.0); | |
649 | } else { | ||
650 | const uint16_t *gains; | ||
651 | |||
652 |
2/2✓ Branch 0 taken 3428 times.
✓ Branch 1 taken 3428 times.
|
6856 | if (mode >= MODE_6k7) { |
653 | 3428 | gains = gains_high[amr_subframe->p_gain]; | |
654 |
2/2✓ Branch 0 taken 2280 times.
✓ Branch 1 taken 1148 times.
|
3428 | } else if (mode >= MODE_5k15) { |
655 | 2280 | gains = gains_low [amr_subframe->p_gain]; | |
656 | } else { | ||
657 | // gain index is only coded in subframes 0,2 for MODE_4k75 | ||
658 | 1148 | gains = gains_MODE_4k75[(p->frame.subframe[subframe & 2].p_gain << 1) + (subframe & 1)]; | |
659 | } | ||
660 | |||
661 | 6856 | p->pitch_gain[4] = gains[0] * (1.0 / 16384.0); | |
662 | 6856 | *fixed_gain_factor = gains[1] * (1.0 / 4096.0); | |
663 | } | ||
664 | 9136 | } | |
665 | |||
666 | /// @} | ||
667 | |||
668 | |||
669 | /// @name AMR preprocessing functions | ||
670 | /// @{ | ||
671 | |||
672 | /** | ||
673 | * Circularly convolve a sparse fixed vector with a phase dispersion impulse | ||
674 | * response filter (D.6.2 of G.729 and 6.1.5 of AMR). | ||
675 | * | ||
676 | * @param out vector with filter applied | ||
677 | * @param in source vector | ||
678 | * @param filter phase filter coefficients | ||
679 | * | ||
680 | * out[n] = sum(i,0,len-1){ in[i] * filter[(len + n - i)%len] } | ||
681 | */ | ||
682 | 4869 | static void apply_ir_filter(float *out, const AMRFixed *in, | |
683 | const float *filter) | ||
684 | { | ||
685 | float filter1[AMR_SUBFRAME_SIZE], ///< filters at pitch lag*1 and *2 | ||
686 | filter2[AMR_SUBFRAME_SIZE]; | ||
687 | 4869 | int lag = in->pitch_lag; | |
688 | 4869 | float fac = in->pitch_fac; | |
689 | int i; | ||
690 | |||
691 |
2/2✓ Branch 0 taken 741 times.
✓ Branch 1 taken 4128 times.
|
4869 | if (lag < AMR_SUBFRAME_SIZE) { |
692 | 741 | ff_celp_circ_addf(filter1, filter, filter, lag, fac, | |
693 | AMR_SUBFRAME_SIZE); | ||
694 | |||
695 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 741 times.
|
741 | if (lag < AMR_SUBFRAME_SIZE >> 1) |
696 | ✗ | ff_celp_circ_addf(filter2, filter, filter1, lag, fac, | |
697 | AMR_SUBFRAME_SIZE); | ||
698 | } | ||
699 | |||
700 | 4869 | memset(out, 0, sizeof(float) * AMR_SUBFRAME_SIZE); | |
701 |
2/2✓ Branch 0 taken 12807 times.
✓ Branch 1 taken 4869 times.
|
17676 | for (i = 0; i < in->n; i++) { |
702 | 12807 | int x = in->x[i]; | |
703 | 12807 | float y = in->y[i]; | |
704 | const float *filterp; | ||
705 | |||
706 |
2/2✓ Branch 0 taken 12481 times.
✓ Branch 1 taken 326 times.
|
12807 | if (x >= AMR_SUBFRAME_SIZE - lag) { |
707 | 12481 | filterp = filter; | |
708 |
1/2✓ Branch 0 taken 326 times.
✗ Branch 1 not taken.
|
326 | } else if (x >= AMR_SUBFRAME_SIZE - (lag << 1)) { |
709 | 326 | filterp = filter1; | |
710 | } else | ||
711 | ✗ | filterp = filter2; | |
712 | |||
713 | 12807 | ff_celp_circ_addf(out, out, filterp, x, y, AMR_SUBFRAME_SIZE); | |
714 | } | ||
715 | 4869 | } | |
716 | |||
717 | /** | ||
718 | * Reduce fixed vector sparseness by smoothing with one of three IR filters. | ||
719 | * Also know as "adaptive phase dispersion". | ||
720 | * | ||
721 | * This implements 3GPP TS 26.090 section 6.1(5). | ||
722 | * | ||
723 | * @param p the context | ||
724 | * @param fixed_sparse algebraic codebook vector | ||
725 | * @param fixed_vector unfiltered fixed vector | ||
726 | * @param fixed_gain smoothed gain | ||
727 | * @param out space for modified vector if necessary | ||
728 | */ | ||
729 | 9136 | static const float *anti_sparseness(AMRContext *p, AMRFixed *fixed_sparse, | |
730 | const float *fixed_vector, | ||
731 | float fixed_gain, float *out) | ||
732 | { | ||
733 | int ir_filter_nr; | ||
734 | |||
735 |
2/2✓ Branch 0 taken 4165 times.
✓ Branch 1 taken 4971 times.
|
9136 | if (p->pitch_gain[4] < 0.6) { |
736 | 4165 | ir_filter_nr = 0; // strong filtering | |
737 |
2/2✓ Branch 0 taken 2995 times.
✓ Branch 1 taken 1976 times.
|
4971 | } else if (p->pitch_gain[4] < 0.9) { |
738 | 2995 | ir_filter_nr = 1; // medium filtering | |
739 | } else | ||
740 | 1976 | ir_filter_nr = 2; // no filtering | |
741 | |||
742 | // detect 'onset' | ||
743 |
2/2✓ Branch 0 taken 232 times.
✓ Branch 1 taken 8904 times.
|
9136 | if (fixed_gain > 2.0 * p->prev_sparse_fixed_gain) { |
744 | 232 | p->ir_filter_onset = 2; | |
745 |
2/2✓ Branch 0 taken 336 times.
✓ Branch 1 taken 8568 times.
|
8904 | } else if (p->ir_filter_onset) |
746 | 336 | p->ir_filter_onset--; | |
747 | |||
748 |
2/2✓ Branch 0 taken 8732 times.
✓ Branch 1 taken 404 times.
|
9136 | if (!p->ir_filter_onset) { |
749 | 8732 | int i, count = 0; | |
750 | |||
751 |
2/2✓ Branch 0 taken 43660 times.
✓ Branch 1 taken 8732 times.
|
52392 | for (i = 0; i < 5; i++) |
752 |
2/2✓ Branch 0 taken 19971 times.
✓ Branch 1 taken 23689 times.
|
43660 | if (p->pitch_gain[i] < 0.6) |
753 | 19971 | count++; | |
754 |
2/2✓ Branch 0 taken 3912 times.
✓ Branch 1 taken 4820 times.
|
8732 | if (count > 2) |
755 | 3912 | ir_filter_nr = 0; | |
756 | |||
757 |
2/2✓ Branch 0 taken 489 times.
✓ Branch 1 taken 8243 times.
|
8732 | if (ir_filter_nr > p->prev_ir_filter_nr + 1) |
758 | 489 | ir_filter_nr--; | |
759 |
2/2✓ Branch 0 taken 262 times.
✓ Branch 1 taken 142 times.
|
404 | } else if (ir_filter_nr < 2) |
760 | 262 | ir_filter_nr++; | |
761 | |||
762 | // Disable filtering for very low level of fixed_gain. | ||
763 | // Note this step is not specified in the technical description but is in | ||
764 | // the reference source in the function Ph_disp. | ||
765 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 9120 times.
|
9136 | if (fixed_gain < 5.0) |
766 | 16 | ir_filter_nr = 2; | |
767 | |||
768 |
4/4✓ Branch 0 taken 7996 times.
✓ Branch 1 taken 1140 times.
✓ Branch 2 taken 5708 times.
✓ Branch 3 taken 2288 times.
|
9136 | if (p->cur_frame_mode != MODE_7k4 && p->cur_frame_mode < MODE_10k2 |
769 |
2/2✓ Branch 0 taken 4869 times.
✓ Branch 1 taken 839 times.
|
5708 | && ir_filter_nr < 2) { |
770 | 4869 | apply_ir_filter(out, fixed_sparse, | |
771 | 4869 | (p->cur_frame_mode == MODE_7k95 ? | |
772 |
2/2✓ Branch 0 taken 1038 times.
✓ Branch 1 taken 3831 times.
|
4869 | ir_filters_lookup_MODE_7k95 : |
773 | 4869 | ir_filters_lookup)[ir_filter_nr]); | |
774 | 4869 | fixed_vector = out; | |
775 | } | ||
776 | |||
777 | // update ir filter strength history | ||
778 | 9136 | p->prev_ir_filter_nr = ir_filter_nr; | |
779 | 9136 | p->prev_sparse_fixed_gain = fixed_gain; | |
780 | |||
781 | 9136 | return fixed_vector; | |
782 | } | ||
783 | |||
784 | /// @} | ||
785 | |||
786 | |||
787 | /// @name AMR synthesis functions | ||
788 | /// @{ | ||
789 | |||
790 | /** | ||
791 | * Conduct 10th order linear predictive coding synthesis. | ||
792 | * | ||
793 | * @param p pointer to the AMRContext | ||
794 | * @param lpc pointer to the LPC coefficients | ||
795 | * @param fixed_gain fixed codebook gain for synthesis | ||
796 | * @param fixed_vector algebraic codebook vector | ||
797 | * @param samples pointer to the output speech samples | ||
798 | * @param overflow 16-bit overflow flag | ||
799 | */ | ||
800 | 9136 | static int synthesis(AMRContext *p, float *lpc, | |
801 | float fixed_gain, const float *fixed_vector, | ||
802 | float *samples, uint8_t overflow) | ||
803 | { | ||
804 | int i; | ||
805 | float excitation[AMR_SUBFRAME_SIZE]; | ||
806 | |||
807 | // if an overflow has been detected, the pitch vector is scaled down by a | ||
808 | // factor of 4 | ||
809 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9136 times.
|
9136 | if (overflow) |
810 | ✗ | for (i = 0; i < AMR_SUBFRAME_SIZE; i++) | |
811 | ✗ | p->pitch_vector[i] *= 0.25; | |
812 | |||
813 | 9136 | p->acelpv_ctx.weighted_vector_sumf(excitation, p->pitch_vector, fixed_vector, | |
814 | p->pitch_gain[4], fixed_gain, AMR_SUBFRAME_SIZE); | ||
815 | |||
816 | // emphasize pitch vector contribution | ||
817 |
3/4✓ Branch 0 taken 6236 times.
✓ Branch 1 taken 2900 times.
✓ Branch 2 taken 6236 times.
✗ Branch 3 not taken.
|
9136 | if (p->pitch_gain[4] > 0.5 && !overflow) { |
818 | 6236 | float energy = p->celpm_ctx.dot_productf(excitation, excitation, | |
819 | AMR_SUBFRAME_SIZE); | ||
820 | 6236 | float pitch_factor = | |
821 | 12472 | p->pitch_gain[4] * | |
822 | 6236 | (p->cur_frame_mode == MODE_12k2 ? | |
823 |
4/4✓ Branch 0 taken 704 times.
✓ Branch 1 taken 5532 times.
✓ Branch 2 taken 106 times.
✓ Branch 3 taken 598 times.
|
11768 | 0.25 * FFMIN(p->pitch_gain[4], 1.0) : |
824 |
2/2✓ Branch 0 taken 2748 times.
✓ Branch 1 taken 2784 times.
|
5532 | 0.5 * FFMIN(p->pitch_gain[4], SHARP_MAX)); |
825 | |||
826 |
2/2✓ Branch 0 taken 249440 times.
✓ Branch 1 taken 6236 times.
|
255676 | for (i = 0; i < AMR_SUBFRAME_SIZE; i++) |
827 | 249440 | excitation[i] += pitch_factor * p->pitch_vector[i]; | |
828 | |||
829 | 6236 | ff_scale_vector_to_given_sum_of_squares(excitation, excitation, energy, | |
830 | AMR_SUBFRAME_SIZE); | ||
831 | } | ||
832 | |||
833 | 9136 | p->celpf_ctx.celp_lp_synthesis_filterf(samples, lpc, excitation, | |
834 | AMR_SUBFRAME_SIZE, | ||
835 | LP_FILTER_ORDER); | ||
836 | |||
837 | // detect overflow | ||
838 |
2/2✓ Branch 0 taken 365440 times.
✓ Branch 1 taken 9136 times.
|
374576 | for (i = 0; i < AMR_SUBFRAME_SIZE; i++) |
839 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 365440 times.
|
365440 | if (fabsf(samples[i]) > AMR_SAMPLE_BOUND) { |
840 | ✗ | return 1; | |
841 | } | ||
842 | |||
843 | 9136 | return 0; | |
844 | } | ||
845 | |||
846 | /// @} | ||
847 | |||
848 | |||
849 | /// @name AMR update functions | ||
850 | /// @{ | ||
851 | |||
852 | /** | ||
853 | * Update buffers and history at the end of decoding a subframe. | ||
854 | * | ||
855 | * @param p pointer to the AMRContext | ||
856 | */ | ||
857 | 9136 | static void update_state(AMRContext *p) | |
858 | { | ||
859 | 9136 | memcpy(p->prev_lsp_sub4, p->lsp[3], LP_FILTER_ORDER * sizeof(p->lsp[3][0])); | |
860 | |||
861 | 9136 | memmove(&p->excitation_buf[0], &p->excitation_buf[AMR_SUBFRAME_SIZE], | |
862 | (PITCH_DELAY_MAX + LP_FILTER_ORDER + 1) * sizeof(float)); | ||
863 | |||
864 | 9136 | memmove(&p->pitch_gain[0], &p->pitch_gain[1], 4 * sizeof(float)); | |
865 | 9136 | memmove(&p->fixed_gain[0], &p->fixed_gain[1], 4 * sizeof(float)); | |
866 | |||
867 | 9136 | memmove(&p->samples_in[0], &p->samples_in[AMR_SUBFRAME_SIZE], | |
868 | LP_FILTER_ORDER * sizeof(float)); | ||
869 | 9136 | } | |
870 | |||
871 | /// @} | ||
872 | |||
873 | |||
874 | /// @name AMR Postprocessing functions | ||
875 | /// @{ | ||
876 | |||
877 | /** | ||
878 | * Get the tilt factor of a formant filter from its transfer function | ||
879 | * | ||
880 | * @param p The Context | ||
881 | * @param lpc_n LP_FILTER_ORDER coefficients of the numerator | ||
882 | * @param lpc_d LP_FILTER_ORDER coefficients of the denominator | ||
883 | */ | ||
884 | 9136 | static float tilt_factor(AMRContext *p, float *lpc_n, float *lpc_d) | |
885 | { | ||
886 | float rh0, rh1; // autocorrelation at lag 0 and 1 | ||
887 | |||
888 | // LP_FILTER_ORDER prior zeros are needed for ff_celp_lp_synthesis_filterf | ||
889 | 9136 | float impulse_buffer[LP_FILTER_ORDER + AMR_TILT_RESPONSE] = { 0 }; | |
890 | 9136 | float *hf = impulse_buffer + LP_FILTER_ORDER; // start of impulse response | |
891 | |||
892 | 9136 | hf[0] = 1.0; | |
893 | 9136 | memcpy(hf + 1, lpc_n, sizeof(float) * LP_FILTER_ORDER); | |
894 | 9136 | p->celpf_ctx.celp_lp_synthesis_filterf(hf, lpc_d, hf, | |
895 | AMR_TILT_RESPONSE, | ||
896 | LP_FILTER_ORDER); | ||
897 | |||
898 | 9136 | rh0 = p->celpm_ctx.dot_productf(hf, hf, AMR_TILT_RESPONSE); | |
899 | 9136 | rh1 = p->celpm_ctx.dot_productf(hf, hf + 1, AMR_TILT_RESPONSE - 1); | |
900 | |||
901 | // The spec only specifies this check for 12.2 and 10.2 kbit/s | ||
902 | // modes. But in the ref source the tilt is always non-negative. | ||
903 |
1/2✓ Branch 0 taken 9136 times.
✗ Branch 1 not taken.
|
9136 | return rh1 >= 0.0 ? rh1 / rh0 * AMR_TILT_GAMMA_T : 0.0; |
904 | } | ||
905 | |||
906 | /** | ||
907 | * Perform adaptive post-filtering to enhance the quality of the speech. | ||
908 | * See section 6.2.1. | ||
909 | * | ||
910 | * @param p pointer to the AMRContext | ||
911 | * @param lpc interpolated LP coefficients for this subframe | ||
912 | * @param buf_out output of the filter | ||
913 | */ | ||
914 | 9136 | static void postfilter(AMRContext *p, float *lpc, float *buf_out) | |
915 | { | ||
916 | int i; | ||
917 | 9136 | float *samples = p->samples_in + LP_FILTER_ORDER; // Start of input | |
918 | |||
919 | 9136 | float speech_gain = p->celpm_ctx.dot_productf(samples, samples, | |
920 | AMR_SUBFRAME_SIZE); | ||
921 | |||
922 | float pole_out[AMR_SUBFRAME_SIZE + LP_FILTER_ORDER]; // Output of pole filter | ||
923 | const float *gamma_n, *gamma_d; // Formant filter factor table | ||
924 | float lpc_n[LP_FILTER_ORDER], lpc_d[LP_FILTER_ORDER]; // Transfer function coefficients | ||
925 | |||
926 |
4/4✓ Branch 0 taken 7996 times.
✓ Branch 1 taken 1140 times.
✓ Branch 2 taken 1148 times.
✓ Branch 3 taken 6848 times.
|
9136 | if (p->cur_frame_mode == MODE_12k2 || p->cur_frame_mode == MODE_10k2) { |
927 | 2288 | gamma_n = ff_pow_0_7; | |
928 | 2288 | gamma_d = ff_pow_0_75; | |
929 | } else { | ||
930 | 6848 | gamma_n = ff_pow_0_55; | |
931 | 6848 | gamma_d = ff_pow_0_7; | |
932 | } | ||
933 | |||
934 |
2/2✓ Branch 0 taken 91360 times.
✓ Branch 1 taken 9136 times.
|
100496 | for (i = 0; i < LP_FILTER_ORDER; i++) { |
935 | 91360 | lpc_n[i] = lpc[i] * gamma_n[i]; | |
936 | 91360 | lpc_d[i] = lpc[i] * gamma_d[i]; | |
937 | } | ||
938 | |||
939 | 9136 | memcpy(pole_out, p->postfilter_mem, sizeof(float) * LP_FILTER_ORDER); | |
940 | 9136 | p->celpf_ctx.celp_lp_synthesis_filterf(pole_out + LP_FILTER_ORDER, lpc_d, samples, | |
941 | AMR_SUBFRAME_SIZE, LP_FILTER_ORDER); | ||
942 | 9136 | memcpy(p->postfilter_mem, pole_out + AMR_SUBFRAME_SIZE, | |
943 | sizeof(float) * LP_FILTER_ORDER); | ||
944 | |||
945 | 9136 | p->celpf_ctx.celp_lp_zero_synthesis_filterf(buf_out, lpc_n, | |
946 | pole_out + LP_FILTER_ORDER, | ||
947 | AMR_SUBFRAME_SIZE, LP_FILTER_ORDER); | ||
948 | |||
949 | 9136 | ff_tilt_compensation(&p->tilt_mem, tilt_factor(p, lpc_n, lpc_d), buf_out, | |
950 | AMR_SUBFRAME_SIZE); | ||
951 | |||
952 | 9136 | ff_adaptive_gain_control(buf_out, buf_out, speech_gain, AMR_SUBFRAME_SIZE, | |
953 | AMR_AGC_ALPHA, &p->postfilter_agc); | ||
954 | 9136 | } | |
955 | |||
956 | /// @} | ||
957 | |||
958 | 2284 | static int amrnb_decode_frame(AVCodecContext *avctx, AVFrame *frame, | |
959 | int *got_frame_ptr, AVPacket *avpkt) | ||
960 | { | ||
961 | |||
962 | 2284 | AMRChannelsContext *s = avctx->priv_data; // pointer to private data | |
963 | 2284 | const uint8_t *buf = avpkt->data; | |
964 | 2284 | int buf_size = avpkt->size; | |
965 | int ret; | ||
966 | |||
967 | /* get output buffer */ | ||
968 | 2284 | frame->nb_samples = AMR_BLOCK_SIZE; | |
969 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2284 times.
|
2284 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
970 | ✗ | return ret; | |
971 | |||
972 |
2/2✓ Branch 0 taken 2284 times.
✓ Branch 1 taken 2284 times.
|
4568 | for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) { |
973 | 2284 | AMRContext *p = &s->ch[ch]; | |
974 | float fixed_gain_factor; | ||
975 | 2284 | AMRFixed fixed_sparse = {0}; // fixed vector up to anti-sparseness processing | |
976 | float spare_vector[AMR_SUBFRAME_SIZE]; // extra stack space to hold result from anti-sparseness processing | ||
977 | float synth_fixed_gain; // the fixed gain that synthesis should use | ||
978 | const float *synth_fixed_vector; // pointer to the fixed vector that synthesis should use | ||
979 | 2284 | float *buf_out = (float *)frame->extended_data[ch]; | |
980 | int channel_size; | ||
981 | int i, subframe; | ||
982 | |||
983 | 2284 | p->cur_frame_mode = unpack_bitstream(p, buf, buf_size); | |
984 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2284 times.
|
2284 | if (p->cur_frame_mode == NO_DATA) { |
985 | ✗ | av_log(avctx, AV_LOG_ERROR, "Corrupt bitstream\n"); | |
986 | ✗ | return AVERROR_INVALIDDATA; | |
987 | } | ||
988 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2284 times.
|
2284 | if (p->cur_frame_mode == MODE_DTX) { |
989 | ✗ | avpriv_report_missing_feature(avctx, "dtx mode"); | |
990 | ✗ | av_log(avctx, AV_LOG_INFO, "Note: libopencore_amrnb supports dtx\n"); | |
991 | ✗ | return AVERROR_PATCHWELCOME; | |
992 | } | ||
993 | |||
994 | 2284 | channel_size = frame_sizes_nb[p->cur_frame_mode] + 1; // +7 for rounding and +8 for TOC | |
995 |
2/2✓ Branch 0 taken 285 times.
✓ Branch 1 taken 1999 times.
|
2284 | if (p->cur_frame_mode == MODE_12k2) { |
996 | 285 | lsf2lsp_5(p); | |
997 | } else | ||
998 | 1999 | lsf2lsp_3(p); | |
999 | |||
1000 |
2/2✓ Branch 0 taken 9136 times.
✓ Branch 1 taken 2284 times.
|
11420 | for (i = 0; i < 4; i++) |
1001 | 9136 | ff_acelp_lspd2lpc(p->lsp[i], p->lpc[i], 5); | |
1002 | |||
1003 |
2/2✓ Branch 0 taken 9136 times.
✓ Branch 1 taken 2284 times.
|
11420 | for (subframe = 0; subframe < 4; subframe++) { |
1004 | 9136 | const AMRNBSubframe *amr_subframe = &p->frame.subframe[subframe]; | |
1005 | |||
1006 | 9136 | decode_pitch_vector(p, amr_subframe, subframe); | |
1007 | |||
1008 | 9136 | decode_fixed_sparse(&fixed_sparse, amr_subframe->pulses, | |
1009 | p->cur_frame_mode, subframe); | ||
1010 | |||
1011 | // The fixed gain (section 6.1.3) depends on the fixed vector | ||
1012 | // (section 6.1.2), but the fixed vector calculation uses | ||
1013 | // pitch sharpening based on the on the pitch gain (section 6.1.3). | ||
1014 | // So the correct order is: pitch gain, pitch sharpening, fixed gain. | ||
1015 | 9136 | decode_gains(p, amr_subframe, p->cur_frame_mode, subframe, | |
1016 | &fixed_gain_factor); | ||
1017 | |||
1018 | 9136 | pitch_sharpening(p, subframe, p->cur_frame_mode, &fixed_sparse); | |
1019 | |||
1020 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9136 times.
|
9136 | if (fixed_sparse.pitch_lag == 0) { |
1021 | ✗ | av_log(avctx, AV_LOG_ERROR, "The file is corrupted, pitch_lag = 0 is not allowed\n"); | |
1022 | ✗ | return AVERROR_INVALIDDATA; | |
1023 | } | ||
1024 | 9136 | ff_set_fixed_vector(p->fixed_vector, &fixed_sparse, 1.0, | |
1025 | AMR_SUBFRAME_SIZE); | ||
1026 | |||
1027 | 9136 | p->fixed_gain[4] = | |
1028 | 9136 | ff_amr_set_fixed_gain(fixed_gain_factor, | |
1029 | 9136 | p->celpm_ctx.dot_productf(p->fixed_vector, | |
1030 | 9136 | p->fixed_vector, | |
1031 | AMR_SUBFRAME_SIZE) / | ||
1032 | AMR_SUBFRAME_SIZE, | ||
1033 | 9136 | p->prediction_error, | |
1034 | 9136 | energy_mean[p->cur_frame_mode], energy_pred_fac); | |
1035 | |||
1036 | // The excitation feedback is calculated without any processing such | ||
1037 | // as fixed gain smoothing. This isn't mentioned in the specification. | ||
1038 |
2/2✓ Branch 0 taken 365440 times.
✓ Branch 1 taken 9136 times.
|
374576 | for (i = 0; i < AMR_SUBFRAME_SIZE; i++) |
1039 | 365440 | p->excitation[i] *= p->pitch_gain[4]; | |
1040 | 9136 | ff_set_fixed_vector(p->excitation, &fixed_sparse, p->fixed_gain[4], | |
1041 | AMR_SUBFRAME_SIZE); | ||
1042 | |||
1043 | // In the ref decoder, excitation is stored with no fractional bits. | ||
1044 | // This step prevents buzz in silent periods. The ref encoder can | ||
1045 | // emit long sequences with pitch factor greater than one. This | ||
1046 | // creates unwanted feedback if the excitation vector is nonzero. | ||
1047 | // (e.g. test sequence T19_795.COD in 3GPP TS 26.074) | ||
1048 |
2/2✓ Branch 0 taken 365440 times.
✓ Branch 1 taken 9136 times.
|
374576 | for (i = 0; i < AMR_SUBFRAME_SIZE; i++) |
1049 | 365440 | p->excitation[i] = truncf(p->excitation[i]); | |
1050 | |||
1051 | // Smooth fixed gain. | ||
1052 | // The specification is ambiguous, but in the reference source, the | ||
1053 | // smoothed value is NOT fed back into later fixed gain smoothing. | ||
1054 | 9136 | synth_fixed_gain = fixed_gain_smooth(p, p->lsf_q[subframe], | |
1055 | 9136 | p->lsf_avg, p->cur_frame_mode); | |
1056 | |||
1057 | 9136 | synth_fixed_vector = anti_sparseness(p, &fixed_sparse, p->fixed_vector, | |
1058 | synth_fixed_gain, spare_vector); | ||
1059 | |||
1060 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 9136 times.
|
9136 | if (synthesis(p, p->lpc[subframe], synth_fixed_gain, |
1061 | synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 0)) | ||
1062 | // overflow detected -> rerun synthesis scaling pitch vector down | ||
1063 | // by a factor of 4, skipping pitch vector contribution emphasis | ||
1064 | // and adaptive gain control | ||
1065 | ✗ | synthesis(p, p->lpc[subframe], synth_fixed_gain, | |
1066 | synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 1); | ||
1067 | |||
1068 | 9136 | postfilter(p, p->lpc[subframe], buf_out + subframe * AMR_SUBFRAME_SIZE); | |
1069 | |||
1070 | // update buffers and history | ||
1071 | 9136 | ff_clear_fixed_vector(p->fixed_vector, &fixed_sparse, AMR_SUBFRAME_SIZE); | |
1072 | 9136 | update_state(p); | |
1073 | } | ||
1074 | |||
1075 | 2284 | p->acelpf_ctx.acelp_apply_order_2_transfer_function(buf_out, | |
1076 | buf_out, highpass_zeros, | ||
1077 | highpass_poles, | ||
1078 | 2284 | highpass_gain * AMR_SAMPLE_SCALE, | |
1079 | 2284 | p->high_pass_mem, AMR_BLOCK_SIZE); | |
1080 | |||
1081 | /* Update averaged lsf vector (used for fixed gain smoothing). | ||
1082 | * | ||
1083 | * Note that lsf_avg should not incorporate the current frame's LSFs | ||
1084 | * for fixed_gain_smooth. | ||
1085 | * The specification has an incorrect formula: the reference decoder uses | ||
1086 | * qbar(n-1) rather than qbar(n) in section 6.1(4) equation 71. */ | ||
1087 | 2284 | p->acelpv_ctx.weighted_vector_sumf(p->lsf_avg, p->lsf_avg, p->lsf_q[3], | |
1088 | 0.84, 0.16, LP_FILTER_ORDER); | ||
1089 | 2284 | buf += channel_size; | |
1090 | 2284 | buf_size -= channel_size; | |
1091 | } | ||
1092 | |||
1093 | 2284 | *got_frame_ptr = 1; | |
1094 | |||
1095 | 2284 | return avpkt->size; | |
1096 | } | ||
1097 | |||
1098 | |||
1099 | const FFCodec ff_amrnb_decoder = { | ||
1100 | .p.name = "amrnb", | ||
1101 | .p.long_name = NULL_IF_CONFIG_SMALL("AMR-NB (Adaptive Multi-Rate NarrowBand)"), | ||
1102 | .p.type = AVMEDIA_TYPE_AUDIO, | ||
1103 | .p.id = AV_CODEC_ID_AMR_NB, | ||
1104 | .priv_data_size = sizeof(AMRChannelsContext), | ||
1105 | .init = amrnb_decode_init, | ||
1106 | FF_CODEC_DECODE_CB(amrnb_decode_frame), | ||
1107 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF, | ||
1108 | .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP, | ||
1109 | AV_SAMPLE_FMT_NONE }, | ||
1110 | .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, | ||
1111 | }; | ||
1112 |