1 /*
2 ** Copyright 2011, The Android Open-Source Project
3 **
4 ** Licensed under the Apache License, Version 2.0 (the "License");
5 ** you may not use this file except in compliance with the License.
6 ** You may obtain a copy of the License at
7 **
8 **     http://www.apache.org/licenses/LICENSE-2.0
9 **
10 ** Unless required by applicable law or agreed to in writing, software
11 ** distributed under the License is distributed on an "AS IS" BASIS,
12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 ** See the License for the specific language governing permissions and
14 ** limitations under the License.
15 */
16 
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "resampler"
19 
20 #include <errno.h>
21 #include <stdlib.h>
22 
23 #include <log/log.h>
24 
25 #include <system/audio.h>
26 #include <audio_utils/resampler.h>
27 #include <speex/speex_resampler.h>
28 
29 struct resampler {
30     struct resampler_itfe itfe;
31     SpeexResamplerState *speex_resampler;       // handle on speex resampler
32     struct resampler_buffer_provider *provider; // buffer provider installed by client
33     uint32_t in_sample_rate;                    // input sampling rate in Hz
34     uint32_t out_sample_rate;                   // output sampling rate in Hz
35     uint32_t channel_count;                     // number of channels (interleaved)
36     int16_t *in_buf;                            // input buffer
37     size_t in_buf_size;                         // input buffer size
38     size_t frames_in;                           // number of frames in input buffer
39     size_t frames_rq;                           // cached number of output frames
40     size_t frames_needed;                       // minimum number of input frames to produce
41                                                 // frames_rq output frames
42     int32_t speex_delay_ns;                     // delay introduced by speex resampler in ns
43 };
44 
45 
46 //------------------------------------------------------------------------------
47 // speex based resampler
48 //------------------------------------------------------------------------------
49 
resampler_reset(struct resampler_itfe * resampler)50 static void resampler_reset(struct resampler_itfe *resampler)
51 {
52     struct resampler *rsmp = (struct resampler *)resampler;
53 
54     rsmp->frames_in = 0;
55     rsmp->frames_rq = 0;
56 
57     if (rsmp != NULL && rsmp->speex_resampler != NULL) {
58         speex_resampler_reset_mem(rsmp->speex_resampler);
59     }
60 }
61 
resampler_delay_ns(struct resampler_itfe * resampler)62 static int32_t resampler_delay_ns(struct resampler_itfe *resampler)
63 {
64     struct resampler *rsmp = (struct resampler *)resampler;
65 
66     int32_t delay = (int32_t)((1000000000 * (int64_t)rsmp->frames_in) / rsmp->in_sample_rate);
67     delay += rsmp->speex_delay_ns;
68 
69     return delay;
70 }
71 
72 // outputs a number of frames less or equal to *outFrameCount and updates *outFrameCount
73 // with the actual number of frames produced.
resampler_resample_from_provider(struct resampler_itfe * resampler,int16_t * out,size_t * outFrameCount)74 int resampler_resample_from_provider(struct resampler_itfe *resampler,
75                        int16_t *out,
76                        size_t *outFrameCount)
77 {
78     struct resampler *rsmp = (struct resampler *)resampler;
79 
80     if (rsmp == NULL || out == NULL || outFrameCount == NULL) {
81         return -EINVAL;
82     }
83     if (rsmp->provider == NULL) {
84         *outFrameCount = 0;
85         return -ENOSYS;
86     }
87 
88     size_t framesRq = *outFrameCount;
89     // update and cache the number of frames needed at the input sampling rate to produce
90     // the number of frames requested at the output sampling rate
91     if (framesRq != rsmp->frames_rq) {
92         rsmp->frames_needed = (framesRq * rsmp->in_sample_rate) / rsmp->out_sample_rate + 1;
93         rsmp->frames_rq = framesRq;
94     }
95 
96     size_t framesWr = 0;
97     spx_uint32_t inFrames = 0;
98     while (framesWr < framesRq) {
99         if (rsmp->frames_in < rsmp->frames_needed) {
100             // make sure that the number of frames present in rsmp->in_buf (rsmp->frames_in) is at
101             // least the number of frames needed to produce the number of frames requested at
102             // the output sampling rate
103             if (rsmp->in_buf_size < rsmp->frames_needed) {
104                 rsmp->in_buf_size = rsmp->frames_needed;
105                 rsmp->in_buf = (int16_t *)realloc(rsmp->in_buf,
106                                         rsmp->in_buf_size * rsmp->channel_count * sizeof(int16_t));
107             }
108             struct resampler_buffer buf;
109             buf.frame_count = rsmp->frames_needed - rsmp->frames_in;
110             rsmp->provider->get_next_buffer(rsmp->provider, &buf);
111             if (buf.raw == NULL) {
112                 break;
113             }
114             memcpy(rsmp->in_buf + rsmp->frames_in * rsmp->channel_count,
115                     buf.raw,
116                     buf.frame_count * rsmp->channel_count * sizeof(int16_t));
117             rsmp->frames_in += buf.frame_count;
118             rsmp->provider->release_buffer(rsmp->provider, &buf);
119         }
120 
121         spx_uint32_t outFrames = framesRq - framesWr;
122         inFrames = rsmp->frames_in;
123         if (rsmp->channel_count == 1) {
124             speex_resampler_process_int(rsmp->speex_resampler,
125                                         0,
126                                         rsmp->in_buf,
127                                         &inFrames,
128                                         out + framesWr,
129                                         &outFrames);
130         } else {
131             speex_resampler_process_interleaved_int(rsmp->speex_resampler,
132                                         rsmp->in_buf,
133                                         &inFrames,
134                                         out + framesWr * rsmp->channel_count,
135                                         &outFrames);
136         }
137         framesWr += outFrames;
138         rsmp->frames_in -= inFrames;
139         ALOGW_IF((framesWr != framesRq) && (rsmp->frames_in != 0),
140                 "ReSampler::resample() remaining %zu frames in and %zu frames out",
141                 rsmp->frames_in, (framesRq - framesWr));
142     }
143     if (rsmp->frames_in) {
144         memmove(rsmp->in_buf,
145                 rsmp->in_buf + inFrames * rsmp->channel_count,
146                 rsmp->frames_in * rsmp->channel_count * sizeof(int16_t));
147     }
148     *outFrameCount = framesWr;
149 
150     return 0;
151 }
152 
resampler_resample_from_input(struct resampler_itfe * resampler,int16_t * in,size_t * inFrameCount,int16_t * out,size_t * outFrameCount)153 int resampler_resample_from_input(struct resampler_itfe *resampler,
154                                   int16_t *in,
155                                   size_t *inFrameCount,
156                                   int16_t *out,
157                                   size_t *outFrameCount)
158 {
159     struct resampler *rsmp = (struct resampler *)resampler;
160 
161     if (rsmp == NULL || in == NULL || inFrameCount == NULL ||
162             out == NULL || outFrameCount == NULL) {
163         return -EINVAL;
164     }
165     if (rsmp->provider != NULL) {
166         *outFrameCount = 0;
167         return -ENOSYS;
168     }
169 
170     if (rsmp->channel_count == 1) {
171         speex_resampler_process_int(rsmp->speex_resampler,
172                                     0,
173                                     in,
174                                     (spx_uint32_t *)inFrameCount,
175                                     out,
176                                     (spx_uint32_t *)outFrameCount);
177     } else {
178         speex_resampler_process_interleaved_int(rsmp->speex_resampler,
179                                                 in,
180                                                 (spx_uint32_t *)inFrameCount,
181                                                 out,
182                                                 (spx_uint32_t *)outFrameCount);
183     }
184 
185     ALOGV("resampler_resample_from_input() DONE in %zu out %zu", *inFrameCount, *outFrameCount);
186 
187     return 0;
188 }
189 
create_resampler(uint32_t inSampleRate,uint32_t outSampleRate,uint32_t channelCount,uint32_t quality,struct resampler_buffer_provider * provider,struct resampler_itfe ** resampler)190 int create_resampler(uint32_t inSampleRate,
191                     uint32_t outSampleRate,
192                     uint32_t channelCount,
193                     uint32_t quality,
194                     struct resampler_buffer_provider* provider,
195                     struct resampler_itfe **resampler)
196 {
197     int error;
198     struct resampler *rsmp;
199 
200     ALOGV("create_resampler() In SR %d Out SR %d channels %d",
201          inSampleRate, outSampleRate, channelCount);
202 
203     if (resampler == NULL) {
204         return -EINVAL;
205     }
206 
207     *resampler = NULL;
208 
209     if (quality <= RESAMPLER_QUALITY_MIN || quality >= RESAMPLER_QUALITY_MAX) {
210         return -EINVAL;
211     }
212 
213     rsmp = (struct resampler *)calloc(1, sizeof(struct resampler));
214 
215     rsmp->speex_resampler = speex_resampler_init(channelCount,
216                                       inSampleRate,
217                                       outSampleRate,
218                                       quality,
219                                       &error);
220     if (rsmp->speex_resampler == NULL) {
221         ALOGW("ReSampler: Cannot create speex resampler: %s", speex_resampler_strerror(error));
222         free(rsmp);
223         return -ENODEV;
224     }
225 
226     rsmp->itfe.reset = resampler_reset;
227     rsmp->itfe.resample_from_provider = resampler_resample_from_provider;
228     rsmp->itfe.resample_from_input = resampler_resample_from_input;
229     rsmp->itfe.delay_ns = resampler_delay_ns;
230 
231     rsmp->provider = provider;
232     rsmp->in_sample_rate = inSampleRate;
233     rsmp->out_sample_rate = outSampleRate;
234     rsmp->channel_count = channelCount;
235     rsmp->in_buf = NULL;
236     rsmp->in_buf_size = 0;
237 
238     resampler_reset(&rsmp->itfe);
239 
240     int frames = speex_resampler_get_input_latency(rsmp->speex_resampler);
241     rsmp->speex_delay_ns = (int32_t)((1000000000 * (int64_t)frames) / rsmp->in_sample_rate);
242     frames = speex_resampler_get_output_latency(rsmp->speex_resampler);
243     rsmp->speex_delay_ns += (int32_t)((1000000000 * (int64_t)frames) / rsmp->out_sample_rate);
244 
245     *resampler = &rsmp->itfe;
246     ALOGV("create_resampler() DONE rsmp %p &rsmp->itfe %p speex %p",
247          rsmp, &rsmp->itfe, rsmp->speex_resampler);
248     return 0;
249 }
250 
release_resampler(struct resampler_itfe * resampler)251 void release_resampler(struct resampler_itfe *resampler)
252 {
253     struct resampler *rsmp = (struct resampler *)resampler;
254 
255     if (rsmp == NULL) {
256         return;
257     }
258 
259     free(rsmp->in_buf);
260 
261     if (rsmp->speex_resampler != NULL) {
262         speex_resampler_destroy(rsmp->speex_resampler);
263     }
264     free(rsmp);
265 }
266