2 * AMR narrowband decoder
3 * Copyright (c) 2006-2007 Robert Swain
4 * Copyright (c) 2009 Colin McQuillan
6 * This file is part of FFmpeg.
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.
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.
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
26 * AMR narrowband decoder
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.
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.
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
46 #include "libavutil/channel_layout.h"
47 #include "libavutil/float_dsp.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"
60 #include "amrnbdata.h"
62 #define AMR_BLOCK_SIZE 160 ///< samples per frame
63 #define AMR_SAMPLE_BOUND 32768.0 ///< threshold for synthesis overflow
66 * Scale from constructed speech to [-1,1]
68 * AMR is designed to produce 16-bit PCM samples (3GPP TS 26.090 4.2) but
69 * upscales by two (section 6.2.2).
71 * Fundamentally, this scale is determined by energy_mean through
72 * the fixed vector contribution to the excitation vector.
74 #define AMR_SAMPLE_SCALE (2.0 / 32768.0)
76 /** Prediction factor for 12.2kbit/s mode */
77 #define PRED_FAC_MODE_12k2 0.65
79 #define LSF_R_FAC (8000.0 / 32768.0) ///< LSF residual tables to Hertz
80 #define MIN_LSF_SPACING (50.0488 / 8000.0) ///< Ensures stability of LPC filter
81 #define PITCH_LAG_MIN_MODE_12k2 18 ///< Lower bound on decoded lag search in 12.2kbit/s mode
83 /** Initial energy in dB. Also used for bad frames (unimplemented). */
84 #define MIN_ENERGY -14.0
86 /** Maximum sharpening factor
88 * The specification says 0.8, which should be 13107, but the reference C code
89 * uses 13017 instead. (Amusingly the same applies to SHARP_MAX in g729dec.c.)
91 #define SHARP_MAX 0.79449462890625
93 /** Number of impulse response coefficients used for tilt factor */
94 #define AMR_TILT_RESPONSE 22
95 /** Tilt factor = 1st reflection coefficient * gamma_t */
96 #define AMR_TILT_GAMMA_T 0.8
97 /** Adaptive gain control factor used in post-filter */
98 #define AMR_AGC_ALPHA 0.9
100 typedef struct AMRContext
{
101 AMRNBFrame frame
; ///< decoded AMR parameters (lsf coefficients, codebook indexes, etc)
102 uint8_t bad_frame_indicator
; ///< bad frame ? 1 : 0
103 enum Mode cur_frame_mode
;
105 int16_t prev_lsf_r
[LP_FILTER_ORDER
]; ///< residual LSF vector from previous subframe
106 double lsp
[4][LP_FILTER_ORDER
]; ///< lsp vectors from current frame
107 double prev_lsp_sub4
[LP_FILTER_ORDER
]; ///< lsp vector for the 4th subframe of the previous frame
109 float lsf_q
[4][LP_FILTER_ORDER
]; ///< Interpolated LSF vector for fixed gain smoothing
110 float lsf_avg
[LP_FILTER_ORDER
]; ///< vector of averaged lsf vector
112 float lpc
[4][LP_FILTER_ORDER
]; ///< lpc coefficient vectors for 4 subframes
114 uint8_t pitch_lag_int
; ///< integer part of pitch lag from current subframe
116 float excitation_buf
[PITCH_DELAY_MAX
+ LP_FILTER_ORDER
+ 1 + AMR_SUBFRAME_SIZE
]; ///< current excitation and all necessary excitation history
117 float *excitation
; ///< pointer to the current excitation vector in excitation_buf
119 float pitch_vector
[AMR_SUBFRAME_SIZE
]; ///< adaptive code book (pitch) vector
120 float fixed_vector
[AMR_SUBFRAME_SIZE
]; ///< algebraic codebook (fixed) vector (must be kept zero between frames)
122 float prediction_error
[4]; ///< quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
123 float pitch_gain
[5]; ///< quantified pitch gains for the current and previous four subframes
124 float fixed_gain
[5]; ///< quantified fixed gains for the current and previous four subframes
126 float beta
; ///< previous pitch_gain, bounded by [0.0,SHARP_MAX]
127 uint8_t diff_count
; ///< the number of subframes for which diff has been above 0.65
128 uint8_t hang_count
; ///< the number of subframes since a hangover period started
130 float prev_sparse_fixed_gain
; ///< previous fixed gain; used by anti-sparseness processing to determine "onset"
131 uint8_t prev_ir_filter_nr
; ///< previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
132 uint8_t ir_filter_onset
; ///< flag for impulse response filter strength
134 float postfilter_mem
[10]; ///< previous intermediate values in the formant filter
135 float tilt_mem
; ///< previous input to tilt compensation filter
136 float postfilter_agc
; ///< previous factor used for adaptive gain control
137 float high_pass_mem
[2]; ///< previous intermediate values in the high-pass filter
139 float samples_in
[LP_FILTER_ORDER
+ AMR_SUBFRAME_SIZE
]; ///< floating point samples
141 ACELPFContext acelpf_ctx
; ///< context for filters for ACELP-based codecs
142 ACELPVContext acelpv_ctx
; ///< context for vector operations for ACELP-based codecs
143 CELPFContext celpf_ctx
; ///< context for filters for CELP-based codecs
144 CELPMContext celpm_ctx
; ///< context for fixed point math operations
148 /** Double version of ff_weighted_vector_sumf() */
149 static void weighted_vector_sumd(double *out
, const double *in_a
,
150 const double *in_b
, double weight_coeff_a
,
151 double weight_coeff_b
, int length
)
155 for (i
= 0; i
< length
; i
++)
156 out
[i
] = weight_coeff_a
* in_a
[i
]
157 + weight_coeff_b
* in_b
[i
];
160 static av_cold
int amrnb_decode_init(AVCodecContext
*avctx
)
162 AMRContext
*p
= avctx
->priv_data
;
165 if (avctx
->channels
> 1) {
166 avpriv_report_missing_feature(avctx
, "multi-channel AMR");
167 return AVERROR_PATCHWELCOME
;
171 avctx
->channel_layout
= AV_CH_LAYOUT_MONO
;
172 if (!avctx
->sample_rate
)
173 avctx
->sample_rate
= 8000;
174 avctx
->sample_fmt
= AV_SAMPLE_FMT_FLT
;
176 // p->excitation always points to the same position in p->excitation_buf
177 p
->excitation
= &p
->excitation_buf
[PITCH_DELAY_MAX
+ LP_FILTER_ORDER
+ 1];
179 for (i
= 0; i
< LP_FILTER_ORDER
; i
++) {
180 p
->prev_lsp_sub4
[i
] = lsp_sub4_init
[i
] * 1000 / (float)(1 << 15);
181 p
->lsf_avg
[i
] = p
->lsf_q
[3][i
] = lsp_avg_init
[i
] / (float)(1 << 15);
184 for (i
= 0; i
< 4; i
++)
185 p
->prediction_error
[i
] = MIN_ENERGY
;
187 ff_acelp_filter_init(&p
->acelpf_ctx
);
188 ff_acelp_vectors_init(&p
->acelpv_ctx
);
189 ff_celp_filter_init(&p
->celpf_ctx
);
190 ff_celp_math_init(&p
->celpm_ctx
);
197 * Unpack an RFC4867 speech frame into the AMR frame mode and parameters.
199 * The order of speech bits is specified by 3GPP TS 26.101.
201 * @param p the context
202 * @param buf pointer to the input buffer
203 * @param buf_size size of the input buffer
205 * @return the frame mode
207 static enum Mode
unpack_bitstream(AMRContext
*p
, const uint8_t *buf
,
212 // Decode the first octet.
213 mode
= buf
[0] >> 3 & 0x0F; // frame type
214 p
->bad_frame_indicator
= (buf
[0] & 0x4) != 0x4; // quality bit
216 if (mode
>= N_MODES
|| buf_size
< frame_sizes_nb
[mode
] + 1) {
221 ff_amr_bit_reorder((uint16_t *) &p
->frame
, sizeof(AMRNBFrame
), buf
+ 1,
222 amr_unpacking_bitmaps_per_mode
[mode
]);
228 /// @name AMR pitch LPC coefficient decoding functions
232 * Interpolate the LSF vector (used for fixed gain smoothing).
233 * The interpolation is done over all four subframes even in MODE_12k2.
235 * @param[in] ctx The Context
236 * @param[in,out] lsf_q LSFs in [0,1] for each subframe
237 * @param[in] lsf_new New LSFs in [0,1] for subframe 4
239 static void interpolate_lsf(ACELPVContext
*ctx
, float lsf_q
[4][LP_FILTER_ORDER
], float *lsf_new
)
243 for (i
= 0; i
< 4; i
++)
244 ctx
->weighted_vector_sumf(lsf_q
[i
], lsf_q
[3], lsf_new
,
245 0.25 * (3 - i
), 0.25 * (i
+ 1),
250 * Decode a set of 5 split-matrix quantized lsf indexes into an lsp vector.
252 * @param p the context
253 * @param lsp output LSP vector
254 * @param lsf_no_r LSF vector without the residual vector added
255 * @param lsf_quantizer pointers to LSF dictionary tables
256 * @param quantizer_offset offset in tables
257 * @param sign for the 3 dictionary table
258 * @param update store data for computing the next frame's LSFs
260 static void lsf2lsp_for_mode12k2(AMRContext
*p
, double lsp
[LP_FILTER_ORDER
],
261 const float lsf_no_r
[LP_FILTER_ORDER
],
262 const int16_t *lsf_quantizer
[5],
263 const int quantizer_offset
,
264 const int sign
, const int update
)
266 int16_t lsf_r
[LP_FILTER_ORDER
]; // residual LSF vector
267 float lsf_q
[LP_FILTER_ORDER
]; // quantified LSF vector
270 for (i
= 0; i
< LP_FILTER_ORDER
>> 1; i
++)
271 memcpy(&lsf_r
[i
<< 1], &lsf_quantizer
[i
][quantizer_offset
],
280 memcpy(p
->prev_lsf_r
, lsf_r
, LP_FILTER_ORDER
* sizeof(*lsf_r
));
282 for (i
= 0; i
< LP_FILTER_ORDER
; i
++)
283 lsf_q
[i
] = lsf_r
[i
] * (LSF_R_FAC
/ 8000.0) + lsf_no_r
[i
] * (1.0 / 8000.0);
285 ff_set_min_dist_lsf(lsf_q
, MIN_LSF_SPACING
, LP_FILTER_ORDER
);
288 interpolate_lsf(&p
->acelpv_ctx
, p
->lsf_q
, lsf_q
);
290 ff_acelp_lsf2lspd(lsp
, lsf_q
, LP_FILTER_ORDER
);
294 * Decode a set of 5 split-matrix quantized lsf indexes into 2 lsp vectors.
296 * @param p pointer to the AMRContext
298 static void lsf2lsp_5(AMRContext
*p
)
300 const uint16_t *lsf_param
= p
->frame
.lsf
;
301 float lsf_no_r
[LP_FILTER_ORDER
]; // LSFs without the residual vector
302 const int16_t *lsf_quantizer
[5];
305 lsf_quantizer
[0] = lsf_5_1
[lsf_param
[0]];
306 lsf_quantizer
[1] = lsf_5_2
[lsf_param
[1]];
307 lsf_quantizer
[2] = lsf_5_3
[lsf_param
[2] >> 1];
308 lsf_quantizer
[3] = lsf_5_4
[lsf_param
[3]];
309 lsf_quantizer
[4] = lsf_5_5
[lsf_param
[4]];
311 for (i
= 0; i
< LP_FILTER_ORDER
; i
++)
312 lsf_no_r
[i
] = p
->prev_lsf_r
[i
] * LSF_R_FAC
* PRED_FAC_MODE_12k2
+ lsf_5_mean
[i
];
314 lsf2lsp_for_mode12k2(p
, p
->lsp
[1], lsf_no_r
, lsf_quantizer
, 0, lsf_param
[2] & 1, 0);
315 lsf2lsp_for_mode12k2(p
, p
->lsp
[3], lsf_no_r
, lsf_quantizer
, 2, lsf_param
[2] & 1, 1);
317 // interpolate LSP vectors at subframes 1 and 3
318 weighted_vector_sumd(p
->lsp
[0], p
->prev_lsp_sub4
, p
->lsp
[1], 0.5, 0.5, LP_FILTER_ORDER
);
319 weighted_vector_sumd(p
->lsp
[2], p
->lsp
[1] , p
->lsp
[3], 0.5, 0.5, LP_FILTER_ORDER
);
323 * Decode a set of 3 split-matrix quantized lsf indexes into an lsp vector.
325 * @param p pointer to the AMRContext
327 static void lsf2lsp_3(AMRContext
*p
)
329 const uint16_t *lsf_param
= p
->frame
.lsf
;
330 int16_t lsf_r
[LP_FILTER_ORDER
]; // residual LSF vector
331 float lsf_q
[LP_FILTER_ORDER
]; // quantified LSF vector
332 const int16_t *lsf_quantizer
;
335 lsf_quantizer
= (p
->cur_frame_mode
== MODE_7k95
? lsf_3_1_MODE_7k95
: lsf_3_1
)[lsf_param
[0]];
336 memcpy(lsf_r
, lsf_quantizer
, 3 * sizeof(*lsf_r
));
338 lsf_quantizer
= lsf_3_2
[lsf_param
[1] << (p
->cur_frame_mode
<= MODE_5k15
)];
339 memcpy(lsf_r
+ 3, lsf_quantizer
, 3 * sizeof(*lsf_r
));
341 lsf_quantizer
= (p
->cur_frame_mode
<= MODE_5k15
? lsf_3_3_MODE_5k15
: lsf_3_3
)[lsf_param
[2]];
342 memcpy(lsf_r
+ 6, lsf_quantizer
, 4 * sizeof(*lsf_r
));
344 // calculate mean-removed LSF vector and add mean
345 for (i
= 0; i
< LP_FILTER_ORDER
; i
++)
346 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);
348 ff_set_min_dist_lsf(lsf_q
, MIN_LSF_SPACING
, LP_FILTER_ORDER
);
350 // store data for computing the next frame's LSFs
351 interpolate_lsf(&p
->acelpv_ctx
, p
->lsf_q
, lsf_q
);
352 memcpy(p
->prev_lsf_r
, lsf_r
, LP_FILTER_ORDER
* sizeof(*lsf_r
));
354 ff_acelp_lsf2lspd(p
->lsp
[3], lsf_q
, LP_FILTER_ORDER
);
356 // interpolate LSP vectors at subframes 1, 2 and 3
357 for (i
= 1; i
<= 3; i
++)
358 for(j
= 0; j
< LP_FILTER_ORDER
; j
++)
359 p
->lsp
[i
-1][j
] = p
->prev_lsp_sub4
[j
] +
360 (p
->lsp
[3][j
] - p
->prev_lsp_sub4
[j
]) * 0.25 * i
;
366 /// @name AMR pitch vector decoding functions
370 * Like ff_decode_pitch_lag(), but with 1/6 resolution
372 static void decode_pitch_lag_1_6(int *lag_int
, int *lag_frac
, int pitch_index
,
373 const int prev_lag_int
, const int subframe
)
375 if (subframe
== 0 || subframe
== 2) {
376 if (pitch_index
< 463) {
377 *lag_int
= (pitch_index
+ 107) * 10923 >> 16;
378 *lag_frac
= pitch_index
- *lag_int
* 6 + 105;
380 *lag_int
= pitch_index
- 368;
384 *lag_int
= ((pitch_index
+ 5) * 10923 >> 16) - 1;
385 *lag_frac
= pitch_index
- *lag_int
* 6 - 3;
386 *lag_int
+= av_clip(prev_lag_int
- 5, PITCH_LAG_MIN_MODE_12k2
,
387 PITCH_DELAY_MAX
- 9);
391 static void decode_pitch_vector(AMRContext
*p
,
392 const AMRNBSubframe
*amr_subframe
,
395 int pitch_lag_int
, pitch_lag_frac
;
396 enum Mode mode
= p
->cur_frame_mode
;
398 if (p
->cur_frame_mode
== MODE_12k2
) {
399 decode_pitch_lag_1_6(&pitch_lag_int
, &pitch_lag_frac
,
400 amr_subframe
->p_lag
, p
->pitch_lag_int
,
403 ff_decode_pitch_lag(&pitch_lag_int
, &pitch_lag_frac
,
405 p
->pitch_lag_int
, subframe
,
406 mode
!= MODE_4k75
&& mode
!= MODE_5k15
,
407 mode
<= MODE_6k7
? 4 : (mode
== MODE_7k95
? 5 : 6));
409 p
->pitch_lag_int
= pitch_lag_int
; // store previous lag in a uint8_t
411 pitch_lag_frac
<<= (p
->cur_frame_mode
!= MODE_12k2
);
413 pitch_lag_int
+= pitch_lag_frac
> 0;
415 /* Calculate the pitch vector by interpolating the past excitation at the
416 pitch lag using a b60 hamming windowed sinc function. */
417 p
->acelpf_ctx
.acelp_interpolatef(p
->excitation
,
418 p
->excitation
+ 1 - pitch_lag_int
,
420 pitch_lag_frac
+ 6 - 6*(pitch_lag_frac
> 0),
421 10, AMR_SUBFRAME_SIZE
);
423 memcpy(p
->pitch_vector
, p
->excitation
, AMR_SUBFRAME_SIZE
* sizeof(float));
429 /// @name AMR algebraic code book (fixed) vector decoding functions
433 * Decode a 10-bit algebraic codebook index from a 10.2 kbit/s frame.
435 static void decode_10bit_pulse(int code
, int pulse_position
[8],
436 int i1
, int i2
, int i3
)
438 // coded using 7+3 bits with the 3 LSBs being, individually, the LSB of 1 of
439 // the 3 pulses and the upper 7 bits being coded in base 5
440 const uint8_t *positions
= base_five_table
[code
>> 3];
441 pulse_position
[i1
] = (positions
[2] << 1) + ( code
& 1);
442 pulse_position
[i2
] = (positions
[1] << 1) + ((code
>> 1) & 1);
443 pulse_position
[i3
] = (positions
[0] << 1) + ((code
>> 2) & 1);
447 * Decode the algebraic codebook index to pulse positions and signs and
448 * construct the algebraic codebook vector for MODE_10k2.
450 * @param fixed_index positions of the eight pulses
451 * @param fixed_sparse pointer to the algebraic codebook vector
453 static void decode_8_pulses_31bits(const int16_t *fixed_index
,
454 AMRFixed
*fixed_sparse
)
456 int pulse_position
[8];
459 decode_10bit_pulse(fixed_index
[4], pulse_position
, 0, 4, 1);
460 decode_10bit_pulse(fixed_index
[5], pulse_position
, 2, 6, 5);
462 // coded using 5+2 bits with the 2 LSBs being, individually, the LSB of 1 of
463 // the 2 pulses and the upper 5 bits being coded in base 5
464 temp
= ((fixed_index
[6] >> 2) * 25 + 12) >> 5;
465 pulse_position
[3] = temp
% 5;
466 pulse_position
[7] = temp
/ 5;
467 if (pulse_position
[7] & 1)
468 pulse_position
[3] = 4 - pulse_position
[3];
469 pulse_position
[3] = (pulse_position
[3] << 1) + ( fixed_index
[6] & 1);
470 pulse_position
[7] = (pulse_position
[7] << 1) + ((fixed_index
[6] >> 1) & 1);
473 for (i
= 0; i
< 4; i
++) {
474 const int pos1
= (pulse_position
[i
] << 2) + i
;
475 const int pos2
= (pulse_position
[i
+ 4] << 2) + i
;
476 const float sign
= fixed_index
[i
] ? -1.0 : 1.0;
477 fixed_sparse
->x
[i
] = pos1
;
478 fixed_sparse
->x
[i
+ 4] = pos2
;
479 fixed_sparse
->y
[i
] = sign
;
480 fixed_sparse
->y
[i
+ 4] = pos2
< pos1
? -sign
: sign
;
485 * Decode the algebraic codebook index to pulse positions and signs,
486 * then construct the algebraic codebook vector.
488 * nb of pulses | bits encoding pulses
489 * For MODE_4k75 or MODE_5k15, 2 | 1-3, 4-6, 7
490 * MODE_5k9, 2 | 1, 2-4, 5-6, 7-9
491 * MODE_6k7, 3 | 1-3, 4, 5-7, 8, 9-11
492 * MODE_7k4 or MODE_7k95, 4 | 1-3, 4-6, 7-9, 10, 11-13
494 * @param fixed_sparse pointer to the algebraic codebook vector
495 * @param pulses algebraic codebook indexes
496 * @param mode mode of the current frame
497 * @param subframe current subframe number
499 static void decode_fixed_sparse(AMRFixed
*fixed_sparse
, const uint16_t *pulses
,
500 const enum Mode mode
, const int subframe
)
502 av_assert1(MODE_4k75
<= (signed)mode
&& mode
<= MODE_12k2
);
504 if (mode
== MODE_12k2
) {
505 ff_decode_10_pulses_35bits(pulses
, fixed_sparse
, gray_decode
, 5, 3);
506 } else if (mode
== MODE_10k2
) {
507 decode_8_pulses_31bits(pulses
, fixed_sparse
);
509 int *pulse_position
= fixed_sparse
->x
;
511 const int fixed_index
= pulses
[0];
513 if (mode
<= MODE_5k15
) {
514 pulse_subset
= ((fixed_index
>> 3) & 8) + (subframe
<< 1);
515 pulse_position
[0] = ( fixed_index
& 7) * 5 + track_position
[pulse_subset
];
516 pulse_position
[1] = ((fixed_index
>> 3) & 7) * 5 + track_position
[pulse_subset
+ 1];
518 } else if (mode
== MODE_5k9
) {
519 pulse_subset
= ((fixed_index
& 1) << 1) + 1;
520 pulse_position
[0] = ((fixed_index
>> 1) & 7) * 5 + pulse_subset
;
521 pulse_subset
= (fixed_index
>> 4) & 3;
522 pulse_position
[1] = ((fixed_index
>> 6) & 7) * 5 + pulse_subset
+ (pulse_subset
== 3 ? 1 : 0);
523 fixed_sparse
->n
= pulse_position
[0] == pulse_position
[1] ? 1 : 2;
524 } else if (mode
== MODE_6k7
) {
525 pulse_position
[0] = (fixed_index
& 7) * 5;
526 pulse_subset
= (fixed_index
>> 2) & 2;
527 pulse_position
[1] = ((fixed_index
>> 4) & 7) * 5 + pulse_subset
+ 1;
528 pulse_subset
= (fixed_index
>> 6) & 2;
529 pulse_position
[2] = ((fixed_index
>> 8) & 7) * 5 + pulse_subset
+ 2;
531 } else { // mode <= MODE_7k95
532 pulse_position
[0] = gray_decode
[ fixed_index
& 7];
533 pulse_position
[1] = gray_decode
[(fixed_index
>> 3) & 7] + 1;
534 pulse_position
[2] = gray_decode
[(fixed_index
>> 6) & 7] + 2;
535 pulse_subset
= (fixed_index
>> 9) & 1;
536 pulse_position
[3] = gray_decode
[(fixed_index
>> 10) & 7] + pulse_subset
+ 3;
539 for (i
= 0; i
< fixed_sparse
->n
; i
++)
540 fixed_sparse
->y
[i
] = (pulses
[1] >> i
) & 1 ? 1.0 : -1.0;
545 * Apply pitch lag to obtain the sharpened fixed vector (section 6.1.2)
547 * @param p the context
548 * @param subframe unpacked amr subframe
549 * @param mode mode of the current frame
550 * @param fixed_sparse sparse respresentation of the fixed vector
552 static void pitch_sharpening(AMRContext
*p
, int subframe
, enum Mode mode
,
553 AMRFixed
*fixed_sparse
)
555 // The spec suggests the current pitch gain is always used, but in other
556 // modes the pitch and codebook gains are joinly quantized (sec 5.8.2)
557 // so the codebook gain cannot depend on the quantized pitch gain.
558 if (mode
== MODE_12k2
)
559 p
->beta
= FFMIN(p
->pitch_gain
[4], 1.0);
561 fixed_sparse
->pitch_lag
= p
->pitch_lag_int
;
562 fixed_sparse
->pitch_fac
= p
->beta
;
564 // Save pitch sharpening factor for the next subframe
565 // MODE_4k75 only updates on the 2nd and 4th subframes - this follows from
566 // the fact that the gains for two subframes are jointly quantized.
567 if (mode
!= MODE_4k75
|| subframe
& 1)
568 p
->beta
= av_clipf(p
->pitch_gain
[4], 0.0, SHARP_MAX
);
573 /// @name AMR gain decoding functions
577 * fixed gain smoothing
578 * Note that where the spec specifies the "spectrum in the q domain"
579 * in section 6.1.4, in fact frequencies should be used.
581 * @param p the context
582 * @param lsf LSFs for the current subframe, in the range [0,1]
583 * @param lsf_avg averaged LSFs
584 * @param mode mode of the current frame
586 * @return fixed gain smoothed
588 static float fixed_gain_smooth(AMRContext
*p
, const float *lsf
,
589 const float *lsf_avg
, const enum Mode mode
)
594 for (i
= 0; i
< LP_FILTER_ORDER
; i
++)
595 diff
+= fabs(lsf_avg
[i
] - lsf
[i
]) / lsf_avg
[i
];
597 // If diff is large for ten subframes, disable smoothing for a 40-subframe
603 if (p
->diff_count
> 10) {
605 p
->diff_count
--; // don't let diff_count overflow
608 if (p
->hang_count
< 40) {
610 } else if (mode
< MODE_7k4
|| mode
== MODE_10k2
) {
611 const float smoothing_factor
= av_clipf(4.0 * diff
- 1.6, 0.0, 1.0);
612 const float fixed_gain_mean
= (p
->fixed_gain
[0] + p
->fixed_gain
[1] +
613 p
->fixed_gain
[2] + p
->fixed_gain
[3] +
614 p
->fixed_gain
[4]) * 0.2;
615 return smoothing_factor
* p
->fixed_gain
[4] +
616 (1.0 - smoothing_factor
) * fixed_gain_mean
;
618 return p
->fixed_gain
[4];
622 * Decode pitch gain and fixed gain factor (part of section 6.1.3).
624 * @param p the context
625 * @param amr_subframe unpacked amr subframe
626 * @param mode mode of the current frame
627 * @param subframe current subframe number
628 * @param fixed_gain_factor decoded gain correction factor
630 static void decode_gains(AMRContext
*p
, const AMRNBSubframe
*amr_subframe
,
631 const enum Mode mode
, const int subframe
,
632 float *fixed_gain_factor
)
634 if (mode
== MODE_12k2
|| mode
== MODE_7k95
) {
635 p
->pitch_gain
[4] = qua_gain_pit
[amr_subframe
->p_gain
]
637 *fixed_gain_factor
= qua_gain_code
[amr_subframe
->fixed_gain
]
640 const uint16_t *gains
;
642 if (mode
>= MODE_6k7
) {
643 gains
= gains_high
[amr_subframe
->p_gain
];
644 } else if (mode
>= MODE_5k15
) {
645 gains
= gains_low
[amr_subframe
->p_gain
];
647 // gain index is only coded in subframes 0,2 for MODE_4k75
648 gains
= gains_MODE_4k75
[(p
->frame
.subframe
[subframe
& 2].p_gain
<< 1) + (subframe
& 1)];
651 p
->pitch_gain
[4] = gains
[0] * (1.0 / 16384.0);
652 *fixed_gain_factor
= gains
[1] * (1.0 / 4096.0);
659 /// @name AMR preprocessing functions
663 * Circularly convolve a sparse fixed vector with a phase dispersion impulse
664 * response filter (D.6.2 of G.729 and 6.1.5 of AMR).
666 * @param out vector with filter applied
667 * @param in source vector
668 * @param filter phase filter coefficients
670 * out[n] = sum(i,0,len-1){ in[i] * filter[(len + n - i)%len] }
672 static void apply_ir_filter(float *out
, const AMRFixed
*in
,
675 float filter1
[AMR_SUBFRAME_SIZE
], ///< filters at pitch lag*1 and *2
676 filter2
[AMR_SUBFRAME_SIZE
];
677 int lag
= in
->pitch_lag
;
678 float fac
= in
->pitch_fac
;
681 if (lag
< AMR_SUBFRAME_SIZE
) {
682 ff_celp_circ_addf(filter1
, filter
, filter
, lag
, fac
,
685 if (lag
< AMR_SUBFRAME_SIZE
>> 1)
686 ff_celp_circ_addf(filter2
, filter
, filter1
, lag
, fac
,
690 memset(out
, 0, sizeof(float) * AMR_SUBFRAME_SIZE
);
691 for (i
= 0; i
< in
->n
; i
++) {
694 const float *filterp
;
696 if (x
>= AMR_SUBFRAME_SIZE
- lag
) {
698 } else if (x
>= AMR_SUBFRAME_SIZE
- (lag
<< 1)) {
703 ff_celp_circ_addf(out
, out
, filterp
, x
, y
, AMR_SUBFRAME_SIZE
);
708 * Reduce fixed vector sparseness by smoothing with one of three IR filters.
709 * Also know as "adaptive phase dispersion".
711 * This implements 3GPP TS 26.090 section 6.1(5).
713 * @param p the context
714 * @param fixed_sparse algebraic codebook vector
715 * @param fixed_vector unfiltered fixed vector
716 * @param fixed_gain smoothed gain
717 * @param out space for modified vector if necessary
719 static const float *anti_sparseness(AMRContext
*p
, AMRFixed
*fixed_sparse
,
720 const float *fixed_vector
,
721 float fixed_gain
, float *out
)
725 if (p
->pitch_gain
[4] < 0.6) {
726 ir_filter_nr
= 0; // strong filtering
727 } else if (p
->pitch_gain
[4] < 0.9) {
728 ir_filter_nr
= 1; // medium filtering
730 ir_filter_nr
= 2; // no filtering
733 if (fixed_gain
> 2.0 * p
->prev_sparse_fixed_gain
) {
734 p
->ir_filter_onset
= 2;
735 } else if (p
->ir_filter_onset
)
736 p
->ir_filter_onset
--;
738 if (!p
->ir_filter_onset
) {
741 for (i
= 0; i
< 5; i
++)
742 if (p
->pitch_gain
[i
] < 0.6)
747 if (ir_filter_nr
> p
->prev_ir_filter_nr
+ 1)
749 } else if (ir_filter_nr
< 2)
752 // Disable filtering for very low level of fixed_gain.
753 // Note this step is not specified in the technical description but is in
754 // the reference source in the function Ph_disp.
755 if (fixed_gain
< 5.0)
758 if (p
->cur_frame_mode
!= MODE_7k4
&& p
->cur_frame_mode
< MODE_10k2
759 && ir_filter_nr
< 2) {
760 apply_ir_filter(out
, fixed_sparse
,
761 (p
->cur_frame_mode
== MODE_7k95
?
762 ir_filters_lookup_MODE_7k95
:
763 ir_filters_lookup
)[ir_filter_nr
]);
767 // update ir filter strength history
768 p
->prev_ir_filter_nr
= ir_filter_nr
;
769 p
->prev_sparse_fixed_gain
= fixed_gain
;
777 /// @name AMR synthesis functions
781 * Conduct 10th order linear predictive coding synthesis.
783 * @param p pointer to the AMRContext
784 * @param lpc pointer to the LPC coefficients
785 * @param fixed_gain fixed codebook gain for synthesis
786 * @param fixed_vector algebraic codebook vector
787 * @param samples pointer to the output speech samples
788 * @param overflow 16-bit overflow flag
790 static int synthesis(AMRContext
*p
, float *lpc
,
791 float fixed_gain
, const float *fixed_vector
,
792 float *samples
, uint8_t overflow
)
795 float excitation
[AMR_SUBFRAME_SIZE
];
797 // if an overflow has been detected, the pitch vector is scaled down by a
800 for (i
= 0; i
< AMR_SUBFRAME_SIZE
; i
++)
801 p
->pitch_vector
[i
] *= 0.25;
803 p
->acelpv_ctx
.weighted_vector_sumf(excitation
, p
->pitch_vector
, fixed_vector
,
804 p
->pitch_gain
[4], fixed_gain
, AMR_SUBFRAME_SIZE
);
806 // emphasize pitch vector contribution
807 if (p
->pitch_gain
[4] > 0.5 && !overflow
) {
808 float energy
= p
->celpm_ctx
.dot_productf(excitation
, excitation
,
812 (p
->cur_frame_mode
== MODE_12k2
?
813 0.25 * FFMIN(p
->pitch_gain
[4], 1.0) :
814 0.5 * FFMIN(p
->pitch_gain
[4], SHARP_MAX
));
816 for (i
= 0; i
< AMR_SUBFRAME_SIZE
; i
++)
817 excitation
[i
] += pitch_factor
* p
->pitch_vector
[i
];
819 ff_scale_vector_to_given_sum_of_squares(excitation
, excitation
, energy
,
823 p
->celpf_ctx
.celp_lp_synthesis_filterf(samples
, lpc
, excitation
,
828 for (i
= 0; i
< AMR_SUBFRAME_SIZE
; i
++)
829 if (fabsf(samples
[i
]) > AMR_SAMPLE_BOUND
) {
839 /// @name AMR update functions
843 * Update buffers and history at the end of decoding a subframe.
845 * @param p pointer to the AMRContext
847 static void update_state(AMRContext
*p
)
849 memcpy(p
->prev_lsp_sub4
, p
->lsp
[3], LP_FILTER_ORDER
* sizeof(p
->lsp
[3][0]));
851 memmove(&p
->excitation_buf
[0], &p
->excitation_buf
[AMR_SUBFRAME_SIZE
],
852 (PITCH_DELAY_MAX
+ LP_FILTER_ORDER
+ 1) * sizeof(float));
854 memmove(&p
->pitch_gain
[0], &p
->pitch_gain
[1], 4 * sizeof(float));
855 memmove(&p
->fixed_gain
[0], &p
->fixed_gain
[1], 4 * sizeof(float));
857 memmove(&p
->samples_in
[0], &p
->samples_in
[AMR_SUBFRAME_SIZE
],
858 LP_FILTER_ORDER
* sizeof(float));
864 /// @name AMR Postprocessing functions
868 * Get the tilt factor of a formant filter from its transfer function
870 * @param p The Context
871 * @param lpc_n LP_FILTER_ORDER coefficients of the numerator
872 * @param lpc_d LP_FILTER_ORDER coefficients of the denominator
874 static float tilt_factor(AMRContext
*p
, float *lpc_n
, float *lpc_d
)
876 float rh0
, rh1
; // autocorrelation at lag 0 and 1
878 // LP_FILTER_ORDER prior zeros are needed for ff_celp_lp_synthesis_filterf
879 float impulse_buffer
[LP_FILTER_ORDER
+ AMR_TILT_RESPONSE
] = { 0 };
880 float *hf
= impulse_buffer
+ LP_FILTER_ORDER
; // start of impulse response
883 memcpy(hf
+ 1, lpc_n
, sizeof(float) * LP_FILTER_ORDER
);
884 p
->celpf_ctx
.celp_lp_synthesis_filterf(hf
, lpc_d
, hf
,
888 rh0
= p
->celpm_ctx
.dot_productf(hf
, hf
, AMR_TILT_RESPONSE
);
889 rh1
= p
->celpm_ctx
.dot_productf(hf
, hf
+ 1, AMR_TILT_RESPONSE
- 1);
891 // The spec only specifies this check for 12.2 and 10.2 kbit/s
892 // modes. But in the ref source the tilt is always non-negative.
893 return rh1
>= 0.0 ? rh1
/ rh0
* AMR_TILT_GAMMA_T
: 0.0;
897 * Perform adaptive post-filtering to enhance the quality of the speech.
900 * @param p pointer to the AMRContext
901 * @param lpc interpolated LP coefficients for this subframe
902 * @param buf_out output of the filter
904 static void postfilter(AMRContext
*p
, float *lpc
, float *buf_out
)
907 float *samples
= p
->samples_in
+ LP_FILTER_ORDER
; // Start of input
909 float speech_gain
= p
->celpm_ctx
.dot_productf(samples
, samples
,
912 float pole_out
[AMR_SUBFRAME_SIZE
+ LP_FILTER_ORDER
]; // Output of pole filter
913 const float *gamma_n
, *gamma_d
; // Formant filter factor table
914 float lpc_n
[LP_FILTER_ORDER
], lpc_d
[LP_FILTER_ORDER
]; // Transfer function coefficients
916 if (p
->cur_frame_mode
== MODE_12k2
|| p
->cur_frame_mode
== MODE_10k2
) {
917 gamma_n
= ff_pow_0_7
;
918 gamma_d
= ff_pow_0_75
;
920 gamma_n
= ff_pow_0_55
;
921 gamma_d
= ff_pow_0_7
;
924 for (i
= 0; i
< LP_FILTER_ORDER
; i
++) {
925 lpc_n
[i
] = lpc
[i
] * gamma_n
[i
];
926 lpc_d
[i
] = lpc
[i
] * gamma_d
[i
];
929 memcpy(pole_out
, p
->postfilter_mem
, sizeof(float) * LP_FILTER_ORDER
);
930 p
->celpf_ctx
.celp_lp_synthesis_filterf(pole_out
+ LP_FILTER_ORDER
, lpc_d
, samples
,
931 AMR_SUBFRAME_SIZE
, LP_FILTER_ORDER
);
932 memcpy(p
->postfilter_mem
, pole_out
+ AMR_SUBFRAME_SIZE
,
933 sizeof(float) * LP_FILTER_ORDER
);
935 p
->celpf_ctx
.celp_lp_zero_synthesis_filterf(buf_out
, lpc_n
,
936 pole_out
+ LP_FILTER_ORDER
,
937 AMR_SUBFRAME_SIZE
, LP_FILTER_ORDER
);
939 ff_tilt_compensation(&p
->tilt_mem
, tilt_factor(p
, lpc_n
, lpc_d
), buf_out
,
942 ff_adaptive_gain_control(buf_out
, buf_out
, speech_gain
, AMR_SUBFRAME_SIZE
,
943 AMR_AGC_ALPHA
, &p
->postfilter_agc
);
948 static int amrnb_decode_frame(AVCodecContext
*avctx
, void *data
,
949 int *got_frame_ptr
, AVPacket
*avpkt
)
952 AMRContext
*p
= avctx
->priv_data
; // pointer to private data
953 AVFrame
*frame
= data
;
954 const uint8_t *buf
= avpkt
->data
;
955 int buf_size
= avpkt
->size
;
956 float *buf_out
; // pointer to the output data buffer
957 int i
, subframe
, ret
;
958 float fixed_gain_factor
;
959 AMRFixed fixed_sparse
= {0}; // fixed vector up to anti-sparseness processing
960 float spare_vector
[AMR_SUBFRAME_SIZE
]; // extra stack space to hold result from anti-sparseness processing
961 float synth_fixed_gain
; // the fixed gain that synthesis should use
962 const float *synth_fixed_vector
; // pointer to the fixed vector that synthesis should use
964 /* get output buffer */
965 frame
->nb_samples
= AMR_BLOCK_SIZE
;
966 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
968 buf_out
= (float *)frame
->data
[0];
970 p
->cur_frame_mode
= unpack_bitstream(p
, buf
, buf_size
);
971 if (p
->cur_frame_mode
== NO_DATA
) {
972 av_log(avctx
, AV_LOG_ERROR
, "Corrupt bitstream\n");
973 return AVERROR_INVALIDDATA
;
975 if (p
->cur_frame_mode
== MODE_DTX
) {
976 avpriv_report_missing_feature(avctx
, "dtx mode");
977 av_log(avctx
, AV_LOG_INFO
, "Note: libopencore_amrnb supports dtx\n");
978 return AVERROR_PATCHWELCOME
;
981 if (p
->cur_frame_mode
== MODE_12k2
) {
986 for (i
= 0; i
< 4; i
++)
987 ff_acelp_lspd2lpc(p
->lsp
[i
], p
->lpc
[i
], 5);
989 for (subframe
= 0; subframe
< 4; subframe
++) {
990 const AMRNBSubframe
*amr_subframe
= &p
->frame
.subframe
[subframe
];
992 decode_pitch_vector(p
, amr_subframe
, subframe
);
994 decode_fixed_sparse(&fixed_sparse
, amr_subframe
->pulses
,
995 p
->cur_frame_mode
, subframe
);
997 // The fixed gain (section 6.1.3) depends on the fixed vector
998 // (section 6.1.2), but the fixed vector calculation uses
999 // pitch sharpening based on the on the pitch gain (section 6.1.3).
1000 // So the correct order is: pitch gain, pitch sharpening, fixed gain.
1001 decode_gains(p
, amr_subframe
, p
->cur_frame_mode
, subframe
,
1002 &fixed_gain_factor
);
1004 pitch_sharpening(p
, subframe
, p
->cur_frame_mode
, &fixed_sparse
);
1006 if (fixed_sparse
.pitch_lag
== 0) {
1007 av_log(avctx
, AV_LOG_ERROR
, "The file is corrupted, pitch_lag = 0 is not allowed\n");
1008 return AVERROR_INVALIDDATA
;
1010 ff_set_fixed_vector(p
->fixed_vector
, &fixed_sparse
, 1.0,
1014 ff_amr_set_fixed_gain(fixed_gain_factor
,
1015 p
->celpm_ctx
.dot_productf(p
->fixed_vector
,
1017 AMR_SUBFRAME_SIZE
) /
1019 p
->prediction_error
,
1020 energy_mean
[p
->cur_frame_mode
], energy_pred_fac
);
1022 // The excitation feedback is calculated without any processing such
1023 // as fixed gain smoothing. This isn't mentioned in the specification.
1024 for (i
= 0; i
< AMR_SUBFRAME_SIZE
; i
++)
1025 p
->excitation
[i
] *= p
->pitch_gain
[4];
1026 ff_set_fixed_vector(p
->excitation
, &fixed_sparse
, p
->fixed_gain
[4],
1029 // In the ref decoder, excitation is stored with no fractional bits.
1030 // This step prevents buzz in silent periods. The ref encoder can
1031 // emit long sequences with pitch factor greater than one. This
1032 // creates unwanted feedback if the excitation vector is nonzero.
1033 // (e.g. test sequence T19_795.COD in 3GPP TS 26.074)
1034 for (i
= 0; i
< AMR_SUBFRAME_SIZE
; i
++)
1035 p
->excitation
[i
] = truncf(p
->excitation
[i
]);
1037 // Smooth fixed gain.
1038 // The specification is ambiguous, but in the reference source, the
1039 // smoothed value is NOT fed back into later fixed gain smoothing.
1040 synth_fixed_gain
= fixed_gain_smooth(p
, p
->lsf_q
[subframe
],
1041 p
->lsf_avg
, p
->cur_frame_mode
);
1043 synth_fixed_vector
= anti_sparseness(p
, &fixed_sparse
, p
->fixed_vector
,
1044 synth_fixed_gain
, spare_vector
);
1046 if (synthesis(p
, p
->lpc
[subframe
], synth_fixed_gain
,
1047 synth_fixed_vector
, &p
->samples_in
[LP_FILTER_ORDER
], 0))
1048 // overflow detected -> rerun synthesis scaling pitch vector down
1049 // by a factor of 4, skipping pitch vector contribution emphasis
1050 // and adaptive gain control
1051 synthesis(p
, p
->lpc
[subframe
], synth_fixed_gain
,
1052 synth_fixed_vector
, &p
->samples_in
[LP_FILTER_ORDER
], 1);
1054 postfilter(p
, p
->lpc
[subframe
], buf_out
+ subframe
* AMR_SUBFRAME_SIZE
);
1056 // update buffers and history
1057 ff_clear_fixed_vector(p
->fixed_vector
, &fixed_sparse
, AMR_SUBFRAME_SIZE
);
1061 p
->acelpf_ctx
.acelp_apply_order_2_transfer_function(buf_out
,
1062 buf_out
, highpass_zeros
,
1064 highpass_gain
* AMR_SAMPLE_SCALE
,
1065 p
->high_pass_mem
, AMR_BLOCK_SIZE
);
1067 /* Update averaged lsf vector (used for fixed gain smoothing).
1069 * Note that lsf_avg should not incorporate the current frame's LSFs
1070 * for fixed_gain_smooth.
1071 * The specification has an incorrect formula: the reference decoder uses
1072 * qbar(n-1) rather than qbar(n) in section 6.1(4) equation 71. */
1073 p
->acelpv_ctx
.weighted_vector_sumf(p
->lsf_avg
, p
->lsf_avg
, p
->lsf_q
[3],
1074 0.84, 0.16, LP_FILTER_ORDER
);
1078 /* return the amount of bytes consumed if everything was OK */
1079 return frame_sizes_nb
[p
->cur_frame_mode
] + 1; // +7 for rounding and +8 for TOC
1083 AVCodec ff_amrnb_decoder
= {
1085 .long_name
= NULL_IF_CONFIG_SMALL("AMR-NB (Adaptive Multi-Rate NarrowBand)"),
1086 .type
= AVMEDIA_TYPE_AUDIO
,
1087 .id
= AV_CODEC_ID_AMR_NB
,
1088 .priv_data_size
= sizeof(AMRContext
),
1089 .init
= amrnb_decode_init
,
1090 .decode
= amrnb_decode_frame
,
1091 .capabilities
= CODEC_CAP_DR1
,
1092 .sample_fmts
= (const enum AVSampleFormat
[]){ AV_SAMPLE_FMT_FLT
,
1093 AV_SAMPLE_FMT_NONE
},