sdk/lib/3rdparty/libsamplerate/samplerate.c

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