LCOV - code coverage report
Current view: top level - src/libavcodec - acelp_vectors.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 65 74 87.8 %
Date: 2017-01-28 02:43:52 Functions: 8 9 88.9 %

          Line data    Source code
       1             : /*
       2             :  * adaptive and fixed codebook vector operations for ACELP-based codecs
       3             :  *
       4             :  * Copyright (c) 2008 Vladimir Voroshilov
       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             : #include <inttypes.h>
      24             : 
      25             : #include "libavutil/avassert.h"
      26             : #include "libavutil/common.h"
      27             : #include "libavutil/float_dsp.h"
      28             : #include "avcodec.h"
      29             : #include "acelp_vectors.h"
      30             : 
      31             : const uint8_t ff_fc_2pulses_9bits_track1[16] =
      32             : {
      33             :     1,  3,
      34             :     6,  8,
      35             :     11, 13,
      36             :     16, 18,
      37             :     21, 23,
      38             :     26, 28,
      39             :     31, 33,
      40             :     36, 38
      41             : };
      42             : const uint8_t ff_fc_2pulses_9bits_track1_gray[16] =
      43             : {
      44             :   1,  3,
      45             :   8,  6,
      46             :   18, 16,
      47             :   11, 13,
      48             :   38, 36,
      49             :   31, 33,
      50             :   21, 23,
      51             :   28, 26,
      52             : };
      53             : 
      54             : const uint8_t ff_fc_2pulses_9bits_track2_gray[32] =
      55             : {
      56             :   0,  2,
      57             :   5,  4,
      58             :   12, 10,
      59             :   7,  9,
      60             :   25, 24,
      61             :   20, 22,
      62             :   14, 15,
      63             :   19, 17,
      64             :   36, 31,
      65             :   21, 26,
      66             :   1,  6,
      67             :   16, 11,
      68             :   27, 29,
      69             :   32, 30,
      70             :   39, 37,
      71             :   34, 35,
      72             : };
      73             : 
      74             : const uint8_t ff_fc_4pulses_8bits_tracks_13[16] =
      75             : {
      76             :   0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75,
      77             : };
      78             : 
      79             : const uint8_t ff_fc_4pulses_8bits_track_4[32] =
      80             : {
      81             :     3,  4,
      82             :     8,  9,
      83             :     13, 14,
      84             :     18, 19,
      85             :     23, 24,
      86             :     28, 29,
      87             :     33, 34,
      88             :     38, 39,
      89             :     43, 44,
      90             :     48, 49,
      91             :     53, 54,
      92             :     58, 59,
      93             :     63, 64,
      94             :     68, 69,
      95             :     73, 74,
      96             :     78, 79,
      97             : };
      98             : 
      99             : const float ff_pow_0_7[10] = {
     100             :     0.700000, 0.490000, 0.343000, 0.240100, 0.168070,
     101             :     0.117649, 0.082354, 0.057648, 0.040354, 0.028248
     102             : };
     103             : 
     104             : const float ff_pow_0_75[10] = {
     105             :     0.750000, 0.562500, 0.421875, 0.316406, 0.237305,
     106             :     0.177979, 0.133484, 0.100113, 0.075085, 0.056314
     107             : };
     108             : 
     109             : const float ff_pow_0_55[10] = {
     110             :     0.550000, 0.302500, 0.166375, 0.091506, 0.050328,
     111             :     0.027681, 0.015224, 0.008373, 0.004605, 0.002533
     112             : };
     113             : 
     114             : const float ff_b60_sinc[61] = {
     115             :  0.898529  ,  0.865051  ,  0.769257  ,  0.624054  ,  0.448639  ,  0.265289   ,
     116             :  0.0959167 , -0.0412598 , -0.134338  , -0.178986  , -0.178528  , -0.142609   ,
     117             : -0.0849304 , -0.0205078 ,  0.0369568 ,  0.0773926 ,  0.0955200 ,  0.0912781  ,
     118             :  0.0689392 ,  0.0357056 ,  0.0       , -0.0305481 , -0.0504150 , -0.0570068  ,
     119             : -0.0508423 , -0.0350037 , -0.0141602 ,  0.00665283,  0.0230713 ,  0.0323486  ,
     120             :  0.0335388 ,  0.0275879 ,  0.0167847 ,  0.00411987, -0.00747681, -0.0156860  ,
     121             : -0.0193481 , -0.0183716 , -0.0137634 , -0.00704956,  0.0       ,  0.00582886 ,
     122             :  0.00939941,  0.0103760 ,  0.00903320,  0.00604248,  0.00238037, -0.00109863 ,
     123             : -0.00366211, -0.00497437, -0.00503540, -0.00402832, -0.00241089, -0.000579834,
     124             :  0.00103760,  0.00222778,  0.00277710,  0.00271606,  0.00213623,  0.00115967 ,
     125             :  0.
     126             : };
     127             : 
     128           0 : void ff_acelp_fc_pulse_per_track(
     129             :         int16_t* fc_v,
     130             :         const uint8_t *tab1,
     131             :         const uint8_t *tab2,
     132             :         int pulse_indexes,
     133             :         int pulse_signs,
     134             :         int pulse_count,
     135             :         int bits)
     136             : {
     137           0 :     int mask = (1 << bits) - 1;
     138             :     int i;
     139             : 
     140           0 :     for(i=0; i<pulse_count; i++)
     141             :     {
     142           0 :         fc_v[i + tab1[pulse_indexes & mask]] +=
     143           0 :                 (pulse_signs & 1) ? 8191 : -8192; // +/-1 in (2.13)
     144             : 
     145           0 :         pulse_indexes >>= bits;
     146           0 :         pulse_signs >>= 1;
     147             :     }
     148             : 
     149           0 :     fc_v[tab2[pulse_indexes]] += (pulse_signs & 1) ? 8191 : -8192;
     150           0 : }
     151             : 
     152        7636 : void ff_decode_10_pulses_35bits(const int16_t *fixed_index,
     153             :                                 AMRFixed *fixed_sparse,
     154             :                                 const uint8_t *gray_decode,
     155             :                                 int half_pulse_count, int bits)
     156             : {
     157             :     int i;
     158        7636 :     int mask = (1 << bits) - 1;
     159             : 
     160        7636 :     fixed_sparse->no_repeat_mask = 0;
     161        7636 :     fixed_sparse->n = 2 * half_pulse_count;
     162       45816 :     for (i = 0; i < half_pulse_count; i++) {
     163       38180 :         const int pos1   = gray_decode[fixed_index[2*i+1] & mask] + i;
     164       38180 :         const int pos2   = gray_decode[fixed_index[2*i  ] & mask] + i;
     165       38180 :         const float sign = (fixed_index[2*i+1] & (1 << bits)) ? -1.0 : 1.0;
     166       38180 :         fixed_sparse->x[2*i+1] = pos1;
     167       38180 :         fixed_sparse->x[2*i  ] = pos2;
     168       38180 :         fixed_sparse->y[2*i+1] = sign;
     169       38180 :         fixed_sparse->y[2*i  ] = pos2 < pos1 ? -sign : sign;
     170             :     }
     171        7636 : }
     172             : 
     173        4650 : void ff_acelp_weighted_vector_sum(
     174             :         int16_t* out,
     175             :         const int16_t *in_a,
     176             :         const int16_t *in_b,
     177             :         int16_t weight_coeff_a,
     178             :         int16_t weight_coeff_b,
     179             :         int16_t rounder,
     180             :         int shift,
     181             :         int length)
     182             : {
     183             :     int i;
     184             : 
     185             :     // Clipping required here; breaks OVERFLOW test.
     186      159750 :     for(i=0; i<length; i++)
     187      310200 :         out[i] = av_clip_int16((
     188      310200 :                  in_a[i] * weight_coeff_a +
     189      310200 :                  in_b[i] * weight_coeff_b +
     190             :                  rounder) >> shift);
     191        4650 : }
     192             : 
     193       84008 : void ff_weighted_vector_sumf(float *out, const float *in_a, const float *in_b,
     194             :                              float weight_coeff_a, float weight_coeff_b, int length)
     195             : {
     196             :     int i;
     197             : 
     198     4076152 :     for(i=0; i<length; i++)
     199     7984288 :         out[i] = weight_coeff_a * in_a[i]
     200     3992144 :                + weight_coeff_b * in_b[i];
     201       84008 : }
     202             : 
     203       12943 : void ff_adaptive_gain_control(float *out, const float *in, float speech_energ,
     204             :                               int size, float alpha, float *gain_mem)
     205             : {
     206             :     int i;
     207       12943 :     float postfilter_energ = avpriv_scalarproduct_float_c(in, in, size);
     208       12943 :     float gain_scale_factor = 1.0;
     209       12943 :     float mem = *gain_mem;
     210             : 
     211       12943 :     if (postfilter_energ)
     212       12943 :         gain_scale_factor = sqrt(speech_energ / postfilter_energ);
     213             : 
     214       12943 :     gain_scale_factor *= 1.0 - alpha;
     215             : 
     216      616943 :     for (i = 0; i < size; i++) {
     217      604000 :         mem = alpha * mem + gain_scale_factor;
     218      604000 :         out[i] = in[i] * mem;
     219             :     }
     220             : 
     221       12943 :     *gain_mem = mem;
     222       12943 : }
     223             : 
     224       36484 : void ff_scale_vector_to_given_sum_of_squares(float *out, const float *in,
     225             :                                              float sum_of_squares, const int n)
     226             : {
     227             :     int i;
     228       36484 :     float scalefactor = avpriv_scalarproduct_float_c(in, in, n);
     229       36484 :     if (scalefactor)
     230       36484 :         scalefactor = sqrt(sum_of_squares / scalefactor);
     231     2624204 :     for (i = 0; i < n; i++)
     232     2587720 :         out[i] = in[i] * scalefactor;
     233       36484 : }
     234             : 
     235       34416 : void ff_set_fixed_vector(float *out, const AMRFixed *in, float scale, int size)
     236             : {
     237             :     int i;
     238             : 
     239      263185 :     for (i=0; i < in->n; i++) {
     240      228769 :         int x   = in->x[i], repeats = !((in->no_repeat_mask >> i) & 1);
     241      228769 :         float y = in->y[i] * scale;
     242             : 
     243      228769 :         if (in->pitch_lag > 0)
     244      228769 :             av_assert0(x < size);
     245             :             do {
     246      239359 :                 out[x] += y;
     247      239359 :                 y *= in->pitch_fac;
     248      239359 :                 x += in->pitch_lag;
     249      239359 :             } while (x < size && repeats);
     250             :     }
     251       34416 : }
     252             : 
     253        9088 : void ff_clear_fixed_vector(float *out, const AMRFixed *in, int size)
     254             : {
     255             :     int i;
     256             : 
     257       48847 :     for (i=0; i < in->n; i++) {
     258       39759 :         int x  = in->x[i], repeats = !((in->no_repeat_mask >> i) & 1);
     259             : 
     260       39759 :         if (in->pitch_lag > 0)
     261             :             do {
     262       40696 :                 out[x] = 0.0;
     263       40696 :                 x += in->pitch_lag;
     264       40696 :             } while (x < size && repeats);
     265             :     }
     266        9088 : }
     267             : 
     268          38 : void ff_acelp_vectors_init(ACELPVContext *c)
     269             : {
     270          38 :     c->weighted_vector_sumf   = ff_weighted_vector_sumf;
     271             : 
     272             :     if(HAVE_MIPSFPU)
     273             :         ff_acelp_vectors_init_mips(c);
     274          38 : }

Generated by: LCOV version 1.12