_sndlib.h

音频信号的重采样程序,如44.1K的WAV转换成采样频率为48K的WAV.

  void mus_snprintf(char *buffer, int buffer_len, const char *format, ...)  __attribute__ ((format (printf, 3, 4)));
#else
  int mus_error(int error, const char *format, ...);
  void mus_print(const char *format, ...);
  char *mus_format(const char *format, ...);
  void mus_snprintf(char *buffer, int buffer_len, const char *format, ...);
#endif

typedef void mus_error_handler_t(int type, char *msg);
mus_error_handler_t *mus_error_set_handler (mus_error_handler_t *new_error_handler);
int mus_make_error(char *error_name);
const char *mus_error_type_to_string(int err);

typedef void mus_print_handler_t(char *msg);
mus_print_handler_t *mus_print_set_handler (mus_print_handler_t *new_print_handler);

off_t mus_sound_samples(const char *arg);
off_t mus_sound_frames(const char *arg);
int mus_sound_datum_size(const char *arg);
off_t mus_sound_data_location(const char *arg);
int mus_sound_chans(const char *arg);
int mus_sound_srate(const char *arg);
int mus_sound_header_type(const char *arg);
int mus_sound_data_format(const char *arg);
int mus_sound_original_format(const char *arg);
off_t mus_sound_comment_start(const char *arg);
off_t mus_sound_comment_end(const char *arg);
off_t mus_sound_length(const char *arg);
int mus_sound_fact_samples(const char *arg);
time_t mus_sound_write_date(const char *arg);
int mus_sound_type_specifier(const char *arg);
int mus_sound_block_align(const char *arg);
int mus_sound_bits_per_sample(const char *arg);

int mus_sound_set_chans(const char *arg, int val);
int mus_sound_set_srate(const char *arg, int val);
int mus_sound_set_header_type(const char *arg, int val);
int mus_sound_set_data_format(const char *arg, int val);
int mus_sound_set_data_location(const char *arg, off_t val);
int mus_sound_set_samples(const char *arg, off_t val);

const char *mus_header_type_name(int type);
const char *mus_data_format_name(int format);
char *mus_header_type_to_string(int type);
char *mus_data_format_to_string(int format);
const char *mus_data_format_short_name(int format);
char *mus_sound_comment(const char *name);
int mus_bytes_per_sample(int format);
float mus_sound_duration(const char *arg);
int mus_sound_initialize(void);
int mus_sample_bits(void);
int mus_sound_override_header(const char *arg, int srate, int chans, int format, int type, off_t location, off_t size);
int mus_sound_forget(const char *name);
int mus_sound_prune(void);
void mus_sound_report_cache(FILE *fp);
int *mus_sound_loop_info(const char *arg);
void mus_sound_set_loop_info(const char *arg, int *loop);

int mus_sound_open_input(const char *arg);
int mus_sound_open_output(const char *arg, int srate, int chans, int data_format, int header_type, const char *comment);
int mus_sound_reopen_output(const char *arg, int chans, int format, int type, off_t data_loc);
int mus_sound_close_input(int fd);
int mus_sound_close_output(int fd, off_t bytes_of_data);
#define mus_sound_seek_frame(Ifd, Frm) mus_file_seek_frame(Ifd, Frm)
#define mus_sound_read(Fd, Beg, End, Chans, Bufs) mus_file_read(Fd, Beg, End, Chans, Bufs)
#define mus_sound_write(Fd, Beg, End, Chans, Bufs) mus_file_write(Fd, Beg, End, Chans, Bufs)

off_t mus_sound_maxamps(const char *ifile, int chans, mus_sample_t *vals, off_t *times);
int mus_sound_set_maxamps(const char *ifile, int chans, mus_sample_t *vals, off_t *times);
bool mus_sound_maxamp_exists(const char *ifile);
int mus_file_to_array(const char *filename, int chan, int start, int samples, mus_sample_t *array);
int mus_array_to_file(const char *filename, mus_sample_t *ddata, int len, int srate, int channels);
char *mus_array_to_file_with_error(const char *filename, mus_sample_t *ddata, int len, int srate, int channels);
int mus_file_to_float_array(const char *filename, int chan, off_t start, int samples, Float *array);
int mus_float_array_to_file(const char *filename, Float *ddata, int len, int srate, int channels);



/* -------- audio.c -------- */

#if (HAVE_OSS || HAVE_ALSA || HAVE_JACK)
  #define ALSA_API 0
  #define OSS_API 1
  #define JACK_API 2
#endif

void mus_audio_describe(void);
char *mus_audio_report(void);
int mus_audio_open_output(int dev, int srate, int chans, int format, int size);
int mus_audio_open_input(int dev, int srate, int chans, int format, int size);
int mus_audio_write(int line, char *buf, int bytes);
int mus_audio_close(int line);
int mus_audio_read(int line, char *buf, int bytes);

int mus_audio_write_buffers(int line, int frames, int chans, mus_sample_t **bufs, int output_format, bool clipped);
int mus_audio_read_buffers(int line, int frames, int chans, mus_sample_t **bufs, int input_format);

int mus_audio_mixer_read(int dev, int field, int chan, float *val);
int mus_audio_mixer_write(int dev, int field, int chan, float *val);
int mus_audio_initialize(void);

#if HAVE_OSS || HAVE_ALSA
  int mus_audio_reinitialize(void); /* 29-Aug-01 for CLM/Snd bugfix? */
  char *mus_alsa_playback_device(void);
  char *mus_alsa_set_playback_device(const char *name);
  char *mus_alsa_capture_device(void);
  char *mus_alsa_set_capture_device(const char *name);
  char *mus_alsa_device(void);
  char *mus_alsa_set_device(const char *name);
  int mus_alsa_buffer_size(void);
  int mus_alsa_set_buffer_size(int size);
  int mus_alsa_buffers(void);
  int mus_alsa_set_buffers(int num);
  bool mus_alsa_squelch_warning(void);
  bool mus_alsa_set_squelch_warning(bool val);
  int mus_audio_api(void);
  void mus_oss_set_buffers(int num, int size);
#endif

int mus_audio_systems(void);
char *mus_audio_system_name(int sys);
char *mus_audio_moniker(void);
int mus_audio_compatible_format(int dev);

#if MUS_SUN
  void mus_sun_set_outputs(int speakers, int headphones, int line_out);
#endif

#if MUS_NETBSD
  void mus_netbsd_set_outputs(int speakers, int headphones, int line_out);
#endif

#if (!HAVE_STRERROR)
  char *strerror(int errnum);
#endif



/* -------- io.c -------- */

int mus_file_open_descriptors(int tfd, const char *arg, int df, int ds, off_t dl, int dc, int dt);
int mus_file_open_read(const char *arg);
bool mus_file_probe(const char *arg);
int mus_file_open_write(const char *arg);
int mus_file_create(const char *arg);
int mus_file_reopen_write(const char *arg);
  int mus_file_close(int fd);
off_t mus_file_seek_frame(int tfd, off_t frame);
int mus_file_read(int fd, int beg, int end, int chans, mus_sample_t **bufs);
int mus_file_read_chans(int fd, int beg, int end, int chans, mus_sample_t **bufs, mus_sample_t **cm);
int mus_file_write(int tfd, int beg, int end, int chans, mus_sample_t **bufs);
int mus_file_read_any(int tfd, int beg, int chans, int nints, mus_sample_t **bufs, mus_sample_t **cm);
int mus_file_read_file(int tfd, int beg, int chans, int nints, mus_sample_t **bufs);
int mus_file_read_buffer(int charbuf_data_format, int beg, int chans, int nints, mus_sample_t **bufs, char *charbuf);
int mus_file_write_file(int tfd, int beg, int end, int chans, mus_sample_t **bufs);
int mus_file_write_buffer(int charbuf_data_format, int beg, int end, int chans, mus_sample_t **bufs, char *charbuf, bool clipped);
char *mus_expand_filename(const char *name);
char *mus_getcwd(void);

bool mus_clipping(void);
bool mus_set_clipping(bool new_value);
bool mus_file_clipping(int tfd);
int mus_file_set_clipping(int tfd, bool clipped);

int mus_file_set_header_type(int tfd, int type);
int mus_file_header_type(int tfd);
char *mus_file_fd_name(int tfd);
int mus_file_set_chans(int tfd, int chans);

Float mus_file_prescaler(int tfd);
Float mus_file_set_prescaler(int tfd, Float val);
Float mus_prescaler(void);
Float mus_set_prescaler(Float new_value);

void mus_bint_to_char(unsigned char *j, int x);
int mus_char_to_bint(const unsigned char *inp);
void mus_lint_to_char(unsigned char *j, int x);
int mus_char_to_lint(const unsigned char *inp);
int mus_char_to_uninterpreted_int(const unsigned char *inp);
void mus_bfloat_to_char(unsigned char *j, float x);
float mus_char_to_bfloat(const unsigned char *inp);
void mus_lfloat_to_char(unsigned char *j, float x);
float mus_char_to_lfloat(const unsigned char *inp);
void mus_bshort_to_char(unsigned char *j, short x);
short mus_char_to_bshort(const unsigned char *inp);
void mus_lshort_to_char(unsigned char *j, short x);
short mus_char_to_lshort(const unsigned char *inp);
void mus_ubshort_to_char(unsigned char *j, unsigned short x);
unsigned short mus_char_to_ubshort(const unsigned char *inp);
void mus_ulshort_to_char(unsigned char *j, unsigned short x);
unsigned short mus_char_to_ulshort(const unsigned char *inp);
double mus_char_to_ldouble(const unsigned char *inp);
double mus_char_to_bdouble(const unsigned char *inp);
void mus_bdouble_to_char(unsigned char *j, double x);
void mus_ldouble_to_char(unsigned char *j, double x);
unsigned int mus_char_to_ubint(const unsigned char *inp);
unsigned int mus_char_to_ulint(const unsigned char *inp);

int mus_iclamp(int lo, int val, int hi);
off_t mus_oclamp(off_t lo, off_t val, off_t hi);
Float mus_fclamp(Float lo, Float val, Float hi);

/* for CLM */
/* these are needed to clear a saved lisp image to the just-initialized state */
void mus_reset_io_c(void);
void mus_reset_headers_c(void);
void mus_reset_audio_c(void);



/* -------- headers.c -------- */

off_t mus_header_samples(void);
off_t mus_header_data_location(void);
int mus_header_chans(void);
int mus_header_srate(void);
int mus_header_type(void);
int mus_header_format(void);
off_t mus_header_comment_start(void);
off_t mus_header_comment_end(void);
int mus_header_type_specifier(void);
int mus_header_bits_per_sample(void);
int mus_header_fact_samples(void);
int mus_header_block_align(void);
int mus_header_loop_mode(int which);
int mus_header_loop_start(int which);
int mus_header_loop_end(int which);
int mus_header_mark_position(int id);
int mus_header_base_note(void);
int mus_header_base_detune(void);
void mus_header_set_raw_defaults(int sr, int chn, int frm);
void mus_header_raw_defaults(int *sr, int *chn, int *frm);
off_t mus_header_true_length(void);
int mus_header_original_format(void);
off_t mus_samples_to_bytes(int format, off_t size);
off_t mus_bytes_to_samples(int format, off_t size);
int mus_header_write_next_header(int chan, int srate, int chans, int loc, int siz, int format, const char *comment, int len);
int mus_header_read(const char *name);
int mus_header_write(const char *name, int type, int srate, int chans, off_t loc, off_t size_in_samples, int format, const char *comment, int len);
off_t mus_header_aux_comment_start(int n);
off_t mus_header_aux_comment_end(int n);
int mus_header_initialize(void);
bool mus_header_writable(int type, int format);
void mus_header_set_aiff_loop_info(int *data);
int mus_header_sf2_entries(void);
char *mus_header_sf2_name(int n);
int mus_header_sf2_start(int n);
int mus_header_sf2_end(int n);
int mus_header_sf2_loop_start(int n);
int mus_header_sf2_loop_end(int n);
const char *mus_header_original_format_name(int format, int type);
bool mus_header_no_header(const char *name);

char *mus_header_riff_aux_comment(const char *name, off_t *starts, off_t *ends);
char *mus_header_aiff_aux_comment(const char *name, off_t *starts, off_t *ends);

int mus_header_change_chans(const char *filename, int type, int new_chans);
int mus_header_change_srate(const char *filename, int type, int new_srate);
int mus_header_change_type(const char *filename, int new_type, int new_format);
int mus_header_change_format(const char *filename, int type, int new_format);
int mus_header_change_location(const char *filename, int type, off_t new_location);
int mus_header_change_comment(const char *filename, int type, char *new_comment);
int mus_header_change_data_size(const char *filename, int type, off_t bytes);

typedef void mus_header_write_hook_t(const char *filename);
mus_header_write_hook_t *mus_header_write_set_hook(mus_header_write_hook_t *new_hook);


/* -------- midi.c -------- */
int mus_midi_open_read(const char *name);
int mus_midi_open_write(const char *name);
int mus_midi_close(int line);
int mus_midi_read(int line, unsigned char *buffer, int bytes);
int mus_midi_write(int line, unsigned char *buffer, int bytes);
char *mus_midi_device_name(int sysdev);
char *mus_midi_describe(void);
#if HAVE_EXTENSION_LANGUAGE
  void mus_midi_init(void);
#endif


#if MUS_DEBUGGING
  /* snd-utils.c (only used in conjunction with Snd's memory tracking functions) */
  void *mem_calloc(int len, int size, const char *func, const char *file, int line);
  void *mem_malloc(int len, const char *func, const char *file, int line);
  void *mem_free(void *ptr, const char *func, const char *file, int line);
  void *mem_realloc(void *ptr, int size, const char *func, const char *file, int line);
#endif

#if (!HAVE_STRDUP)
char *strdup(const char *str);
#endif
#if (!HAVE_FILENO)
int fileno(FILE *fp);
#endif

#ifdef __cplusplus
}
#endif

#endif