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
