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