sox.h

Go to the documentation of this file.

/* libSoX Library Public Interface
 *
 * Copyright 1999-2012 Chris Bagwell and SoX Contributors.
 *
 * This source code is freely redistributable and may be used for
 * any purpose.  This copyright notice must be maintained.
 * Chris Bagwell And SoX Contributors are not responsible for
 * the consequences of using this software.
 */
 
#ifndef SOX_H
#define SOX_H 
#include <limits.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
 
#if defined(__cplusplus)
extern "C" {
#endif
 
/* Suppress warnings from use of type long long. */
#if defined __GNUC__
#pragma GCC system_header
#endif
 
#if defined __GNUC__
#define LSX_GCC(maj, min) \
  ((__GNUC__ > (maj)) || (__GNUC__ == (maj) && __GNUC_MINOR__ >= (min)))
#else
#define LSX_GCC(maj, min) 0
#endif
 
#if LSX_GCC(4,9)
#define _Ret_ __attribute__ ((returns_nonnull))
#define _Ret_valid_ _Ret_
#define _Ret_z_ _Ret_
#endif
 
/*****************************************************************************
API decoration macros:
Mostly for documentation purposes. For some compilers, decorations also affect
code generation, influence compiler warnings or activate compiler
optimizations.
*****************************************************************************/
 
#if defined __GNUC__ && defined __i386__
#define LSX_API  __attribute__ ((cdecl)) /* libSoX function */
#elif _MSC_VER
#define LSX_API  __cdecl /* libSoX function */
#else
#define LSX_API /* libSoX function */
#endif
 
#ifdef __GNUC__
#define LSX_UNUSED  __attribute__ ((unused)) /* Parameter or local variable is intentionally unused. */
#else
#define LSX_UNUSED /* Parameter or local variable is intentionally unused. */
#endif
 
#ifdef __GNUC__
#define LSX_PRINTF12  __attribute__ ((format (printf, 1, 2))) /* Function has printf-style arguments. */
#else
#define LSX_PRINTF12 /* Function has printf-style arguments. */
#endif
 
#ifdef __GNUC__
#define LSX_RETURN_PURE __attribute__ ((pure)) /* Function is pure. */
#else
#define LSX_RETURN_PURE /* Function is pure. */
#endif
 
#ifdef _Ret_
#define LSX_RETURN_VALID _Ret_ /* Function always returns a valid object (never NULL). */
#else
#define LSX_RETURN_VALID /* Function always returns a valid object (never NULL). */
#endif
 
#ifdef _Ret_valid_
#define LSX_RETURN_ARRAY _Ret_valid_ /* Function always returns a valid array (never NULL). */
#else
#define LSX_RETURN_ARRAY /* Function always returns a valid array (never NULL). */
#endif
 
#ifdef _Ret_z_
#define LSX_RETURN_VALID_Z _Ret_z_ /* Function always returns a 0-terminated array (never NULL). */
#else
#define LSX_RETURN_VALID_Z /* Function always returns a 0-terminated array (never NULL). */
#endif
 
#ifdef _Ret_opt_
#define LSX_RETURN_OPT _Ret_opt_ /* Function may return NULL. */
#else
#define LSX_RETURN_OPT /* Function may return NULL. */
#endif
 
#ifdef _In_
#define LSX_PARAM_IN _In_ /* Required const pointer to a valid object (never NULL). */
#else
#define LSX_PARAM_IN /* Required const pointer to a valid object (never NULL). */
#endif
 
#ifdef _In_z_
#define LSX_PARAM_IN_Z _In_z_ /* Required const pointer to 0-terminated string (never NULL). */
#else
#define LSX_PARAM_IN_Z /* Required const pointer to 0-terminated string (never NULL). */
#endif
 
#ifdef _Printf_format_string_
#define LSX_PARAM_IN_PRINTF _Printf_format_string_ /* Required const pointer to 0-terminated printf format string (never NULL). */
#else
#define LSX_PARAM_IN_PRINTF /* Required const pointer to 0-terminated printf format string (never NULL). */
#endif
 
#ifdef _In_count_
#define LSX_PARAM_IN_COUNT(len) _In_count_(len) /* Required const pointer to (len) valid objects (never NULL). */
#else
#define LSX_PARAM_IN_COUNT(len) /* Required const pointer to (len) valid objects (never NULL). */
#endif
 
#ifdef _In_bytecount_
#define LSX_PARAM_IN_BYTECOUNT(len) _In_bytecount_(len) /* Required const pointer to (len) bytes of data (never NULL). */
#else
#define LSX_PARAM_IN_BYTECOUNT(len) /* Required const pointer to (len) bytes of data (never NULL). */
#endif
 
#ifdef _In_opt_
#define LSX_PARAM_IN_OPT _In_opt_ /* Optional const pointer to a valid object (may be NULL). */
#else
#define LSX_PARAM_IN_OPT /* Optional const pointer to a valid object (may be NULL). */
#endif
 
#ifdef _In_opt_z_
#define LSX_PARAM_IN_OPT_Z _In_opt_z_ /* Optional const pointer to 0-terminated string (may be NULL). */
#else
#define LSX_PARAM_IN_OPT_Z /* Optional const pointer to 0-terminated string (may be NULL). */
#endif
 
#ifdef _Inout_
#define LSX_PARAM_INOUT _Inout_ /* Required pointer to a valid object (never NULL). */
#else
#define LSX_PARAM_INOUT /* Required pointer to a valid object (never NULL). */
#endif
 
#ifdef _Inout_count_x_
#define LSX_PARAM_INOUT_COUNT(len) _Inout_count_x_(len) /* Required pointer to (len) valid objects (never NULL). */
#else
#define LSX_PARAM_INOUT_COUNT(len) /* Required pointer to (len) valid objects (never NULL). */
#endif
 
#ifdef _Out_
#define LSX_PARAM_OUT _Out_ /* Required pointer to an object to be initialized (never NULL). */
#else
#define LSX_PARAM_OUT /* Required pointer to an object to be initialized (never NULL). */
#endif
 
#ifdef _Out_bytecap_
#define LSX_PARAM_OUT_BYTECAP(len) _Out_bytecap_(len) /* Required pointer to writable buffer with room for len bytes. */
#else
#define LSX_PARAM_OUT_BYTECAP(len) /* Required pointer to writable buffer with room for len bytes. */
#endif
 
#ifdef _Out_cap_post_count_
#define LSX_PARAM_OUT_CAP_POST_COUNT(len,filled) _Out_cap_post_count_(len,filled) /* Required pointer to buffer for (len) elements (never NULL); on return, (filled) elements will have been initialized. */
#else
#define LSX_PARAM_OUT_CAP_POST_COUNT(len,filled) /* Required pointer to buffer for (len) elements (never NULL); on return, (filled) elements will have been initialized. */
#endif
 
#ifdef _Out_z_cap_post_count_
#define LSX_PARAM_OUT_Z_CAP_POST_COUNT(len,filled) _Out_z_cap_post_count_(len,filled) /* Required pointer to buffer for (len) elements (never NULL); on return, (filled+1) elements will have been initialized, and the array will be 0-terminated. */
#else
#define LSX_PARAM_OUT_Z_CAP_POST_COUNT(len,filled) /* Required pointer to buffer for (len) elements (never NULL); on return, (filled+1) elements will have been initialized, and the array will be 0-terminated. */
#endif
 
#ifdef _Out_opt_
#define LSX_PARAM_OUT_OPT _Out_opt_ /* Optional pointer to an object to be initialized (may be NULL). */
#else
#define LSX_PARAM_OUT_OPT /* Optional pointer to an object to be initialized (may be NULL). */
#endif
 
#ifdef _Deref_pre_maybenull_
#define LSX_PARAM_DEREF_PRE_MAYBENULL _Deref_pre_maybenull_ /* Required pointer (never NULL) to another pointer (may be NULL). */
#else
#define LSX_PARAM_DEREF_PRE_MAYBENULL /* Required pointer (never NULL) to another pointer (may be NULL). */
#endif
 
#ifdef _Deref_post_null_
#define LSX_PARAM_DEREF_POST_NULL _Deref_post_null_ /* Required pointer (never NULL) to another pointer, which will be NULL on exit. */
#else
#define LSX_PARAM_DEREF_POST_NULL /* Required pointer (never NULL) to another pointer, which will be NULL on exit. */
#endif
 
#ifdef _Deref_post_notnull_
#define LSX_PARAM_DEREF_POST_NOTNULL _Deref_post_notnull_ /* Required pointer (never NULL) to another pointer, which will be valid (not NULL) on exit. */
#else
#define LSX_PARAM_DEREF_POST_NOTNULL /* Required pointer (never NULL) to another pointer, which will be valid (not NULL) on exit. */
#endif
 
#ifdef _PREFAST_
#define LSX_USE_VAR(x)  ((void)(x=0)) /* During static analysis, initialize unused variables to 0. */
#else
#define LSX_USE_VAR(x)  ((void)(x)) /* Parameter or variable is intentionally unused. */
#endif
 
#define lsx_static_assert(e,f) enum {lsx_static_assert_##f = 1/((e) ? 1 : 0)}
 
/*****************************************************************************
Basic typedefs:
*****************************************************************************/
 
typedef int8_t sox_int8_t;
 
typedef uint8_t sox_uint8_t;
 
typedef int16_t sox_int16_t;
 
typedef uint16_t sox_uint16_t;
 
typedef int32_t sox_int32_t;
 
typedef uint32_t sox_uint32_t;
 
typedef int64_t sox_int64_t;
 
typedef uint64_t sox_uint64_t;
 
typedef sox_int32_t sox_int24_t;
 
typedef sox_uint32_t sox_uint24_t;
 
typedef sox_int32_t sox_sample_t;
 
typedef double sox_rate_t;
 
typedef char * * sox_comments_t;
 
/*****************************************************************************
Enumerations:
*****************************************************************************/
 
typedef enum sox_bool {
    sox_bool_dummy = -1, /* Ensure a signed type */
    sox_false, 
    sox_true   
} sox_bool;
 
typedef enum sox_option_t {
    sox_option_no,      
    sox_option_yes,     
    sox_option_default  
} sox_option_t;
 
enum sox_error_t {
  SOX_SUCCESS = 0,     
  SOX_EOF = -1,        
  SOX_EHDR = 2000,     
  SOX_EFMT,            
  SOX_ENOMEM,          
  SOX_EPERM,           
  SOX_ENOTSUP,         
  SOX_EINVAL           
};
 
typedef enum sox_version_flags_t {
    sox_version_none = 0,         
    sox_version_have_popen = 1,   
    sox_version_have_magic = 2,   
    sox_version_have_threads = 4, 
    sox_version_have_memopen = 8  
} sox_version_flags_t;
 
typedef enum sox_encoding_t {
  SOX_ENCODING_UNKNOWN   , 
  SOX_ENCODING_SIGN2     , 
  SOX_ENCODING_UNSIGNED  , 
  SOX_ENCODING_FLOAT     , 
  SOX_ENCODING_FLOAT_TEXT, 
  SOX_ENCODING_FLAC      , 
  SOX_ENCODING_HCOM      , 
  SOX_ENCODING_WAVPACK   , 
  SOX_ENCODING_WAVPACKF  , 
  SOX_ENCODING_ULAW      , 
  SOX_ENCODING_ALAW      , 
  SOX_ENCODING_G721      , 
  SOX_ENCODING_G723      , 
  SOX_ENCODING_CL_ADPCM  , 
  SOX_ENCODING_CL_ADPCM16, 
  SOX_ENCODING_MS_ADPCM  , 
  SOX_ENCODING_IMA_ADPCM , 
  SOX_ENCODING_OKI_ADPCM , 
  SOX_ENCODING_DPCM      , 
  SOX_ENCODING_DWVW      , 
  SOX_ENCODING_DWVWN     , 
  SOX_ENCODING_GSM       , 
  SOX_ENCODING_MP3       , 
  SOX_ENCODING_VORBIS    , 
  SOX_ENCODING_AMR_WB    , 
  SOX_ENCODING_AMR_NB    , 
  SOX_ENCODING_CVSD      , 
  SOX_ENCODING_LPC10     , 
  SOX_ENCODING_OPUS      , 
  SOX_ENCODINGS            
} sox_encoding_t;
 
typedef enum sox_encodings_flags_t {
  sox_encodings_none   = 0, 
  sox_encodings_lossy1 = 1, 
  sox_encodings_lossy2 = 2  
} sox_encodings_flags_t;
 
typedef enum sox_plot_t {
    sox_plot_off,     
    sox_plot_octave,  
    sox_plot_gnuplot, 
    sox_plot_data     
} sox_plot_t;
 
enum sox_loop_flags_t {
  sox_loop_none = 0,          
  sox_loop_forward = 1,       
  sox_loop_forward_back = 2,  
  sox_loop_8 = 32,            
  sox_loop_sustain_decay = 64 
};
 
typedef enum lsx_io_type
{
    lsx_io_file, 
    lsx_io_pipe, 
    lsx_io_url   
} lsx_io_type;
 
/*****************************************************************************
Macros:
*****************************************************************************/
 
#define SOX_LIB_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
 
#define SOX_LIB_VERSION_CODE   SOX_LIB_VERSION(14, 4, 2)
 
#define SOX_INT_MIN(bits) (1 <<((bits)-1))
 
#define SOX_INT_MAX(bits) (((unsigned)-1)>>(33-(bits)))
 
#define SOX_UINT_MAX(bits) (SOX_INT_MIN(bits)|SOX_INT_MAX(bits))
 
#define SOX_INT8_MAX  SOX_INT_MAX(8)
 
#define SOX_INT16_MAX SOX_INT_MAX(16)
 
#define SOX_INT24_MAX SOX_INT_MAX(24)
 
#define SOX_INT32_MAX SOX_INT_MAX(32)
 
#define SOX_SAMPLE_PRECISION 32
 
#define SOX_SAMPLE_MAX (sox_sample_t)SOX_INT_MAX(32)
 
#define SOX_SAMPLE_MIN (sox_sample_t)SOX_INT_MIN(32)
 
 
/*                Conversions: Linear PCM <--> sox_sample_t
 *
 *   I/O      Input    sox_sample_t Clips?   Input    sox_sample_t Clips?
 *  Format   Minimum     Minimum     I O    Maximum     Maximum     I O
 *  ------  ---------  ------------ -- --   --------  ------------ -- --
 *  Float     -inf         -1        y n      inf      1 - 5e-10    y n
 *  Int8      -128        -128       n n      127     127.9999999   n y
 *  Int16    -32768      -32768      n n     32767    32767.99998   n y
 *  Int24   -8388608    -8388608     n n    8388607   8388607.996   n y
 *  Int32  -2147483648 -2147483648   n n   2147483647 2147483647    n n
 *
 * Conversions are as accurate as possible (with rounding).
 *
 * Rounding: halves toward +inf, all others to nearest integer.
 *
 * Clips? shows whether on not there is the possibility of a conversion
 * clipping to the minimum or maximum value when inputing from or outputing
 * to a given type.
 *
 * Unsigned integers are converted to and from signed integers by flipping
 * the upper-most bit then treating them as signed integers.
 */
 
#define SOX_SAMPLE_LOCALS sox_sample_t sox_macro_temp_sample LSX_UNUSED; \
  double sox_macro_temp_double LSX_UNUSED
 
#define SOX_SAMPLE_NEG SOX_INT_MIN(32)
 
#define SOX_SAMPLE_TO_UNSIGNED(bits,d,clips) \
  (sox_uint##bits##_t)(SOX_SAMPLE_TO_SIGNED(bits,d,clips) ^ SOX_INT_MIN(bits))
 
#define SOX_SAMPLE_TO_SIGNED(bits,d,clips)                              \
  (sox_int##bits##_t)(                                                  \
    LSX_USE_VAR(sox_macro_temp_double),                                 \
    sox_macro_temp_sample = (d),                                        \
    sox_macro_temp_sample > SOX_SAMPLE_MAX - (1 << (31-bits)) ?         \
      ++(clips), SOX_INT_MAX(bits) :                                    \
      ((sox_uint32_t)(sox_macro_temp_sample + (1 << (31-bits)))) >> (32-bits))
 
#define SOX_SIGNED_TO_SAMPLE(bits,d) ((sox_sample_t)(d) << (32-bits))
 
#define SOX_UNSIGNED_TO_SAMPLE(bits,d) \
      (SOX_SIGNED_TO_SAMPLE(bits,d) ^ SOX_SAMPLE_NEG)
 
#define SOX_UNSIGNED_8BIT_TO_SAMPLE(d,clips) SOX_UNSIGNED_TO_SAMPLE(8,d)
 
#define SOX_SIGNED_8BIT_TO_SAMPLE(d,clips) SOX_SIGNED_TO_SAMPLE(8,d)
 
#define SOX_UNSIGNED_16BIT_TO_SAMPLE(d,clips) SOX_UNSIGNED_TO_SAMPLE(16,d)
 
#define SOX_SIGNED_16BIT_TO_SAMPLE(d,clips) SOX_SIGNED_TO_SAMPLE(16,d)
 
#define SOX_UNSIGNED_24BIT_TO_SAMPLE(d,clips) SOX_UNSIGNED_TO_SAMPLE(24,d)
 
#define SOX_SIGNED_24BIT_TO_SAMPLE(d,clips) SOX_SIGNED_TO_SAMPLE(24,d)
 
#define SOX_UNSIGNED_32BIT_TO_SAMPLE(d,clips) \
  ((sox_sample_t)(d) ^ SOX_SAMPLE_NEG)
 
#define SOX_SIGNED_32BIT_TO_SAMPLE(d,clips) (sox_sample_t)(d)
 
#define SOX_FLOAT_32BIT_TO_SAMPLE(d,clips) SOX_FLOAT_64BIT_TO_SAMPLE(d, clips)
 
#define SOX_FLOAT_64BIT_TO_SAMPLE(d, clips)                     \
  (sox_sample_t)(                                               \
    LSX_USE_VAR(sox_macro_temp_sample),                         \
    sox_macro_temp_double = (d) * (SOX_SAMPLE_MAX + 1.0),       \
    sox_macro_temp_double < 0 ?                                 \
      sox_macro_temp_double <= SOX_SAMPLE_MIN - 0.5 ?           \
        ++(clips), SOX_SAMPLE_MIN :                             \
        sox_macro_temp_double - 0.5 :                           \
      sox_macro_temp_double >= SOX_SAMPLE_MAX + 0.5 ?           \
        sox_macro_temp_double > SOX_SAMPLE_MAX + 1.0 ?          \
          ++(clips), SOX_SAMPLE_MAX :                           \
          SOX_SAMPLE_MAX :                                      \
        sox_macro_temp_double + 0.5                             \
  )
 
#define SOX_SAMPLE_TO_UNSIGNED_8BIT(d,clips) SOX_SAMPLE_TO_UNSIGNED(8,d,clips)
 
#define SOX_SAMPLE_TO_SIGNED_8BIT(d,clips) SOX_SAMPLE_TO_SIGNED(8,d,clips)
 
#define SOX_SAMPLE_TO_UNSIGNED_16BIT(d,clips) SOX_SAMPLE_TO_UNSIGNED(16,d,clips)
 
#define SOX_SAMPLE_TO_SIGNED_16BIT(d,clips) SOX_SAMPLE_TO_SIGNED(16,d,clips)
 
#define SOX_SAMPLE_TO_UNSIGNED_24BIT(d,clips) SOX_SAMPLE_TO_UNSIGNED(24,d,clips)
 
#define SOX_SAMPLE_TO_SIGNED_24BIT(d,clips) SOX_SAMPLE_TO_SIGNED(24,d,clips)
 
#define SOX_SAMPLE_TO_UNSIGNED_32BIT(d,clips) (sox_uint32_t)((d)^SOX_SAMPLE_NEG)
 
#define SOX_SAMPLE_TO_SIGNED_32BIT(d,clips) (sox_int32_t)(d)
 
#define SOX_SAMPLE_TO_FLOAT_32BIT(d,clips) ((d)*(1.0 / (SOX_SAMPLE_MAX + 1.0)))
 
#define SOX_SAMPLE_TO_FLOAT_64BIT(d,clips) ((d)*(1.0 / (SOX_SAMPLE_MAX + 1.0)))
 
#define SOX_SAMPLE_CLIP_COUNT(samp, clips) \
  do { \
    if (samp > SOX_SAMPLE_MAX) \
      { samp = SOX_SAMPLE_MAX; clips++; } \
    else if (samp < SOX_SAMPLE_MIN) \
      { samp = SOX_SAMPLE_MIN; clips++; } \
  } while (0)
 
#define SOX_ROUND_CLIP_COUNT(d, clips) \
  ((d) < 0? (d) <= SOX_SAMPLE_MIN - 0.5? ++(clips), SOX_SAMPLE_MIN: (d) - 0.5 \
        : (d) >= SOX_SAMPLE_MAX + 0.5? ++(clips), SOX_SAMPLE_MAX: (d) + 0.5)
 
#define SOX_INTEGER_CLIP_COUNT(bits,i,clips) ( \
  (i) >(1 << ((bits)-1))- 1? ++(clips),(1 << ((bits)-1))- 1 : \
  (i) <-1 << ((bits)-1)    ? ++(clips),-1 << ((bits)-1) : (i))
 
#define SOX_16BIT_CLIP_COUNT(i,clips) SOX_INTEGER_CLIP_COUNT(16,i,clips)
 
#define SOX_24BIT_CLIP_COUNT(i,clips) SOX_INTEGER_CLIP_COUNT(24,i,clips)
 
#define SOX_SIZE_MAX ((size_t)(-1)) 
#define SOX_UNSPEC 0                         
#define SOX_UNKNOWN_LEN (sox_uint64_t)(-1) 
#define SOX_IGNORE_LENGTH (sox_uint64_t)(-2) 
#define SOX_DEFAULT_CHANNELS  2     
#define SOX_DEFAULT_RATE      48000 
#define SOX_DEFAULT_PRECISION 16    
#define SOX_DEFAULT_ENCODING  SOX_ENCODING_SIGN2 
#define SOX_LOOP_NONE          ((unsigned char)sox_loop_none)          
#define SOX_LOOP_8             ((unsigned char)sox_loop_8)             
#define SOX_LOOP_SUSTAIN_DECAY ((unsigned char)sox_loop_sustain_decay) 
#define SOX_MAX_NLOOPS         8 
#define SOX_FILE_NOSTDIO 0x0001 
#define SOX_FILE_DEVICE  0x0002 
#define SOX_FILE_PHONY   0x0004 
#define SOX_FILE_REWIND  0x0008 
#define SOX_FILE_BIT_REV 0x0010 
#define SOX_FILE_NIB_REV 0x0020 
#define SOX_FILE_ENDIAN  0x0040 
#define SOX_FILE_ENDBIG  0x0080 
#define SOX_FILE_MONO    0x0100 
#define SOX_FILE_STEREO  0x0200 
#define SOX_FILE_QUAD    0x0400 
#define SOX_FILE_CHANS   (SOX_FILE_MONO | SOX_FILE_STEREO | SOX_FILE_QUAD) 
#define SOX_FILE_LIT_END (SOX_FILE_ENDIAN | 0)                             
#define SOX_FILE_BIG_END (SOX_FILE_ENDIAN | SOX_FILE_ENDBIG)               
#define SOX_EFF_CHAN     1           
#define SOX_EFF_RATE     2           
#define SOX_EFF_PREC     4           
#define SOX_EFF_LENGTH   8           
#define SOX_EFF_MCHAN    16          
#define SOX_EFF_NULL     32          
#define SOX_EFF_DEPRECATED 64        
#define SOX_EFF_GAIN     128         
#define SOX_EFF_MODIFY   256         
#define SOX_EFF_ALPHA    512         
#define SOX_EFF_INTERNAL 1024        
#define SOX_SEEK_SET 0
 
/*****************************************************************************
Forward declarations:
*****************************************************************************/
 
typedef struct sox_format_t sox_format_t;
typedef struct sox_effect_t sox_effect_t;
typedef struct sox_effect_handler_t sox_effect_handler_t;
typedef struct sox_format_handler_t sox_format_handler_t;
 
/*****************************************************************************
Function pointers:
*****************************************************************************/
 
typedef void (LSX_API * sox_output_message_handler_t)(
    unsigned level,                       
    LSX_PARAM_IN_Z char const * filename, 
    LSX_PARAM_IN_PRINTF char const * fmt, 
    LSX_PARAM_IN va_list ap               
    );
 
typedef sox_format_handler_t const * (LSX_API * sox_format_fn_t)(void);
 
typedef sox_effect_handler_t const * (LSX_API *sox_effect_fn_t)(void);
 
typedef int (LSX_API * sox_format_handler_startread)(
    LSX_PARAM_INOUT sox_format_t * ft 
    );
 
typedef size_t (LSX_API * sox_format_handler_read)(
    LSX_PARAM_INOUT sox_format_t * ft, 
    LSX_PARAM_OUT_CAP_POST_COUNT(len,return) sox_sample_t *buf, 
    size_t len 
    );
 
typedef int (LSX_API * sox_format_handler_stopread)(
    LSX_PARAM_INOUT sox_format_t * ft 
    );
 
typedef int (LSX_API * sox_format_handler_startwrite)(
    LSX_PARAM_INOUT sox_format_t * ft 
    );
 
typedef size_t (LSX_API * sox_format_handler_write)(
    LSX_PARAM_INOUT sox_format_t * ft, 
    LSX_PARAM_IN_COUNT(len) sox_sample_t const * buf, 
    size_t len 
    );
 
typedef int (LSX_API * sox_format_handler_stopwrite)(
    LSX_PARAM_INOUT sox_format_t * ft 
    );
 
typedef int (LSX_API * sox_format_handler_seek)(
    LSX_PARAM_INOUT sox_format_t * ft, 
    sox_uint64_t offset 
    );
 
typedef int (LSX_API * sox_effect_handler_getopts)(
    LSX_PARAM_INOUT sox_effect_t * effp, 
    int argc, 
    LSX_PARAM_IN_COUNT(argc) char *argv[] 
    );
 
typedef int (LSX_API * sox_effect_handler_start)(
    LSX_PARAM_INOUT sox_effect_t * effp 
    );
 
typedef int (LSX_API * sox_effect_handler_flow)(
    LSX_PARAM_INOUT sox_effect_t * effp, 
    LSX_PARAM_IN_COUNT(*isamp) sox_sample_t const * ibuf, 
    LSX_PARAM_OUT_CAP_POST_COUNT(*osamp,*osamp) sox_sample_t * obuf, 
    LSX_PARAM_INOUT size_t *isamp, 
    LSX_PARAM_INOUT size_t *osamp 
    );
 
typedef int (LSX_API * sox_effect_handler_drain)(
    LSX_PARAM_INOUT sox_effect_t * effp, 
    LSX_PARAM_OUT_CAP_POST_COUNT(*osamp,*osamp) sox_sample_t *obuf, 
    LSX_PARAM_INOUT size_t *osamp 
    );
 
typedef int (LSX_API * sox_effect_handler_stop)(
    LSX_PARAM_INOUT sox_effect_t * effp 
    );
 
typedef int (LSX_API * sox_effect_handler_kill)(
    LSX_PARAM_INOUT sox_effect_t * effp 
    );
 
typedef int (LSX_API * sox_flow_effects_callback)(
    sox_bool all_done,
    void * client_data
    );
 
typedef int (LSX_API * sox_playlist_callback_t)(
    void * callback_data,
    LSX_PARAM_IN_Z char const * filename
    );
 
/*****************************************************************************
Structures:
*****************************************************************************/
 
typedef struct sox_version_info_t {
    size_t       size;         
    sox_version_flags_t flags; 
    sox_uint32_t version_code; 
    char const * version;      
    char const * version_extra;
    char const * time;         
    char const * distro;       
    char const * compiler;     
    char const * arch;         
    /* new info should be added at the end for version backwards-compatibility. */
} sox_version_info_t;
 
typedef struct sox_globals_t {
/* public: */
  unsigned     verbosity; 
  sox_output_message_handler_t output_message_handler; 
  sox_bool     repeatable; 
  size_t       bufsiz;
 
  size_t       input_bufsiz;
 
  sox_int32_t  ranqd1; 
  char const * stdin_in_use_by;  
  char const * stdout_in_use_by; 
  char const * subsystem;        
  char       * tmp_path;         
  sox_bool     use_magic;        
  sox_bool     use_threads;      
  size_t       log2_dft_min_size;
} sox_globals_t;
 
typedef struct sox_signalinfo_t {
  sox_rate_t       rate;         
  unsigned         channels;     
  unsigned         precision;    
  sox_uint64_t     length;       
  double           * mult;       
} sox_signalinfo_t;
 
typedef struct sox_encodings_info_t {
  sox_encodings_flags_t flags; 
  char const * name;           
  char const * desc;           
} sox_encodings_info_t;
 
typedef struct sox_encodinginfo_t {
  sox_encoding_t encoding; 
  unsigned bits_per_sample;
  double compression;      
  sox_option_t reverse_bytes;
 
  sox_option_t reverse_nibbles;
 
  sox_option_t reverse_bits;
 
  sox_bool opposite_endian;
} sox_encodinginfo_t;
 
typedef struct sox_loopinfo_t {
  sox_uint64_t  start;  
  sox_uint64_t  length; 
  unsigned      count;  
  unsigned char type;   
} sox_loopinfo_t;
 
typedef struct sox_instrinfo_t{
  signed char MIDInote;   
  signed char MIDIlow;    
  signed char MIDIhi;     
  unsigned char loopmode; 
  unsigned nloops;  
} sox_instrinfo_t;
 
typedef struct sox_fileinfo_t {
  char          *buf;                 
  size_t        size;                 
  size_t        count;                
  size_t        pos;                  
} sox_fileinfo_t;
 
struct sox_format_handler_t {
  unsigned     sox_lib_version_code;  
  char         const * description;   
  char         const * const * names; 
  unsigned int flags;                 
  sox_format_handler_startread startread; 
  sox_format_handler_read read;       
  sox_format_handler_stopread stopread; 
  sox_format_handler_startwrite startwrite; 
  sox_format_handler_write write;     
  sox_format_handler_stopwrite stopwrite; 
  sox_format_handler_seek seek;       
  unsigned     const * write_formats;
 
  sox_rate_t   const * write_rates;
 
  size_t       priv_size;
};
 
typedef struct sox_oob_t{
  /* Decoded: */
  sox_comments_t   comments;              
  sox_instrinfo_t  instr;                 
  sox_loopinfo_t   loops[SOX_MAX_NLOOPS]; 
  /* TBD: Non-decoded chunks, etc: */
} sox_oob_t;
 
struct sox_format_t {
  char             * filename;      
  sox_signalinfo_t signal;
 
  sox_encodinginfo_t encoding;
 
  char             * filetype;      
  sox_oob_t        oob;             
  sox_bool         seekable;        
  char             mode;            
  sox_uint64_t     olength;         
  sox_uint64_t     clips;           
  int              sox_errno;       
  char             sox_errstr[256]; 
  void             * fp;            
  lsx_io_type      io_type;         
  sox_uint64_t     tell_off;        
  sox_uint64_t     data_start;      
  sox_format_handler_t handler;     
  void             * priv;          
};
 
typedef struct sox_format_tab_t {
  char *name;         
  sox_format_fn_t fn; 
} sox_format_tab_t;
 
typedef struct sox_effects_globals_t {
  sox_plot_t plot;         
  sox_globals_t * global_info; 
} sox_effects_globals_t;
 
struct sox_effect_handler_t {
  char const * name;  
  char const * usage; 
  unsigned int flags; 
  sox_effect_handler_getopts getopts; 
  sox_effect_handler_start start;     
  sox_effect_handler_flow flow;       
  sox_effect_handler_drain drain;     
  sox_effect_handler_stop stop;       
  sox_effect_handler_kill kill;       
  size_t       priv_size;             
};
 
struct sox_effect_t {
  sox_effects_globals_t    * global_info; 
  sox_signalinfo_t         in_signal;     
  sox_signalinfo_t         out_signal;    
  sox_encodinginfo_t       const * in_encoding;  
  sox_encodinginfo_t       const * out_encoding; 
  sox_effect_handler_t     handler;   
  sox_uint64_t         clips;         
  size_t               flows;         
  size_t               flow;          
  void                 * priv;        
  /* The following items are private to the libSoX effects chain functions. */
  sox_sample_t             * obuf;    
  size_t                   obeg;      
  size_t                   oend;      
  size_t               imin;          
};
 
typedef struct sox_effects_chain_t {
  sox_effect_t **effects;                  
  size_t length;                           
  sox_effects_globals_t global_info;       
  sox_encodinginfo_t const * in_enc;       
  sox_encodinginfo_t const * out_enc;      
  /* The following items are private to the libSoX effects chain functions. */
  size_t table_size;                       
  sox_sample_t *il_buf;                    
} sox_effects_chain_t;
 
/*****************************************************************************
Functions:
*****************************************************************************/
 
LSX_RETURN_VALID_Z
char const *
LSX_API
sox_version(void);
 
LSX_RETURN_VALID LSX_RETURN_PURE
sox_version_info_t const *
LSX_API
sox_version_info(void);
 
LSX_RETURN_VALID LSX_RETURN_PURE
sox_globals_t *
LSX_API
sox_get_globals(void);
 
#define sox_globals (*sox_get_globals())
 
LSX_RETURN_ARRAY LSX_RETURN_PURE
sox_encodings_info_t const *
LSX_API
sox_get_encodings_info(void);
 
#define sox_encodings_info (sox_get_encodings_info())
 
void
LSX_API
sox_init_encodinginfo(
    LSX_PARAM_OUT sox_encodinginfo_t * e 
    );
 
LSX_RETURN_PURE
unsigned
LSX_API
sox_precision(
    sox_encoding_t encoding,   
    unsigned bits_per_sample   
    );
 
size_t
LSX_API
sox_num_comments(
    LSX_PARAM_IN_OPT sox_comments_t comments 
    );
 
void
LSX_API
sox_append_comment(
    LSX_PARAM_DEREF_PRE_MAYBENULL LSX_PARAM_DEREF_POST_NOTNULL sox_comments_t * comments, 
    LSX_PARAM_IN_Z char const * item 
    );
 
void
LSX_API
sox_append_comments(
    LSX_PARAM_DEREF_PRE_MAYBENULL LSX_PARAM_DEREF_POST_NOTNULL sox_comments_t * comments, 
    LSX_PARAM_IN_Z char const * items 
    );
 
LSX_RETURN_OPT
sox_comments_t
LSX_API
sox_copy_comments(
    LSX_PARAM_IN_OPT sox_comments_t comments 
    );
 
void
LSX_API
sox_delete_comments(
    LSX_PARAM_DEREF_PRE_MAYBENULL LSX_PARAM_DEREF_POST_NULL sox_comments_t * comments 
    );
 
LSX_RETURN_OPT
char const *
LSX_API
sox_find_comment(
    LSX_PARAM_IN_OPT sox_comments_t comments, 
    LSX_PARAM_IN_Z char const * id 
    );
 
int
LSX_API
sox_format_init(void);
 
void
LSX_API
sox_format_quit(void);
 
int
LSX_API
sox_init(void);
 
int
LSX_API
sox_quit(void);
 
LSX_RETURN_ARRAY LSX_RETURN_PURE
sox_format_tab_t const *
LSX_API
sox_get_format_fns(void);
 
#define sox_format_fns (sox_get_format_fns())
 
LSX_RETURN_OPT
sox_format_t *
LSX_API
sox_open_read(
    LSX_PARAM_IN_Z   char               const * path,      
    LSX_PARAM_IN_OPT sox_signalinfo_t   const * signal,    
    LSX_PARAM_IN_OPT sox_encodinginfo_t const * encoding,  
    LSX_PARAM_IN_OPT_Z char             const * filetype   
    );
 
LSX_RETURN_OPT
sox_format_t *
LSX_API
sox_open_mem_read(
    LSX_PARAM_IN_BYTECOUNT(buffer_size) void  * buffer,     
    size_t                                      buffer_size,
    LSX_PARAM_IN_OPT sox_signalinfo_t   const * signal,     
    LSX_PARAM_IN_OPT sox_encodinginfo_t const * encoding,   
    LSX_PARAM_IN_OPT_Z char             const * filetype    
    );
 
sox_bool
LSX_API
sox_format_supports_encoding(
    LSX_PARAM_IN_OPT_Z char               const * path,       
    LSX_PARAM_IN_OPT_Z char               const * filetype,   
    LSX_PARAM_IN       sox_encodinginfo_t const * encoding    
    );
 
LSX_RETURN_OPT
sox_format_handler_t const *
LSX_API
sox_write_handler(
    LSX_PARAM_IN_OPT_Z char               const * path,         
    LSX_PARAM_IN_OPT_Z char               const * filetype,     
    LSX_PARAM_OUT_OPT  char               const * * filetype1   
    );
 
LSX_RETURN_OPT
sox_format_t *
LSX_API
sox_open_write(
    LSX_PARAM_IN_Z     char               const * path,     
    LSX_PARAM_IN       sox_signalinfo_t   const * signal,   
    LSX_PARAM_IN_OPT   sox_encodinginfo_t const * encoding, 
    LSX_PARAM_IN_OPT_Z char               const * filetype, 
    LSX_PARAM_IN_OPT   sox_oob_t          const * oob,      
    LSX_PARAM_IN_OPT   sox_bool           (LSX_API * overwrite_permitted)(LSX_PARAM_IN_Z char const * filename) 
    );
 
LSX_RETURN_OPT
sox_format_t *
LSX_API
sox_open_mem_write(
    LSX_PARAM_OUT_BYTECAP(buffer_size) void                     * buffer,      
    LSX_PARAM_IN                       size_t                     buffer_size, 
    LSX_PARAM_IN                       sox_signalinfo_t   const * signal,      
    LSX_PARAM_IN_OPT                   sox_encodinginfo_t const * encoding,    
    LSX_PARAM_IN_OPT_Z                 char               const * filetype,    
    LSX_PARAM_IN_OPT                   sox_oob_t          const * oob          
    );
 
LSX_RETURN_OPT
sox_format_t *
LSX_API
sox_open_memstream_write(
    LSX_PARAM_OUT      char                     * * buffer_ptr,    
    LSX_PARAM_OUT      size_t                   * buffer_size_ptr, 
    LSX_PARAM_IN       sox_signalinfo_t   const * signal,          
    LSX_PARAM_IN_OPT   sox_encodinginfo_t const * encoding,        
    LSX_PARAM_IN_OPT_Z char               const * filetype,        
    LSX_PARAM_IN_OPT   sox_oob_t          const * oob              
    );
 
size_t
LSX_API
sox_read(
    LSX_PARAM_INOUT sox_format_t * ft, 
    LSX_PARAM_OUT_CAP_POST_COUNT(len,return) sox_sample_t *buf, 
    size_t len 
    );
 
size_t
LSX_API
sox_write(
    LSX_PARAM_INOUT sox_format_t * ft, 
    LSX_PARAM_IN_COUNT(len) sox_sample_t const * buf, 
    size_t len 
    );
 
int
LSX_API
sox_close(
    LSX_PARAM_INOUT sox_format_t * ft 
    );
 
int
LSX_API
sox_seek(
    LSX_PARAM_INOUT sox_format_t * ft, 
    sox_uint64_t offset, 
    int whence 
    );
 
LSX_RETURN_OPT
sox_format_handler_t const *
LSX_API
sox_find_format(
    LSX_PARAM_IN_Z char const * name, 
    sox_bool ignore_devices 
    );
 
LSX_RETURN_VALID LSX_RETURN_PURE
sox_effects_globals_t *
LSX_API
sox_get_effects_globals(void);
 
#define sox_effects_globals (*sox_get_effects_globals())
 
LSX_RETURN_OPT LSX_RETURN_PURE
sox_effect_handler_t const *
LSX_API
sox_find_effect(
    LSX_PARAM_IN_Z char const * name 
    );
 
LSX_RETURN_OPT
sox_effect_t *
LSX_API
sox_create_effect(
    LSX_PARAM_IN sox_effect_handler_t const * eh 
    );
 
int
LSX_API
sox_effect_options(
    LSX_PARAM_IN sox_effect_t *effp, 
    int argc, 
    LSX_PARAM_IN_COUNT(argc) char * const argv[] 
    );
 
LSX_RETURN_VALID_Z LSX_RETURN_PURE
sox_effect_fn_t const *
LSX_API
sox_get_effect_fns(void);
 
#define sox_effect_fns (sox_get_effect_fns())
 
LSX_RETURN_OPT
sox_effects_chain_t *
LSX_API
sox_create_effects_chain(
    LSX_PARAM_IN sox_encodinginfo_t const * in_enc, 
    LSX_PARAM_IN sox_encodinginfo_t const * out_enc 
    );
 
void
LSX_API
sox_delete_effects_chain(
    LSX_PARAM_INOUT sox_effects_chain_t *ecp 
    );
 
int
LSX_API
sox_add_effect(
    LSX_PARAM_INOUT sox_effects_chain_t * chain, 
    LSX_PARAM_INOUT sox_effect_t * effp, 
    LSX_PARAM_INOUT sox_signalinfo_t * in, 
    LSX_PARAM_IN    sox_signalinfo_t const * out 
    );
 
int
LSX_API
sox_flow_effects(
    LSX_PARAM_INOUT  sox_effects_chain_t * chain, 
    LSX_PARAM_IN_OPT sox_flow_effects_callback callback, 
    LSX_PARAM_IN_OPT void * client_data 
    );
 
sox_uint64_t
LSX_API
sox_effects_clips(
    LSX_PARAM_IN sox_effects_chain_t * chain 
    );
 
sox_uint64_t
LSX_API
sox_stop_effect(
    LSX_PARAM_INOUT_COUNT(effp->flows) sox_effect_t * effp 
    );
 
void
LSX_API
sox_push_effect_last(
    LSX_PARAM_INOUT sox_effects_chain_t * chain, 
    LSX_PARAM_INOUT sox_effect_t * effp 
    );
 
LSX_RETURN_OPT
sox_effect_t *
LSX_API
sox_pop_effect_last(
    LSX_PARAM_INOUT sox_effects_chain_t *chain 
    );
 
void
LSX_API
sox_delete_effect(
    LSX_PARAM_INOUT_COUNT(effp->flows) sox_effect_t *effp 
    );
 
void
LSX_API
sox_delete_effect_last(
    LSX_PARAM_INOUT sox_effects_chain_t *chain 
    );
 
void
LSX_API
sox_delete_effects(
    LSX_PARAM_INOUT sox_effects_chain_t *chain 
    );
 
sox_uint64_t
LSX_API
sox_trim_get_start(
    LSX_PARAM_IN sox_effect_t * effp 
    );
 
void
LSX_API
sox_trim_clear_start(
    LSX_PARAM_INOUT sox_effect_t * effp 
    );
 
sox_bool
LSX_API
sox_is_playlist(
    LSX_PARAM_IN_Z char const * filename 
    );
 
int
LSX_API
sox_parse_playlist(
    LSX_PARAM_IN sox_playlist_callback_t callback, 
    void * p, 
    LSX_PARAM_IN char const * const listname 
    );
 
LSX_RETURN_VALID_Z LSX_RETURN_PURE
char const *
LSX_API
sox_strerror(
    int sox_errno 
    );
 
size_t
LSX_API
sox_basename(
    LSX_PARAM_OUT_Z_CAP_POST_COUNT(base_buffer_len,return) char * base_buffer, 
    size_t base_buffer_len, 
    LSX_PARAM_IN_Z char const * filename 
    );
 
/*****************************************************************************
Internal API:
WARNING - The items in this section are subject to instability. They only
exist in the public header because sox (the application) currently uses them.
These may be changed or removed in future versions of libSoX.
*****************************************************************************/
 
void
LSX_API
lsx_fail_impl(
    LSX_PARAM_IN_PRINTF char const * fmt, 
    ...)
    LSX_PRINTF12;
 
void
LSX_API
lsx_warn_impl(
    LSX_PARAM_IN_PRINTF char const * fmt, 
    ...)
    LSX_PRINTF12;
 
void
LSX_API
lsx_report_impl(
    LSX_PARAM_IN_PRINTF char const * fmt, 
    ...)
    LSX_PRINTF12;
 
void
LSX_API
lsx_debug_impl(
    LSX_PARAM_IN_PRINTF char const * fmt, 
    ...)
    LSX_PRINTF12;
 
#define lsx_fail       sox_get_globals()->subsystem=__FILE__,lsx_fail_impl
 
#define lsx_warn       sox_get_globals()->subsystem=__FILE__,lsx_warn_impl
 
#define lsx_report     sox_get_globals()->subsystem=__FILE__,lsx_report_impl
 
#define lsx_debug      sox_get_globals()->subsystem=__FILE__,lsx_debug_impl
 
typedef struct lsx_enum_item {
    char const *text; 
    unsigned value;   
} lsx_enum_item;
 
#define LSX_ENUM_ITEM(prefix, item) {#item, prefix##item},
 
enum
{
    lsx_find_enum_item_none = 0, 
    lsx_find_enum_item_case_sensitive = 1 
};
 
LSX_RETURN_OPT LSX_RETURN_PURE
lsx_enum_item const *
LSX_API
lsx_find_enum_text(
    LSX_PARAM_IN_Z char const * text, 
    LSX_PARAM_IN lsx_enum_item const * lsx_enum_items, 
    int flags 
    );
 
LSX_RETURN_OPT LSX_RETURN_PURE
lsx_enum_item const *
LSX_API
lsx_find_enum_value(
    unsigned value, 
    LSX_PARAM_IN lsx_enum_item const * lsx_enum_items 
    );
 
LSX_RETURN_PURE
int
LSX_API
lsx_enum_option(
    int c, 
    LSX_PARAM_IN_Z char const * arg, 
    LSX_PARAM_IN lsx_enum_item const * items 
    );
 
LSX_RETURN_PURE
sox_bool
LSX_API
lsx_strends(
    LSX_PARAM_IN_Z char const * str, 
    LSX_PARAM_IN_Z char const * end  
    );
 
LSX_RETURN_OPT LSX_RETURN_PURE
char const *
LSX_API
lsx_find_file_extension(
    LSX_PARAM_IN_Z char const * pathname 
    );
 
LSX_RETURN_VALID_Z
char const *
LSX_API
lsx_sigfigs3(
    double number 
    );
 
LSX_RETURN_VALID_Z
char const *
LSX_API
lsx_sigfigs3p(
    double percentage 
    );
 
LSX_RETURN_OPT
void *
LSX_API
lsx_realloc(
    LSX_PARAM_IN_OPT void *ptr, 
    size_t newsize 
    );
 
LSX_RETURN_PURE
int
LSX_API
lsx_strcasecmp(
    LSX_PARAM_IN_Z char const * s1, 
    LSX_PARAM_IN_Z char const * s2  
    );
 
 
LSX_RETURN_PURE
int
LSX_API
lsx_strncasecmp(
    LSX_PARAM_IN_Z char const * s1, 
    LSX_PARAM_IN_Z char const * s2, 
    size_t n 
    );
 
typedef enum lsx_option_arg_t {
    lsx_option_arg_none, 
    lsx_option_arg_required, 
    lsx_option_arg_optional 
} lsx_option_arg_t;
 
typedef enum lsx_getopt_flags_t {
    lsx_getopt_flag_none = 0,      
    lsx_getopt_flag_opterr = 1,    
    lsx_getopt_flag_longonly = 2   
} lsx_getopt_flags_t;
 
typedef struct lsx_option_t {
    char const *     name;    
    lsx_option_arg_t has_arg; 
    int *            flag;    
    int              val;     
} lsx_option_t;
 
typedef struct lsx_getopt_t {
    int                  argc;     
    char * const *       argv;     
    char const *         shortopts;
    lsx_option_t const * longopts; 
    lsx_getopt_flags_t   flags;    
    char const *         curpos;   
    int                  ind;      
    int                  opt;      
    char const *         arg;      
    int                  lngind;   
} lsx_getopt_t;
 
void
LSX_API
lsx_getopt_init(
    LSX_PARAM_IN             int argc,                      
    LSX_PARAM_IN_COUNT(argc) char * const * argv,           
    LSX_PARAM_IN_Z           char const * shortopts,        
    LSX_PARAM_IN_OPT         lsx_option_t const * longopts, 
    LSX_PARAM_IN             lsx_getopt_flags_t flags,      
    LSX_PARAM_IN             int first,                     
    LSX_PARAM_OUT            lsx_getopt_t * state           
    );
 
int
LSX_API
lsx_getopt(
    LSX_PARAM_INOUT lsx_getopt_t * state 
    );
 
sox_uint64_t
LSX_API
lsx_filelength(
    LSX_PARAM_IN sox_format_t * ft
    );
 
/* WARNING END */
 
#if defined(__cplusplus)
}
#endif
 
#endif /* SOX_H */