]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | ** Copyright (c) 2002-2016, Erik de Castro Lopo <erikd@mega-nerd.com> | |
3 | ** All rights reserved. | |
4 | ** | |
5 | ** This code is released under 2-clause BSD license. Please see the | |
6 | ** file at : https://github.com/erikd/libsamplerate/blob/master/COPYING | |
7 | */ | |
8 | ||
9 | #include <stdio.h> | |
10 | #include <stdlib.h> | |
11 | #include <string.h> | |
12 | ||
13 | #include "config.h" | |
14 | ||
15 | #include "samplerate.h" | |
16 | #include "float_cast.h" | |
17 | #include "common.h" | |
18 | ||
19 | static int psrc_set_converter (SRC_PRIVATE *psrc, int converter_type) ; | |
20 | ||
21 | ||
22 | SRC_STATE * | |
23 | src_new (int converter_type, int channels, int *error) | |
24 | { SRC_PRIVATE *psrc ; | |
25 | ||
26 | if (error) | |
27 | *error = SRC_ERR_NO_ERROR ; | |
28 | ||
29 | if (channels < 1) | |
30 | { if (error) | |
31 | *error = SRC_ERR_BAD_CHANNEL_COUNT ; | |
32 | return NULL ; | |
33 | } ; | |
34 | ||
35 | if ((psrc = calloc (1, sizeof (*psrc))) == NULL) | |
36 | { if (error) | |
37 | *error = SRC_ERR_MALLOC_FAILED ; | |
38 | return NULL ; | |
39 | } ; | |
40 | ||
41 | psrc->channels = channels ; | |
42 | psrc->mode = SRC_MODE_PROCESS ; | |
43 | ||
44 | if (psrc_set_converter (psrc, converter_type) != SRC_ERR_NO_ERROR) | |
45 | { if (error) | |
46 | *error = SRC_ERR_BAD_CONVERTER ; | |
47 | free (psrc) ; | |
48 | psrc = NULL ; | |
49 | } ; | |
50 | ||
51 | src_reset ((SRC_STATE*) psrc) ; | |
52 | ||
53 | return (SRC_STATE*) psrc ; | |
54 | } /* src_new */ | |
55 | ||
56 | SRC_STATE* | |
57 | src_callback_new (src_callback_t func, int converter_type, int channels, int *error, void* cb_data) | |
58 | { SRC_STATE *src_state ; | |
59 | ||
60 | if (func == NULL) | |
61 | { if (error) | |
62 | *error = SRC_ERR_BAD_CALLBACK ; | |
63 | return NULL ; | |
64 | } ; | |
65 | ||
66 | if (error != NULL) | |
67 | *error = 0 ; | |
68 | ||
69 | if ((src_state = src_new (converter_type, channels, error)) == NULL) | |
70 | return NULL ; | |
71 | ||
72 | src_reset (src_state) ; | |
73 | ||
74 | ((SRC_PRIVATE*) src_state)->mode = SRC_MODE_CALLBACK ; | |
75 | ((SRC_PRIVATE*) src_state)->callback_func = func ; | |
76 | ((SRC_PRIVATE*) src_state)->user_callback_data = cb_data ; | |
77 | ||
78 | return src_state ; | |
79 | } /* src_callback_new */ | |
80 | ||
81 | SRC_STATE * | |
82 | src_delete (SRC_STATE *state) | |
83 | { SRC_PRIVATE *psrc ; | |
84 | ||
85 | psrc = (SRC_PRIVATE*) state ; | |
86 | if (psrc) | |
87 | { if (psrc->private_data) | |
88 | free (psrc->private_data) ; | |
89 | memset (psrc, 0, sizeof (SRC_PRIVATE)) ; | |
90 | free (psrc) ; | |
91 | } ; | |
92 | ||
93 | return NULL ; | |
94 | } /* src_state */ | |
95 | ||
96 | int | |
97 | src_process (SRC_STATE *state, SRC_DATA *data) | |
98 | { SRC_PRIVATE *psrc ; | |
99 | int error ; | |
100 | ||
101 | psrc = (SRC_PRIVATE*) state ; | |
102 | ||
103 | if (psrc == NULL) | |
104 | return SRC_ERR_BAD_STATE ; | |
105 | if (psrc->vari_process == NULL || psrc->const_process == NULL) | |
106 | return SRC_ERR_BAD_PROC_PTR ; | |
107 | ||
108 | if (psrc->mode != SRC_MODE_PROCESS) | |
109 | return SRC_ERR_BAD_MODE ; | |
110 | ||
111 | /* Check for valid SRC_DATA first. */ | |
112 | if (data == NULL) | |
113 | return SRC_ERR_BAD_DATA ; | |
114 | ||
115 | /* And that data_in and data_out are valid. */ | |
116 | if (data->data_in == NULL || data->data_out == NULL) | |
117 | return SRC_ERR_BAD_DATA_PTR ; | |
118 | ||
119 | /* Check src_ratio is in range. */ | |
120 | if (is_bad_src_ratio (data->src_ratio)) | |
121 | return SRC_ERR_BAD_SRC_RATIO ; | |
122 | ||
123 | if (data->input_frames < 0) | |
124 | data->input_frames = 0 ; | |
125 | if (data->output_frames < 0) | |
126 | data->output_frames = 0 ; | |
127 | ||
128 | if (data->data_in < data->data_out) | |
129 | { if (data->data_in + data->input_frames * psrc->channels > data->data_out) | |
130 | { /*-printf ("\n\ndata_in: %p data_out: %p\n", | |
131 | (void*) (data->data_in + data->input_frames * psrc->channels), (void*) data->data_out) ;-*/ | |
132 | return SRC_ERR_DATA_OVERLAP ; | |
133 | } ; | |
134 | } | |
135 | else if (data->data_out + data->output_frames * psrc->channels > data->data_in) | |
136 | { /*-printf ("\n\ndata_in : %p ouput frames: %ld data_out: %p\n", (void*) data->data_in, data->output_frames, (void*) data->data_out) ; | |
137 | ||
138 | printf ("data_out: %p (%p) data_in: %p\n", (void*) data->data_out, | |
139 | (void*) (data->data_out + data->input_frames * psrc->channels), (void*) data->data_in) ;-*/ | |
140 | return SRC_ERR_DATA_OVERLAP ; | |
141 | } ; | |
142 | ||
143 | /* Set the input and output counts to zero. */ | |
144 | data->input_frames_used = 0 ; | |
145 | data->output_frames_gen = 0 ; | |
146 | ||
147 | /* Special case for when last_ratio has not been set. */ | |
148 | if (psrc->last_ratio < (1.0 / SRC_MAX_RATIO)) | |
149 | psrc->last_ratio = data->src_ratio ; | |
150 | ||
151 | /* Now process. */ | |
152 | if (fabs (psrc->last_ratio - data->src_ratio) < 1e-15) | |
153 | error = psrc->const_process (psrc, data) ; | |
154 | else | |
155 | error = psrc->vari_process (psrc, data) ; | |
156 | ||
157 | return error ; | |
158 | } /* src_process */ | |
159 | ||
160 | long | |
161 | src_callback_read (SRC_STATE *state, double src_ratio, long frames, float *data) | |
162 | { SRC_PRIVATE *psrc ; | |
163 | SRC_DATA src_data ; | |
164 | ||
165 | long output_frames_gen ; | |
166 | int error = 0 ; | |
167 | ||
168 | if (state == NULL) | |
169 | return 0 ; | |
170 | ||
171 | if (frames <= 0) | |
172 | return 0 ; | |
173 | ||
174 | psrc = (SRC_PRIVATE*) state ; | |
175 | ||
176 | if (psrc->mode != SRC_MODE_CALLBACK) | |
177 | { psrc->error = SRC_ERR_BAD_MODE ; | |
178 | return 0 ; | |
179 | } ; | |
180 | ||
181 | if (psrc->callback_func == NULL) | |
182 | { psrc->error = SRC_ERR_NULL_CALLBACK ; | |
183 | return 0 ; | |
184 | } ; | |
185 | ||
186 | memset (&src_data, 0, sizeof (src_data)) ; | |
187 | ||
188 | /* Check src_ratio is in range. */ | |
189 | if (is_bad_src_ratio (src_ratio)) | |
190 | { psrc->error = SRC_ERR_BAD_SRC_RATIO ; | |
191 | return 0 ; | |
192 | } ; | |
193 | ||
194 | /* Switch modes temporarily. */ | |
195 | src_data.src_ratio = src_ratio ; | |
196 | src_data.data_out = data ; | |
197 | src_data.output_frames = frames ; | |
198 | ||
199 | src_data.data_in = psrc->saved_data ; | |
200 | src_data.input_frames = psrc->saved_frames ; | |
201 | ||
202 | output_frames_gen = 0 ; | |
203 | while (output_frames_gen < frames) | |
204 | { /* Use a dummy array for the case where the callback function | |
205 | ** returns without setting the ptr. | |
206 | */ | |
207 | float dummy [1] ; | |
208 | ||
209 | if (src_data.input_frames == 0) | |
210 | { float *ptr = dummy ; | |
211 | ||
212 | src_data.input_frames = psrc->callback_func (psrc->user_callback_data, &ptr) ; | |
213 | src_data.data_in = ptr ; | |
214 | ||
215 | if (src_data.input_frames == 0) | |
216 | src_data.end_of_input = 1 ; | |
217 | } ; | |
218 | ||
219 | /* | |
220 | ** Now call process function. However, we need to set the mode | |
221 | ** to SRC_MODE_PROCESS first and when we return set it back to | |
222 | ** SRC_MODE_CALLBACK. | |
223 | */ | |
224 | psrc->mode = SRC_MODE_PROCESS ; | |
225 | error = src_process (state, &src_data) ; | |
226 | psrc->mode = SRC_MODE_CALLBACK ; | |
227 | ||
228 | if (error != 0) | |
229 | break ; | |
230 | ||
231 | src_data.data_in += src_data.input_frames_used * psrc->channels ; | |
232 | src_data.input_frames -= src_data.input_frames_used ; | |
233 | ||
234 | src_data.data_out += src_data.output_frames_gen * psrc->channels ; | |
235 | src_data.output_frames -= src_data.output_frames_gen ; | |
236 | ||
237 | output_frames_gen += src_data.output_frames_gen ; | |
238 | ||
239 | if (src_data.end_of_input == SRC_TRUE && src_data.output_frames_gen == 0) | |
240 | break ; | |
241 | } ; | |
242 | ||
243 | psrc->saved_data = src_data.data_in ; | |
244 | psrc->saved_frames = src_data.input_frames ; | |
245 | ||
246 | if (error != 0) | |
247 | { psrc->error = error ; | |
248 | return 0 ; | |
249 | } ; | |
250 | ||
251 | return output_frames_gen ; | |
252 | } /* src_callback_read */ | |
253 | ||
254 | /*========================================================================== | |
255 | */ | |
256 | ||
257 | int | |
258 | src_set_ratio (SRC_STATE *state, double new_ratio) | |
259 | { SRC_PRIVATE *psrc ; | |
260 | ||
261 | psrc = (SRC_PRIVATE*) state ; | |
262 | ||
263 | if (psrc == NULL) | |
264 | return SRC_ERR_BAD_STATE ; | |
265 | if (psrc->vari_process == NULL || psrc->const_process == NULL) | |
266 | return SRC_ERR_BAD_PROC_PTR ; | |
267 | ||
268 | if (is_bad_src_ratio (new_ratio)) | |
269 | return SRC_ERR_BAD_SRC_RATIO ; | |
270 | ||
271 | psrc->last_ratio = new_ratio ; | |
272 | ||
273 | return SRC_ERR_NO_ERROR ; | |
274 | } /* src_set_ratio */ | |
275 | ||
276 | int | |
277 | src_get_channels (SRC_STATE *state) | |
278 | { SRC_PRIVATE *psrc ; | |
279 | ||
280 | psrc = (SRC_PRIVATE*) state ; | |
281 | ||
282 | if (psrc == NULL) | |
283 | return SRC_ERR_BAD_STATE ; | |
284 | if (psrc->vari_process == NULL || psrc->const_process == NULL) | |
285 | return SRC_ERR_BAD_PROC_PTR ; | |
286 | ||
287 | return psrc->channels ; | |
288 | } /* src_get_channels */ | |
289 | ||
290 | int | |
291 | src_reset (SRC_STATE *state) | |
292 | { SRC_PRIVATE *psrc ; | |
293 | ||
294 | if ((psrc = (SRC_PRIVATE*) state) == NULL) | |
295 | return SRC_ERR_BAD_STATE ; | |
296 | ||
297 | if (psrc->reset != NULL) | |
298 | psrc->reset (psrc) ; | |
299 | ||
300 | psrc->last_position = 0.0 ; | |
301 | psrc->last_ratio = 0.0 ; | |
302 | ||
303 | psrc->saved_data = NULL ; | |
304 | psrc->saved_frames = 0 ; | |
305 | ||
306 | psrc->error = SRC_ERR_NO_ERROR ; | |
307 | ||
308 | return SRC_ERR_NO_ERROR ; | |
309 | } /* src_reset */ | |
310 | ||
311 | /*============================================================================== | |
312 | ** Control functions. | |
313 | */ | |
314 | ||
315 | const char * | |
316 | src_get_name (int converter_type) | |
317 | { const char *desc ; | |
318 | ||
319 | if ((desc = sinc_get_name (converter_type)) != NULL) | |
320 | return desc ; | |
321 | ||
322 | if ((desc = zoh_get_name (converter_type)) != NULL) | |
323 | return desc ; | |
324 | ||
325 | if ((desc = linear_get_name (converter_type)) != NULL) | |
326 | return desc ; | |
327 | ||
328 | return NULL ; | |
329 | } /* src_get_name */ | |
330 | ||
331 | const char * | |
332 | src_get_description (int converter_type) | |
333 | { const char *desc ; | |
334 | ||
335 | if ((desc = sinc_get_description (converter_type)) != NULL) | |
336 | return desc ; | |
337 | ||
338 | if ((desc = zoh_get_description (converter_type)) != NULL) | |
339 | return desc ; | |
340 | ||
341 | if ((desc = linear_get_description (converter_type)) != NULL) | |
342 | return desc ; | |
343 | ||
344 | return NULL ; | |
345 | } /* src_get_description */ | |
346 | ||
347 | const char * | |
348 | src_get_version (void) | |
349 | { return PACKAGE "-" VERSION " (c) 2002-2008 Erik de Castro Lopo" ; | |
350 | } /* src_get_version */ | |
351 | ||
352 | int | |
353 | src_is_valid_ratio (double ratio) | |
354 | { | |
355 | if (is_bad_src_ratio (ratio)) | |
356 | return SRC_FALSE ; | |
357 | ||
358 | return SRC_TRUE ; | |
359 | } /* src_is_valid_ratio */ | |
360 | ||
361 | /*============================================================================== | |
362 | ** Error reporting functions. | |
363 | */ | |
364 | ||
365 | int | |
366 | src_error (SRC_STATE *state) | |
367 | { if (state) | |
368 | return ((SRC_PRIVATE*) state)->error ; | |
369 | return SRC_ERR_NO_ERROR ; | |
370 | } /* src_error */ | |
371 | ||
372 | const char* | |
373 | src_strerror (int error) | |
374 | { | |
375 | switch (error) | |
376 | { case SRC_ERR_NO_ERROR : | |
377 | return "No error." ; | |
378 | case SRC_ERR_MALLOC_FAILED : | |
379 | return "Malloc failed." ; | |
380 | case SRC_ERR_BAD_STATE : | |
381 | return "SRC_STATE pointer is NULL." ; | |
382 | case SRC_ERR_BAD_DATA : | |
383 | return "SRC_DATA pointer is NULL." ; | |
384 | case SRC_ERR_BAD_DATA_PTR : | |
385 | return "SRC_DATA->data_out or SRC_DATA->data_in is NULL." ; | |
386 | case SRC_ERR_NO_PRIVATE : | |
387 | return "Internal error. No private data." ; | |
388 | ||
389 | case SRC_ERR_BAD_SRC_RATIO : | |
390 | return "SRC ratio outside [1/" SRC_MAX_RATIO_STR ", " SRC_MAX_RATIO_STR "] range." ; | |
391 | ||
392 | case SRC_ERR_BAD_SINC_STATE : | |
393 | return "src_process() called without reset after end_of_input." ; | |
394 | case SRC_ERR_BAD_PROC_PTR : | |
395 | return "Internal error. No process pointer." ; | |
396 | case SRC_ERR_SHIFT_BITS : | |
397 | return "Internal error. SHIFT_BITS too large." ; | |
398 | case SRC_ERR_FILTER_LEN : | |
399 | return "Internal error. Filter length too large." ; | |
400 | case SRC_ERR_BAD_CONVERTER : | |
401 | return "Bad converter number." ; | |
402 | case SRC_ERR_BAD_CHANNEL_COUNT : | |
403 | return "Channel count must be >= 1." ; | |
404 | case SRC_ERR_SINC_BAD_BUFFER_LEN : | |
405 | return "Internal error. Bad buffer length. Please report this." ; | |
406 | case SRC_ERR_SIZE_INCOMPATIBILITY : | |
407 | return "Internal error. Input data / internal buffer size difference. Please report this." ; | |
408 | case SRC_ERR_BAD_PRIV_PTR : | |
409 | return "Internal error. Private pointer is NULL. Please report this." ; | |
410 | case SRC_ERR_DATA_OVERLAP : | |
411 | return "Input and output data arrays overlap." ; | |
412 | case SRC_ERR_BAD_CALLBACK : | |
413 | return "Supplied callback function pointer is NULL." ; | |
414 | case SRC_ERR_BAD_MODE : | |
415 | return "Calling mode differs from initialisation mode (ie process v callback)." ; | |
416 | case SRC_ERR_NULL_CALLBACK : | |
417 | return "Callback function pointer is NULL in src_callback_read ()." ; | |
418 | case SRC_ERR_NO_VARIABLE_RATIO : | |
419 | return "This converter only allows constant conversion ratios." ; | |
420 | case SRC_ERR_SINC_PREPARE_DATA_BAD_LEN : | |
421 | return "Internal error : Bad length in prepare_data ()." ; | |
422 | case SRC_ERR_BAD_INTERNAL_STATE : | |
423 | return "Error : Someone is trampling on my internal state." ; | |
424 | ||
425 | case SRC_ERR_MAX_ERROR : | |
426 | return "Placeholder. No error defined for this error number." ; | |
427 | ||
428 | default : break ; | |
429 | } | |
430 | ||
431 | return NULL ; | |
432 | } /* src_strerror */ | |
433 | ||
434 | /*============================================================================== | |
435 | ** Simple interface for performing a single conversion from input buffer to | |
436 | ** output buffer at a fixed conversion ratio. | |
437 | */ | |
438 | ||
439 | int | |
440 | src_simple (SRC_DATA *src_data, int converter, int channels) | |
441 | { SRC_STATE *src_state ; | |
442 | int error ; | |
443 | ||
444 | if ((src_state = src_new (converter, channels, &error)) == NULL) | |
445 | return error ; | |
446 | ||
447 | src_data->end_of_input = 1 ; /* Only one buffer worth of input. */ | |
448 | ||
449 | error = src_process (src_state, src_data) ; | |
450 | ||
451 | src_delete (src_state) ; | |
452 | ||
453 | return error ; | |
454 | } /* src_simple */ | |
455 | ||
456 | void | |
457 | src_short_to_float_array (const short *in, float *out, int len) | |
458 | { | |
459 | while (len) | |
460 | { len -- ; | |
461 | out [len] = (float) (in [len] / (1.0 * 0x8000)) ; | |
462 | } ; | |
463 | ||
464 | return ; | |
465 | } /* src_short_to_float_array */ | |
466 | ||
467 | void | |
468 | src_float_to_short_array (const float *in, short *out, int len) | |
469 | { double scaled_value ; | |
470 | ||
471 | while (len) | |
472 | { len -- ; | |
473 | ||
474 | scaled_value = in [len] * (8.0 * 0x10000000) ; | |
475 | if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF)) | |
476 | { out [len] = 32767 ; | |
477 | continue ; | |
478 | } ; | |
479 | if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000)) | |
480 | { out [len] = -32768 ; | |
481 | continue ; | |
482 | } ; | |
483 | ||
484 | out [len] = (short) (lrint (scaled_value) >> 16) ; | |
485 | } ; | |
486 | ||
487 | } /* src_float_to_short_array */ | |
488 | ||
489 | void | |
490 | src_int_to_float_array (const int *in, float *out, int len) | |
491 | { | |
492 | while (len) | |
493 | { len -- ; | |
494 | out [len] = (float) (in [len] / (8.0 * 0x10000000)) ; | |
495 | } ; | |
496 | ||
497 | return ; | |
498 | } /* src_int_to_float_array */ | |
499 | ||
500 | void | |
501 | src_float_to_int_array (const float *in, int *out, int len) | |
502 | { double scaled_value ; | |
503 | ||
504 | while (len) | |
505 | { len -- ; | |
506 | ||
507 | scaled_value = in [len] * (8.0 * 0x10000000) ; | |
508 | if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF)) | |
509 | { out [len] = 0x7fffffff ; | |
510 | continue ; | |
511 | } ; | |
512 | if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000)) | |
513 | { out [len] = -1 - 0x7fffffff ; | |
514 | continue ; | |
515 | } ; | |
516 | ||
517 | out [len] = lrint (scaled_value) ; | |
518 | } ; | |
519 | ||
520 | } /* src_float_to_int_array */ | |
521 | ||
522 | /*============================================================================== | |
523 | ** Private functions. | |
524 | */ | |
525 | ||
526 | static int | |
527 | psrc_set_converter (SRC_PRIVATE *psrc, int converter_type) | |
528 | { | |
529 | if (sinc_set_converter (psrc, converter_type) == SRC_ERR_NO_ERROR) | |
530 | return SRC_ERR_NO_ERROR ; | |
531 | ||
532 | if (zoh_set_converter (psrc, converter_type) == SRC_ERR_NO_ERROR) | |
533 | return SRC_ERR_NO_ERROR ; | |
534 | ||
535 | if (linear_set_converter (psrc, converter_type) == SRC_ERR_NO_ERROR) | |
536 | return SRC_ERR_NO_ERROR ; | |
537 | ||
538 | return SRC_ERR_BAD_CONVERTER ; | |
539 | } /* psrc_set_converter */ | |
540 |