1 /*
2 ** Copyright (C) 2002-2008 Erik de Castro Lopo <erikd@mega-nerd.com>
3 **
4 ** This program is free software; you can redistribute it and/or modify
5 ** it under the terms of the GNU General Public License as published by
6 ** the Free Software Foundation; either version 2 of the License, or
7 ** (at your option) any later version.
8 **
9 ** This program is distributed in the hope that it will be useful,
10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 ** GNU General Public License for more details.
13 **
14 ** You should have received a copy of the GNU General Public License
15 ** along with this program; if not, write to the Free Software
16 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19 /*
20 ** This code is part of Secret Rabibt Code aka libsamplerate. A commercial
21 ** use license for this code is available, please see:
22 ** http://www.mega-nerd.com/SRC/procedure.html
23 */
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #include "config.h"
30
31 #include "samplerate.h"
32 #include "float_cast.h"
33 #include "common.h"
34
35 static int psrc_set_converter (SRC_PRIVATE *psrc,
36 int converter_type, int d) ;
37
38 static inline int
is_bad_src_ratio(double ratio)39 is_bad_src_ratio (double ratio)
40 { return (ratio < (1.0 / SRC_MAX_RATIO) || ratio > (1.0 * SRC_MAX_RATIO)) ;
41 } /* is_bad_src_ratio */
42
43 SRC_STATE *
gavl_src_new(int converter_type,int channels,int * error,int d)44 gavl_src_new (int converter_type, int channels, int *error, int d)
45 { SRC_PRIVATE *psrc ;
46
47 if (error)
48 *error = SRC_ERR_NO_ERROR ;
49
50 if (channels < 1)
51 { if (error)
52 *error = SRC_ERR_BAD_CHANNEL_COUNT ;
53 return NULL ;
54 } ;
55
56 if ((psrc = calloc (1, sizeof (*psrc))) == NULL)
57 { if (error)
58 *error = SRC_ERR_MALLOC_FAILED ;
59 return NULL ;
60 } ;
61
62 psrc->channels = channels ;
63 psrc->mode = SRC_MODE_PROCESS ;
64
65 if (psrc_set_converter (psrc, converter_type, d) != SRC_ERR_NO_ERROR)
66 { if (error)
67 *error = SRC_ERR_BAD_CONVERTER ;
68 free (psrc) ;
69 psrc = NULL ;
70 } ;
71
72 gavl_src_reset ((SRC_STATE*) psrc) ;
73
74 return (SRC_STATE*) psrc ;
75 } /* src_new */
76
77 SRC_STATE*
gavl_src_callback_new(src_callback_t func,int converter_type,int channels,int * error,void * cb_data,int d)78 gavl_src_callback_new (src_callback_t func, int converter_type, int channels, int *error, void* cb_data, int d)
79 { SRC_STATE *src_state ;
80
81 if (func == NULL)
82 { if (error)
83 *error = SRC_ERR_BAD_CALLBACK ;
84 return NULL ;
85 } ;
86
87 if (error != NULL)
88 *error = 0 ;
89
90 src_state = gavl_src_new (converter_type, channels, error, d) ;
91
92 gavl_src_reset (src_state) ;
93
94 ((SRC_PRIVATE*) src_state)->mode = SRC_MODE_CALLBACK ;
95 ((SRC_PRIVATE*) src_state)->callback_func = func ;
96 ((SRC_PRIVATE*) src_state)->user_callback_data = cb_data ;
97
98 return src_state ;
99 } /* src_callback_new */
100
101 SRC_STATE *
gavl_src_delete(SRC_STATE * state)102 gavl_src_delete (SRC_STATE *state)
103 { SRC_PRIVATE *psrc ;
104
105 psrc = (SRC_PRIVATE*) state ;
106 if (psrc)
107 { if (psrc->private_data)
108 free (psrc->private_data) ;
109 memset (psrc, 0, sizeof (SRC_PRIVATE)) ;
110 free (psrc) ;
111 } ;
112
113 return NULL ;
114 } /* src_state */
115
116 int
gavl_src_process(SRC_STATE * state,SRC_DATA * data)117 gavl_src_process (SRC_STATE *state, SRC_DATA *data)
118 { SRC_PRIVATE *psrc ;
119 int error ;
120
121 psrc = (SRC_PRIVATE*) state ;
122
123 if (psrc == NULL)
124 return SRC_ERR_BAD_STATE ;
125 if (psrc->vari_process == NULL || psrc->const_process == NULL)
126 return SRC_ERR_BAD_PROC_PTR ;
127
128 if (psrc->mode != SRC_MODE_PROCESS)
129 return SRC_ERR_BAD_MODE ;
130
131 /* Check for valid SRC_DATA first. */
132 if (data == NULL)
133 return SRC_ERR_BAD_DATA ;
134
135 /* Check src_ratio is in range. */
136 if (is_bad_src_ratio (data->src_ratio))
137 return SRC_ERR_BAD_SRC_RATIO ;
138
139
140 if (data->input_frames < 0)
141 data->input_frames = 0 ;
142 if (data->output_frames < 0)
143 data->output_frames = 0 ;
144
145 /* Set the input and output counts to zero. */
146 data->input_frames_used = 0 ;
147 data->output_frames_gen = 0 ;
148
149 /* Special case for when last_ratio has not been set. */
150 if (psrc->last_ratio < (1.0 / SRC_MAX_RATIO))
151 psrc->last_ratio = data->src_ratio ;
152
153 /* Now process. */
154 if (fabs (psrc->last_ratio - data->src_ratio) < 1e-15)
155 error = psrc->const_process (psrc, data) ;
156 else
157 error = psrc->vari_process (psrc, data) ;
158
159 return error ;
160 } /* src_process */
161
162 /*==========================================================================
163 */
164
165 int
gavl_src_set_ratio(SRC_STATE * state,double new_ratio)166 gavl_src_set_ratio (SRC_STATE *state, double new_ratio)
167 { SRC_PRIVATE *psrc ;
168
169 psrc = (SRC_PRIVATE*) state ;
170
171 if (psrc == NULL)
172 return SRC_ERR_BAD_STATE ;
173 if (psrc->vari_process == NULL || psrc->const_process == NULL)
174 return SRC_ERR_BAD_PROC_PTR ;
175
176 if (is_bad_src_ratio (new_ratio))
177 return SRC_ERR_BAD_SRC_RATIO ;
178
179 psrc->last_ratio = new_ratio ;
180
181 return SRC_ERR_NO_ERROR ;
182 } /* src_set_ratio */
183
184 int
gavl_src_reset(SRC_STATE * state)185 gavl_src_reset (SRC_STATE *state)
186 { SRC_PRIVATE *psrc ;
187
188 if ((psrc = (SRC_PRIVATE*) state) == NULL)
189 return SRC_ERR_BAD_STATE ;
190
191 if (psrc->reset != NULL)
192 psrc->reset (psrc) ;
193
194 psrc->last_position = 0.0 ;
195 psrc->last_ratio = 0.0 ;
196
197 psrc->saved_data_d = NULL ;
198 psrc->saved_data_f = NULL ;
199 psrc->saved_frames = 0 ;
200
201 psrc->error = SRC_ERR_NO_ERROR ;
202
203 return SRC_ERR_NO_ERROR ;
204 } /* src_reset */
205
206 /*==============================================================================
207 ** Control functions.
208 */
209
210 const char *
gavl_src_get_name(int converter_type)211 gavl_src_get_name (int converter_type)
212 { const char *desc ;
213
214 if ((desc = sinc_get_name (converter_type)) != NULL)
215 return desc ;
216
217 if ((desc = zoh_get_name (converter_type)) != NULL)
218 return desc ;
219
220 if ((desc = linear_get_name (converter_type)) != NULL)
221 return desc ;
222
223 return NULL ;
224 } /* src_get_name */
225
226 const char *
gavl_src_get_description(int converter_type)227 gavl_src_get_description (int converter_type)
228 { const char *desc ;
229
230 if ((desc = sinc_get_description (converter_type)) != NULL)
231 return desc ;
232
233 if ((desc = zoh_get_description (converter_type)) != NULL)
234 return desc ;
235
236 if ((desc = linear_get_description (converter_type)) != NULL)
237 return desc ;
238
239 return NULL ;
240 } /* src_get_description */
241
242 const char *
gavl_src_get_version(void)243 gavl_src_get_version (void)
244 { return PACKAGE "-" VERSION " (c) 2002-2008 Erik de Castro Lopo" ;
245 } /* src_get_version */
246
247 int
gavl_src_is_valid_ratio(double ratio)248 gavl_src_is_valid_ratio (double ratio)
249 {
250 if (is_bad_src_ratio (ratio))
251 return SRC_FALSE ;
252
253 return SRC_TRUE ;
254 } /* src_is_valid_ratio */
255
256 /*==============================================================================
257 ** Error reporting functions.
258 */
259
260 int
gavl_src_error(SRC_STATE * state)261 gavl_src_error (SRC_STATE *state)
262 { if (state)
263 return ((SRC_PRIVATE*) state)->error ;
264 return SRC_ERR_NO_ERROR ;
265 } /* src_error */
266
267 const char*
gavl_src_strerror(int error)268 gavl_src_strerror (int error)
269 {
270 switch (error)
271 { case SRC_ERR_NO_ERROR :
272 return "No error." ;
273 case SRC_ERR_MALLOC_FAILED :
274 return "Malloc failed." ;
275 case SRC_ERR_BAD_STATE :
276 return "SRC_STATE pointer is NULL." ;
277 case SRC_ERR_BAD_DATA :
278 return "SRC_DATA pointer is NULL." ;
279 case SRC_ERR_BAD_DATA_PTR :
280 return "SRC_DATA->data_out is NULL." ;
281 case SRC_ERR_NO_PRIVATE :
282 return "Internal error. No private data." ;
283 case SRC_ERR_BAD_SRC_RATIO :
284 return "SRC ratio outside [1/12, 12] range." ;
285 case SRC_ERR_BAD_SINC_STATE :
286 return "src_process() called without reset after end_of_input." ;
287 case SRC_ERR_BAD_PROC_PTR :
288 return "Internal error. No process pointer." ;
289 case SRC_ERR_SHIFT_BITS :
290 return "Internal error. SHIFT_BITS too large." ;
291 case SRC_ERR_FILTER_LEN :
292 return "Internal error. Filter length too large." ;
293 case SRC_ERR_BAD_CONVERTER :
294 return "Bad converter number." ;
295 case SRC_ERR_BAD_CHANNEL_COUNT :
296 return "Channel count must be >= 1." ;
297 case SRC_ERR_SINC_BAD_BUFFER_LEN :
298 return "Internal error. Bad buffer length. Please report this." ;
299 case SRC_ERR_SIZE_INCOMPATIBILITY :
300 return "Internal error. Input data / internal buffer size difference. Please report this." ;
301 case SRC_ERR_BAD_PRIV_PTR :
302 return "Internal error. Private pointer is NULL. Please report this." ;
303 case SRC_ERR_DATA_OVERLAP :
304 return "Input and output data arrays overlap." ;
305 case SRC_ERR_BAD_CALLBACK :
306 return "Supplied callback function pointer is NULL." ;
307 case SRC_ERR_BAD_MODE :
308 return "Calling mode differs from initialisation mode (ie process v callback)." ;
309 case SRC_ERR_NULL_CALLBACK :
310 return "Callback function pointer is NULL in src_callback_read ()." ;
311 case SRC_ERR_NO_VARIABLE_RATIO :
312 return "This converter only allows constant conversion ratios." ;
313
314 case SRC_ERR_MAX_ERROR :
315 return "Placeholder. No error defined for this error number." ;
316
317 default : break ;
318 }
319
320 return NULL ;
321 } /* src_strerror */
322
323 /*==============================================================================
324 ** Simple interface for performing a single conversion from input buffer to
325 ** output buffer at a fixed conversion ratio.
326 */
327
328 #if 0
329 void
330 src_short_to_float_array (const short *in, float *out, int len)
331 {
332 while (len)
333 { len -- ;
334 out [len] = (float) (in [len] / (1.0 * 0x8000)) ;
335 } ;
336
337 return ;
338 } /* src_short_to_float_array */
339
340 void
341 src_float_to_short_array (const float *in, short *out, int len)
342 { double scaled_value ;
343
344 while (len)
345 { len -- ;
346
347 scaled_value = in [len] * (8.0 * 0x10000000) ;
348 if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
349 { out [len] = 32767 ;
350 continue ;
351 } ;
352 if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
353 { out [len] = -32768 ;
354 continue ;
355 } ;
356
357 out [len] = (short) (lrint (scaled_value) >> 16) ;
358 } ;
359
360 } /* src_float_to_short_array */
361
362 void
363 src_int_to_float_array (const int *in, float *out, int len)
364 {
365 while (len)
366 { len -- ;
367 out [len] = (float) (in [len] / (8.0 * 0x10000000)) ;
368 } ;
369
370 return ;
371 } /* src_int_to_float_array */
372
373 void
374 src_float_to_int_array (const float *in, int *out, int len)
375 { double scaled_value ;
376
377 while (len)
378 { len -- ;
379
380 scaled_value = in [len] * (8.0 * 0x10000000) ;
381 if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
382 { out [len] = 0x7fffffff ;
383 continue ;
384 } ;
385 if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
386 { out [len] = -1 - 0x7fffffff ;
387 continue ;
388 } ;
389
390 out [len] = lrint (scaled_value) ;
391 } ;
392
393 } /* src_float_to_int_array */
394 #endif
395 /*==============================================================================
396 ** Private functions.
397 */
398
399 static int
psrc_set_converter(SRC_PRIVATE * psrc,int converter_type,int d)400 psrc_set_converter (SRC_PRIVATE *psrc, int converter_type, int d)
401 {
402 if (gavl_sinc_set_converter (psrc, converter_type, d) == SRC_ERR_NO_ERROR)
403 return SRC_ERR_NO_ERROR ;
404
405 if (gavl_zoh_set_converter (psrc, converter_type, d) == SRC_ERR_NO_ERROR)
406 return SRC_ERR_NO_ERROR ;
407
408 if (gavl_linear_set_converter (psrc, converter_type, d) == SRC_ERR_NO_ERROR)
409 return SRC_ERR_NO_ERROR ;
410
411 return SRC_ERR_BAD_CONVERTER ;
412 } /* psrc_set_converter */
413
414