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 * A wrapper for resampling a numerous amount of sampling combinations.
13 */
14
15 #include "common_audio/resampler/include/resampler.h"
16
17 #include <stdint.h>
18 #include <stdlib.h>
19 #include <string.h>
20
21 #include "common_audio/signal_processing/include/signal_processing_library.h"
22 #include "rtc_base/logging.h"
23
24 namespace webrtc {
25
Resampler()26 Resampler::Resampler()
27 : state1_(nullptr),
28 state2_(nullptr),
29 state3_(nullptr),
30 in_buffer_(nullptr),
31 out_buffer_(nullptr),
32 in_buffer_size_(0),
33 out_buffer_size_(0),
34 in_buffer_size_max_(0),
35 out_buffer_size_max_(0),
36 my_in_frequency_khz_(0),
37 my_out_frequency_khz_(0),
38 my_mode_(kResamplerMode1To1),
39 num_channels_(0),
40 helper_left_(nullptr),
41 helper_right_(nullptr) {}
42
Resampler(int inFreq,int outFreq,size_t num_channels)43 Resampler::Resampler(int inFreq, int outFreq, size_t num_channels)
44 : Resampler() {
45 Reset(inFreq, outFreq, num_channels);
46 }
47
~Resampler()48 Resampler::~Resampler() {
49 if (state1_) {
50 free(state1_);
51 }
52 if (state2_) {
53 free(state2_);
54 }
55 if (state3_) {
56 free(state3_);
57 }
58 if (in_buffer_) {
59 free(in_buffer_);
60 }
61 if (out_buffer_) {
62 free(out_buffer_);
63 }
64 if (helper_left_) {
65 delete helper_left_;
66 }
67 if (helper_right_) {
68 delete helper_right_;
69 }
70 }
71
ResetIfNeeded(int inFreq,int outFreq,size_t num_channels)72 int Resampler::ResetIfNeeded(int inFreq, int outFreq, size_t num_channels) {
73 int tmpInFreq_kHz = inFreq / 1000;
74 int tmpOutFreq_kHz = outFreq / 1000;
75
76 if ((tmpInFreq_kHz != my_in_frequency_khz_) ||
77 (tmpOutFreq_kHz != my_out_frequency_khz_) ||
78 (num_channels != num_channels_)) {
79 return Reset(inFreq, outFreq, num_channels);
80 } else {
81 return 0;
82 }
83 }
84
Reset(int inFreq,int outFreq,size_t num_channels)85 int Resampler::Reset(int inFreq, int outFreq, size_t num_channels) {
86 if (num_channels != 1 && num_channels != 2) {
87 RTC_LOG(LS_WARNING)
88 << "Reset() called with unsupported channel count, num_channels = "
89 << num_channels;
90 return -1;
91 }
92 ResamplerMode mode;
93 if (ComputeResamplerMode(inFreq, outFreq, &mode) != 0) {
94 RTC_LOG(LS_WARNING)
95 << "Reset() called with unsupported sample rates, inFreq = " << inFreq
96 << ", outFreq = " << outFreq;
97 return -1;
98 }
99 // Reinitialize internal state for the frequencies and sample rates.
100 num_channels_ = num_channels;
101 my_mode_ = mode;
102
103 if (state1_) {
104 free(state1_);
105 state1_ = nullptr;
106 }
107 if (state2_) {
108 free(state2_);
109 state2_ = nullptr;
110 }
111 if (state3_) {
112 free(state3_);
113 state3_ = nullptr;
114 }
115 if (in_buffer_) {
116 free(in_buffer_);
117 in_buffer_ = nullptr;
118 }
119 if (out_buffer_) {
120 free(out_buffer_);
121 out_buffer_ = nullptr;
122 }
123 if (helper_left_) {
124 delete helper_left_;
125 helper_left_ = nullptr;
126 }
127 if (helper_right_) {
128 delete helper_right_;
129 helper_right_ = nullptr;
130 }
131
132 in_buffer_size_ = 0;
133 out_buffer_size_ = 0;
134 in_buffer_size_max_ = 0;
135 out_buffer_size_max_ = 0;
136
137 // We need to track what domain we're in.
138 my_in_frequency_khz_ = inFreq / 1000;
139 my_out_frequency_khz_ = outFreq / 1000;
140
141 if (num_channels_ == 2) {
142 // Create two mono resamplers.
143 helper_left_ = new Resampler(inFreq, outFreq, 1);
144 helper_right_ = new Resampler(inFreq, outFreq, 1);
145 }
146
147 // Now create the states we need.
148 switch (my_mode_) {
149 case kResamplerMode1To1:
150 // No state needed;
151 break;
152 case kResamplerMode1To2:
153 state1_ = malloc(8 * sizeof(int32_t));
154 memset(state1_, 0, 8 * sizeof(int32_t));
155 break;
156 case kResamplerMode1To3:
157 state1_ = malloc(sizeof(WebRtcSpl_State16khzTo48khz));
158 WebRtcSpl_ResetResample16khzTo48khz(
159 static_cast<WebRtcSpl_State16khzTo48khz*>(state1_));
160 break;
161 case kResamplerMode1To4:
162 // 1:2
163 state1_ = malloc(8 * sizeof(int32_t));
164 memset(state1_, 0, 8 * sizeof(int32_t));
165 // 2:4
166 state2_ = malloc(8 * sizeof(int32_t));
167 memset(state2_, 0, 8 * sizeof(int32_t));
168 break;
169 case kResamplerMode1To6:
170 // 1:2
171 state1_ = malloc(8 * sizeof(int32_t));
172 memset(state1_, 0, 8 * sizeof(int32_t));
173 // 2:6
174 state2_ = malloc(sizeof(WebRtcSpl_State16khzTo48khz));
175 WebRtcSpl_ResetResample16khzTo48khz(
176 static_cast<WebRtcSpl_State16khzTo48khz*>(state2_));
177 break;
178 case kResamplerMode1To12:
179 // 1:2
180 state1_ = malloc(8 * sizeof(int32_t));
181 memset(state1_, 0, 8 * sizeof(int32_t));
182 // 2:4
183 state2_ = malloc(8 * sizeof(int32_t));
184 memset(state2_, 0, 8 * sizeof(int32_t));
185 // 4:12
186 state3_ = malloc(sizeof(WebRtcSpl_State16khzTo48khz));
187 WebRtcSpl_ResetResample16khzTo48khz(
188 static_cast<WebRtcSpl_State16khzTo48khz*>(state3_));
189 break;
190 case kResamplerMode2To3:
191 // 2:6
192 state1_ = malloc(sizeof(WebRtcSpl_State16khzTo48khz));
193 WebRtcSpl_ResetResample16khzTo48khz(
194 static_cast<WebRtcSpl_State16khzTo48khz*>(state1_));
195 // 6:3
196 state2_ = malloc(8 * sizeof(int32_t));
197 memset(state2_, 0, 8 * sizeof(int32_t));
198 break;
199 case kResamplerMode2To11:
200 state1_ = malloc(8 * sizeof(int32_t));
201 memset(state1_, 0, 8 * sizeof(int32_t));
202
203 state2_ = malloc(sizeof(WebRtcSpl_State8khzTo22khz));
204 WebRtcSpl_ResetResample8khzTo22khz(
205 static_cast<WebRtcSpl_State8khzTo22khz*>(state2_));
206 break;
207 case kResamplerMode4To11:
208 state1_ = malloc(sizeof(WebRtcSpl_State8khzTo22khz));
209 WebRtcSpl_ResetResample8khzTo22khz(
210 static_cast<WebRtcSpl_State8khzTo22khz*>(state1_));
211 break;
212 case kResamplerMode8To11:
213 state1_ = malloc(sizeof(WebRtcSpl_State16khzTo22khz));
214 WebRtcSpl_ResetResample16khzTo22khz(
215 static_cast<WebRtcSpl_State16khzTo22khz*>(state1_));
216 break;
217 case kResamplerMode11To16:
218 state1_ = malloc(8 * sizeof(int32_t));
219 memset(state1_, 0, 8 * sizeof(int32_t));
220
221 state2_ = malloc(sizeof(WebRtcSpl_State22khzTo16khz));
222 WebRtcSpl_ResetResample22khzTo16khz(
223 static_cast<WebRtcSpl_State22khzTo16khz*>(state2_));
224 break;
225 case kResamplerMode11To32:
226 // 11 -> 22
227 state1_ = malloc(8 * sizeof(int32_t));
228 memset(state1_, 0, 8 * sizeof(int32_t));
229
230 // 22 -> 16
231 state2_ = malloc(sizeof(WebRtcSpl_State22khzTo16khz));
232 WebRtcSpl_ResetResample22khzTo16khz(
233 static_cast<WebRtcSpl_State22khzTo16khz*>(state2_));
234
235 // 16 -> 32
236 state3_ = malloc(8 * sizeof(int32_t));
237 memset(state3_, 0, 8 * sizeof(int32_t));
238
239 break;
240 case kResamplerMode2To1:
241 state1_ = malloc(8 * sizeof(int32_t));
242 memset(state1_, 0, 8 * sizeof(int32_t));
243 break;
244 case kResamplerMode3To1:
245 state1_ = malloc(sizeof(WebRtcSpl_State48khzTo16khz));
246 WebRtcSpl_ResetResample48khzTo16khz(
247 static_cast<WebRtcSpl_State48khzTo16khz*>(state1_));
248 break;
249 case kResamplerMode4To1:
250 // 4:2
251 state1_ = malloc(8 * sizeof(int32_t));
252 memset(state1_, 0, 8 * sizeof(int32_t));
253 // 2:1
254 state2_ = malloc(8 * sizeof(int32_t));
255 memset(state2_, 0, 8 * sizeof(int32_t));
256 break;
257 case kResamplerMode6To1:
258 // 6:2
259 state1_ = malloc(sizeof(WebRtcSpl_State48khzTo16khz));
260 WebRtcSpl_ResetResample48khzTo16khz(
261 static_cast<WebRtcSpl_State48khzTo16khz*>(state1_));
262 // 2:1
263 state2_ = malloc(8 * sizeof(int32_t));
264 memset(state2_, 0, 8 * sizeof(int32_t));
265 break;
266 case kResamplerMode12To1:
267 // 12:4
268 state1_ = malloc(sizeof(WebRtcSpl_State48khzTo16khz));
269 WebRtcSpl_ResetResample48khzTo16khz(
270 static_cast<WebRtcSpl_State48khzTo16khz*>(state1_));
271 // 4:2
272 state2_ = malloc(8 * sizeof(int32_t));
273 memset(state2_, 0, 8 * sizeof(int32_t));
274 // 2:1
275 state3_ = malloc(8 * sizeof(int32_t));
276 memset(state3_, 0, 8 * sizeof(int32_t));
277 break;
278 case kResamplerMode3To2:
279 // 3:6
280 state1_ = malloc(8 * sizeof(int32_t));
281 memset(state1_, 0, 8 * sizeof(int32_t));
282 // 6:2
283 state2_ = malloc(sizeof(WebRtcSpl_State48khzTo16khz));
284 WebRtcSpl_ResetResample48khzTo16khz(
285 static_cast<WebRtcSpl_State48khzTo16khz*>(state2_));
286 break;
287 case kResamplerMode11To2:
288 state1_ = malloc(sizeof(WebRtcSpl_State22khzTo8khz));
289 WebRtcSpl_ResetResample22khzTo8khz(
290 static_cast<WebRtcSpl_State22khzTo8khz*>(state1_));
291
292 state2_ = malloc(8 * sizeof(int32_t));
293 memset(state2_, 0, 8 * sizeof(int32_t));
294
295 break;
296 case kResamplerMode11To4:
297 state1_ = malloc(sizeof(WebRtcSpl_State22khzTo8khz));
298 WebRtcSpl_ResetResample22khzTo8khz(
299 static_cast<WebRtcSpl_State22khzTo8khz*>(state1_));
300 break;
301 case kResamplerMode11To8:
302 state1_ = malloc(sizeof(WebRtcSpl_State22khzTo16khz));
303 WebRtcSpl_ResetResample22khzTo16khz(
304 static_cast<WebRtcSpl_State22khzTo16khz*>(state1_));
305 break;
306 }
307
308 return 0;
309 }
310
ComputeResamplerMode(int in_freq_hz,int out_freq_hz,ResamplerMode * mode)311 int Resampler::ComputeResamplerMode(int in_freq_hz,
312 int out_freq_hz,
313 ResamplerMode* mode) {
314 // Start with a math exercise, Euclid's algorithm to find the gcd:
315 int a = in_freq_hz;
316 int b = out_freq_hz;
317 int c = a % b;
318 while (c != 0) {
319 a = b;
320 b = c;
321 c = a % b;
322 }
323 // b is now the gcd;
324
325 // Scale with GCD
326 const int reduced_in_freq = in_freq_hz / b;
327 const int reduced_out_freq = out_freq_hz / b;
328
329 if (reduced_in_freq == reduced_out_freq) {
330 *mode = kResamplerMode1To1;
331 } else if (reduced_in_freq == 1) {
332 switch (reduced_out_freq) {
333 case 2:
334 *mode = kResamplerMode1To2;
335 break;
336 case 3:
337 *mode = kResamplerMode1To3;
338 break;
339 case 4:
340 *mode = kResamplerMode1To4;
341 break;
342 case 6:
343 *mode = kResamplerMode1To6;
344 break;
345 case 12:
346 *mode = kResamplerMode1To12;
347 break;
348 default:
349 return -1;
350 }
351 } else if (reduced_out_freq == 1) {
352 switch (reduced_in_freq) {
353 case 2:
354 *mode = kResamplerMode2To1;
355 break;
356 case 3:
357 *mode = kResamplerMode3To1;
358 break;
359 case 4:
360 *mode = kResamplerMode4To1;
361 break;
362 case 6:
363 *mode = kResamplerMode6To1;
364 break;
365 case 12:
366 *mode = kResamplerMode12To1;
367 break;
368 default:
369 return -1;
370 }
371 } else if ((reduced_in_freq == 2) && (reduced_out_freq == 3)) {
372 *mode = kResamplerMode2To3;
373 } else if ((reduced_in_freq == 2) && (reduced_out_freq == 11)) {
374 *mode = kResamplerMode2To11;
375 } else if ((reduced_in_freq == 4) && (reduced_out_freq == 11)) {
376 *mode = kResamplerMode4To11;
377 } else if ((reduced_in_freq == 8) && (reduced_out_freq == 11)) {
378 *mode = kResamplerMode8To11;
379 } else if ((reduced_in_freq == 3) && (reduced_out_freq == 2)) {
380 *mode = kResamplerMode3To2;
381 } else if ((reduced_in_freq == 11) && (reduced_out_freq == 2)) {
382 *mode = kResamplerMode11To2;
383 } else if ((reduced_in_freq == 11) && (reduced_out_freq == 4)) {
384 *mode = kResamplerMode11To4;
385 } else if ((reduced_in_freq == 11) && (reduced_out_freq == 16)) {
386 *mode = kResamplerMode11To16;
387 } else if ((reduced_in_freq == 11) && (reduced_out_freq == 32)) {
388 *mode = kResamplerMode11To32;
389 } else if ((reduced_in_freq == 11) && (reduced_out_freq == 8)) {
390 *mode = kResamplerMode11To8;
391 } else {
392 return -1;
393 }
394 return 0;
395 }
396
397 // Synchronous resampling, all output samples are written to samplesOut
Push(const int16_t * samplesIn,size_t lengthIn,int16_t * samplesOut,size_t maxLen,size_t & outLen)398 int Resampler::Push(const int16_t* samplesIn,
399 size_t lengthIn,
400 int16_t* samplesOut,
401 size_t maxLen,
402 size_t& outLen) {
403 if (num_channels_ == 2) {
404 // Split up the signal and call the helper object for each channel
405 int16_t* left =
406 static_cast<int16_t*>(malloc(lengthIn * sizeof(int16_t) / 2));
407 int16_t* right =
408 static_cast<int16_t*>(malloc(lengthIn * sizeof(int16_t) / 2));
409 int16_t* out_left =
410 static_cast<int16_t*>(malloc(maxLen / 2 * sizeof(int16_t)));
411 int16_t* out_right =
412 static_cast<int16_t*>(malloc(maxLen / 2 * sizeof(int16_t)));
413 int res = 0;
414 for (size_t i = 0; i < lengthIn; i += 2) {
415 left[i >> 1] = samplesIn[i];
416 right[i >> 1] = samplesIn[i + 1];
417 }
418
419 // It's OK to overwrite the local parameter, since it's just a copy
420 lengthIn = lengthIn / 2;
421
422 size_t actualOutLen_left = 0;
423 size_t actualOutLen_right = 0;
424 // Do resampling for right channel
425 res |= helper_left_->Push(left, lengthIn, out_left, maxLen / 2,
426 actualOutLen_left);
427 res |= helper_right_->Push(right, lengthIn, out_right, maxLen / 2,
428 actualOutLen_right);
429 if (res || (actualOutLen_left != actualOutLen_right)) {
430 free(left);
431 free(right);
432 free(out_left);
433 free(out_right);
434 return -1;
435 }
436
437 // Reassemble the signal
438 for (size_t i = 0; i < actualOutLen_left; i++) {
439 samplesOut[i * 2] = out_left[i];
440 samplesOut[i * 2 + 1] = out_right[i];
441 }
442 outLen = 2 * actualOutLen_left;
443
444 free(left);
445 free(right);
446 free(out_left);
447 free(out_right);
448
449 return 0;
450 }
451
452 // Containers for temp samples
453 int16_t* tmp;
454 int16_t* tmp_2;
455 // tmp data for resampling routines
456 int32_t* tmp_mem;
457
458 switch (my_mode_) {
459 case kResamplerMode1To1:
460 memcpy(samplesOut, samplesIn, lengthIn * sizeof(int16_t));
461 outLen = lengthIn;
462 break;
463 case kResamplerMode1To2:
464 if (maxLen < (lengthIn * 2)) {
465 return -1;
466 }
467 WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, samplesOut,
468 static_cast<int32_t*>(state1_));
469 outLen = lengthIn * 2;
470 return 0;
471 case kResamplerMode1To3:
472
473 // We can only handle blocks of 160 samples
474 // Can be fixed, but I don't think it's needed
475 if ((lengthIn % 160) != 0) {
476 return -1;
477 }
478 if (maxLen < (lengthIn * 3)) {
479 return -1;
480 }
481 tmp_mem = static_cast<int32_t*>(malloc(336 * sizeof(int32_t)));
482
483 for (size_t i = 0; i < lengthIn; i += 160) {
484 WebRtcSpl_Resample16khzTo48khz(
485 samplesIn + i, samplesOut + i * 3,
486 static_cast<WebRtcSpl_State16khzTo48khz*>(state1_), tmp_mem);
487 }
488 outLen = lengthIn * 3;
489 free(tmp_mem);
490 return 0;
491 case kResamplerMode1To4:
492 if (maxLen < (lengthIn * 4)) {
493 return -1;
494 }
495
496 tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * 2 * lengthIn));
497 // 1:2
498 WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp,
499 static_cast<int32_t*>(state1_));
500 // 2:4
501 WebRtcSpl_UpsampleBy2(tmp, lengthIn * 2, samplesOut,
502 static_cast<int32_t*>(state2_));
503 outLen = lengthIn * 4;
504 free(tmp);
505 return 0;
506 case kResamplerMode1To6:
507 // We can only handle blocks of 80 samples
508 // Can be fixed, but I don't think it's needed
509 if ((lengthIn % 80) != 0) {
510 return -1;
511 }
512 if (maxLen < (lengthIn * 6)) {
513 return -1;
514 }
515
516 // 1:2
517
518 tmp_mem = static_cast<int32_t*>(malloc(336 * sizeof(int32_t)));
519 tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * 2 * lengthIn));
520
521 WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp,
522 static_cast<int32_t*>(state1_));
523 outLen = lengthIn * 2;
524
525 for (size_t i = 0; i < outLen; i += 160) {
526 WebRtcSpl_Resample16khzTo48khz(
527 tmp + i, samplesOut + i * 3,
528 static_cast<WebRtcSpl_State16khzTo48khz*>(state2_), tmp_mem);
529 }
530 outLen = outLen * 3;
531 free(tmp_mem);
532 free(tmp);
533
534 return 0;
535 case kResamplerMode1To12:
536 // We can only handle blocks of 40 samples
537 // Can be fixed, but I don't think it's needed
538 if ((lengthIn % 40) != 0) {
539 return -1;
540 }
541 if (maxLen < (lengthIn * 12)) {
542 return -1;
543 }
544
545 tmp_mem = static_cast<int32_t*>(malloc(336 * sizeof(int32_t)));
546 tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * 4 * lengthIn));
547 // 1:2
548 WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, samplesOut,
549 static_cast<int32_t*>(state1_));
550 outLen = lengthIn * 2;
551 // 2:4
552 WebRtcSpl_UpsampleBy2(samplesOut, outLen, tmp,
553 static_cast<int32_t*>(state2_));
554 outLen = outLen * 2;
555 // 4:12
556 for (size_t i = 0; i < outLen; i += 160) {
557 // WebRtcSpl_Resample16khzTo48khz() takes a block of 160 samples
558 // as input and outputs a resampled block of 480 samples. The
559 // data is now actually in 32 kHz sampling rate, despite the
560 // function name, and with a resampling factor of three becomes
561 // 96 kHz.
562 WebRtcSpl_Resample16khzTo48khz(
563 tmp + i, samplesOut + i * 3,
564 static_cast<WebRtcSpl_State16khzTo48khz*>(state3_), tmp_mem);
565 }
566 outLen = outLen * 3;
567 free(tmp_mem);
568 free(tmp);
569
570 return 0;
571 case kResamplerMode2To3:
572 if (maxLen < (lengthIn * 3 / 2)) {
573 return -1;
574 }
575 // 2:6
576 // We can only handle blocks of 160 samples
577 // Can be fixed, but I don't think it's needed
578 if ((lengthIn % 160) != 0) {
579 return -1;
580 }
581 tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * lengthIn * 3));
582 tmp_mem = static_cast<int32_t*>(malloc(336 * sizeof(int32_t)));
583 for (size_t i = 0; i < lengthIn; i += 160) {
584 WebRtcSpl_Resample16khzTo48khz(
585 samplesIn + i, tmp + i * 3,
586 static_cast<WebRtcSpl_State16khzTo48khz*>(state1_), tmp_mem);
587 }
588 lengthIn = lengthIn * 3;
589 // 6:3
590 WebRtcSpl_DownsampleBy2(tmp, lengthIn, samplesOut,
591 static_cast<int32_t*>(state2_));
592 outLen = lengthIn / 2;
593 free(tmp);
594 free(tmp_mem);
595 return 0;
596 case kResamplerMode2To11:
597
598 // We can only handle blocks of 80 samples
599 // Can be fixed, but I don't think it's needed
600 if ((lengthIn % 80) != 0) {
601 return -1;
602 }
603 if (maxLen < ((lengthIn * 11) / 2)) {
604 return -1;
605 }
606 tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * 2 * lengthIn));
607 // 1:2
608 WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp,
609 static_cast<int32_t*>(state1_));
610 lengthIn *= 2;
611
612 tmp_mem = static_cast<int32_t*>(malloc(98 * sizeof(int32_t)));
613
614 for (size_t i = 0; i < lengthIn; i += 80) {
615 WebRtcSpl_Resample8khzTo22khz(
616 tmp + i, samplesOut + (i * 11) / 4,
617 static_cast<WebRtcSpl_State8khzTo22khz*>(state2_), tmp_mem);
618 }
619 outLen = (lengthIn * 11) / 4;
620 free(tmp_mem);
621 free(tmp);
622 return 0;
623 case kResamplerMode4To11:
624
625 // We can only handle blocks of 80 samples
626 // Can be fixed, but I don't think it's needed
627 if ((lengthIn % 80) != 0) {
628 return -1;
629 }
630 if (maxLen < ((lengthIn * 11) / 4)) {
631 return -1;
632 }
633 tmp_mem = static_cast<int32_t*>(malloc(98 * sizeof(int32_t)));
634
635 for (size_t i = 0; i < lengthIn; i += 80) {
636 WebRtcSpl_Resample8khzTo22khz(
637 samplesIn + i, samplesOut + (i * 11) / 4,
638 static_cast<WebRtcSpl_State8khzTo22khz*>(state1_), tmp_mem);
639 }
640 outLen = (lengthIn * 11) / 4;
641 free(tmp_mem);
642 return 0;
643 case kResamplerMode8To11:
644 // We can only handle blocks of 160 samples
645 // Can be fixed, but I don't think it's needed
646 if ((lengthIn % 160) != 0) {
647 return -1;
648 }
649 if (maxLen < ((lengthIn * 11) / 8)) {
650 return -1;
651 }
652 tmp_mem = static_cast<int32_t*>(malloc(88 * sizeof(int32_t)));
653
654 for (size_t i = 0; i < lengthIn; i += 160) {
655 WebRtcSpl_Resample16khzTo22khz(
656 samplesIn + i, samplesOut + (i * 11) / 8,
657 static_cast<WebRtcSpl_State16khzTo22khz*>(state1_), tmp_mem);
658 }
659 outLen = (lengthIn * 11) / 8;
660 free(tmp_mem);
661 return 0;
662
663 case kResamplerMode11To16:
664 // We can only handle blocks of 110 samples
665 if ((lengthIn % 110) != 0) {
666 return -1;
667 }
668 if (maxLen < ((lengthIn * 16) / 11)) {
669 return -1;
670 }
671
672 tmp_mem = static_cast<int32_t*>(malloc(104 * sizeof(int32_t)));
673 tmp = static_cast<int16_t*>(malloc((sizeof(int16_t) * lengthIn * 2)));
674
675 WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp,
676 static_cast<int32_t*>(state1_));
677
678 for (size_t i = 0; i < (lengthIn * 2); i += 220) {
679 WebRtcSpl_Resample22khzTo16khz(
680 tmp + i, samplesOut + (i / 220) * 160,
681 static_cast<WebRtcSpl_State22khzTo16khz*>(state2_), tmp_mem);
682 }
683
684 outLen = (lengthIn * 16) / 11;
685
686 free(tmp_mem);
687 free(tmp);
688 return 0;
689
690 case kResamplerMode11To32:
691
692 // We can only handle blocks of 110 samples
693 if ((lengthIn % 110) != 0) {
694 return -1;
695 }
696 if (maxLen < ((lengthIn * 32) / 11)) {
697 return -1;
698 }
699
700 tmp_mem = static_cast<int32_t*>(malloc(104 * sizeof(int32_t)));
701 tmp = static_cast<int16_t*>(malloc((sizeof(int16_t) * lengthIn * 2)));
702
703 // 11 -> 22 kHz in samplesOut
704 WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, samplesOut,
705 static_cast<int32_t*>(state1_));
706
707 // 22 -> 16 in tmp
708 for (size_t i = 0; i < (lengthIn * 2); i += 220) {
709 WebRtcSpl_Resample22khzTo16khz(
710 samplesOut + i, tmp + (i / 220) * 160,
711 static_cast<WebRtcSpl_State22khzTo16khz*>(state2_), tmp_mem);
712 }
713
714 // 16 -> 32 in samplesOut
715 WebRtcSpl_UpsampleBy2(tmp, (lengthIn * 16) / 11, samplesOut,
716 static_cast<int32_t*>(state3_));
717
718 outLen = (lengthIn * 32) / 11;
719
720 free(tmp_mem);
721 free(tmp);
722 return 0;
723
724 case kResamplerMode2To1:
725 if (maxLen < (lengthIn / 2)) {
726 return -1;
727 }
728 WebRtcSpl_DownsampleBy2(samplesIn, lengthIn, samplesOut,
729 static_cast<int32_t*>(state1_));
730 outLen = lengthIn / 2;
731 return 0;
732 case kResamplerMode3To1:
733 // We can only handle blocks of 480 samples
734 // Can be fixed, but I don't think it's needed
735 if ((lengthIn % 480) != 0) {
736 return -1;
737 }
738 if (maxLen < (lengthIn / 3)) {
739 return -1;
740 }
741 tmp_mem = static_cast<int32_t*>(malloc(496 * sizeof(int32_t)));
742
743 for (size_t i = 0; i < lengthIn; i += 480) {
744 WebRtcSpl_Resample48khzTo16khz(
745 samplesIn + i, samplesOut + i / 3,
746 static_cast<WebRtcSpl_State48khzTo16khz*>(state1_), tmp_mem);
747 }
748 outLen = lengthIn / 3;
749 free(tmp_mem);
750 return 0;
751 case kResamplerMode4To1:
752 if (maxLen < (lengthIn / 4)) {
753 return -1;
754 }
755 tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * lengthIn / 2));
756 // 4:2
757 WebRtcSpl_DownsampleBy2(samplesIn, lengthIn, tmp,
758 static_cast<int32_t*>(state1_));
759 // 2:1
760 WebRtcSpl_DownsampleBy2(tmp, lengthIn / 2, samplesOut,
761 static_cast<int32_t*>(state2_));
762 outLen = lengthIn / 4;
763 free(tmp);
764 return 0;
765
766 case kResamplerMode6To1:
767 // We can only handle blocks of 480 samples
768 // Can be fixed, but I don't think it's needed
769 if ((lengthIn % 480) != 0) {
770 return -1;
771 }
772 if (maxLen < (lengthIn / 6)) {
773 return -1;
774 }
775
776 tmp_mem = static_cast<int32_t*>(malloc(496 * sizeof(int32_t)));
777 tmp = static_cast<int16_t*>(malloc((sizeof(int16_t) * lengthIn) / 3));
778
779 for (size_t i = 0; i < lengthIn; i += 480) {
780 WebRtcSpl_Resample48khzTo16khz(
781 samplesIn + i, tmp + i / 3,
782 static_cast<WebRtcSpl_State48khzTo16khz*>(state1_), tmp_mem);
783 }
784 outLen = lengthIn / 3;
785 free(tmp_mem);
786 WebRtcSpl_DownsampleBy2(tmp, outLen, samplesOut,
787 static_cast<int32_t*>(state2_));
788 free(tmp);
789 outLen = outLen / 2;
790 return 0;
791 case kResamplerMode12To1:
792 // We can only handle blocks of 480 samples
793 // Can be fixed, but I don't think it's needed
794 if ((lengthIn % 480) != 0) {
795 return -1;
796 }
797 if (maxLen < (lengthIn / 12)) {
798 return -1;
799 }
800
801 tmp_mem = static_cast<int32_t*>(malloc(496 * sizeof(int32_t)));
802 tmp = static_cast<int16_t*>(malloc((sizeof(int16_t) * lengthIn) / 3));
803 tmp_2 = static_cast<int16_t*>(malloc((sizeof(int16_t) * lengthIn) / 6));
804 // 12:4
805 for (size_t i = 0; i < lengthIn; i += 480) {
806 // WebRtcSpl_Resample48khzTo16khz() takes a block of 480 samples
807 // as input and outputs a resampled block of 160 samples. The
808 // data is now actually in 96 kHz sampling rate, despite the
809 // function name, and with a resampling factor of 1/3 becomes
810 // 32 kHz.
811 WebRtcSpl_Resample48khzTo16khz(
812 samplesIn + i, tmp + i / 3,
813 static_cast<WebRtcSpl_State48khzTo16khz*>(state1_), tmp_mem);
814 }
815 outLen = lengthIn / 3;
816 free(tmp_mem);
817 // 4:2
818 WebRtcSpl_DownsampleBy2(tmp, outLen, tmp_2,
819 static_cast<int32_t*>(state2_));
820 outLen = outLen / 2;
821 free(tmp);
822 // 2:1
823 WebRtcSpl_DownsampleBy2(tmp_2, outLen, samplesOut,
824 static_cast<int32_t*>(state3_));
825 free(tmp_2);
826 outLen = outLen / 2;
827 return 0;
828 case kResamplerMode3To2:
829 if (maxLen < (lengthIn * 2 / 3)) {
830 return -1;
831 }
832 // 3:6
833 tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * lengthIn * 2));
834 WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp,
835 static_cast<int32_t*>(state1_));
836 lengthIn *= 2;
837 // 6:2
838 // We can only handle blocks of 480 samples
839 // Can be fixed, but I don't think it's needed
840 if ((lengthIn % 480) != 0) {
841 free(tmp);
842 return -1;
843 }
844 tmp_mem = static_cast<int32_t*>(malloc(496 * sizeof(int32_t)));
845 for (size_t i = 0; i < lengthIn; i += 480) {
846 WebRtcSpl_Resample48khzTo16khz(
847 tmp + i, samplesOut + i / 3,
848 static_cast<WebRtcSpl_State48khzTo16khz*>(state2_), tmp_mem);
849 }
850 outLen = lengthIn / 3;
851 free(tmp);
852 free(tmp_mem);
853 return 0;
854 case kResamplerMode11To2:
855 // We can only handle blocks of 220 samples
856 // Can be fixed, but I don't think it's needed
857 if ((lengthIn % 220) != 0) {
858 return -1;
859 }
860 if (maxLen < ((lengthIn * 2) / 11)) {
861 return -1;
862 }
863 tmp_mem = static_cast<int32_t*>(malloc(126 * sizeof(int32_t)));
864 tmp =
865 static_cast<int16_t*>(malloc((lengthIn * 4) / 11 * sizeof(int16_t)));
866
867 for (size_t i = 0; i < lengthIn; i += 220) {
868 WebRtcSpl_Resample22khzTo8khz(
869 samplesIn + i, tmp + (i * 4) / 11,
870 static_cast<WebRtcSpl_State22khzTo8khz*>(state1_), tmp_mem);
871 }
872 lengthIn = (lengthIn * 4) / 11;
873
874 WebRtcSpl_DownsampleBy2(tmp, lengthIn, samplesOut,
875 static_cast<int32_t*>(state2_));
876 outLen = lengthIn / 2;
877
878 free(tmp_mem);
879 free(tmp);
880 return 0;
881 case kResamplerMode11To4:
882 // We can only handle blocks of 220 samples
883 // Can be fixed, but I don't think it's needed
884 if ((lengthIn % 220) != 0) {
885 return -1;
886 }
887 if (maxLen < ((lengthIn * 4) / 11)) {
888 return -1;
889 }
890 tmp_mem = static_cast<int32_t*>(malloc(126 * sizeof(int32_t)));
891
892 for (size_t i = 0; i < lengthIn; i += 220) {
893 WebRtcSpl_Resample22khzTo8khz(
894 samplesIn + i, samplesOut + (i * 4) / 11,
895 static_cast<WebRtcSpl_State22khzTo8khz*>(state1_), tmp_mem);
896 }
897 outLen = (lengthIn * 4) / 11;
898 free(tmp_mem);
899 return 0;
900 case kResamplerMode11To8:
901 // We can only handle blocks of 160 samples
902 // Can be fixed, but I don't think it's needed
903 if ((lengthIn % 220) != 0) {
904 return -1;
905 }
906 if (maxLen < ((lengthIn * 8) / 11)) {
907 return -1;
908 }
909 tmp_mem = static_cast<int32_t*>(malloc(104 * sizeof(int32_t)));
910
911 for (size_t i = 0; i < lengthIn; i += 220) {
912 WebRtcSpl_Resample22khzTo16khz(
913 samplesIn + i, samplesOut + (i * 8) / 11,
914 static_cast<WebRtcSpl_State22khzTo16khz*>(state1_), tmp_mem);
915 }
916 outLen = (lengthIn * 8) / 11;
917 free(tmp_mem);
918 return 0;
919 break;
920 }
921 return 0;
922 }
923
924 } // namespace webrtc
925