Home | History | Annotate | Download | only in signal_processing
      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  * This file contains the splitting filter functions.
     13  *
     14  */
     15 
     16 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
     17 
     18 #include <assert.h>
     19 
     20 // Maximum number of samples in a low/high-band frame.
     21 enum
     22 {
     23     kMaxBandFrameLength = 240  // 10 ms at 48 kHz.
     24 };
     25 
     26 // QMF filter coefficients in Q16.
     27 static const uint16_t WebRtcSpl_kAllPassFilter1[3] = {6418, 36982, 57261};
     28 static const uint16_t WebRtcSpl_kAllPassFilter2[3] = {21333, 49062, 63010};
     29 
     30 ///////////////////////////////////////////////////////////////////////////////////////////////
     31 // WebRtcSpl_AllPassQMF(...)
     32 //
     33 // Allpass filter used by the analysis and synthesis parts of the QMF filter.
     34 //
     35 // Input:
     36 //    - in_data             : Input data sequence (Q10)
     37 //    - data_length         : Length of data sequence (>2)
     38 //    - filter_coefficients : Filter coefficients (length 3, Q16)
     39 //
     40 // Input & Output:
     41 //    - filter_state        : Filter state (length 6, Q10).
     42 //
     43 // Output:
     44 //    - out_data            : Output data sequence (Q10), length equal to
     45 //                            |data_length|
     46 //
     47 
     48 void WebRtcSpl_AllPassQMF(int32_t* in_data, int data_length,
     49                           int32_t* out_data, const uint16_t* filter_coefficients,
     50                           int32_t* filter_state)
     51 {
     52     // The procedure is to filter the input with three first order all pass filters
     53     // (cascade operations).
     54     //
     55     //         a_3 + q^-1    a_2 + q^-1    a_1 + q^-1
     56     // y[n] =  -----------   -----------   -----------   x[n]
     57     //         1 + a_3q^-1   1 + a_2q^-1   1 + a_1q^-1
     58     //
     59     // The input vector |filter_coefficients| includes these three filter coefficients.
     60     // The filter state contains the in_data state, in_data[-1], followed by
     61     // the out_data state, out_data[-1]. This is repeated for each cascade.
     62     // The first cascade filter will filter the |in_data| and store the output in
     63     // |out_data|. The second will the take the |out_data| as input and make an
     64     // intermediate storage in |in_data|, to save memory. The third, and final, cascade
     65     // filter operation takes the |in_data| (which is the output from the previous cascade
     66     // filter) and store the output in |out_data|.
     67     // Note that the input vector values are changed during the process.
     68     int k;
     69     int32_t diff;
     70     // First all-pass cascade; filter from in_data to out_data.
     71 
     72     // Let y_i[n] indicate the output of cascade filter i (with filter coefficient a_i) at
     73     // vector position n. Then the final output will be y[n] = y_3[n]
     74 
     75     // First loop, use the states stored in memory.
     76     // "diff" should be safe from wrap around since max values are 2^25
     77     // diff = (x[0] - y_1[-1])
     78     diff = WebRtcSpl_SubSatW32(in_data[0], filter_state[1]);
     79     // y_1[0] =  x[-1] + a_1 * (x[0] - y_1[-1])
     80     out_data[0] = WEBRTC_SPL_SCALEDIFF32(filter_coefficients[0], diff, filter_state[0]);
     81 
     82     // For the remaining loops, use previous values.
     83     for (k = 1; k < data_length; k++)
     84     {
     85         // diff = (x[n] - y_1[n-1])
     86         diff = WebRtcSpl_SubSatW32(in_data[k], out_data[k - 1]);
     87         // y_1[n] =  x[n-1] + a_1 * (x[n] - y_1[n-1])
     88         out_data[k] = WEBRTC_SPL_SCALEDIFF32(filter_coefficients[0], diff, in_data[k - 1]);
     89     }
     90 
     91     // Update states.
     92     filter_state[0] = in_data[data_length - 1]; // x[N-1], becomes x[-1] next time
     93     filter_state[1] = out_data[data_length - 1]; // y_1[N-1], becomes y_1[-1] next time
     94 
     95     // Second all-pass cascade; filter from out_data to in_data.
     96     // diff = (y_1[0] - y_2[-1])
     97     diff = WebRtcSpl_SubSatW32(out_data[0], filter_state[3]);
     98     // y_2[0] =  y_1[-1] + a_2 * (y_1[0] - y_2[-1])
     99     in_data[0] = WEBRTC_SPL_SCALEDIFF32(filter_coefficients[1], diff, filter_state[2]);
    100     for (k = 1; k < data_length; k++)
    101     {
    102         // diff = (y_1[n] - y_2[n-1])
    103         diff = WebRtcSpl_SubSatW32(out_data[k], in_data[k - 1]);
    104         // y_2[0] =  y_1[-1] + a_2 * (y_1[0] - y_2[-1])
    105         in_data[k] = WEBRTC_SPL_SCALEDIFF32(filter_coefficients[1], diff, out_data[k-1]);
    106     }
    107 
    108     filter_state[2] = out_data[data_length - 1]; // y_1[N-1], becomes y_1[-1] next time
    109     filter_state[3] = in_data[data_length - 1]; // y_2[N-1], becomes y_2[-1] next time
    110 
    111     // Third all-pass cascade; filter from in_data to out_data.
    112     // diff = (y_2[0] - y[-1])
    113     diff = WebRtcSpl_SubSatW32(in_data[0], filter_state[5]);
    114     // y[0] =  y_2[-1] + a_3 * (y_2[0] - y[-1])
    115     out_data[0] = WEBRTC_SPL_SCALEDIFF32(filter_coefficients[2], diff, filter_state[4]);
    116     for (k = 1; k < data_length; k++)
    117     {
    118         // diff = (y_2[n] - y[n-1])
    119         diff = WebRtcSpl_SubSatW32(in_data[k], out_data[k - 1]);
    120         // y[n] =  y_2[n-1] + a_3 * (y_2[n] - y[n-1])
    121         out_data[k] = WEBRTC_SPL_SCALEDIFF32(filter_coefficients[2], diff, in_data[k-1]);
    122     }
    123     filter_state[4] = in_data[data_length - 1]; // y_2[N-1], becomes y_2[-1] next time
    124     filter_state[5] = out_data[data_length - 1]; // y[N-1], becomes y[-1] next time
    125 }
    126 
    127 void WebRtcSpl_AnalysisQMF(const int16_t* in_data, int in_data_length,
    128                            int16_t* low_band, int16_t* high_band,
    129                            int32_t* filter_state1, int32_t* filter_state2)
    130 {
    131     int16_t i;
    132     int16_t k;
    133     int32_t tmp;
    134     int32_t half_in1[kMaxBandFrameLength];
    135     int32_t half_in2[kMaxBandFrameLength];
    136     int32_t filter1[kMaxBandFrameLength];
    137     int32_t filter2[kMaxBandFrameLength];
    138     const int band_length = in_data_length / 2;
    139     assert(in_data_length % 2 == 0);
    140     assert(band_length <= kMaxBandFrameLength);
    141 
    142     // Split even and odd samples. Also shift them to Q10.
    143     for (i = 0, k = 0; i < band_length; i++, k += 2)
    144     {
    145         half_in2[i] = WEBRTC_SPL_LSHIFT_W32((int32_t)in_data[k], 10);
    146         half_in1[i] = WEBRTC_SPL_LSHIFT_W32((int32_t)in_data[k + 1], 10);
    147     }
    148 
    149     // All pass filter even and odd samples, independently.
    150     WebRtcSpl_AllPassQMF(half_in1, band_length, filter1,
    151                          WebRtcSpl_kAllPassFilter1, filter_state1);
    152     WebRtcSpl_AllPassQMF(half_in2, band_length, filter2,
    153                          WebRtcSpl_kAllPassFilter2, filter_state2);
    154 
    155     // Take the sum and difference of filtered version of odd and even
    156     // branches to get upper & lower band.
    157     for (i = 0; i < band_length; i++)
    158     {
    159         tmp = filter1[i] + filter2[i] + 1024;
    160         tmp = WEBRTC_SPL_RSHIFT_W32(tmp, 11);
    161         low_band[i] = WebRtcSpl_SatW32ToW16(tmp);
    162 
    163         tmp = filter1[i] - filter2[i] + 1024;
    164         tmp = WEBRTC_SPL_RSHIFT_W32(tmp, 11);
    165         high_band[i] = WebRtcSpl_SatW32ToW16(tmp);
    166     }
    167 }
    168 
    169 void WebRtcSpl_SynthesisQMF(const int16_t* low_band, const int16_t* high_band,
    170                             int band_length, int16_t* out_data,
    171                             int32_t* filter_state1, int32_t* filter_state2)
    172 {
    173     int32_t tmp;
    174     int32_t half_in1[kMaxBandFrameLength];
    175     int32_t half_in2[kMaxBandFrameLength];
    176     int32_t filter1[kMaxBandFrameLength];
    177     int32_t filter2[kMaxBandFrameLength];
    178     int16_t i;
    179     int16_t k;
    180     assert(band_length <= kMaxBandFrameLength);
    181 
    182     // Obtain the sum and difference channels out of upper and lower-band channels.
    183     // Also shift to Q10 domain.
    184     for (i = 0; i < band_length; i++)
    185     {
    186         tmp = (int32_t)low_band[i] + (int32_t)high_band[i];
    187         half_in1[i] = WEBRTC_SPL_LSHIFT_W32(tmp, 10);
    188         tmp = (int32_t)low_band[i] - (int32_t)high_band[i];
    189         half_in2[i] = WEBRTC_SPL_LSHIFT_W32(tmp, 10);
    190     }
    191 
    192     // all-pass filter the sum and difference channels
    193     WebRtcSpl_AllPassQMF(half_in1, band_length, filter1,
    194                          WebRtcSpl_kAllPassFilter2, filter_state1);
    195     WebRtcSpl_AllPassQMF(half_in2, band_length, filter2,
    196                          WebRtcSpl_kAllPassFilter1, filter_state2);
    197 
    198     // The filtered signals are even and odd samples of the output. Combine
    199     // them. The signals are Q10 should shift them back to Q0 and take care of
    200     // saturation.
    201     for (i = 0, k = 0; i < band_length; i++)
    202     {
    203         tmp = WEBRTC_SPL_RSHIFT_W32(filter2[i] + 512, 10);
    204         out_data[k++] = WebRtcSpl_SatW32ToW16(tmp);
    205 
    206         tmp = WEBRTC_SPL_RSHIFT_W32(filter1[i] + 512, 10);
    207         out_data[k++] = WebRtcSpl_SatW32ToW16(tmp);
    208     }
    209 
    210 }
    211