LCOV - code coverage report
Current view: top level - src/libavcodec - amrnbdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 362 380 95.3 %
Date: 2017-08-17 10:06:07 Functions: 22 22 100.0 %

          Line data    Source code
       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 "internal.h"
      59             : 
      60             : #include "amrnbdata.h"
      61             : 
      62             : #define AMR_BLOCK_SIZE              160   ///< samples per frame
      63             : #define AMR_SAMPLE_BOUND        32768.0   ///< threshold for synthesis overflow
      64             : 
      65             : /**
      66             :  * Scale from constructed speech to [-1,1]
      67             :  *
      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).
      70             :  *
      71             :  * Fundamentally, this scale is determined by energy_mean through
      72             :  * the fixed vector contribution to the excitation vector.
      73             :  */
      74             : #define AMR_SAMPLE_SCALE  (2.0 / 32768.0)
      75             : 
      76             : /** Prediction factor for 12.2kbit/s mode */
      77             : #define PRED_FAC_MODE_12k2             0.65
      78             : 
      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
      82             : 
      83             : /** Initial energy in dB. Also used for bad frames (unimplemented). */
      84             : #define MIN_ENERGY -14.0
      85             : 
      86             : /** Maximum sharpening factor
      87             :  *
      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.)
      90             :  */
      91             : #define SHARP_MAX 0.79449462890625
      92             : 
      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
      99             : 
     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;
     104             : 
     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
     108             : 
     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
     111             : 
     112             :     float           lpc[4][LP_FILTER_ORDER]; ///< lpc coefficient vectors for 4 subframes
     113             : 
     114             :     uint8_t                   pitch_lag_int; ///< integer part of pitch lag from current subframe
     115             : 
     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
     118             : 
     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)
     121             : 
     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
     125             : 
     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
     129             : 
     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
     133             : 
     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
     138             : 
     139             :     float samples_in[LP_FILTER_ORDER + AMR_SUBFRAME_SIZE]; ///< floating point samples
     140             : 
     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
     145             : 
     146             : } AMRContext;
     147             : 
     148             : /** Double version of ff_weighted_vector_sumf() */
     149         568 : 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)
     152             : {
     153             :     int i;
     154             : 
     155        6248 :     for (i = 0; i < length; i++)
     156       17040 :         out[i] = weight_coeff_a * in_a[i]
     157       11360 :                + weight_coeff_b * in_b[i];
     158         568 : }
     159             : 
     160          16 : static av_cold int amrnb_decode_init(AVCodecContext *avctx)
     161             : {
     162          16 :     AMRContext *p = avctx->priv_data;
     163             :     int i;
     164             : 
     165          16 :     if (avctx->channels > 1) {
     166           0 :         avpriv_report_missing_feature(avctx, "multi-channel AMR");
     167           0 :         return AVERROR_PATCHWELCOME;
     168             :     }
     169             : 
     170          16 :     avctx->channels       = 1;
     171          16 :     avctx->channel_layout = AV_CH_LAYOUT_MONO;
     172          16 :     if (!avctx->sample_rate)
     173           0 :         avctx->sample_rate = 8000;
     174          16 :     avctx->sample_fmt     = AV_SAMPLE_FMT_FLT;
     175             : 
     176             :     // p->excitation always points to the same position in p->excitation_buf
     177          16 :     p->excitation = &p->excitation_buf[PITCH_DELAY_MAX + LP_FILTER_ORDER + 1];
     178             : 
     179         176 :     for (i = 0; i < LP_FILTER_ORDER; i++) {
     180         160 :         p->prev_lsp_sub4[i] =    lsp_sub4_init[i] * 1000 / (float)(1 << 15);
     181         160 :         p->lsf_avg[i] = p->lsf_q[3][i] = lsp_avg_init[i] / (float)(1 << 15);
     182             :     }
     183             : 
     184          80 :     for (i = 0; i < 4; i++)
     185          64 :         p->prediction_error[i] = MIN_ENERGY;
     186             : 
     187          16 :     ff_acelp_filter_init(&p->acelpf_ctx);
     188          16 :     ff_acelp_vectors_init(&p->acelpv_ctx);
     189          16 :     ff_celp_filter_init(&p->celpf_ctx);
     190          16 :     ff_celp_math_init(&p->celpm_ctx);
     191             : 
     192          16 :     return 0;
     193             : }
     194             : 
     195             : 
     196             : /**
     197             :  * Unpack an RFC4867 speech frame into the AMR frame mode and parameters.
     198             :  *
     199             :  * The order of speech bits is specified by 3GPP TS 26.101.
     200             :  *
     201             :  * @param p the context
     202             :  * @param buf               pointer to the input buffer
     203             :  * @param buf_size          size of the input buffer
     204             :  *
     205             :  * @return the frame mode
     206             :  */
     207        2272 : static enum Mode unpack_bitstream(AMRContext *p, const uint8_t *buf,
     208             :                                   int buf_size)
     209             : {
     210             :     enum Mode mode;
     211             : 
     212             :     // Decode the first octet.
     213        2272 :     mode = buf[0] >> 3 & 0x0F;                      // frame type
     214        2272 :     p->bad_frame_indicator = (buf[0] & 0x4) != 0x4; // quality bit
     215             : 
     216        2272 :     if (mode >= N_MODES || buf_size < frame_sizes_nb[mode] + 1) {
     217           0 :         return NO_DATA;
     218             :     }
     219             : 
     220        2272 :     if (mode < MODE_DTX)
     221        2272 :         ff_amr_bit_reorder((uint16_t *) &p->frame, sizeof(AMRNBFrame), buf + 1,
     222        2272 :                            amr_unpacking_bitmaps_per_mode[mode]);
     223             : 
     224        2272 :     return mode;
     225             : }
     226             : 
     227             : 
     228             : /// @name AMR pitch LPC coefficient decoding functions
     229             : /// @{
     230             : 
     231             : /**
     232             :  * Interpolate the LSF vector (used for fixed gain smoothing).
     233             :  * The interpolation is done over all four subframes even in MODE_12k2.
     234             :  *
     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
     238             :  */
     239        2272 : static void interpolate_lsf(ACELPVContext *ctx, float lsf_q[4][LP_FILTER_ORDER], float *lsf_new)
     240             : {
     241             :     int i;
     242             : 
     243       11360 :     for (i = 0; i < 4; i++)
     244       27264 :         ctx->weighted_vector_sumf(lsf_q[i], lsf_q[3], lsf_new,
     245       18176 :                                 0.25 * (3 - i), 0.25 * (i + 1),
     246             :                                 LP_FILTER_ORDER);
     247        2272 : }
     248             : 
     249             : /**
     250             :  * Decode a set of 5 split-matrix quantized lsf indexes into an lsp vector.
     251             :  *
     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
     259             :  */
     260         568 : 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)
     265             : {
     266             :     int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector
     267             :     float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector
     268             :     int i;
     269             : 
     270        3408 :     for (i = 0; i < LP_FILTER_ORDER >> 1; i++)
     271        2840 :         memcpy(&lsf_r[i << 1], &lsf_quantizer[i][quantizer_offset],
     272             :                2 * sizeof(*lsf_r));
     273             : 
     274         568 :     if (sign) {
     275         266 :         lsf_r[4] *= -1;
     276         266 :         lsf_r[5] *= -1;
     277             :     }
     278             : 
     279         568 :     if (update)
     280         284 :         memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r));
     281             : 
     282        6248 :     for (i = 0; i < LP_FILTER_ORDER; i++)
     283        5680 :         lsf_q[i] = lsf_r[i] * (LSF_R_FAC / 8000.0) + lsf_no_r[i] * (1.0 / 8000.0);
     284             : 
     285         568 :     ff_set_min_dist_lsf(lsf_q, MIN_LSF_SPACING, LP_FILTER_ORDER);
     286             : 
     287         568 :     if (update)
     288         284 :         interpolate_lsf(&p->acelpv_ctx, p->lsf_q, lsf_q);
     289             : 
     290         568 :     ff_acelp_lsf2lspd(lsp, lsf_q, LP_FILTER_ORDER);
     291         568 : }
     292             : 
     293             : /**
     294             :  * Decode a set of 5 split-matrix quantized lsf indexes into 2 lsp vectors.
     295             :  *
     296             :  * @param p                 pointer to the AMRContext
     297             :  */
     298         284 : static void lsf2lsp_5(AMRContext *p)
     299             : {
     300         284 :     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];
     303             :     int i;
     304             : 
     305         284 :     lsf_quantizer[0] = lsf_5_1[lsf_param[0]];
     306         284 :     lsf_quantizer[1] = lsf_5_2[lsf_param[1]];
     307         284 :     lsf_quantizer[2] = lsf_5_3[lsf_param[2] >> 1];
     308         284 :     lsf_quantizer[3] = lsf_5_4[lsf_param[3]];
     309         284 :     lsf_quantizer[4] = lsf_5_5[lsf_param[4]];
     310             : 
     311        3124 :     for (i = 0; i < LP_FILTER_ORDER; i++)
     312        2840 :         lsf_no_r[i] = p->prev_lsf_r[i] * LSF_R_FAC * PRED_FAC_MODE_12k2 + lsf_5_mean[i];
     313             : 
     314         284 :     lsf2lsp_for_mode12k2(p, p->lsp[1], lsf_no_r, lsf_quantizer, 0, lsf_param[2] & 1, 0);
     315         284 :     lsf2lsp_for_mode12k2(p, p->lsp[3], lsf_no_r, lsf_quantizer, 2, lsf_param[2] & 1, 1);
     316             : 
     317             :     // interpolate LSP vectors at subframes 1 and 3
     318         284 :     weighted_vector_sumd(p->lsp[0], p->prev_lsp_sub4, p->lsp[1], 0.5, 0.5, LP_FILTER_ORDER);
     319         284 :     weighted_vector_sumd(p->lsp[2], p->lsp[1]       , p->lsp[3], 0.5, 0.5, LP_FILTER_ORDER);
     320         284 : }
     321             : 
     322             : /**
     323             :  * Decode a set of 3 split-matrix quantized lsf indexes into an lsp vector.
     324             :  *
     325             :  * @param p                 pointer to the AMRContext
     326             :  */
     327        1988 : static void lsf2lsp_3(AMRContext *p)
     328             : {
     329        1988 :     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;
     333             :     int i, j;
     334             : 
     335        1988 :     lsf_quantizer = (p->cur_frame_mode == MODE_7k95 ? lsf_3_1_MODE_7k95 : lsf_3_1)[lsf_param[0]];
     336        1988 :     memcpy(lsf_r, lsf_quantizer, 3 * sizeof(*lsf_r));
     337             : 
     338        1988 :     lsf_quantizer = lsf_3_2[lsf_param[1] << (p->cur_frame_mode <= MODE_5k15)];
     339        1988 :     memcpy(lsf_r + 3, lsf_quantizer, 3 * sizeof(*lsf_r));
     340             : 
     341        1988 :     lsf_quantizer = (p->cur_frame_mode <= MODE_5k15 ? lsf_3_3_MODE_5k15 : lsf_3_3)[lsf_param[2]];
     342        1988 :     memcpy(lsf_r + 6, lsf_quantizer, 4 * sizeof(*lsf_r));
     343             : 
     344             :     // calculate mean-removed LSF vector and add mean
     345       21868 :     for (i = 0; i < LP_FILTER_ORDER; i++)
     346       19880 :         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);
     347             : 
     348        1988 :     ff_set_min_dist_lsf(lsf_q, MIN_LSF_SPACING, LP_FILTER_ORDER);
     349             : 
     350             :     // store data for computing the next frame's LSFs
     351        1988 :     interpolate_lsf(&p->acelpv_ctx, p->lsf_q, lsf_q);
     352        1988 :     memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r));
     353             : 
     354        1988 :     ff_acelp_lsf2lspd(p->lsp[3], lsf_q, LP_FILTER_ORDER);
     355             : 
     356             :     // interpolate LSP vectors at subframes 1, 2 and 3
     357        7952 :     for (i = 1; i <= 3; i++)
     358       65604 :         for(j = 0; j < LP_FILTER_ORDER; j++)
     359      119280 :             p->lsp[i-1][j] = p->prev_lsp_sub4[j] +
     360       59640 :                 (p->lsp[3][j] - p->prev_lsp_sub4[j]) * 0.25 * i;
     361        1988 : }
     362             : 
     363             : /// @}
     364             : 
     365             : 
     366             : /// @name AMR pitch vector decoding functions
     367             : /// @{
     368             : 
     369             : /**
     370             :  * Like ff_decode_pitch_lag(), but with 1/6 resolution
     371             :  */
     372        1136 : 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)
     374             : {
     375        1136 :     if (subframe == 0 || subframe == 2) {
     376        1136 :         if (pitch_index < 463) {
     377         457 :             *lag_int  = (pitch_index + 107) * 10923 >> 16;
     378         457 :             *lag_frac = pitch_index - *lag_int * 6 + 105;
     379             :         } else {
     380         111 :             *lag_int  = pitch_index - 368;
     381         111 :             *lag_frac = 0;
     382             :         }
     383             :     } else {
     384         568 :         *lag_int  = ((pitch_index + 5) * 10923 >> 16) - 1;
     385         568 :         *lag_frac = pitch_index - *lag_int * 6 - 3;
     386         568 :         *lag_int += av_clip(prev_lag_int - 5, PITCH_LAG_MIN_MODE_12k2,
     387             :                             PITCH_DELAY_MAX - 9);
     388             :     }
     389        1136 : }
     390             : 
     391        9088 : static void decode_pitch_vector(AMRContext *p,
     392             :                                 const AMRNBSubframe *amr_subframe,
     393             :                                 const int subframe)
     394             : {
     395             :     int pitch_lag_int, pitch_lag_frac;
     396        9088 :     enum Mode mode = p->cur_frame_mode;
     397             : 
     398        9088 :     if (p->cur_frame_mode == MODE_12k2) {
     399        2272 :         decode_pitch_lag_1_6(&pitch_lag_int, &pitch_lag_frac,
     400        2272 :                              amr_subframe->p_lag, p->pitch_lag_int,
     401             :                              subframe);
     402             :     } else {
     403       27264 :         ff_decode_pitch_lag(&pitch_lag_int, &pitch_lag_frac,
     404        7952 :                             amr_subframe->p_lag,
     405        7952 :                             p->pitch_lag_int, subframe,
     406             :                             mode != MODE_4k75 && mode != MODE_5k15,
     407        3408 :                             mode <= MODE_6k7 ? 4 : (mode == MODE_7k95 ? 5 : 6));
     408        7952 :         pitch_lag_frac *= 2;
     409             :     }
     410             : 
     411        9088 :     p->pitch_lag_int = pitch_lag_int; // store previous lag in a uint8_t
     412             : 
     413        9088 :     pitch_lag_int += pitch_lag_frac > 0;
     414             : 
     415             :     /* Calculate the pitch vector by interpolating the past excitation at the
     416             :        pitch lag using a b60 hamming windowed sinc function.   */
     417       36352 :     p->acelpf_ctx.acelp_interpolatef(p->excitation,
     418       18176 :                           p->excitation + 1 - pitch_lag_int,
     419             :                           ff_b60_sinc, 6,
     420        9088 :                           pitch_lag_frac + 6 - 6*(pitch_lag_frac > 0),
     421             :                           10, AMR_SUBFRAME_SIZE);
     422             : 
     423        9088 :     memcpy(p->pitch_vector, p->excitation, AMR_SUBFRAME_SIZE * sizeof(float));
     424        9088 : }
     425             : 
     426             : /// @}
     427             : 
     428             : 
     429             : /// @name AMR algebraic code book (fixed) vector decoding functions
     430             : /// @{
     431             : 
     432             : /**
     433             :  * Decode a 10-bit algebraic codebook index from a 10.2 kbit/s frame.
     434             :  */
     435        2272 : static void decode_10bit_pulse(int code, int pulse_position[8],
     436             :                                int i1, int i2, int i3)
     437             : {
     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        2272 :     const uint8_t *positions = base_five_table[code >> 3];
     441        2272 :     pulse_position[i1] = (positions[2] << 1) + ( code       & 1);
     442        2272 :     pulse_position[i2] = (positions[1] << 1) + ((code >> 1) & 1);
     443        2272 :     pulse_position[i3] = (positions[0] << 1) + ((code >> 2) & 1);
     444        2272 : }
     445             : 
     446             : /**
     447             :  * Decode the algebraic codebook index to pulse positions and signs and
     448             :  * construct the algebraic codebook vector for MODE_10k2.
     449             :  *
     450             :  * @param fixed_index          positions of the eight pulses
     451             :  * @param fixed_sparse         pointer to the algebraic codebook vector
     452             :  */
     453        1136 : static void decode_8_pulses_31bits(const int16_t *fixed_index,
     454             :                                    AMRFixed *fixed_sparse)
     455             : {
     456             :     int pulse_position[8];
     457             :     int i, temp;
     458             : 
     459        1136 :     decode_10bit_pulse(fixed_index[4], pulse_position, 0, 4, 1);
     460        1136 :     decode_10bit_pulse(fixed_index[5], pulse_position, 2, 6, 5);
     461             : 
     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        1136 :     temp = ((fixed_index[6] >> 2) * 25 + 12) >> 5;
     465        1136 :     pulse_position[3] = temp % 5;
     466        1136 :     pulse_position[7] = temp / 5;
     467        1136 :     if (pulse_position[7] & 1)
     468         477 :         pulse_position[3] = 4 - pulse_position[3];
     469        1136 :     pulse_position[3] = (pulse_position[3] << 1) + ( fixed_index[6]       & 1);
     470        1136 :     pulse_position[7] = (pulse_position[7] << 1) + ((fixed_index[6] >> 1) & 1);
     471             : 
     472        1136 :     fixed_sparse->n = 8;
     473        5680 :     for (i = 0; i < 4; i++) {
     474        4544 :         const int pos1   = (pulse_position[i]     << 2) + i;
     475        4544 :         const int pos2   = (pulse_position[i + 4] << 2) + i;
     476        4544 :         const float sign = fixed_index[i] ? -1.0 : 1.0;
     477        4544 :         fixed_sparse->x[i    ] = pos1;
     478        4544 :         fixed_sparse->x[i + 4] = pos2;
     479        4544 :         fixed_sparse->y[i    ] = sign;
     480        4544 :         fixed_sparse->y[i + 4] = pos2 < pos1 ? -sign : sign;
     481             :     }
     482        1136 : }
     483             : 
     484             : /**
     485             :  * Decode the algebraic codebook index to pulse positions and signs,
     486             :  * then construct the algebraic codebook vector.
     487             :  *
     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
     493             :  *
     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
     498             :  */
     499        9088 : static void decode_fixed_sparse(AMRFixed *fixed_sparse, const uint16_t *pulses,
     500             :                                 const enum Mode mode, const int subframe)
     501             : {
     502             :     av_assert1(MODE_4k75 <= (signed)mode && mode <= MODE_12k2);
     503             : 
     504        9088 :     if (mode == MODE_12k2) {
     505        1136 :         ff_decode_10_pulses_35bits(pulses, fixed_sparse, gray_decode, 5, 3);
     506        7952 :     } else if (mode == MODE_10k2) {
     507        1136 :         decode_8_pulses_31bits(pulses, fixed_sparse);
     508             :     } else {
     509        6816 :         int *pulse_position = fixed_sparse->x;
     510             :         int i, pulse_subset;
     511        6816 :         const int fixed_index = pulses[0];
     512             : 
     513        6816 :         if (mode <= MODE_5k15) {
     514        2272 :             pulse_subset      = ((fixed_index >> 3) & 8)     + (subframe << 1);
     515        2272 :             pulse_position[0] = ( fixed_index       & 7) * 5 + track_position[pulse_subset];
     516        2272 :             pulse_position[1] = ((fixed_index >> 3) & 7) * 5 + track_position[pulse_subset + 1];
     517        2272 :             fixed_sparse->n = 2;
     518        4544 :         } else if (mode == MODE_5k9) {
     519        1136 :             pulse_subset      = ((fixed_index & 1) << 1) + 1;
     520        1136 :             pulse_position[0] = ((fixed_index >> 1) & 7) * 5 + pulse_subset;
     521        1136 :             pulse_subset      = (fixed_index  >> 4) & 3;
     522        1136 :             pulse_position[1] = ((fixed_index >> 6) & 7) * 5 + pulse_subset + (pulse_subset == 3 ? 1 : 0);
     523        1136 :             fixed_sparse->n = pulse_position[0] == pulse_position[1] ? 1 : 2;
     524        3408 :         } else if (mode == MODE_6k7) {
     525        1136 :             pulse_position[0] = (fixed_index        & 7) * 5;
     526        1136 :             pulse_subset      = (fixed_index  >> 2) & 2;
     527        1136 :             pulse_position[1] = ((fixed_index >> 4) & 7) * 5 + pulse_subset + 1;
     528        1136 :             pulse_subset      = (fixed_index  >> 6) & 2;
     529        1136 :             pulse_position[2] = ((fixed_index >> 8) & 7) * 5 + pulse_subset + 2;
     530        1136 :             fixed_sparse->n = 3;
     531             :         } else { // mode <= MODE_7k95
     532        2272 :             pulse_position[0] = gray_decode[ fixed_index        & 7];
     533        2272 :             pulse_position[1] = gray_decode[(fixed_index >> 3)  & 7] + 1;
     534        2272 :             pulse_position[2] = gray_decode[(fixed_index >> 6)  & 7] + 2;
     535        2272 :             pulse_subset      = (fixed_index >> 9) & 1;
     536        2272 :             pulse_position[3] = gray_decode[(fixed_index >> 10) & 7] + pulse_subset + 3;
     537        2272 :             fixed_sparse->n = 4;
     538             :         }
     539       26127 :         for (i = 0; i < fixed_sparse->n; i++)
     540       19311 :             fixed_sparse->y[i] = (pulses[1] >> i) & 1 ? 1.0 : -1.0;
     541             :     }
     542        9088 : }
     543             : 
     544             : /**
     545             :  * Apply pitch lag to obtain the sharpened fixed vector (section 6.1.2)
     546             :  *
     547             :  * @param p the context
     548             :  * @param subframe unpacked amr subframe
     549             :  * @param mode mode of the current frame
     550             :  * @param fixed_sparse sparse representation of the fixed vector
     551             :  */
     552        9088 : static void pitch_sharpening(AMRContext *p, int subframe, enum Mode mode,
     553             :                              AMRFixed *fixed_sparse)
     554             : {
     555             :     // The spec suggests the current pitch gain is always used, but in other
     556             :     // modes the pitch and codebook gains are jointly quantized (sec 5.8.2)
     557             :     // so the codebook gain cannot depend on the quantized pitch gain.
     558        9088 :     if (mode == MODE_12k2)
     559        1136 :         p->beta = FFMIN(p->pitch_gain[4], 1.0);
     560             : 
     561        9088 :     fixed_sparse->pitch_lag  = p->pitch_lag_int;
     562        9088 :     fixed_sparse->pitch_fac  = p->beta;
     563             : 
     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        9088 :     if (mode != MODE_4k75 || subframe & 1)
     568        8520 :         p->beta = av_clipf(p->pitch_gain[4], 0.0, SHARP_MAX);
     569        9088 : }
     570             : /// @}
     571             : 
     572             : 
     573             : /// @name AMR gain decoding functions
     574             : /// @{
     575             : 
     576             : /**
     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.
     580             :  *
     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
     585             :  *
     586             :  * @return fixed gain smoothed
     587             :  */
     588        9088 : static float fixed_gain_smooth(AMRContext *p , const float *lsf,
     589             :                                const float *lsf_avg, const enum Mode mode)
     590             : {
     591        9088 :     float diff = 0.0;
     592             :     int i;
     593             : 
     594       99968 :     for (i = 0; i < LP_FILTER_ORDER; i++)
     595       90880 :         diff += fabs(lsf_avg[i] - lsf[i]) / lsf_avg[i];
     596             : 
     597             :     // If diff is large for ten subframes, disable smoothing for a 40-subframe
     598             :     // hangover period.
     599        9088 :     p->diff_count++;
     600        9088 :     if (diff <= 0.65)
     601        6688 :         p->diff_count = 0;
     602             : 
     603        9088 :     if (p->diff_count > 10) {
     604         687 :         p->hang_count = 0;
     605         687 :         p->diff_count--; // don't let diff_count overflow
     606             :     }
     607             : 
     608        9088 :     if (p->hang_count < 40) {
     609        3803 :         p->hang_count++;
     610        5285 :     } else if (mode < MODE_7k4 || mode == MODE_10k2) {
     611        3413 :         const float smoothing_factor = av_clipf(4.0 * diff - 1.6, 0.0, 1.0);
     612       10239 :         const float fixed_gain_mean = (p->fixed_gain[0] + p->fixed_gain[1] +
     613       10239 :                                        p->fixed_gain[2] + p->fixed_gain[3] +
     614        6826 :                                        p->fixed_gain[4]) * 0.2;
     615        6826 :         return smoothing_factor * p->fixed_gain[4] +
     616        3413 :                (1.0 - smoothing_factor) * fixed_gain_mean;
     617             :     }
     618        5675 :     return p->fixed_gain[4];
     619             : }
     620             : 
     621             : /**
     622             :  * Decode pitch gain and fixed gain factor (part of section 6.1.3).
     623             :  *
     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
     629             :  */
     630        9088 : static void decode_gains(AMRContext *p, const AMRNBSubframe *amr_subframe,
     631             :                          const enum Mode mode, const int subframe,
     632             :                          float *fixed_gain_factor)
     633             : {
     634        9088 :     if (mode == MODE_12k2 || mode == MODE_7k95) {
     635        4544 :         p->pitch_gain[4]   = qua_gain_pit [amr_subframe->p_gain    ]
     636        2272 :             * (1.0 / 16384.0);
     637        4544 :         *fixed_gain_factor = qua_gain_code[amr_subframe->fixed_gain]
     638        2272 :             * (1.0 /  2048.0);
     639             :     } else {
     640             :         const uint16_t *gains;
     641             : 
     642        6816 :         if (mode >= MODE_6k7) {
     643        3408 :             gains = gains_high[amr_subframe->p_gain];
     644        3408 :         } else if (mode >= MODE_5k15) {
     645        2272 :             gains = gains_low [amr_subframe->p_gain];
     646             :         } else {
     647             :             // gain index is only coded in subframes 0,2 for MODE_4k75
     648        1136 :             gains = gains_MODE_4k75[(p->frame.subframe[subframe & 2].p_gain << 1) + (subframe & 1)];
     649             :         }
     650             : 
     651        6816 :         p->pitch_gain[4]   = gains[0] * (1.0 / 16384.0);
     652        6816 :         *fixed_gain_factor = gains[1] * (1.0 /  4096.0);
     653             :     }
     654        9088 : }
     655             : 
     656             : /// @}
     657             : 
     658             : 
     659             : /// @name AMR preprocessing functions
     660             : /// @{
     661             : 
     662             : /**
     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).
     665             :  *
     666             :  * @param out vector with filter applied
     667             :  * @param in source vector
     668             :  * @param filter phase filter coefficients
     669             :  *
     670             :  *  out[n] = sum(i,0,len-1){ in[i] * filter[(len + n - i)%len] }
     671             :  */
     672        4859 : static void apply_ir_filter(float *out, const AMRFixed *in,
     673             :                             const float *filter)
     674             : {
     675             :     float filter1[AMR_SUBFRAME_SIZE],     ///< filters at pitch lag*1 and *2
     676             :           filter2[AMR_SUBFRAME_SIZE];
     677        4859 :     int   lag = in->pitch_lag;
     678        4859 :     float fac = in->pitch_fac;
     679             :     int i;
     680             : 
     681        4859 :     if (lag < AMR_SUBFRAME_SIZE) {
     682         731 :         ff_celp_circ_addf(filter1, filter, filter, lag, fac,
     683             :                           AMR_SUBFRAME_SIZE);
     684             : 
     685         731 :         if (lag < AMR_SUBFRAME_SIZE >> 1)
     686           0 :             ff_celp_circ_addf(filter2, filter, filter1, lag, fac,
     687             :                               AMR_SUBFRAME_SIZE);
     688             :     }
     689             : 
     690        4859 :     memset(out, 0, sizeof(float) * AMR_SUBFRAME_SIZE);
     691       17641 :     for (i = 0; i < in->n; i++) {
     692       12782 :         int   x = in->x[i];
     693       12782 :         float y = in->y[i];
     694             :         const float *filterp;
     695             : 
     696       12782 :         if (x >= AMR_SUBFRAME_SIZE - lag) {
     697       12467 :             filterp = filter;
     698         315 :         } else if (x >= AMR_SUBFRAME_SIZE - (lag << 1)) {
     699         315 :             filterp = filter1;
     700             :         } else
     701           0 :             filterp = filter2;
     702             : 
     703       12782 :         ff_celp_circ_addf(out, out, filterp, x, y, AMR_SUBFRAME_SIZE);
     704             :     }
     705        4859 : }
     706             : 
     707             : /**
     708             :  * Reduce fixed vector sparseness by smoothing with one of three IR filters.
     709             :  * Also know as "adaptive phase dispersion".
     710             :  *
     711             :  * This implements 3GPP TS 26.090 section 6.1(5).
     712             :  *
     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
     718             :  */
     719        9088 : static const float *anti_sparseness(AMRContext *p, AMRFixed *fixed_sparse,
     720             :                                     const float *fixed_vector,
     721             :                                     float fixed_gain, float *out)
     722             : {
     723             :     int ir_filter_nr;
     724             : 
     725        9088 :     if (p->pitch_gain[4] < 0.6) {
     726        4143 :         ir_filter_nr = 0;      // strong filtering
     727        4945 :     } else if (p->pitch_gain[4] < 0.9) {
     728        2985 :         ir_filter_nr = 1;      // medium filtering
     729             :     } else
     730        1960 :         ir_filter_nr = 2;      // no filtering
     731             : 
     732             :     // detect 'onset'
     733        9088 :     if (fixed_gain > 2.0 * p->prev_sparse_fixed_gain) {
     734         189 :         p->ir_filter_onset = 2;
     735        8899 :     } else if (p->ir_filter_onset)
     736         331 :         p->ir_filter_onset--;
     737             : 
     738        9088 :     if (!p->ir_filter_onset) {
     739        8732 :         int i, count = 0;
     740             : 
     741       52392 :         for (i = 0; i < 5; i++)
     742       43660 :             if (p->pitch_gain[i] < 0.6)
     743       19971 :                 count++;
     744        8732 :         if (count > 2)
     745        3912 :             ir_filter_nr = 0;
     746             : 
     747        8732 :         if (ir_filter_nr > p->prev_ir_filter_nr + 1)
     748         489 :             ir_filter_nr--;
     749         356 :     } else if (ir_filter_nr < 2)
     750         230 :         ir_filter_nr++;
     751             : 
     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        9088 :     if (fixed_gain < 5.0)
     756           7 :         ir_filter_nr = 2;
     757             : 
     758        9088 :     if (p->cur_frame_mode != MODE_7k4 && p->cur_frame_mode < MODE_10k2
     759        5680 :          && ir_filter_nr < 2) {
     760        4859 :         apply_ir_filter(out, fixed_sparse,
     761        4859 :                         (p->cur_frame_mode == MODE_7k95 ?
     762        4859 :                              ir_filters_lookup_MODE_7k95 :
     763        4859 :                              ir_filters_lookup)[ir_filter_nr]);
     764        4859 :         fixed_vector = out;
     765             :     }
     766             : 
     767             :     // update ir filter strength history
     768        9088 :     p->prev_ir_filter_nr       = ir_filter_nr;
     769        9088 :     p->prev_sparse_fixed_gain  = fixed_gain;
     770             : 
     771        9088 :     return fixed_vector;
     772             : }
     773             : 
     774             : /// @}
     775             : 
     776             : 
     777             : /// @name AMR synthesis functions
     778             : /// @{
     779             : 
     780             : /**
     781             :  * Conduct 10th order linear predictive coding synthesis.
     782             :  *
     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
     789             :  */
     790        9088 : static int synthesis(AMRContext *p, float *lpc,
     791             :                      float fixed_gain, const float *fixed_vector,
     792             :                      float *samples, uint8_t overflow)
     793             : {
     794             :     int i;
     795             :     float excitation[AMR_SUBFRAME_SIZE];
     796             : 
     797             :     // if an overflow has been detected, the pitch vector is scaled down by a
     798             :     // factor of 4
     799        9088 :     if (overflow)
     800           0 :         for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
     801           0 :             p->pitch_vector[i] *= 0.25;
     802             : 
     803        9088 :     p->acelpv_ctx.weighted_vector_sumf(excitation, p->pitch_vector, fixed_vector,
     804             :                             p->pitch_gain[4], fixed_gain, AMR_SUBFRAME_SIZE);
     805             : 
     806             :     // emphasize pitch vector contribution
     807        9088 :     if (p->pitch_gain[4] > 0.5 && !overflow) {
     808        6201 :         float energy = p->celpm_ctx.dot_productf(excitation, excitation,
     809             :                                                     AMR_SUBFRAME_SIZE);
     810        6201 :         float pitch_factor =
     811       12402 :             p->pitch_gain[4] *
     812        6201 :             (p->cur_frame_mode == MODE_12k2 ?
     813       11700 :                 0.25 * FFMIN(p->pitch_gain[4], 1.0) :
     814        5499 :                 0.5  * FFMIN(p->pitch_gain[4], SHARP_MAX));
     815             : 
     816      254241 :         for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
     817      248040 :             excitation[i] += pitch_factor * p->pitch_vector[i];
     818             : 
     819        6201 :         ff_scale_vector_to_given_sum_of_squares(excitation, excitation, energy,
     820             :                                                 AMR_SUBFRAME_SIZE);
     821             :     }
     822             : 
     823        9088 :     p->celpf_ctx.celp_lp_synthesis_filterf(samples, lpc, excitation,
     824             :                                  AMR_SUBFRAME_SIZE,
     825             :                                  LP_FILTER_ORDER);
     826             : 
     827             :     // detect overflow
     828      372608 :     for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
     829      363520 :         if (fabsf(samples[i]) > AMR_SAMPLE_BOUND) {
     830           0 :             return 1;
     831             :         }
     832             : 
     833        9088 :     return 0;
     834             : }
     835             : 
     836             : /// @}
     837             : 
     838             : 
     839             : /// @name AMR update functions
     840             : /// @{
     841             : 
     842             : /**
     843             :  * Update buffers and history at the end of decoding a subframe.
     844             :  *
     845             :  * @param p             pointer to the AMRContext
     846             :  */
     847        9088 : static void update_state(AMRContext *p)
     848             : {
     849        9088 :     memcpy(p->prev_lsp_sub4, p->lsp[3], LP_FILTER_ORDER * sizeof(p->lsp[3][0]));
     850             : 
     851        9088 :     memmove(&p->excitation_buf[0], &p->excitation_buf[AMR_SUBFRAME_SIZE],
     852             :             (PITCH_DELAY_MAX + LP_FILTER_ORDER + 1) * sizeof(float));
     853             : 
     854        9088 :     memmove(&p->pitch_gain[0], &p->pitch_gain[1], 4 * sizeof(float));
     855        9088 :     memmove(&p->fixed_gain[0], &p->fixed_gain[1], 4 * sizeof(float));
     856             : 
     857        9088 :     memmove(&p->samples_in[0], &p->samples_in[AMR_SUBFRAME_SIZE],
     858             :             LP_FILTER_ORDER * sizeof(float));
     859        9088 : }
     860             : 
     861             : /// @}
     862             : 
     863             : 
     864             : /// @name AMR Postprocessing functions
     865             : /// @{
     866             : 
     867             : /**
     868             :  * Get the tilt factor of a formant filter from its transfer function
     869             :  *
     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
     873             :  */
     874        9088 : static float tilt_factor(AMRContext *p, float *lpc_n, float *lpc_d)
     875             : {
     876             :     float rh0, rh1; // autocorrelation at lag 0 and 1
     877             : 
     878             :     // LP_FILTER_ORDER prior zeros are needed for ff_celp_lp_synthesis_filterf
     879        9088 :     float impulse_buffer[LP_FILTER_ORDER + AMR_TILT_RESPONSE] = { 0 };
     880        9088 :     float *hf = impulse_buffer + LP_FILTER_ORDER; // start of impulse response
     881             : 
     882        9088 :     hf[0] = 1.0;
     883        9088 :     memcpy(hf + 1, lpc_n, sizeof(float) * LP_FILTER_ORDER);
     884        9088 :     p->celpf_ctx.celp_lp_synthesis_filterf(hf, lpc_d, hf,
     885             :                                  AMR_TILT_RESPONSE,
     886             :                                  LP_FILTER_ORDER);
     887             : 
     888        9088 :     rh0 = p->celpm_ctx.dot_productf(hf, hf,     AMR_TILT_RESPONSE);
     889        9088 :     rh1 = p->celpm_ctx.dot_productf(hf, hf + 1, AMR_TILT_RESPONSE - 1);
     890             : 
     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        9088 :     return rh1 >= 0.0 ? rh1 / rh0 * AMR_TILT_GAMMA_T : 0.0;
     894             : }
     895             : 
     896             : /**
     897             :  * Perform adaptive post-filtering to enhance the quality of the speech.
     898             :  * See section 6.2.1.
     899             :  *
     900             :  * @param p             pointer to the AMRContext
     901             :  * @param lpc           interpolated LP coefficients for this subframe
     902             :  * @param buf_out       output of the filter
     903             :  */
     904        9088 : static void postfilter(AMRContext *p, float *lpc, float *buf_out)
     905             : {
     906             :     int i;
     907        9088 :     float *samples          = p->samples_in + LP_FILTER_ORDER; // Start of input
     908             : 
     909        9088 :     float speech_gain       = p->celpm_ctx.dot_productf(samples, samples,
     910             :                                                            AMR_SUBFRAME_SIZE);
     911             : 
     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
     915             : 
     916        9088 :     if (p->cur_frame_mode == MODE_12k2 || p->cur_frame_mode == MODE_10k2) {
     917        2272 :         gamma_n = ff_pow_0_7;
     918        2272 :         gamma_d = ff_pow_0_75;
     919             :     } else {
     920        6816 :         gamma_n = ff_pow_0_55;
     921        6816 :         gamma_d = ff_pow_0_7;
     922             :     }
     923             : 
     924       99968 :     for (i = 0; i < LP_FILTER_ORDER; i++) {
     925       90880 :          lpc_n[i] = lpc[i] * gamma_n[i];
     926       90880 :          lpc_d[i] = lpc[i] * gamma_d[i];
     927             :     }
     928             : 
     929        9088 :     memcpy(pole_out, p->postfilter_mem, sizeof(float) * LP_FILTER_ORDER);
     930        9088 :     p->celpf_ctx.celp_lp_synthesis_filterf(pole_out + LP_FILTER_ORDER, lpc_d, samples,
     931             :                                  AMR_SUBFRAME_SIZE, LP_FILTER_ORDER);
     932        9088 :     memcpy(p->postfilter_mem, pole_out + AMR_SUBFRAME_SIZE,
     933             :            sizeof(float) * LP_FILTER_ORDER);
     934             : 
     935        9088 :     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);
     938             : 
     939        9088 :     ff_tilt_compensation(&p->tilt_mem, tilt_factor(p, lpc_n, lpc_d), buf_out,
     940             :                          AMR_SUBFRAME_SIZE);
     941             : 
     942        9088 :     ff_adaptive_gain_control(buf_out, buf_out, speech_gain, AMR_SUBFRAME_SIZE,
     943             :                              AMR_AGC_ALPHA, &p->postfilter_agc);
     944        9088 : }
     945             : 
     946             : /// @}
     947             : 
     948        2272 : static int amrnb_decode_frame(AVCodecContext *avctx, void *data,
     949             :                               int *got_frame_ptr, AVPacket *avpkt)
     950             : {
     951             : 
     952        2272 :     AMRContext *p = avctx->priv_data;        // pointer to private data
     953        2272 :     AVFrame *frame     = data;
     954        2272 :     const uint8_t *buf = avpkt->data;
     955        2272 :     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        2272 :     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
     963             : 
     964             :     /* get output buffer */
     965        2272 :     frame->nb_samples = AMR_BLOCK_SIZE;
     966        2272 :     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
     967           0 :         return ret;
     968        2272 :     buf_out = (float *)frame->data[0];
     969             : 
     970        2272 :     p->cur_frame_mode = unpack_bitstream(p, buf, buf_size);
     971        2272 :     if (p->cur_frame_mode == NO_DATA) {
     972           0 :         av_log(avctx, AV_LOG_ERROR, "Corrupt bitstream\n");
     973           0 :         return AVERROR_INVALIDDATA;
     974             :     }
     975        2272 :     if (p->cur_frame_mode == MODE_DTX) {
     976           0 :         avpriv_report_missing_feature(avctx, "dtx mode");
     977           0 :         av_log(avctx, AV_LOG_INFO, "Note: libopencore_amrnb supports dtx\n");
     978           0 :         return AVERROR_PATCHWELCOME;
     979             :     }
     980             : 
     981        2272 :     if (p->cur_frame_mode == MODE_12k2) {
     982         284 :         lsf2lsp_5(p);
     983             :     } else
     984        1988 :         lsf2lsp_3(p);
     985             : 
     986       11360 :     for (i = 0; i < 4; i++)
     987        9088 :         ff_acelp_lspd2lpc(p->lsp[i], p->lpc[i], 5);
     988             : 
     989       11360 :     for (subframe = 0; subframe < 4; subframe++) {
     990        9088 :         const AMRNBSubframe *amr_subframe = &p->frame.subframe[subframe];
     991             : 
     992        9088 :         decode_pitch_vector(p, amr_subframe, subframe);
     993             : 
     994        9088 :         decode_fixed_sparse(&fixed_sparse, amr_subframe->pulses,
     995             :                             p->cur_frame_mode, subframe);
     996             : 
     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        9088 :         decode_gains(p, amr_subframe, p->cur_frame_mode, subframe,
    1002             :                      &fixed_gain_factor);
    1003             : 
    1004        9088 :         pitch_sharpening(p, subframe, p->cur_frame_mode, &fixed_sparse);
    1005             : 
    1006        9088 :         if (fixed_sparse.pitch_lag == 0) {
    1007           0 :             av_log(avctx, AV_LOG_ERROR, "The file is corrupted, pitch_lag = 0 is not allowed\n");
    1008           0 :             return AVERROR_INVALIDDATA;
    1009             :         }
    1010        9088 :         ff_set_fixed_vector(p->fixed_vector, &fixed_sparse, 1.0,
    1011             :                             AMR_SUBFRAME_SIZE);
    1012             : 
    1013        9088 :         p->fixed_gain[4] =
    1014       18176 :             ff_amr_set_fixed_gain(fixed_gain_factor,
    1015       18176 :                        p->celpm_ctx.dot_productf(p->fixed_vector,
    1016        9088 :                                                                p->fixed_vector,
    1017             :                                                                AMR_SUBFRAME_SIZE) /
    1018             :                                   AMR_SUBFRAME_SIZE,
    1019        9088 :                        p->prediction_error,
    1020        9088 :                        energy_mean[p->cur_frame_mode], energy_pred_fac);
    1021             : 
    1022             :         // The excitation feedback is calculated without any processing such
    1023             :         // as fixed gain smoothing. This isn't mentioned in the specification.
    1024      372608 :         for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
    1025      363520 :             p->excitation[i] *= p->pitch_gain[4];
    1026        9088 :         ff_set_fixed_vector(p->excitation, &fixed_sparse, p->fixed_gain[4],
    1027             :                             AMR_SUBFRAME_SIZE);
    1028             : 
    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      372608 :         for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
    1035      363520 :             p->excitation[i] = truncf(p->excitation[i]);
    1036             : 
    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       18176 :         synth_fixed_gain = fixed_gain_smooth(p, p->lsf_q[subframe],
    1041        9088 :                                              p->lsf_avg, p->cur_frame_mode);
    1042             : 
    1043        9088 :         synth_fixed_vector = anti_sparseness(p, &fixed_sparse, p->fixed_vector,
    1044             :                                              synth_fixed_gain, spare_vector);
    1045             : 
    1046        9088 :         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           0 :             synthesis(p, p->lpc[subframe], synth_fixed_gain,
    1052             :                       synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 1);
    1053             : 
    1054        9088 :         postfilter(p, p->lpc[subframe], buf_out + subframe * AMR_SUBFRAME_SIZE);
    1055             : 
    1056             :         // update buffers and history
    1057        9088 :         ff_clear_fixed_vector(p->fixed_vector, &fixed_sparse, AMR_SUBFRAME_SIZE);
    1058        9088 :         update_state(p);
    1059             :     }
    1060             : 
    1061        4544 :     p->acelpf_ctx.acelp_apply_order_2_transfer_function(buf_out,
    1062             :                                              buf_out, highpass_zeros,
    1063             :                                              highpass_poles,
    1064             :                                              highpass_gain * AMR_SAMPLE_SCALE,
    1065        2272 :                                              p->high_pass_mem, AMR_BLOCK_SIZE);
    1066             : 
    1067             :     /* Update averaged lsf vector (used for fixed gain smoothing).
    1068             :      *
    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        2272 :     p->acelpv_ctx.weighted_vector_sumf(p->lsf_avg, p->lsf_avg, p->lsf_q[3],
    1074             :                             0.84, 0.16, LP_FILTER_ORDER);
    1075             : 
    1076        2272 :     *got_frame_ptr = 1;
    1077             : 
    1078             :     /* return the amount of bytes consumed if everything was OK */
    1079        2272 :     return frame_sizes_nb[p->cur_frame_mode] + 1; // +7 for rounding and +8 for TOC
    1080             : }
    1081             : 
    1082             : 
    1083             : AVCodec ff_amrnb_decoder = {
    1084             :     .name           = "amrnb",
    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   = AV_CODEC_CAP_DR1,
    1092             :     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
    1093             :                                                      AV_SAMPLE_FMT_NONE },
    1094             : };

Generated by: LCOV version 1.13