Home | History | Annotate | Download | only in source
      1 /*
      2  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 
     12 /*
     13  * This file contains the resampling functions for 22 kHz.
     14  * The description header can be found in signal_processing_library.h
     15  *
     16  */
     17 
     18 #include "signal_processing_library.h"
     19 #include "resample_by_2_internal.h"
     20 
     21 // Declaration of internally used functions
     22 static void WebRtcSpl_32khzTo22khzIntToShort(const WebRtc_Word32 *In, WebRtc_Word16 *Out,
     23                                              const WebRtc_Word32 K);
     24 
     25 void WebRtcSpl_32khzTo22khzIntToInt(const WebRtc_Word32 *In, WebRtc_Word32 *Out,
     26                                     const WebRtc_Word32 K);
     27 
     28 // interpolation coefficients
     29 static const WebRtc_Word16 kCoefficients32To22[5][9] = {
     30         {127, -712,  2359, -6333, 23456, 16775, -3695,  945, -154},
     31         {-39,  230,  -830,  2785, 32366, -2324,   760, -218,   38},
     32         {117, -663,  2222, -6133, 26634, 13070, -3174,  831, -137},
     33         {-77,  457, -1677,  5958, 31175, -4136,  1405, -408,   71},
     34         { 98, -560,  1900, -5406, 29240,  9423, -2480,  663, -110}
     35 };
     36 
     37 //////////////////////
     38 // 22 kHz -> 16 kHz //
     39 //////////////////////
     40 
     41 // number of subblocks; options: 1, 2, 4, 5, 10
     42 #define SUB_BLOCKS_22_16    5
     43 
     44 // 22 -> 16 resampler
     45 void WebRtcSpl_Resample22khzTo16khz(const WebRtc_Word16* in, WebRtc_Word16* out,
     46                                     WebRtcSpl_State22khzTo16khz* state, WebRtc_Word32* tmpmem)
     47 {
     48     int k;
     49 
     50     // process two blocks of 10/SUB_BLOCKS_22_16 ms (to reduce temp buffer size)
     51     for (k = 0; k < SUB_BLOCKS_22_16; k++)
     52     {
     53         ///// 22 --> 44 /////
     54         // WebRtc_Word16  in[220/SUB_BLOCKS_22_16]
     55         // WebRtc_Word32 out[440/SUB_BLOCKS_22_16]
     56         /////
     57         WebRtcSpl_UpBy2ShortToInt(in, 220 / SUB_BLOCKS_22_16, tmpmem + 16, state->S_22_44);
     58 
     59         ///// 44 --> 32 /////
     60         // WebRtc_Word32  in[440/SUB_BLOCKS_22_16]
     61         // WebRtc_Word32 out[320/SUB_BLOCKS_22_16]
     62         /////
     63         // copy state to and from input array
     64         tmpmem[8] = state->S_44_32[0];
     65         tmpmem[9] = state->S_44_32[1];
     66         tmpmem[10] = state->S_44_32[2];
     67         tmpmem[11] = state->S_44_32[3];
     68         tmpmem[12] = state->S_44_32[4];
     69         tmpmem[13] = state->S_44_32[5];
     70         tmpmem[14] = state->S_44_32[6];
     71         tmpmem[15] = state->S_44_32[7];
     72         state->S_44_32[0] = tmpmem[440 / SUB_BLOCKS_22_16 + 8];
     73         state->S_44_32[1] = tmpmem[440 / SUB_BLOCKS_22_16 + 9];
     74         state->S_44_32[2] = tmpmem[440 / SUB_BLOCKS_22_16 + 10];
     75         state->S_44_32[3] = tmpmem[440 / SUB_BLOCKS_22_16 + 11];
     76         state->S_44_32[4] = tmpmem[440 / SUB_BLOCKS_22_16 + 12];
     77         state->S_44_32[5] = tmpmem[440 / SUB_BLOCKS_22_16 + 13];
     78         state->S_44_32[6] = tmpmem[440 / SUB_BLOCKS_22_16 + 14];
     79         state->S_44_32[7] = tmpmem[440 / SUB_BLOCKS_22_16 + 15];
     80 
     81         WebRtcSpl_Resample44khzTo32khz(tmpmem + 8, tmpmem, 40 / SUB_BLOCKS_22_16);
     82 
     83         ///// 32 --> 16 /////
     84         // WebRtc_Word32  in[320/SUB_BLOCKS_22_16]
     85         // WebRtc_Word32 out[160/SUB_BLOCKS_22_16]
     86         /////
     87         WebRtcSpl_DownBy2IntToShort(tmpmem, 320 / SUB_BLOCKS_22_16, out, state->S_32_16);
     88 
     89         // move input/output pointers 10/SUB_BLOCKS_22_16 ms seconds ahead
     90         in += 220 / SUB_BLOCKS_22_16;
     91         out += 160 / SUB_BLOCKS_22_16;
     92     }
     93 }
     94 
     95 // initialize state of 22 -> 16 resampler
     96 void WebRtcSpl_ResetResample22khzTo16khz(WebRtcSpl_State22khzTo16khz* state)
     97 {
     98     int k;
     99     for (k = 0; k < 8; k++)
    100     {
    101         state->S_22_44[k] = 0;
    102         state->S_44_32[k] = 0;
    103         state->S_32_16[k] = 0;
    104     }
    105 }
    106 
    107 //////////////////////
    108 // 16 kHz -> 22 kHz //
    109 //////////////////////
    110 
    111 // number of subblocks; options: 1, 2, 4, 5, 10
    112 #define SUB_BLOCKS_16_22    4
    113 
    114 // 16 -> 22 resampler
    115 void WebRtcSpl_Resample16khzTo22khz(const WebRtc_Word16* in, WebRtc_Word16* out,
    116                                     WebRtcSpl_State16khzTo22khz* state, WebRtc_Word32* tmpmem)
    117 {
    118     int k;
    119 
    120     // process two blocks of 10/SUB_BLOCKS_16_22 ms (to reduce temp buffer size)
    121     for (k = 0; k < SUB_BLOCKS_16_22; k++)
    122     {
    123         ///// 16 --> 32 /////
    124         // WebRtc_Word16  in[160/SUB_BLOCKS_16_22]
    125         // WebRtc_Word32 out[320/SUB_BLOCKS_16_22]
    126         /////
    127         WebRtcSpl_UpBy2ShortToInt(in, 160 / SUB_BLOCKS_16_22, tmpmem + 8, state->S_16_32);
    128 
    129         ///// 32 --> 22 /////
    130         // WebRtc_Word32  in[320/SUB_BLOCKS_16_22]
    131         // WebRtc_Word32 out[220/SUB_BLOCKS_16_22]
    132         /////
    133         // copy state to and from input array
    134         tmpmem[0] = state->S_32_22[0];
    135         tmpmem[1] = state->S_32_22[1];
    136         tmpmem[2] = state->S_32_22[2];
    137         tmpmem[3] = state->S_32_22[3];
    138         tmpmem[4] = state->S_32_22[4];
    139         tmpmem[5] = state->S_32_22[5];
    140         tmpmem[6] = state->S_32_22[6];
    141         tmpmem[7] = state->S_32_22[7];
    142         state->S_32_22[0] = tmpmem[320 / SUB_BLOCKS_16_22];
    143         state->S_32_22[1] = tmpmem[320 / SUB_BLOCKS_16_22 + 1];
    144         state->S_32_22[2] = tmpmem[320 / SUB_BLOCKS_16_22 + 2];
    145         state->S_32_22[3] = tmpmem[320 / SUB_BLOCKS_16_22 + 3];
    146         state->S_32_22[4] = tmpmem[320 / SUB_BLOCKS_16_22 + 4];
    147         state->S_32_22[5] = tmpmem[320 / SUB_BLOCKS_16_22 + 5];
    148         state->S_32_22[6] = tmpmem[320 / SUB_BLOCKS_16_22 + 6];
    149         state->S_32_22[7] = tmpmem[320 / SUB_BLOCKS_16_22 + 7];
    150 
    151         WebRtcSpl_32khzTo22khzIntToShort(tmpmem, out, 20 / SUB_BLOCKS_16_22);
    152 
    153         // move input/output pointers 10/SUB_BLOCKS_16_22 ms seconds ahead
    154         in += 160 / SUB_BLOCKS_16_22;
    155         out += 220 / SUB_BLOCKS_16_22;
    156     }
    157 }
    158 
    159 // initialize state of 16 -> 22 resampler
    160 void WebRtcSpl_ResetResample16khzTo22khz(WebRtcSpl_State16khzTo22khz* state)
    161 {
    162     int k;
    163     for (k = 0; k < 8; k++)
    164     {
    165         state->S_16_32[k] = 0;
    166         state->S_32_22[k] = 0;
    167     }
    168 }
    169 
    170 //////////////////////
    171 // 22 kHz ->  8 kHz //
    172 //////////////////////
    173 
    174 // number of subblocks; options: 1, 2, 5, 10
    175 #define SUB_BLOCKS_22_8     2
    176 
    177 // 22 -> 8 resampler
    178 void WebRtcSpl_Resample22khzTo8khz(const WebRtc_Word16* in, WebRtc_Word16* out,
    179                                    WebRtcSpl_State22khzTo8khz* state, WebRtc_Word32* tmpmem)
    180 {
    181     int k;
    182 
    183     // process two blocks of 10/SUB_BLOCKS_22_8 ms (to reduce temp buffer size)
    184     for (k = 0; k < SUB_BLOCKS_22_8; k++)
    185     {
    186         ///// 22 --> 22 lowpass /////
    187         // WebRtc_Word16  in[220/SUB_BLOCKS_22_8]
    188         // WebRtc_Word32 out[220/SUB_BLOCKS_22_8]
    189         /////
    190         WebRtcSpl_LPBy2ShortToInt(in, 220 / SUB_BLOCKS_22_8, tmpmem + 16, state->S_22_22);
    191 
    192         ///// 22 --> 16 /////
    193         // WebRtc_Word32  in[220/SUB_BLOCKS_22_8]
    194         // WebRtc_Word32 out[160/SUB_BLOCKS_22_8]
    195         /////
    196         // copy state to and from input array
    197         tmpmem[8] = state->S_22_16[0];
    198         tmpmem[9] = state->S_22_16[1];
    199         tmpmem[10] = state->S_22_16[2];
    200         tmpmem[11] = state->S_22_16[3];
    201         tmpmem[12] = state->S_22_16[4];
    202         tmpmem[13] = state->S_22_16[5];
    203         tmpmem[14] = state->S_22_16[6];
    204         tmpmem[15] = state->S_22_16[7];
    205         state->S_22_16[0] = tmpmem[220 / SUB_BLOCKS_22_8 + 8];
    206         state->S_22_16[1] = tmpmem[220 / SUB_BLOCKS_22_8 + 9];
    207         state->S_22_16[2] = tmpmem[220 / SUB_BLOCKS_22_8 + 10];
    208         state->S_22_16[3] = tmpmem[220 / SUB_BLOCKS_22_8 + 11];
    209         state->S_22_16[4] = tmpmem[220 / SUB_BLOCKS_22_8 + 12];
    210         state->S_22_16[5] = tmpmem[220 / SUB_BLOCKS_22_8 + 13];
    211         state->S_22_16[6] = tmpmem[220 / SUB_BLOCKS_22_8 + 14];
    212         state->S_22_16[7] = tmpmem[220 / SUB_BLOCKS_22_8 + 15];
    213 
    214         WebRtcSpl_Resample44khzTo32khz(tmpmem + 8, tmpmem, 20 / SUB_BLOCKS_22_8);
    215 
    216         ///// 16 --> 8 /////
    217         // WebRtc_Word32 in[160/SUB_BLOCKS_22_8]
    218         // WebRtc_Word32 out[80/SUB_BLOCKS_22_8]
    219         /////
    220         WebRtcSpl_DownBy2IntToShort(tmpmem, 160 / SUB_BLOCKS_22_8, out, state->S_16_8);
    221 
    222         // move input/output pointers 10/SUB_BLOCKS_22_8 ms seconds ahead
    223         in += 220 / SUB_BLOCKS_22_8;
    224         out += 80 / SUB_BLOCKS_22_8;
    225     }
    226 }
    227 
    228 // initialize state of 22 -> 8 resampler
    229 void WebRtcSpl_ResetResample22khzTo8khz(WebRtcSpl_State22khzTo8khz* state)
    230 {
    231     int k;
    232     for (k = 0; k < 8; k++)
    233     {
    234         state->S_22_22[k] = 0;
    235         state->S_22_22[k + 8] = 0;
    236         state->S_22_16[k] = 0;
    237         state->S_16_8[k] = 0;
    238     }
    239 }
    240 
    241 //////////////////////
    242 //  8 kHz -> 22 kHz //
    243 //////////////////////
    244 
    245 // number of subblocks; options: 1, 2, 5, 10
    246 #define SUB_BLOCKS_8_22     2
    247 
    248 // 8 -> 22 resampler
    249 void WebRtcSpl_Resample8khzTo22khz(const WebRtc_Word16* in, WebRtc_Word16* out,
    250                                    WebRtcSpl_State8khzTo22khz* state, WebRtc_Word32* tmpmem)
    251 {
    252     int k;
    253 
    254     // process two blocks of 10/SUB_BLOCKS_8_22 ms (to reduce temp buffer size)
    255     for (k = 0; k < SUB_BLOCKS_8_22; k++)
    256     {
    257         ///// 8 --> 16 /////
    258         // WebRtc_Word16  in[80/SUB_BLOCKS_8_22]
    259         // WebRtc_Word32 out[160/SUB_BLOCKS_8_22]
    260         /////
    261         WebRtcSpl_UpBy2ShortToInt(in, 80 / SUB_BLOCKS_8_22, tmpmem + 18, state->S_8_16);
    262 
    263         ///// 16 --> 11 /////
    264         // WebRtc_Word32  in[160/SUB_BLOCKS_8_22]
    265         // WebRtc_Word32 out[110/SUB_BLOCKS_8_22]
    266         /////
    267         // copy state to and from input array
    268         tmpmem[10] = state->S_16_11[0];
    269         tmpmem[11] = state->S_16_11[1];
    270         tmpmem[12] = state->S_16_11[2];
    271         tmpmem[13] = state->S_16_11[3];
    272         tmpmem[14] = state->S_16_11[4];
    273         tmpmem[15] = state->S_16_11[5];
    274         tmpmem[16] = state->S_16_11[6];
    275         tmpmem[17] = state->S_16_11[7];
    276         state->S_16_11[0] = tmpmem[160 / SUB_BLOCKS_8_22 + 10];
    277         state->S_16_11[1] = tmpmem[160 / SUB_BLOCKS_8_22 + 11];
    278         state->S_16_11[2] = tmpmem[160 / SUB_BLOCKS_8_22 + 12];
    279         state->S_16_11[3] = tmpmem[160 / SUB_BLOCKS_8_22 + 13];
    280         state->S_16_11[4] = tmpmem[160 / SUB_BLOCKS_8_22 + 14];
    281         state->S_16_11[5] = tmpmem[160 / SUB_BLOCKS_8_22 + 15];
    282         state->S_16_11[6] = tmpmem[160 / SUB_BLOCKS_8_22 + 16];
    283         state->S_16_11[7] = tmpmem[160 / SUB_BLOCKS_8_22 + 17];
    284 
    285         WebRtcSpl_32khzTo22khzIntToInt(tmpmem + 10, tmpmem, 10 / SUB_BLOCKS_8_22);
    286 
    287         ///// 11 --> 22 /////
    288         // WebRtc_Word32  in[110/SUB_BLOCKS_8_22]
    289         // WebRtc_Word16 out[220/SUB_BLOCKS_8_22]
    290         /////
    291         WebRtcSpl_UpBy2IntToShort(tmpmem, 110 / SUB_BLOCKS_8_22, out, state->S_11_22);
    292 
    293         // move input/output pointers 10/SUB_BLOCKS_8_22 ms seconds ahead
    294         in += 80 / SUB_BLOCKS_8_22;
    295         out += 220 / SUB_BLOCKS_8_22;
    296     }
    297 }
    298 
    299 // initialize state of 8 -> 22 resampler
    300 void WebRtcSpl_ResetResample8khzTo22khz(WebRtcSpl_State8khzTo22khz* state)
    301 {
    302     int k;
    303     for (k = 0; k < 8; k++)
    304     {
    305         state->S_8_16[k] = 0;
    306         state->S_16_11[k] = 0;
    307         state->S_11_22[k] = 0;
    308     }
    309 }
    310 
    311 // compute two inner-products and store them to output array
    312 static void WebRtcSpl_DotProdIntToInt(const WebRtc_Word32* in1, const WebRtc_Word32* in2,
    313                                       const WebRtc_Word16* coef_ptr, WebRtc_Word32* out1,
    314                                       WebRtc_Word32* out2)
    315 {
    316     WebRtc_Word32 tmp1 = 16384;
    317     WebRtc_Word32 tmp2 = 16384;
    318     WebRtc_Word16 coef;
    319 
    320     coef = coef_ptr[0];
    321     tmp1 += coef * in1[0];
    322     tmp2 += coef * in2[-0];
    323 
    324     coef = coef_ptr[1];
    325     tmp1 += coef * in1[1];
    326     tmp2 += coef * in2[-1];
    327 
    328     coef = coef_ptr[2];
    329     tmp1 += coef * in1[2];
    330     tmp2 += coef * in2[-2];
    331 
    332     coef = coef_ptr[3];
    333     tmp1 += coef * in1[3];
    334     tmp2 += coef * in2[-3];
    335 
    336     coef = coef_ptr[4];
    337     tmp1 += coef * in1[4];
    338     tmp2 += coef * in2[-4];
    339 
    340     coef = coef_ptr[5];
    341     tmp1 += coef * in1[5];
    342     tmp2 += coef * in2[-5];
    343 
    344     coef = coef_ptr[6];
    345     tmp1 += coef * in1[6];
    346     tmp2 += coef * in2[-6];
    347 
    348     coef = coef_ptr[7];
    349     tmp1 += coef * in1[7];
    350     tmp2 += coef * in2[-7];
    351 
    352     coef = coef_ptr[8];
    353     *out1 = tmp1 + coef * in1[8];
    354     *out2 = tmp2 + coef * in2[-8];
    355 }
    356 
    357 // compute two inner-products and store them to output array
    358 static void WebRtcSpl_DotProdIntToShort(const WebRtc_Word32* in1, const WebRtc_Word32* in2,
    359                                         const WebRtc_Word16* coef_ptr, WebRtc_Word16* out1,
    360                                         WebRtc_Word16* out2)
    361 {
    362     WebRtc_Word32 tmp1 = 16384;
    363     WebRtc_Word32 tmp2 = 16384;
    364     WebRtc_Word16 coef;
    365 
    366     coef = coef_ptr[0];
    367     tmp1 += coef * in1[0];
    368     tmp2 += coef * in2[-0];
    369 
    370     coef = coef_ptr[1];
    371     tmp1 += coef * in1[1];
    372     tmp2 += coef * in2[-1];
    373 
    374     coef = coef_ptr[2];
    375     tmp1 += coef * in1[2];
    376     tmp2 += coef * in2[-2];
    377 
    378     coef = coef_ptr[3];
    379     tmp1 += coef * in1[3];
    380     tmp2 += coef * in2[-3];
    381 
    382     coef = coef_ptr[4];
    383     tmp1 += coef * in1[4];
    384     tmp2 += coef * in2[-4];
    385 
    386     coef = coef_ptr[5];
    387     tmp1 += coef * in1[5];
    388     tmp2 += coef * in2[-5];
    389 
    390     coef = coef_ptr[6];
    391     tmp1 += coef * in1[6];
    392     tmp2 += coef * in2[-6];
    393 
    394     coef = coef_ptr[7];
    395     tmp1 += coef * in1[7];
    396     tmp2 += coef * in2[-7];
    397 
    398     coef = coef_ptr[8];
    399     tmp1 += coef * in1[8];
    400     tmp2 += coef * in2[-8];
    401 
    402     // scale down, round and saturate
    403     tmp1 >>= 15;
    404     if (tmp1 > (WebRtc_Word32)0x00007FFF)
    405         tmp1 = 0x00007FFF;
    406     if (tmp1 < (WebRtc_Word32)0xFFFF8000)
    407         tmp1 = 0xFFFF8000;
    408     tmp2 >>= 15;
    409     if (tmp2 > (WebRtc_Word32)0x00007FFF)
    410         tmp2 = 0x00007FFF;
    411     if (tmp2 < (WebRtc_Word32)0xFFFF8000)
    412         tmp2 = 0xFFFF8000;
    413     *out1 = (WebRtc_Word16)tmp1;
    414     *out2 = (WebRtc_Word16)tmp2;
    415 }
    416 
    417 //   Resampling ratio: 11/16
    418 // input:  WebRtc_Word32 (normalized, not saturated) :: size 16 * K
    419 // output: WebRtc_Word32 (shifted 15 positions to the left, + offset 16384) :: size 11 * K
    420 //      K: Number of blocks
    421 
    422 void WebRtcSpl_32khzTo22khzIntToInt(const WebRtc_Word32* In,
    423                                     WebRtc_Word32* Out,
    424                                     const WebRtc_Word32 K)
    425 {
    426     /////////////////////////////////////////////////////////////
    427     // Filter operation:
    428     //
    429     // Perform resampling (16 input samples -> 11 output samples);
    430     // process in sub blocks of size 16 samples.
    431     WebRtc_Word32 m;
    432 
    433     for (m = 0; m < K; m++)
    434     {
    435         // first output sample
    436         Out[0] = ((WebRtc_Word32)In[3] << 15) + (1 << 14);
    437 
    438         // sum and accumulate filter coefficients and input samples
    439         WebRtcSpl_DotProdIntToInt(&In[0], &In[22], kCoefficients32To22[0], &Out[1], &Out[10]);
    440 
    441         // sum and accumulate filter coefficients and input samples
    442         WebRtcSpl_DotProdIntToInt(&In[2], &In[20], kCoefficients32To22[1], &Out[2], &Out[9]);
    443 
    444         // sum and accumulate filter coefficients and input samples
    445         WebRtcSpl_DotProdIntToInt(&In[3], &In[19], kCoefficients32To22[2], &Out[3], &Out[8]);
    446 
    447         // sum and accumulate filter coefficients and input samples
    448         WebRtcSpl_DotProdIntToInt(&In[5], &In[17], kCoefficients32To22[3], &Out[4], &Out[7]);
    449 
    450         // sum and accumulate filter coefficients and input samples
    451         WebRtcSpl_DotProdIntToInt(&In[6], &In[16], kCoefficients32To22[4], &Out[5], &Out[6]);
    452 
    453         // update pointers
    454         In += 16;
    455         Out += 11;
    456     }
    457 }
    458 
    459 //   Resampling ratio: 11/16
    460 // input:  WebRtc_Word32 (normalized, not saturated) :: size 16 * K
    461 // output: WebRtc_Word16 (saturated) :: size 11 * K
    462 //      K: Number of blocks
    463 
    464 void WebRtcSpl_32khzTo22khzIntToShort(const WebRtc_Word32 *In,
    465                                       WebRtc_Word16 *Out,
    466                                       const WebRtc_Word32 K)
    467 {
    468     /////////////////////////////////////////////////////////////
    469     // Filter operation:
    470     //
    471     // Perform resampling (16 input samples -> 11 output samples);
    472     // process in sub blocks of size 16 samples.
    473     WebRtc_Word32 tmp;
    474     WebRtc_Word32 m;
    475 
    476     for (m = 0; m < K; m++)
    477     {
    478         // first output sample
    479         tmp = In[3];
    480         if (tmp > (WebRtc_Word32)0x00007FFF)
    481             tmp = 0x00007FFF;
    482         if (tmp < (WebRtc_Word32)0xFFFF8000)
    483             tmp = 0xFFFF8000;
    484         Out[0] = (WebRtc_Word16)tmp;
    485 
    486         // sum and accumulate filter coefficients and input samples
    487         WebRtcSpl_DotProdIntToShort(&In[0], &In[22], kCoefficients32To22[0], &Out[1], &Out[10]);
    488 
    489         // sum and accumulate filter coefficients and input samples
    490         WebRtcSpl_DotProdIntToShort(&In[2], &In[20], kCoefficients32To22[1], &Out[2], &Out[9]);
    491 
    492         // sum and accumulate filter coefficients and input samples
    493         WebRtcSpl_DotProdIntToShort(&In[3], &In[19], kCoefficients32To22[2], &Out[3], &Out[8]);
    494 
    495         // sum and accumulate filter coefficients and input samples
    496         WebRtcSpl_DotProdIntToShort(&In[5], &In[17], kCoefficients32To22[3], &Out[4], &Out[7]);
    497 
    498         // sum and accumulate filter coefficients and input samples
    499         WebRtcSpl_DotProdIntToShort(&In[6], &In[16], kCoefficients32To22[4], &Out[5], &Out[6]);
    500 
    501         // update pointers
    502         In += 16;
    503         Out += 11;
    504     }
    505 }
    506