You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

541 lines
13KB

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