LCOV - code coverage report
Current view: top level - libavcodec - qcelpdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 269 354 76.0 %
Date: 2017-12-15 18:13:28 Functions: 14 15 93.3 %

          Line data    Source code
       1             : /*
       2             :  * QCELP decoder
       3             :  * Copyright (c) 2007 Reynaldo H. Verdejo Pinochet
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * QCELP decoder
      25             :  * @author Reynaldo H. Verdejo Pinochet
      26             :  * @remark FFmpeg merging spearheaded by Kenan Gillet
      27             :  * @remark Development mentored by Benjamin Larson
      28             :  */
      29             : 
      30             : #include <stddef.h>
      31             : 
      32             : #include "libavutil/avassert.h"
      33             : #include "libavutil/channel_layout.h"
      34             : #include "libavutil/float_dsp.h"
      35             : #include "avcodec.h"
      36             : #include "internal.h"
      37             : #include "get_bits.h"
      38             : #include "qcelpdata.h"
      39             : #include "celp_filters.h"
      40             : #include "acelp_filters.h"
      41             : #include "acelp_vectors.h"
      42             : #include "lsp.h"
      43             : 
      44             : typedef enum {
      45             :     I_F_Q = -1,    /**< insufficient frame quality */
      46             :     SILENCE,
      47             :     RATE_OCTAVE,
      48             :     RATE_QUARTER,
      49             :     RATE_HALF,
      50             :     RATE_FULL
      51             : } qcelp_packet_rate;
      52             : 
      53             : typedef struct QCELPContext {
      54             :     GetBitContext     gb;
      55             :     qcelp_packet_rate bitrate;
      56             :     QCELPFrame        frame;    /**< unpacked data frame */
      57             : 
      58             :     uint8_t  erasure_count;
      59             :     uint8_t  octave_count;      /**< count the consecutive RATE_OCTAVE frames */
      60             :     float    prev_lspf[10];
      61             :     float    predictor_lspf[10];/**< LSP predictor for RATE_OCTAVE and I_F_Q */
      62             :     float    pitch_synthesis_filter_mem[303];
      63             :     float    pitch_pre_filter_mem[303];
      64             :     float    rnd_fir_filter_mem[180];
      65             :     float    formant_mem[170];
      66             :     float    last_codebook_gain;
      67             :     int      prev_g1[2];
      68             :     int      prev_bitrate;
      69             :     float    pitch_gain[4];
      70             :     uint8_t  pitch_lag[4];
      71             :     uint16_t first16bits;
      72             :     uint8_t  warned_buf_mismatch_bitrate;
      73             : 
      74             :     /* postfilter */
      75             :     float    postfilter_synth_mem[10];
      76             :     float    postfilter_agc_mem;
      77             :     float    postfilter_tilt_mem;
      78             : } QCELPContext;
      79             : 
      80             : /**
      81             :  * Initialize the speech codec according to the specification.
      82             :  *
      83             :  * TIA/EIA/IS-733 2.4.9
      84             :  */
      85           3 : static av_cold int qcelp_decode_init(AVCodecContext *avctx)
      86             : {
      87           3 :     QCELPContext *q = avctx->priv_data;
      88             :     int i;
      89             : 
      90           3 :     avctx->channels       = 1;
      91           3 :     avctx->channel_layout = AV_CH_LAYOUT_MONO;
      92           3 :     avctx->sample_fmt     = AV_SAMPLE_FMT_FLT;
      93             : 
      94          33 :     for (i = 0; i < 10; i++)
      95          30 :         q->prev_lspf[i] = (i + 1) / 11.0;
      96             : 
      97           3 :     return 0;
      98             : }
      99             : 
     100             : /**
     101             :  * Decode the 10 quantized LSP frequencies from the LSPV/LSP
     102             :  * transmission codes of any bitrate and check for badly received packets.
     103             :  *
     104             :  * @param q the context
     105             :  * @param lspf line spectral pair frequencies
     106             :  *
     107             :  * @return 0 on success, -1 if the packet is badly received
     108             :  *
     109             :  * TIA/EIA/IS-733 2.4.3.2.6.2-2, 2.4.8.7.3
     110             :  */
     111         495 : static int decode_lspf(QCELPContext *q, float *lspf)
     112             : {
     113             :     int i;
     114             :     float tmp_lspf, smooth, erasure_coeff;
     115             :     const float *predictors;
     116             : 
     117         495 :     if (q->bitrate == RATE_OCTAVE || q->bitrate == I_F_Q) {
     118         193 :         predictors = q->prev_bitrate != RATE_OCTAVE &&
     119          27 :                      q->prev_bitrate != I_F_Q ? q->prev_lspf
     120             :                                               : q->predictor_lspf;
     121             : 
     122         166 :         if (q->bitrate == RATE_OCTAVE) {
     123         151 :             q->octave_count++;
     124             : 
     125        1661 :             for (i = 0; i < 10; i++) {
     126        1510 :                 q->predictor_lspf[i] =
     127        4530 :                              lspf[i] = (q->frame.lspv[i] ?  QCELP_LSP_SPREAD_FACTOR
     128        3020 :                                                          : -QCELP_LSP_SPREAD_FACTOR) +
     129        4530 :                                         predictors[i] * QCELP_LSP_OCTAVE_PREDICTOR   +
     130        1510 :                                         (i + 1) * ((1 - QCELP_LSP_OCTAVE_PREDICTOR) / 11);
     131             :             }
     132         151 :             smooth = q->octave_count < 10 ? .875 : 0.1;
     133             :         } else {
     134          15 :             erasure_coeff = QCELP_LSP_OCTAVE_PREDICTOR;
     135             : 
     136             :             av_assert2(q->bitrate == I_F_Q);
     137             : 
     138          15 :             if (q->erasure_count > 1)
     139          14 :                 erasure_coeff *= q->erasure_count < 4 ? 0.9 : 0.7;
     140             : 
     141         165 :             for (i = 0; i < 10; i++) {
     142         150 :                 q->predictor_lspf[i] =
     143         300 :                              lspf[i] = (i + 1) * (1 - erasure_coeff) / 11 +
     144         150 :                                        erasure_coeff * predictors[i];
     145             :             }
     146          15 :             smooth = 0.125;
     147             :         }
     148             : 
     149             :         // Check the stability of the LSP frequencies.
     150         166 :         lspf[0] = FFMAX(lspf[0], QCELP_LSP_SPREAD_FACTOR);
     151        1660 :         for (i = 1; i < 10; i++)
     152        1494 :             lspf[i] = FFMAX(lspf[i], lspf[i - 1] + QCELP_LSP_SPREAD_FACTOR);
     153             : 
     154         166 :         lspf[9] = FFMIN(lspf[9], 1.0 - QCELP_LSP_SPREAD_FACTOR);
     155        1660 :         for (i = 9; i > 0; i--)
     156        1494 :             lspf[i - 1] = FFMIN(lspf[i - 1], lspf[i] - QCELP_LSP_SPREAD_FACTOR);
     157             : 
     158             :         // Low-pass filter the LSP frequencies.
     159         166 :         ff_weighted_vector_sumf(lspf, lspf, q->prev_lspf, smooth, 1.0 - smooth, 10);
     160             :     } else {
     161         329 :         q->octave_count = 0;
     162             : 
     163         329 :         tmp_lspf = 0.0;
     164        1974 :         for (i = 0; i < 5; i++) {
     165        1645 :             lspf[2 * i + 0] = tmp_lspf += qcelp_lspvq[i][q->frame.lspv[i]][0] * 0.0001;
     166        1645 :             lspf[2 * i + 1] = tmp_lspf += qcelp_lspvq[i][q->frame.lspv[i]][1] * 0.0001;
     167             :         }
     168             : 
     169             :         // Check for badly received packets.
     170         329 :         if (q->bitrate == RATE_QUARTER) {
     171           0 :             if (lspf[9] <= .70 || lspf[9] >= .97)
     172           0 :                 return -1;
     173           0 :             for (i = 3; i < 10; i++)
     174           0 :                 if (fabs(lspf[i] - lspf[i - 2]) < .08)
     175           0 :                     return -1;
     176             :         } else {
     177         329 :             if (lspf[9] <= .66 || lspf[9] >= .985)
     178           0 :                 return -1;
     179        2303 :             for (i = 4; i < 10; i++)
     180        1974 :                 if (fabs(lspf[i] - lspf[i - 4]) < .0931)
     181           0 :                     return -1;
     182             :         }
     183             :     }
     184         495 :     return 0;
     185             : }
     186             : 
     187             : /**
     188             :  * Convert codebook transmission codes to GAIN and INDEX.
     189             :  *
     190             :  * @param q the context
     191             :  * @param gain array holding the decoded gain
     192             :  *
     193             :  * TIA/EIA/IS-733 2.4.6.2
     194             :  */
     195         495 : static void decode_gain_and_index(QCELPContext *q, float *gain)
     196             : {
     197             :     int i, subframes_count, g1[16];
     198             :     float slope;
     199             : 
     200         495 :     if (q->bitrate >= RATE_QUARTER) {
     201         329 :         switch (q->bitrate) {
     202         282 :         case RATE_FULL: subframes_count = 16; break;
     203          47 :         case RATE_HALF: subframes_count =  4; break;
     204           0 :         default:        subframes_count =  5;
     205             :         }
     206        5029 :         for (i = 0; i < subframes_count; i++) {
     207        4700 :             g1[i] = 4 * q->frame.cbgain[i];
     208        4700 :             if (q->bitrate == RATE_FULL && !((i + 1) & 3)) {
     209        1128 :                 g1[i] += av_clip((g1[i - 1] + g1[i - 2] + g1[i - 3]) / 3 - 6, 0, 32);
     210             :             }
     211             : 
     212        4700 :             gain[i] = qcelp_g12ga[g1[i]];
     213             : 
     214        4700 :             if (q->frame.cbsign[i]) {
     215        2227 :                 gain[i] = -gain[i];
     216        2227 :                 q->frame.cindex[i] = (q->frame.cindex[i] - 89) & 127;
     217             :             }
     218             :         }
     219             : 
     220         329 :         q->prev_g1[0]         = g1[i - 2];
     221         329 :         q->prev_g1[1]         = g1[i - 1];
     222         329 :         q->last_codebook_gain = qcelp_g12ga[g1[i - 1]];
     223             : 
     224         329 :         if (q->bitrate == RATE_QUARTER) {
     225             :             // Provide smoothing of the unvoiced excitation energy.
     226           0 :             gain[7] =       gain[4];
     227           0 :             gain[6] = 0.4 * gain[3] + 0.6 * gain[4];
     228           0 :             gain[5] =       gain[3];
     229           0 :             gain[4] = 0.8 * gain[2] + 0.2 * gain[3];
     230           0 :             gain[3] = 0.2 * gain[1] + 0.8 * gain[2];
     231           0 :             gain[2] =       gain[1];
     232           0 :             gain[1] = 0.6 * gain[0] + 0.4 * gain[1];
     233             :         }
     234         166 :     } else if (q->bitrate != SILENCE) {
     235         166 :         if (q->bitrate == RATE_OCTAVE) {
     236         302 :             g1[0] = 2 * q->frame.cbgain[0] +
     237         151 :                     av_clip((q->prev_g1[0] + q->prev_g1[1]) / 2 - 5, 0, 54);
     238         151 :             subframes_count = 8;
     239             :         } else {
     240             :             av_assert2(q->bitrate == I_F_Q);
     241             : 
     242          15 :             g1[0] = q->prev_g1[1];
     243          15 :             switch (q->erasure_count) {
     244           1 :             case 1 : break;
     245           1 :             case 2 : g1[0] -= 1; break;
     246           1 :             case 3 : g1[0] -= 2; break;
     247          12 :             default: g1[0] -= 6;
     248             :             }
     249          15 :             if (g1[0] < 0)
     250          14 :                 g1[0] = 0;
     251          15 :             subframes_count = 4;
     252             :         }
     253             :         // This interpolation is done to produce smoother background noise.
     254         166 :         slope = 0.5 * (qcelp_g12ga[g1[0]] - q->last_codebook_gain) / subframes_count;
     255        1434 :         for (i = 1; i <= subframes_count; i++)
     256        1268 :                 gain[i - 1] = q->last_codebook_gain + slope * i;
     257             : 
     258         166 :         q->last_codebook_gain = gain[i - 2];
     259         166 :         q->prev_g1[0]         = q->prev_g1[1];
     260         166 :         q->prev_g1[1]         = g1[0];
     261             :     }
     262         495 : }
     263             : 
     264             : /**
     265             :  * If the received packet is Rate 1/4 a further sanity check is made of the
     266             :  * codebook gain.
     267             :  *
     268             :  * @param cbgain the unpacked cbgain array
     269             :  * @return -1 if the sanity check fails, 0 otherwise
     270             :  *
     271             :  * TIA/EIA/IS-733 2.4.8.7.3
     272             :  */
     273           0 : static int codebook_sanity_check_for_rate_quarter(const uint8_t *cbgain)
     274             : {
     275           0 :     int i, diff, prev_diff = 0;
     276             : 
     277           0 :     for (i = 1; i < 5; i++) {
     278           0 :         diff = cbgain[i] - cbgain[i-1];
     279           0 :         if (FFABS(diff) > 10)
     280           0 :             return -1;
     281           0 :         else if (FFABS(diff - prev_diff) > 12)
     282           0 :             return -1;
     283           0 :         prev_diff = diff;
     284             :     }
     285           0 :     return 0;
     286             : }
     287             : 
     288             : /**
     289             :  * Compute the scaled codebook vector Cdn From INDEX and GAIN
     290             :  * for all rates.
     291             :  *
     292             :  * The specification lacks some information here.
     293             :  *
     294             :  * TIA/EIA/IS-733 has an omission on the codebook index determination
     295             :  * formula for RATE_FULL and RATE_HALF frames at section 2.4.8.1.1. It says
     296             :  * you have to subtract the decoded index parameter from the given scaled
     297             :  * codebook vector index 'n' to get the desired circular codebook index, but
     298             :  * it does not mention that you have to clamp 'n' to [0-9] in order to get
     299             :  * RI-compliant results.
     300             :  *
     301             :  * The reason for this mistake seems to be the fact they forgot to mention you
     302             :  * have to do these calculations per codebook subframe and adjust given
     303             :  * equation values accordingly.
     304             :  *
     305             :  * @param q the context
     306             :  * @param gain array holding the 4 pitch subframe gain values
     307             :  * @param cdn_vector array for the generated scaled codebook vector
     308             :  */
     309         495 : static void compute_svector(QCELPContext *q, const float *gain,
     310             :                             float *cdn_vector)
     311             : {
     312             :     int i, j, k;
     313             :     uint16_t cbseed, cindex;
     314             :     float *rnd, tmp_gain, fir_filter_value;
     315             : 
     316         495 :     switch (q->bitrate) {
     317         282 :     case RATE_FULL:
     318        4794 :         for (i = 0; i < 16; i++) {
     319        4512 :             tmp_gain = gain[i] * QCELP_RATE_FULL_CODEBOOK_RATIO;
     320        4512 :             cindex   = -q->frame.cindex[i];
     321       49632 :             for (j = 0; j < 10; j++)
     322       45120 :                 *cdn_vector++ = tmp_gain *
     323       45120 :                                 qcelp_rate_full_codebook[cindex++ & 127];
     324             :         }
     325         282 :         break;
     326          47 :     case RATE_HALF:
     327         235 :         for (i = 0; i < 4; i++) {
     328         188 :             tmp_gain = gain[i] * QCELP_RATE_HALF_CODEBOOK_RATIO;
     329         188 :             cindex   = -q->frame.cindex[i];
     330        7708 :             for (j = 0; j < 40; j++)
     331        7520 :                 *cdn_vector++ = tmp_gain *
     332        7520 :                                 qcelp_rate_half_codebook[cindex++ & 127];
     333             :         }
     334          47 :         break;
     335           0 :     case RATE_QUARTER:
     336           0 :         cbseed = (0x0003 & q->frame.lspv[4]) << 14 |
     337           0 :                  (0x003F & q->frame.lspv[3]) <<  8 |
     338           0 :                  (0x0060 & q->frame.lspv[2]) <<  1 |
     339           0 :                  (0x0007 & q->frame.lspv[1]) <<  3 |
     340           0 :                  (0x0038 & q->frame.lspv[0]) >>  3;
     341           0 :         rnd    = q->rnd_fir_filter_mem + 20;
     342           0 :         for (i = 0; i < 8; i++) {
     343           0 :             tmp_gain = gain[i] * (QCELP_SQRT1887 / 32768.0);
     344           0 :             for (k = 0; k < 20; k++) {
     345           0 :                 cbseed = 521 * cbseed + 259;
     346           0 :                 *rnd   = (int16_t) cbseed;
     347             : 
     348             :                     // FIR filter
     349           0 :                 fir_filter_value = 0.0;
     350           0 :                 for (j = 0; j < 10; j++)
     351           0 :                     fir_filter_value += qcelp_rnd_fir_coefs[j] *
     352           0 :                                         (rnd[-j] + rnd[-20+j]);
     353             : 
     354           0 :                 fir_filter_value += qcelp_rnd_fir_coefs[10] * rnd[-10];
     355           0 :                 *cdn_vector++     = tmp_gain * fir_filter_value;
     356           0 :                 rnd++;
     357             :             }
     358             :         }
     359           0 :         memcpy(q->rnd_fir_filter_mem, q->rnd_fir_filter_mem + 160,
     360             :                20 * sizeof(float));
     361           0 :         break;
     362         151 :     case RATE_OCTAVE:
     363         151 :         cbseed = q->first16bits;
     364        1359 :         for (i = 0; i < 8; i++) {
     365        1208 :             tmp_gain = gain[i] * (QCELP_SQRT1887 / 32768.0);
     366       25368 :             for (j = 0; j < 20; j++) {
     367       24160 :                 cbseed        = 521 * cbseed + 259;
     368       24160 :                 *cdn_vector++ = tmp_gain * (int16_t) cbseed;
     369             :             }
     370             :         }
     371         151 :         break;
     372          15 :     case I_F_Q:
     373          15 :         cbseed = -44; // random codebook index
     374          75 :         for (i = 0; i < 4; i++) {
     375          60 :             tmp_gain = gain[i] * QCELP_RATE_FULL_CODEBOOK_RATIO;
     376        2460 :             for (j = 0; j < 40; j++)
     377        2400 :                 *cdn_vector++ = tmp_gain *
     378        2400 :                                 qcelp_rate_full_codebook[cbseed++ & 127];
     379             :         }
     380          15 :         break;
     381           0 :     case SILENCE:
     382           0 :         memset(cdn_vector, 0, 160 * sizeof(float));
     383           0 :         break;
     384             :     }
     385         495 : }
     386             : 
     387             : /**
     388             :  * Apply generic gain control.
     389             :  *
     390             :  * @param v_out output vector
     391             :  * @param v_in gain-controlled vector
     392             :  * @param v_ref vector to control gain of
     393             :  *
     394             :  * TIA/EIA/IS-733 2.4.8.3, 2.4.8.6
     395             :  */
     396         329 : static void apply_gain_ctrl(float *v_out, const float *v_ref, const float *v_in)
     397             : {
     398             :     int i;
     399             : 
     400        1645 :     for (i = 0; i < 160; i += 40) {
     401        1316 :         float res = avpriv_scalarproduct_float_c(v_ref + i, v_ref + i, 40);
     402        1316 :         ff_scale_vector_to_given_sum_of_squares(v_out + i, v_in + i, res, 40);
     403             :     }
     404         329 : }
     405             : 
     406             : /**
     407             :  * Apply filter in pitch-subframe steps.
     408             :  *
     409             :  * @param memory buffer for the previous state of the filter
     410             :  *        - must be able to contain 303 elements
     411             :  *        - the 143 first elements are from the previous state
     412             :  *        - the next 160 are for output
     413             :  * @param v_in input filter vector
     414             :  * @param gain per-subframe gain array, each element is between 0.0 and 2.0
     415             :  * @param lag per-subframe lag array, each element is
     416             :  *        - between 16 and 143 if its corresponding pfrac is 0,
     417             :  *        - between 16 and 139 otherwise
     418             :  * @param pfrac per-subframe boolean array, 1 if the lag is fractional, 0
     419             :  *        otherwise
     420             :  *
     421             :  * @return filter output vector
     422             :  */
     423         658 : static const float *do_pitchfilter(float memory[303], const float v_in[160],
     424             :                                    const float gain[4], const uint8_t *lag,
     425             :                                    const uint8_t pfrac[4])
     426             : {
     427             :     int i, j;
     428             :     float *v_lag, *v_out;
     429             :     const float *v_len;
     430             : 
     431         658 :     v_out = memory + 143; // Output vector starts at memory[143].
     432             : 
     433        3290 :     for (i = 0; i < 4; i++) {
     434        2632 :         if (gain[i]) {
     435        2632 :             v_lag = memory + 143 + 40 * i - lag[i];
     436      107912 :             for (v_len = v_in + 40; v_in < v_len; v_in++) {
     437      105280 :                 if (pfrac[i]) { // If it is a fractional lag...
     438      156400 :                     for (j = 0, *v_out = 0.0; j < 4; j++)
     439      250240 :                         *v_out += qcelp_hammsinc_table[j] *
     440      125120 :                                   (v_lag[j - 4] + v_lag[3 - j]);
     441             :                 } else
     442       74000 :                     *v_out = *v_lag;
     443             : 
     444      105280 :                 *v_out = *v_in + gain[i] * *v_out;
     445             : 
     446      105280 :                 v_lag++;
     447      105280 :                 v_out++;
     448             :             }
     449             :         } else {
     450           0 :             memcpy(v_out, v_in, 40 * sizeof(float));
     451           0 :             v_in  += 40;
     452           0 :             v_out += 40;
     453             :         }
     454             :     }
     455             : 
     456         658 :     memmove(memory, memory + 160, 143 * sizeof(float));
     457         658 :     return memory + 143;
     458             : }
     459             : 
     460             : /**
     461             :  * Apply pitch synthesis filter and pitch prefilter to the scaled codebook vector.
     462             :  * TIA/EIA/IS-733 2.4.5.2, 2.4.8.7.2
     463             :  *
     464             :  * @param q the context
     465             :  * @param cdn_vector the scaled codebook vector
     466             :  */
     467         495 : static void apply_pitch_filters(QCELPContext *q, float *cdn_vector)
     468             : {
     469             :     int i;
     470             :     const float *v_synthesis_filtered, *v_pre_filtered;
     471             : 
     472         661 :     if (q->bitrate >= RATE_HALF || q->bitrate == SILENCE ||
     473         181 :         (q->bitrate == I_F_Q && (q->prev_bitrate >= RATE_HALF))) {
     474             : 
     475         329 :         if (q->bitrate >= RATE_HALF) {
     476             :             // Compute gain & lag for the whole frame.
     477        1645 :             for (i = 0; i < 4; i++) {
     478        1316 :                 q->pitch_gain[i] = q->frame.plag[i] ? (q->frame.pgain[i] + 1) * 0.25 : 0.0;
     479             : 
     480        1316 :                 q->pitch_lag[i] = q->frame.plag[i] + 16;
     481             :             }
     482             :         } else {
     483             :             float max_pitch_gain;
     484             : 
     485           0 :             if (q->bitrate == I_F_Q) {
     486           0 :                   if (q->erasure_count < 3)
     487           0 :                       max_pitch_gain = 0.9 - 0.3 * (q->erasure_count - 1);
     488             :                   else
     489           0 :                       max_pitch_gain = 0.0;
     490             :             } else {
     491             :                 av_assert2(q->bitrate == SILENCE);
     492           0 :                 max_pitch_gain = 1.0;
     493             :             }
     494           0 :             for (i = 0; i < 4; i++)
     495           0 :                 q->pitch_gain[i] = FFMIN(q->pitch_gain[i], max_pitch_gain);
     496             : 
     497           0 :             memset(q->frame.pfrac, 0, sizeof(q->frame.pfrac));
     498             :         }
     499             : 
     500             :         // pitch synthesis filter
     501         329 :         v_synthesis_filtered = do_pitchfilter(q->pitch_synthesis_filter_mem,
     502         329 :                                               cdn_vector, q->pitch_gain,
     503         329 :                                               q->pitch_lag, q->frame.pfrac);
     504             : 
     505             :         // pitch prefilter update
     506        1645 :         for (i = 0; i < 4; i++)
     507        1316 :             q->pitch_gain[i] = 0.5 * FFMIN(q->pitch_gain[i], 1.0);
     508             : 
     509         329 :         v_pre_filtered       = do_pitchfilter(q->pitch_pre_filter_mem,
     510             :                                               v_synthesis_filtered,
     511         329 :                                               q->pitch_gain, q->pitch_lag,
     512         329 :                                               q->frame.pfrac);
     513             : 
     514         329 :         apply_gain_ctrl(cdn_vector, v_synthesis_filtered, v_pre_filtered);
     515             :     } else {
     516         166 :         memcpy(q->pitch_synthesis_filter_mem,
     517         166 :                cdn_vector + 17, 143 * sizeof(float));
     518         166 :         memcpy(q->pitch_pre_filter_mem, cdn_vector + 17, 143 * sizeof(float));
     519         166 :         memset(q->pitch_gain, 0, sizeof(q->pitch_gain));
     520         166 :         memset(q->pitch_lag,  0, sizeof(q->pitch_lag));
     521             :     }
     522         495 : }
     523             : 
     524             : /**
     525             :  * Reconstruct LPC coefficients from the line spectral pair frequencies
     526             :  * and perform bandwidth expansion.
     527             :  *
     528             :  * @param lspf line spectral pair frequencies
     529             :  * @param lpc linear predictive coding coefficients
     530             :  *
     531             :  * @note: bandwidth_expansion_coeff could be precalculated into a table
     532             :  *        but it seems to be slower on x86
     533             :  *
     534             :  * TIA/EIA/IS-733 2.4.3.3.5
     535             :  */
     536        1482 : static void lspf2lpc(const float *lspf, float *lpc)
     537             : {
     538             :     double lsp[10];
     539        1482 :     double bandwidth_expansion_coeff = QCELP_BANDWIDTH_EXPANSION_COEFF;
     540             :     int i;
     541             : 
     542       16302 :     for (i = 0; i < 10; i++)
     543       14820 :         lsp[i] = cos(M_PI * lspf[i]);
     544             : 
     545        1482 :     ff_acelp_lspd2lpc(lsp, lpc, 5);
     546             : 
     547       16302 :     for (i = 0; i < 10; i++) {
     548       14820 :         lpc[i]                    *= bandwidth_expansion_coeff;
     549       14820 :         bandwidth_expansion_coeff *= QCELP_BANDWIDTH_EXPANSION_COEFF;
     550             :     }
     551        1482 : }
     552             : 
     553             : /**
     554             :  * Interpolate LSP frequencies and compute LPC coefficients
     555             :  * for a given bitrate & pitch subframe.
     556             :  *
     557             :  * TIA/EIA/IS-733 2.4.3.3.4, 2.4.8.7.2
     558             :  *
     559             :  * @param q the context
     560             :  * @param curr_lspf LSP frequencies vector of the current frame
     561             :  * @param lpc float vector for the resulting LPC
     562             :  * @param subframe_num frame number in decoded stream
     563             :  */
     564        1980 : static void interpolate_lpc(QCELPContext *q, const float *curr_lspf,
     565             :                             float *lpc, const int subframe_num)
     566             : {
     567             :     float interpolated_lspf[10];
     568             :     float weight;
     569             : 
     570        1980 :     if (q->bitrate >= RATE_QUARTER)
     571        1316 :         weight = 0.25 * (subframe_num + 1);
     572         664 :     else if (q->bitrate == RATE_OCTAVE && !subframe_num)
     573         151 :         weight = 0.625;
     574             :     else
     575         513 :         weight = 1.0;
     576             : 
     577        1980 :     if (weight != 1.0) {
     578        1138 :         ff_weighted_vector_sumf(interpolated_lspf, curr_lspf, q->prev_lspf,
     579             :                                 weight, 1.0 - weight, 10);
     580        1138 :         lspf2lpc(interpolated_lspf, lpc);
     581        1355 :     } else if (q->bitrate >= RATE_QUARTER ||
     582         573 :                (q->bitrate == I_F_Q && !subframe_num))
     583         344 :         lspf2lpc(curr_lspf, lpc);
     584         498 :     else if (q->bitrate == SILENCE && !subframe_num)
     585           0 :         lspf2lpc(q->prev_lspf, lpc);
     586        1980 : }
     587             : 
     588         990 : static qcelp_packet_rate buf_size2bitrate(const int buf_size)
     589             : {
     590         990 :     switch (buf_size) {
     591         283 :     case 35: return RATE_FULL;
     592          48 :     case 17: return RATE_HALF;
     593           0 :     case  8: return RATE_QUARTER;
     594         164 :     case  4: return RATE_OCTAVE;
     595           0 :     case  1: return SILENCE;
     596             :     }
     597             : 
     598         495 :     return I_F_Q;
     599             : }
     600             : 
     601             : /**
     602             :  * Determine the bitrate from the frame size and/or the first byte of the frame.
     603             :  *
     604             :  * @param avctx the AV codec context
     605             :  * @param buf_size length of the buffer
     606             :  * @param buf the buffer
     607             :  *
     608             :  * @return the bitrate on success,
     609             :  *         I_F_Q  if the bitrate cannot be satisfactorily determined
     610             :  *
     611             :  * TIA/EIA/IS-733 2.4.8.7.1
     612             :  */
     613         495 : static qcelp_packet_rate determine_bitrate(AVCodecContext *avctx,
     614             :                                            const int buf_size,
     615             :                                            const uint8_t **buf)
     616             : {
     617             :     qcelp_packet_rate bitrate;
     618             : 
     619         495 :     if ((bitrate = buf_size2bitrate(buf_size)) >= 0) {
     620           0 :         if (bitrate > **buf) {
     621           0 :             QCELPContext *q = avctx->priv_data;
     622           0 :             if (!q->warned_buf_mismatch_bitrate) {
     623           0 :             av_log(avctx, AV_LOG_WARNING,
     624             :                    "Claimed bitrate and buffer size mismatch.\n");
     625           0 :                 q->warned_buf_mismatch_bitrate = 1;
     626             :             }
     627           0 :             bitrate = **buf;
     628           0 :         } else if (bitrate < **buf) {
     629           0 :             av_log(avctx, AV_LOG_ERROR,
     630             :                    "Buffer is too small for the claimed bitrate.\n");
     631           0 :             return I_F_Q;
     632             :         }
     633           0 :         (*buf)++;
     634         495 :     } else if ((bitrate = buf_size2bitrate(buf_size + 1)) >= 0) {
     635         495 :         av_log(avctx, AV_LOG_WARNING,
     636             :                "Bitrate byte missing, guessing bitrate from packet size.\n");
     637             :     } else
     638           0 :         return I_F_Q;
     639             : 
     640         495 :     if (bitrate == SILENCE) {
     641             :         // FIXME: Remove this warning when tested with samples.
     642           0 :         avpriv_request_sample(avctx, "Blank frame handling");
     643             :     }
     644         495 :     return bitrate;
     645             : }
     646             : 
     647          15 : static void warn_insufficient_frame_quality(AVCodecContext *avctx,
     648             :                                             const char *message)
     649             : {
     650          15 :     av_log(avctx, AV_LOG_WARNING, "Frame #%d, IFQ: %s\n",
     651             :            avctx->frame_number, message);
     652          15 : }
     653             : 
     654         495 : static void postfilter(QCELPContext *q, float *samples, float *lpc)
     655             : {
     656             :     static const float pow_0_775[10] = {
     657             :         0.775000, 0.600625, 0.465484, 0.360750, 0.279582,
     658             :         0.216676, 0.167924, 0.130141, 0.100859, 0.078166
     659             :     }, pow_0_625[10] = {
     660             :         0.625000, 0.390625, 0.244141, 0.152588, 0.095367,
     661             :         0.059605, 0.037253, 0.023283, 0.014552, 0.009095
     662             :     };
     663             :     float lpc_s[10], lpc_p[10], pole_out[170], zero_out[160];
     664             :     int n;
     665             : 
     666        5445 :     for (n = 0; n < 10; n++) {
     667        4950 :         lpc_s[n] = lpc[n] * pow_0_625[n];
     668        4950 :         lpc_p[n] = lpc[n] * pow_0_775[n];
     669             :     }
     670             : 
     671         495 :     ff_celp_lp_zero_synthesis_filterf(zero_out, lpc_s,
     672         495 :                                       q->formant_mem + 10, 160, 10);
     673         495 :     memcpy(pole_out, q->postfilter_synth_mem, sizeof(float) * 10);
     674         495 :     ff_celp_lp_synthesis_filterf(pole_out + 10, lpc_p, zero_out, 160, 10);
     675         495 :     memcpy(q->postfilter_synth_mem, pole_out + 160, sizeof(float) * 10);
     676             : 
     677         495 :     ff_tilt_compensation(&q->postfilter_tilt_mem, 0.3, pole_out + 10, 160);
     678             : 
     679        1485 :     ff_adaptive_gain_control(samples, pole_out + 10,
     680         495 :                              avpriv_scalarproduct_float_c(q->formant_mem + 10,
     681         495 :                                                           q->formant_mem + 10,
     682             :                                                           160),
     683             :                              160, 0.9375, &q->postfilter_agc_mem);
     684         495 : }
     685             : 
     686         495 : static int qcelp_decode_frame(AVCodecContext *avctx, void *data,
     687             :                               int *got_frame_ptr, AVPacket *avpkt)
     688             : {
     689         495 :     const uint8_t *buf = avpkt->data;
     690         495 :     int buf_size       = avpkt->size;
     691         495 :     QCELPContext *q    = avctx->priv_data;
     692         495 :     AVFrame *frame     = data;
     693             :     float *outbuffer;
     694             :     int   i, ret;
     695             :     float quantized_lspf[10], lpc[10];
     696             :     float gain[16];
     697             :     float *formant_mem;
     698             : 
     699             :     /* get output buffer */
     700         495 :     frame->nb_samples = 160;
     701         495 :     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
     702           0 :         return ret;
     703         495 :     outbuffer = (float *)frame->data[0];
     704             : 
     705         495 :     if ((q->bitrate = determine_bitrate(avctx, buf_size, &buf)) == I_F_Q) {
     706           0 :         warn_insufficient_frame_quality(avctx, "Bitrate cannot be determined.");
     707           0 :         goto erasure;
     708             :     }
     709             : 
     710         659 :     if (q->bitrate == RATE_OCTAVE &&
     711         164 :         (q->first16bits = AV_RB16(buf)) == 0xFFFF) {
     712          13 :         warn_insufficient_frame_quality(avctx, "Bitrate is 1/8 and first 16 bits are on.");
     713          13 :         goto erasure;
     714             :     }
     715             : 
     716         482 :     if (q->bitrate > SILENCE) {
     717         482 :         const QCELPBitmap *bitmaps     = qcelp_unpacking_bitmaps_per_rate[q->bitrate];
     718         964 :         const QCELPBitmap *bitmaps_end = qcelp_unpacking_bitmaps_per_rate[q->bitrate] +
     719         482 :                                          qcelp_unpacking_bitmaps_lengths[q->bitrate];
     720         482 :         uint8_t *unpacked_data         = (uint8_t *)&q->frame;
     721             : 
     722         482 :         if ((ret = init_get_bits8(&q->gb, buf, buf_size)) < 0)
     723           0 :             return ret;
     724             : 
     725         482 :         memset(&q->frame, 0, sizeof(QCELPFrame));
     726             : 
     727       26556 :         for (; bitmaps < bitmaps_end; bitmaps++)
     728       26074 :             unpacked_data[bitmaps->index] |= get_bits(&q->gb, bitmaps->bitlen) << bitmaps->bitpos;
     729             : 
     730             :         // Check for erasures/blanks on rates 1, 1/4 and 1/8.
     731         482 :         if (q->frame.reserved) {
     732           1 :             warn_insufficient_frame_quality(avctx, "Wrong data in reserved frame area.");
     733           1 :             goto erasure;
     734             :         }
     735         481 :         if (q->bitrate == RATE_QUARTER &&
     736           0 :             codebook_sanity_check_for_rate_quarter(q->frame.cbgain)) {
     737           0 :             warn_insufficient_frame_quality(avctx, "Codebook gain sanity check failed.");
     738           0 :             goto erasure;
     739             :         }
     740             : 
     741         481 :         if (q->bitrate >= RATE_HALF) {
     742        1646 :             for (i = 0; i < 4; i++) {
     743        1317 :                 if (q->frame.pfrac[i] && q->frame.plag[i] >= 124) {
     744           1 :                     warn_insufficient_frame_quality(avctx, "Cannot initialize pitch filter.");
     745           1 :                     goto erasure;
     746             :                 }
     747             :             }
     748             :         }
     749             :     }
     750             : 
     751         480 :     decode_gain_and_index(q, gain);
     752         480 :     compute_svector(q, gain, outbuffer);
     753             : 
     754         480 :     if (decode_lspf(q, quantized_lspf) < 0) {
     755           0 :         warn_insufficient_frame_quality(avctx, "Badly received packets in frame.");
     756           0 :         goto erasure;
     757             :     }
     758             : 
     759         480 :     apply_pitch_filters(q, outbuffer);
     760             : 
     761         480 :     if (q->bitrate == I_F_Q) {
     762           0 : erasure:
     763          15 :         q->bitrate = I_F_Q;
     764          15 :         q->erasure_count++;
     765          15 :         decode_gain_and_index(q, gain);
     766          15 :         compute_svector(q, gain, outbuffer);
     767          15 :         decode_lspf(q, quantized_lspf);
     768          15 :         apply_pitch_filters(q, outbuffer);
     769             :     } else
     770         480 :         q->erasure_count = 0;
     771             : 
     772         495 :     formant_mem = q->formant_mem + 10;
     773        2475 :     for (i = 0; i < 4; i++) {
     774        1980 :         interpolate_lpc(q, quantized_lspf, lpc, i);
     775        3960 :         ff_celp_lp_synthesis_filterf(formant_mem, lpc,
     776        1980 :                                      outbuffer + i * 40, 40, 10);
     777        1980 :         formant_mem += 40;
     778             :     }
     779             : 
     780             :     // postfilter, as per TIA/EIA/IS-733 2.4.8.6
     781         495 :     postfilter(q, outbuffer, lpc);
     782             : 
     783         495 :     memcpy(q->formant_mem, q->formant_mem + 160, 10 * sizeof(float));
     784             : 
     785         495 :     memcpy(q->prev_lspf, quantized_lspf, sizeof(q->prev_lspf));
     786         495 :     q->prev_bitrate  = q->bitrate;
     787             : 
     788         495 :     *got_frame_ptr = 1;
     789             : 
     790         495 :     return buf_size;
     791             : }
     792             : 
     793             : AVCodec ff_qcelp_decoder = {
     794             :     .name           = "qcelp",
     795             :     .long_name      = NULL_IF_CONFIG_SMALL("QCELP / PureVoice"),
     796             :     .type           = AVMEDIA_TYPE_AUDIO,
     797             :     .id             = AV_CODEC_ID_QCELP,
     798             :     .init           = qcelp_decode_init,
     799             :     .decode         = qcelp_decode_frame,
     800             :     .capabilities   = AV_CODEC_CAP_DR1,
     801             :     .priv_data_size = sizeof(QCELPContext),
     802             : };

Generated by: LCOV version 1.13