1 /* 2 * Copyright (c) 2012 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 * filterbanks.c 13 * 14 * This file contains function 15 * WebRtcIsacfix_SplitAndFilter, and WebRtcIsacfix_FilterAndCombine 16 * which implement filterbanks that produce decimated lowpass and 17 * highpass versions of a signal, and performs reconstruction. 18 * 19 */ 20 21 #include "filterbank_internal.h" 22 23 #include <assert.h> 24 25 #include "codec.h" 26 #include "filterbank_tables.h" 27 #include "settings.h" 28 29 // Declare a function pointer. 30 AllpassFilter2FixDec16 WebRtcIsacfix_AllpassFilter2FixDec16; 31 32 void WebRtcIsacfix_AllpassFilter2FixDec16C( 33 int16_t *data_ch1, // Input and output in channel 1, in Q0 34 int16_t *data_ch2, // Input and output in channel 2, in Q0 35 const int16_t *factor_ch1, // Scaling factor for channel 1, in Q15 36 const int16_t *factor_ch2, // Scaling factor for channel 2, in Q15 37 const int length, // Length of the data buffers 38 int32_t *filter_state_ch1, // Filter state for channel 1, in Q16 39 int32_t *filter_state_ch2) { // Filter state for channel 2, in Q16 40 int n = 0; 41 int32_t state0_ch1 = filter_state_ch1[0], state1_ch1 = filter_state_ch1[1]; 42 int32_t state0_ch2 = filter_state_ch2[0], state1_ch2 = filter_state_ch2[1]; 43 int16_t in_out = 0; 44 int32_t a = 0, b = 0; 45 46 // Assembly file assumption. 47 assert(length % 2 == 0); 48 49 for (n = 0; n < length; n++) { 50 // Process channel 1: 51 in_out = data_ch1[n]; 52 a = WEBRTC_SPL_MUL_16_16(factor_ch1[0], in_out); // Q15 * Q0 = Q15 53 a <<= 1; // Q15 -> Q16 54 b = WebRtcSpl_AddSatW32(a, state0_ch1); 55 a = WEBRTC_SPL_MUL_16_16(-factor_ch1[0], (int16_t) (b >> 16)); // Q15 56 state0_ch1 = WebRtcSpl_AddSatW32(a << 1, (uint32_t)in_out << 16); // Q16 57 in_out = (int16_t) (b >> 16); // Save as Q0 58 59 a = WEBRTC_SPL_MUL_16_16(factor_ch1[1], in_out); // Q15 * Q0 = Q15 60 a <<= 1; // Q15 -> Q16 61 b = WebRtcSpl_AddSatW32(a, state1_ch1); // Q16 62 a = WEBRTC_SPL_MUL_16_16(-factor_ch1[1], (int16_t) (b >> 16)); // Q15 63 state1_ch1 = WebRtcSpl_AddSatW32(a << 1, (uint32_t)in_out << 16); // Q16 64 data_ch1[n] = (int16_t) (b >> 16); // Save as Q0 65 66 // Process channel 2: 67 in_out = data_ch2[n]; 68 a = WEBRTC_SPL_MUL_16_16(factor_ch2[0], in_out); // Q15 * Q0 = Q15 69 a <<= 1; // Q15 -> Q16 70 b = WebRtcSpl_AddSatW32(a, state0_ch2); // Q16 71 a = WEBRTC_SPL_MUL_16_16(-factor_ch2[0], (int16_t) (b >> 16)); // Q15 72 state0_ch2 = WebRtcSpl_AddSatW32(a << 1, (uint32_t)in_out << 16); // Q16 73 in_out = (int16_t) (b >> 16); // Save as Q0 74 75 a = WEBRTC_SPL_MUL_16_16(factor_ch2[1], in_out); // Q15 * Q0 = Q15 76 a <<= 1; // Q15 -> Q16 77 b = WebRtcSpl_AddSatW32(a, state1_ch2); // Q16 78 a = WEBRTC_SPL_MUL_16_16(-factor_ch2[1], (int16_t) (b >> 16)); // Q15 79 state1_ch2 = WebRtcSpl_AddSatW32(a << 1, (uint32_t)in_out << 16); // Q16 80 data_ch2[n] = (int16_t) (b >> 16); // Save as Q0 81 } 82 83 filter_state_ch1[0] = state0_ch1; 84 filter_state_ch1[1] = state1_ch1; 85 filter_state_ch2[0] = state0_ch2; 86 filter_state_ch2[1] = state1_ch2; 87 } 88 89 // Declare a function pointer. 90 HighpassFilterFixDec32 WebRtcIsacfix_HighpassFilterFixDec32; 91 92 void WebRtcIsacfix_HighpassFilterFixDec32C(int16_t *io, 93 int16_t len, 94 const int16_t *coefficient, 95 int32_t *state) 96 { 97 int k; 98 int32_t a1 = 0, b1 = 0, c = 0, in = 0; 99 int32_t a2 = 0, b2 = 0; 100 int32_t state0 = state[0]; 101 int32_t state1 = state[1]; 102 103 for (k=0; k<len; k++) { 104 in = (int32_t)io[k]; 105 106 #ifdef WEBRTC_ARCH_ARM_V7 107 { 108 register int tmp_coeff0; 109 register int tmp_coeff1; 110 __asm __volatile( 111 "ldr %[tmp_coeff0], [%[coeff]]\n\t" 112 "ldr %[tmp_coeff1], [%[coeff], #4]\n\t" 113 "smmulr %[a2], %[tmp_coeff0], %[state0]\n\t" 114 "smmulr %[b2], %[tmp_coeff1], %[state1]\n\t" 115 "ldr %[tmp_coeff0], [%[coeff], #8]\n\t" 116 "ldr %[tmp_coeff1], [%[coeff], #12]\n\t" 117 "smmulr %[a1], %[tmp_coeff0], %[state0]\n\t" 118 "smmulr %[b1], %[tmp_coeff1], %[state1]\n\t" 119 :[a2]"=&r"(a2), 120 [b2]"=&r"(b2), 121 [a1]"=&r"(a1), 122 [b1]"=r"(b1), 123 [tmp_coeff0]"=&r"(tmp_coeff0), 124 [tmp_coeff1]"=&r"(tmp_coeff1) 125 :[coeff]"r"(coefficient), 126 [state0]"r"(state0), 127 [state1]"r"(state1) 128 ); 129 } 130 #else 131 /* Q35 * Q4 = Q39 ; shift 32 bit => Q7 */ 132 a1 = WEBRTC_SPL_MUL_16_32_RSFT16(coefficient[5], state0) + 133 (WEBRTC_SPL_MUL_16_32_RSFT16(coefficient[4], state0) >> 16); 134 b1 = WEBRTC_SPL_MUL_16_32_RSFT16(coefficient[7], state1) + 135 (WEBRTC_SPL_MUL_16_32_RSFT16(coefficient[6], state1) >> 16); 136 137 /* Q30 * Q4 = Q34 ; shift 32 bit => Q2 */ 138 a2 = WEBRTC_SPL_MUL_16_32_RSFT16(coefficient[1], state0) + 139 (WEBRTC_SPL_MUL_16_32_RSFT16(coefficient[0], state0) >> 16); 140 b2 = WEBRTC_SPL_MUL_16_32_RSFT16(coefficient[3], state1) + 141 (WEBRTC_SPL_MUL_16_32_RSFT16(coefficient[2], state1) >> 16); 142 #endif 143 144 c = ((int32_t)in) + WEBRTC_SPL_RSHIFT_W32(a1+b1, 7); // Q0 145 io[k] = (int16_t)WebRtcSpl_SatW32ToW16(c); // Write output as Q0. 146 147 c = WEBRTC_SPL_LSHIFT_W32((int32_t)in, 2) - a2 - b2; // In Q2. 148 c = (int32_t)WEBRTC_SPL_SAT(536870911, c, -536870912); 149 150 state1 = state0; 151 state0 = WEBRTC_SPL_LSHIFT_W32(c, 2); // Write state as Q4 152 } 153 state[0] = state0; 154 state[1] = state1; 155 } 156 157 158 void WebRtcIsacfix_SplitAndFilter1(int16_t *pin, 159 int16_t *LP16, 160 int16_t *HP16, 161 PreFiltBankstr *prefiltdata) 162 { 163 /* Function WebRtcIsacfix_SplitAndFilter */ 164 /* This function creates low-pass and high-pass decimated versions of part of 165 the input signal, and part of the signal in the input 'lookahead buffer'. */ 166 167 int k; 168 169 int16_t tempin_ch1[FRAMESAMPLES/2 + QLOOKAHEAD]; 170 int16_t tempin_ch2[FRAMESAMPLES/2 + QLOOKAHEAD]; 171 int32_t tmpState_ch1[2 * (QORDER-1)]; /* 4 */ 172 int32_t tmpState_ch2[2 * (QORDER-1)]; /* 4 */ 173 174 /* High pass filter */ 175 WebRtcIsacfix_HighpassFilterFixDec32(pin, FRAMESAMPLES, WebRtcIsacfix_kHpStCoeffInQ30, prefiltdata->HPstates_fix); 176 177 178 /* First Channel */ 179 for (k=0;k<FRAMESAMPLES/2;k++) { 180 tempin_ch1[QLOOKAHEAD + k] = pin[1+WEBRTC_SPL_MUL_16_16(2, k)]; 181 } 182 for (k=0;k<QLOOKAHEAD;k++) { 183 tempin_ch1[k]=prefiltdata->INLABUF1_fix[k]; 184 prefiltdata->INLABUF1_fix[k]=pin[FRAMESAMPLES+1-WEBRTC_SPL_MUL_16_16(2, QLOOKAHEAD)+WEBRTC_SPL_MUL_16_16(2, k)]; 185 } 186 187 /* Second Channel. This is exactly like the first channel, except that the 188 even samples are now filtered instead (lower channel). */ 189 for (k=0;k<FRAMESAMPLES/2;k++) { 190 tempin_ch2[QLOOKAHEAD+k] = pin[WEBRTC_SPL_MUL_16_16(2, k)]; 191 } 192 for (k=0;k<QLOOKAHEAD;k++) { 193 tempin_ch2[k]=prefiltdata->INLABUF2_fix[k]; 194 prefiltdata->INLABUF2_fix[k]=pin[FRAMESAMPLES-WEBRTC_SPL_MUL_16_16(2, QLOOKAHEAD)+WEBRTC_SPL_MUL_16_16(2, k)]; 195 } 196 197 198 /*obtain polyphase components by forward all-pass filtering through each channel */ 199 /* The all pass filtering automatically updates the filter states which are exported in the 200 prefiltdata structure */ 201 WebRtcIsacfix_AllpassFilter2FixDec16(tempin_ch1, 202 tempin_ch2, 203 WebRtcIsacfix_kUpperApFactorsQ15, 204 WebRtcIsacfix_kLowerApFactorsQ15, 205 FRAMESAMPLES/2, 206 prefiltdata->INSTAT1_fix, 207 prefiltdata->INSTAT2_fix); 208 209 for (k=0;k<WEBRTC_SPL_MUL_16_16(2, (QORDER-1));k++) { 210 tmpState_ch1[k] = prefiltdata->INSTAT1_fix[k]; 211 tmpState_ch2[k] = prefiltdata->INSTAT2_fix[k]; 212 } 213 WebRtcIsacfix_AllpassFilter2FixDec16(tempin_ch1 + FRAMESAMPLES/2, 214 tempin_ch2 + FRAMESAMPLES/2, 215 WebRtcIsacfix_kUpperApFactorsQ15, 216 WebRtcIsacfix_kLowerApFactorsQ15, 217 QLOOKAHEAD, 218 tmpState_ch1, 219 tmpState_ch2); 220 221 /* Now Construct low-pass and high-pass signals as combinations of polyphase components */ 222 for (k=0; k<FRAMESAMPLES/2 + QLOOKAHEAD; k++) { 223 int32_t tmp1, tmp2, tmp3; 224 tmp1 = (int32_t)tempin_ch1[k]; // Q0 -> Q0 225 tmp2 = (int32_t)tempin_ch2[k]; // Q0 -> Q0 226 tmp3 = (int32_t)WEBRTC_SPL_RSHIFT_W32((tmp1 + tmp2), 1);/* low pass signal*/ 227 LP16[k] = (int16_t)WebRtcSpl_SatW32ToW16(tmp3); /*low pass */ 228 tmp3 = (int32_t)WEBRTC_SPL_RSHIFT_W32((tmp1 - tmp2), 1);/* high pass signal*/ 229 HP16[k] = (int16_t)WebRtcSpl_SatW32ToW16(tmp3); /*high pass */ 230 } 231 232 }/*end of WebRtcIsacfix_SplitAndFilter */ 233 234 235 #ifdef WEBRTC_ISAC_FIX_NB_CALLS_ENABLED 236 237 /* Without lookahead */ 238 void WebRtcIsacfix_SplitAndFilter2(int16_t *pin, 239 int16_t *LP16, 240 int16_t *HP16, 241 PreFiltBankstr *prefiltdata) 242 { 243 /* Function WebRtcIsacfix_SplitAndFilter2 */ 244 /* This function creates low-pass and high-pass decimated versions of part of 245 the input signal. */ 246 247 int k; 248 249 int16_t tempin_ch1[FRAMESAMPLES/2]; 250 int16_t tempin_ch2[FRAMESAMPLES/2]; 251 252 253 /* High pass filter */ 254 WebRtcIsacfix_HighpassFilterFixDec32(pin, FRAMESAMPLES, WebRtcIsacfix_kHpStCoeffInQ30, prefiltdata->HPstates_fix); 255 256 257 /* First Channel */ 258 for (k=0;k<FRAMESAMPLES/2;k++) { 259 tempin_ch1[k] = pin[1+WEBRTC_SPL_MUL_16_16(2, k)]; 260 } 261 262 /* Second Channel. This is exactly like the first channel, except that the 263 even samples are now filtered instead (lower channel). */ 264 for (k=0;k<FRAMESAMPLES/2;k++) { 265 tempin_ch2[k] = pin[WEBRTC_SPL_MUL_16_16(2, k)]; 266 } 267 268 269 /*obtain polyphase components by forward all-pass filtering through each channel */ 270 /* The all pass filtering automatically updates the filter states which are exported in the 271 prefiltdata structure */ 272 WebRtcIsacfix_AllpassFilter2FixDec16(tempin_ch1, 273 tempin_ch2, 274 WebRtcIsacfix_kUpperApFactorsQ15, 275 WebRtcIsacfix_kLowerApFactorsQ15, 276 FRAMESAMPLES/2, 277 prefiltdata->INSTAT1_fix, 278 prefiltdata->INSTAT2_fix); 279 280 /* Now Construct low-pass and high-pass signals as combinations of polyphase components */ 281 for (k=0; k<FRAMESAMPLES/2; k++) { 282 int32_t tmp1, tmp2, tmp3; 283 tmp1 = (int32_t)tempin_ch1[k]; // Q0 -> Q0 284 tmp2 = (int32_t)tempin_ch2[k]; // Q0 -> Q0 285 tmp3 = (int32_t)WEBRTC_SPL_RSHIFT_W32((tmp1 + tmp2), 1);/* low pass signal*/ 286 LP16[k] = (int16_t)WebRtcSpl_SatW32ToW16(tmp3); /*low pass */ 287 tmp3 = (int32_t)WEBRTC_SPL_RSHIFT_W32((tmp1 - tmp2), 1);/* high pass signal*/ 288 HP16[k] = (int16_t)WebRtcSpl_SatW32ToW16(tmp3); /*high pass */ 289 } 290 291 }/*end of WebRtcIsacfix_SplitAndFilter */ 292 293 #endif 294 295 296 297 ////////////////////////////////////////////////////////// 298 ////////// Combining 299 /* Function WebRtcIsacfix_FilterAndCombine */ 300 /* This is a decoder function that takes the decimated 301 length FRAMESAMPLES/2 input low-pass and 302 high-pass signals and creates a reconstructed fullband 303 output signal of length FRAMESAMPLES. WebRtcIsacfix_FilterAndCombine 304 is the sibling function of WebRtcIsacfix_SplitAndFilter */ 305 /* INPUTS: 306 inLP: a length FRAMESAMPLES/2 array of input low-pass 307 samples. 308 inHP: a length FRAMESAMPLES/2 array of input high-pass 309 samples. 310 postfiltdata: input data structure containing the filterbank 311 states from the previous decoding iteration. 312 OUTPUTS: 313 Out: a length FRAMESAMPLES array of output reconstructed 314 samples (fullband) based on the input low-pass and 315 high-pass signals. 316 postfiltdata: the input data structure containing the filterbank 317 states is updated for the next decoding iteration */ 318 void WebRtcIsacfix_FilterAndCombine1(int16_t *tempin_ch1, 319 int16_t *tempin_ch2, 320 int16_t *out16, 321 PostFiltBankstr *postfiltdata) 322 { 323 int k; 324 int16_t in[FRAMESAMPLES]; 325 326 /* all-pass filter the new upper and lower channel signal. 327 For upper channel, use the all-pass filter factors that were used as a 328 lower channel at the encoding side. So at the decoder, the corresponding 329 all-pass filter factors for each channel are swapped. 330 For lower channel signal, since all-pass filter factors at the decoder are 331 swapped from the ones at the encoder, the 'upper' channel all-pass filter 332 factors (kUpperApFactors) are used to filter this new lower channel signal. 333 */ 334 WebRtcIsacfix_AllpassFilter2FixDec16(tempin_ch1, 335 tempin_ch2, 336 WebRtcIsacfix_kLowerApFactorsQ15, 337 WebRtcIsacfix_kUpperApFactorsQ15, 338 FRAMESAMPLES/2, 339 postfiltdata->STATE_0_UPPER_fix, 340 postfiltdata->STATE_0_LOWER_fix); 341 342 /* Merge outputs to form the full length output signal.*/ 343 for (k=0;k<FRAMESAMPLES/2;k++) { 344 in[WEBRTC_SPL_MUL_16_16(2, k)]=tempin_ch2[k]; 345 in[WEBRTC_SPL_MUL_16_16(2, k)+1]=tempin_ch1[k]; 346 } 347 348 /* High pass filter */ 349 WebRtcIsacfix_HighpassFilterFixDec32(in, FRAMESAMPLES, WebRtcIsacfix_kHPStCoeffOut1Q30, postfiltdata->HPstates1_fix); 350 WebRtcIsacfix_HighpassFilterFixDec32(in, FRAMESAMPLES, WebRtcIsacfix_kHPStCoeffOut2Q30, postfiltdata->HPstates2_fix); 351 352 for (k=0;k<FRAMESAMPLES;k++) { 353 out16[k] = in[k]; 354 } 355 } 356 357 358 #ifdef WEBRTC_ISAC_FIX_NB_CALLS_ENABLED 359 /* Function WebRtcIsacfix_FilterAndCombine */ 360 /* This is a decoder function that takes the decimated 361 length len/2 input low-pass and 362 high-pass signals and creates a reconstructed fullband 363 output signal of length len. WebRtcIsacfix_FilterAndCombine 364 is the sibling function of WebRtcIsacfix_SplitAndFilter */ 365 /* INPUTS: 366 inLP: a length len/2 array of input low-pass 367 samples. 368 inHP: a length len/2 array of input high-pass 369 samples. 370 postfiltdata: input data structure containing the filterbank 371 states from the previous decoding iteration. 372 OUTPUTS: 373 Out: a length len array of output reconstructed 374 samples (fullband) based on the input low-pass and 375 high-pass signals. 376 postfiltdata: the input data structure containing the filterbank 377 states is updated for the next decoding iteration */ 378 void WebRtcIsacfix_FilterAndCombine2(int16_t *tempin_ch1, 379 int16_t *tempin_ch2, 380 int16_t *out16, 381 PostFiltBankstr *postfiltdata, 382 int16_t len) 383 { 384 int k; 385 int16_t in[FRAMESAMPLES]; 386 387 /* all-pass filter the new upper and lower channel signal. 388 For upper channel, use the all-pass filter factors that were used as a 389 lower channel at the encoding side. So at the decoder, the corresponding 390 all-pass filter factors for each channel are swapped. 391 For lower channel signal, since all-pass filter factors at the decoder are 392 swapped from the ones at the encoder, the 'upper' channel all-pass filter 393 factors (kUpperApFactors) are used to filter this new lower channel signal. 394 */ 395 WebRtcIsacfix_AllpassFilter2FixDec16(tempin_ch1, 396 tempin_ch2, 397 WebRtcIsacfix_kLowerApFactorsQ15, 398 WebRtcIsacfix_kUpperApFactorsQ15, 399 len / 2, 400 postfiltdata->STATE_0_UPPER_fix, 401 postfiltdata->STATE_0_LOWER_fix); 402 403 /* Merge outputs to form the full length output signal.*/ 404 for (k=0;k<len/2;k++) { 405 in[WEBRTC_SPL_MUL_16_16(2, k)]=tempin_ch2[k]; 406 in[WEBRTC_SPL_MUL_16_16(2, k)+1]=tempin_ch1[k]; 407 } 408 409 /* High pass filter */ 410 WebRtcIsacfix_HighpassFilterFixDec32(in, len, WebRtcIsacfix_kHPStCoeffOut1Q30, postfiltdata->HPstates1_fix); 411 WebRtcIsacfix_HighpassFilterFixDec32(in, len, WebRtcIsacfix_kHPStCoeffOut2Q30, postfiltdata->HPstates2_fix); 412 413 for (k=0;k<len;k++) { 414 out16[k] = in[k]; 415 } 416 } 417 418 #endif 419
