Imported Upstream version 16.1

1 files changed, 261 insertions, 222 deletions

diff --git a/clm.h b/clm.h
index 4287049..c174fca 100644
--- a/clm.h
+++ b/clm.h
@@ -1,16 +1,19 @@
 #ifndef CLM_H
 #define CLM_H
 
-#define MUS_VERSION 4
-#define MUS_REVISION 31
-#define MUS_DATE "7-Mar-10"
+#define MUS_VERSION 6
+#define MUS_REVISION 13
+#define MUS_DATE "5-Aug-15"
 
 /* isn't mus_env_interp backwards? */
 
 #include "sndlib.h"
 
+#ifndef _MSC_VER
+  #include <sys/param.h>
+#endif
 #if HAVE_COMPLEX_TRIG
-#include <complex.h>
+  #include <complex.h>
 #endif
 
 #if(!defined(M_PI))
@@ -24,64 +27,14 @@
 
 typedef enum {MUS_NOT_SPECIAL, MUS_SIMPLE_FILTER, MUS_FULL_FILTER, MUS_OUTPUT, MUS_INPUT, MUS_DELAY_LINE} mus_clm_extended_t;
 
+typedef struct mus_any_class mus_any_class;
 typedef struct {
   struct mus_any_class *core;
 } mus_any;
 
-typedef struct mus_any_class {
-  int type;
-  char *name;
-  int (*release)(mus_any *ptr);
-  char *(*describe)(mus_any *ptr);                            /* caller should free the string */
-  bool (*equalp)(mus_any *gen1, mus_any *gen2);
-  mus_float_t *(*data)(mus_any *ptr);
-  mus_float_t *(*set_data)(mus_any *ptr, mus_float_t *new_data);
-  mus_long_t (*length)(mus_any *ptr);
-  mus_long_t (*set_length)(mus_any *ptr, mus_long_t new_length);
-  mus_float_t (*frequency)(mus_any *ptr);
-  mus_float_t (*set_frequency)(mus_any *ptr, mus_float_t new_freq);
-  mus_float_t (*phase)(mus_any *ptr); 
-  mus_float_t (*set_phase)(mus_any *ptr, mus_float_t new_phase);
-  mus_float_t (*scaler)(mus_any *ptr);
-  mus_float_t (*set_scaler)(mus_any *ptr, mus_float_t val);
-  mus_float_t (*increment)(mus_any *ptr);
-  mus_float_t (*set_increment)(mus_any *ptr, mus_float_t val);
-  mus_float_t (*run)(mus_any *gen, mus_float_t arg1, mus_float_t arg2);
-  mus_clm_extended_t extended_type;
-  void *(*closure)(mus_any *gen);
-  int (*channels)(mus_any *ptr);
-  mus_float_t (*offset)(mus_any *ptr);
-  mus_float_t (*set_offset)(mus_any *ptr, mus_float_t val);
-  mus_float_t (*width)(mus_any *ptr);
-  mus_float_t (*set_width)(mus_any *ptr, mus_float_t val);
-  mus_float_t (*xcoeff)(mus_any *ptr, int index);
-  mus_float_t (*set_xcoeff)(mus_any *ptr, int index, mus_float_t val);
-  mus_long_t (*hop)(mus_any *ptr);
-  mus_long_t (*set_hop)(mus_any *ptr, mus_long_t new_length);
-  mus_long_t (*ramp)(mus_any *ptr);
-  mus_long_t (*set_ramp)(mus_any *ptr, mus_long_t new_length);
-  mus_float_t (*read_sample)(mus_any *ptr, mus_long_t samp, int chan);
-  mus_float_t (*write_sample)(mus_any *ptr, mus_long_t samp, int chan, mus_float_t data);
-  char *(*file_name)(mus_any *ptr);
-  int (*end)(mus_any *ptr);
-  mus_long_t (*location)(mus_any *ptr);
-  mus_long_t (*set_location)(mus_any *ptr, mus_long_t loc);
-  int (*channel)(mus_any *ptr);
-  mus_float_t (*ycoeff)(mus_any *ptr, int index);
-  mus_float_t (*set_ycoeff)(mus_any *ptr, int index, mus_float_t val);
-  mus_float_t *(*xcoeffs)(mus_any *ptr);
-  mus_float_t *(*ycoeffs)(mus_any *ptr);
-  void *original_class; /* class chain perhaps */
-  void (*reset)(mus_any *ptr);
-  void *(*set_closure)(mus_any *gen, void *e);
-  int (*safety)(mus_any *ptr);
-  int (*set_safety)(mus_any *ptr, int val);
-} mus_any_class;
-
 
 typedef enum {MUS_INTERP_NONE, MUS_INTERP_LINEAR, MUS_INTERP_SINUSOIDAL, MUS_INTERP_ALL_PASS, 
-	      MUS_INTERP_LAGRANGE, MUS_INTERP_BEZIER, MUS_INTERP_HERMITE, MUS_NUM_INTERPS} mus_interp_t;
-typedef enum {MUS_ENV_LINEAR, MUS_ENV_EXPONENTIAL, MUS_ENV_STEP} mus_env_t;
+	      MUS_INTERP_LAGRANGE, MUS_INTERP_BEZIER, MUS_INTERP_HERMITE} mus_interp_t;
 
 typedef enum {MUS_RECTANGULAR_WINDOW, MUS_HANN_WINDOW, MUS_WELCH_WINDOW, MUS_PARZEN_WINDOW, MUS_BARTLETT_WINDOW,
 	      MUS_HAMMING_WINDOW, MUS_BLACKMAN2_WINDOW, MUS_BLACKMAN3_WINDOW, MUS_BLACKMAN4_WINDOW,
@@ -94,31 +47,67 @@ typedef enum {MUS_RECTANGULAR_WINDOW, MUS_HANN_WINDOW, MUS_WELCH_WINDOW, MUS_PAR
 	      MUS_NUM_FFT_WINDOWS} mus_fft_window_t;
 
 typedef enum {MUS_SPECTRUM_IN_DB, MUS_SPECTRUM_NORMALIZED, MUS_SPECTRUM_RAW} mus_spectrum_t;
-typedef enum {MUS_CHEBYSHEV_EITHER_KIND, MUS_CHEBYSHEV_FIRST_KIND, MUS_CHEBYSHEV_SECOND_KIND} mus_polynomial_t;
+typedef enum {MUS_CHEBYSHEV_EITHER_KIND, MUS_CHEBYSHEV_FIRST_KIND, MUS_CHEBYSHEV_SECOND_KIND, MUS_CHEBYSHEV_BOTH_KINDS} mus_polynomial_t;
 
-#if defined(__GNUC__) && (!(defined(__cplusplus)))
-  #define MUS_RUN(GEN, ARG_1, ARG_2) ({ mus_any *_clm_h_1 = (mus_any *)(GEN); \
-                                       ((*((_clm_h_1->core)->run))(_clm_h_1, ARG_1, ARG_2)); })
-#else
-  #define MUS_RUN(GEN, ARG_1, ARG_2) ((*(((GEN)->core)->run))(GEN, ARG_1, ARG_2))
-#endif
-#define MUS_RUN_P(GEN) (((GEN)->core)->run)
 #define MUS_MAX_CLM_SINC_WIDTH 65536
 #define MUS_MAX_CLM_SRC 65536.0
 
+
+/* this is internal -- for clm->clm2xen */
+typedef struct {
+  mus_any_class *core;
+  int chan;
+  mus_long_t loc;
+  char *file_name;
+  int chans;
+  mus_float_t **obufs;
+  mus_float_t *obuf0, *obuf1;
+  mus_long_t data_start, data_end;
+  mus_long_t out_end;
+  mus_sample_t output_sample_type;
+  mus_header_t output_header_type;
+} rdout;
+/* end internal stuff */
+
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 MUS_EXPORT void mus_initialize(void);
 
-MUS_EXPORT int mus_make_class_tag(void);
+MUS_EXPORT int mus_make_generator_type(void);
+
+MUS_EXPORT mus_any_class *mus_generator_class(mus_any *ptr);
+MUS_EXPORT mus_any_class *mus_make_generator(int type, char *name, 
+					     void (*release)(mus_any *ptr), 
+					     char *(*describe)(mus_any *ptr), 
+					     bool (*equalp)(mus_any *gen1, mus_any *gen2));
+
+MUS_EXPORT void mus_generator_set_length(mus_any_class *p, mus_long_t (*length)(mus_any *ptr));
+MUS_EXPORT void mus_generator_set_scaler(mus_any_class *p, mus_float_t (*scaler)(mus_any *ptr));
+MUS_EXPORT void mus_generator_set_channels(mus_any_class *p, int (*channels)(mus_any *ptr));
+MUS_EXPORT void mus_generator_set_location(mus_any_class *p, mus_long_t (*location)(mus_any *ptr));
+MUS_EXPORT void mus_generator_set_set_location(mus_any_class *p, mus_long_t (*set_location)(mus_any *ptr, mus_long_t loc));
+MUS_EXPORT void mus_generator_set_channel(mus_any_class *p, int (*channel)(mus_any *ptr));
+MUS_EXPORT void mus_generator_set_file_name(mus_any_class *p, char *(*file_name)(mus_any *ptr));
+MUS_EXPORT void mus_generator_set_extended_type(mus_any_class *p, mus_clm_extended_t extended_type);
+MUS_EXPORT void mus_generator_set_read_sample(mus_any_class *p, mus_float_t (*read_sample)(mus_any *ptr, mus_long_t samp, int chan));
+MUS_EXPORT void mus_generator_set_feeders(mus_any *g, 
+					  mus_float_t (*feed)(void *arg, int direction),
+					  mus_float_t (*block_feed)(void *arg, int direction, mus_float_t *block, mus_long_t start, mus_long_t end));
+MUS_EXPORT void mus_generator_copy_feeders(mus_any *dest, mus_any *source);
+
 MUS_EXPORT mus_float_t mus_radians_to_hz(mus_float_t radians);
 MUS_EXPORT mus_float_t mus_hz_to_radians(mus_float_t hz);
 MUS_EXPORT mus_float_t mus_degrees_to_radians(mus_float_t degrees);
 MUS_EXPORT mus_float_t mus_radians_to_degrees(mus_float_t radians);
 MUS_EXPORT mus_float_t mus_db_to_linear(mus_float_t x);
 MUS_EXPORT mus_float_t mus_linear_to_db(mus_float_t x);
+MUS_EXPORT mus_float_t mus_odd_multiple(mus_float_t x, mus_float_t y);
+MUS_EXPORT mus_float_t mus_even_multiple(mus_float_t x, mus_float_t y);
+MUS_EXPORT mus_float_t mus_odd_weight(mus_float_t x);
+MUS_EXPORT mus_float_t mus_even_weight(mus_float_t x);
 
 MUS_EXPORT mus_float_t mus_srate(void);
 MUS_EXPORT mus_float_t mus_set_srate(mus_float_t val);
@@ -134,28 +123,28 @@ MUS_EXPORT mus_float_t mus_amplitude_modulate(mus_float_t s1, mus_float_t s2, mu
 MUS_EXPORT mus_float_t mus_contrast_enhancement(mus_float_t sig, mus_float_t index);
 MUS_EXPORT mus_float_t mus_dot_product(mus_float_t *data1, mus_float_t *data2, mus_long_t size);
 #if HAVE_COMPLEX_TRIG
-MUS_EXPORT complex double mus_edot_product(complex double freq, complex double *data, mus_long_t size);
+  MUS_EXPORT complex double mus_edot_product(complex double freq, complex double *data, mus_long_t size);
 #endif
 
-MUS_EXPORT void mus_clear_array(mus_float_t *arr, mus_long_t size);
 MUS_EXPORT bool mus_arrays_are_equal(mus_float_t *arr1, mus_float_t *arr2, mus_float_t fudge, mus_long_t len);
 MUS_EXPORT mus_float_t mus_polynomial(mus_float_t *coeffs, mus_float_t x, int ncoeffs);
-MUS_EXPORT void mus_multiply_arrays(mus_float_t *data, mus_float_t *window, mus_long_t len);
 MUS_EXPORT void mus_rectangular_to_polar(mus_float_t *rl, mus_float_t *im, mus_long_t size);
 MUS_EXPORT void mus_rectangular_to_magnitudes(mus_float_t *rl, mus_float_t *im, mus_long_t size);
 MUS_EXPORT void mus_polar_to_rectangular(mus_float_t *rl, mus_float_t *im, mus_long_t size);
 MUS_EXPORT mus_float_t mus_array_interp(mus_float_t *wave, mus_float_t phase, mus_long_t size);
-MUS_EXPORT double mus_bessi0(mus_float_t x);
+MUS_EXPORT mus_float_t mus_bessi0(mus_float_t x);
 MUS_EXPORT mus_float_t mus_interpolate(mus_interp_t type, mus_float_t x, mus_float_t *table, mus_long_t table_size, mus_float_t y);
-MUS_EXPORT bool mus_interp_type_p(int val);
-MUS_EXPORT bool mus_fft_window_p(int val);
+MUS_EXPORT bool mus_is_interp_type(int val);
+MUS_EXPORT bool mus_is_fft_window(int val);
 
-MUS_EXPORT int mus_data_format_zero(int format);
+MUS_EXPORT int mus_sample_type_zero(mus_sample_t samp_type);
+MUS_EXPORT mus_float_t (*mus_run_function(mus_any *g))(mus_any *gen, mus_float_t arg1, mus_float_t arg2);
 
 
 /* -------- generic functions -------- */
 
-MUS_EXPORT int mus_free(mus_any *ptr);
+MUS_EXPORT int mus_type(mus_any *ptr);
+MUS_EXPORT void mus_free(mus_any *ptr);
 MUS_EXPORT char *mus_describe(mus_any *gen);
 MUS_EXPORT bool mus_equalp(mus_any *g1, mus_any *g2);
 MUS_EXPORT mus_float_t mus_phase(mus_any *gen);
@@ -169,7 +158,6 @@ MUS_EXPORT mus_long_t mus_order(mus_any *gen);
 MUS_EXPORT mus_float_t *mus_data(mus_any *gen);
 MUS_EXPORT mus_float_t *mus_set_data(mus_any *gen, mus_float_t *data);
 MUS_EXPORT const char *mus_name(mus_any *ptr);
-MUS_EXPORT const char *mus_set_name(mus_any *ptr, const char *new_name);
 MUS_EXPORT mus_float_t mus_scaler(mus_any *gen);
 MUS_EXPORT mus_float_t mus_set_scaler(mus_any *gen, mus_float_t val);
 MUS_EXPORT mus_float_t mus_offset(mus_any *gen);
@@ -178,6 +166,7 @@ MUS_EXPORT mus_float_t mus_width(mus_any *gen);
 MUS_EXPORT mus_float_t mus_set_width(mus_any *gen, mus_float_t val);
 MUS_EXPORT char *mus_file_name(mus_any *ptr);
 MUS_EXPORT void mus_reset(mus_any *ptr);
+MUS_EXPORT mus_any *mus_copy(mus_any *gen);
 MUS_EXPORT mus_float_t *mus_xcoeffs(mus_any *ptr);
 MUS_EXPORT mus_float_t *mus_ycoeffs(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_xcoeff(mus_any *ptr, int index);
@@ -200,8 +189,6 @@ MUS_EXPORT mus_float_t mus_feedforward(mus_any *gen);
 MUS_EXPORT mus_float_t mus_set_feedforward(mus_any *gen, mus_float_t val);
 MUS_EXPORT mus_float_t mus_feedback(mus_any *rd);
 MUS_EXPORT mus_float_t mus_set_feedback(mus_any *rd, mus_float_t dir);
-MUS_EXPORT int mus_safety(mus_any *gen);
-MUS_EXPORT int mus_set_safety(mus_any *gen, int val);
 
 
 /* -------- generators -------- */
@@ -210,146 +197,183 @@ MUS_EXPORT mus_float_t mus_oscil(mus_any *o, mus_float_t fm, mus_float_t pm);
 MUS_EXPORT mus_float_t mus_oscil_unmodulated(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_oscil_fm(mus_any *ptr, mus_float_t fm);
 MUS_EXPORT mus_float_t mus_oscil_pm(mus_any *ptr, mus_float_t pm);
-MUS_EXPORT bool mus_oscil_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_oscil(mus_any *ptr);
 MUS_EXPORT mus_any *mus_make_oscil(mus_float_t freq, mus_float_t phase);
 
+MUS_EXPORT bool mus_is_oscil_bank(mus_any *ptr);
+MUS_EXPORT mus_float_t mus_oscil_bank(mus_any *ptr);
+MUS_EXPORT mus_any *mus_make_oscil_bank(int size, mus_float_t *freqs, mus_float_t *phases, mus_float_t *amps, bool stable);
+
 MUS_EXPORT mus_any *mus_make_ncos(mus_float_t freq, int n);
 MUS_EXPORT mus_float_t mus_ncos(mus_any *ptr, mus_float_t fm);
-MUS_EXPORT bool mus_ncos_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_ncos(mus_any *ptr);
 
 MUS_EXPORT mus_any *mus_make_nsin(mus_float_t freq, int n);
 MUS_EXPORT mus_float_t mus_nsin(mus_any *ptr, mus_float_t fm);
-MUS_EXPORT bool mus_nsin_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_nsin(mus_any *ptr);
 
 MUS_EXPORT mus_any *mus_make_nrxysin(mus_float_t frequency, mus_float_t y_over_x, int n, mus_float_t r);
 MUS_EXPORT mus_float_t mus_nrxysin(mus_any *ptr, mus_float_t fm);
-MUS_EXPORT bool mus_nrxysin_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_nrxysin(mus_any *ptr);
 
 MUS_EXPORT mus_any *mus_make_nrxycos(mus_float_t frequency, mus_float_t y_over_x, int n, mus_float_t r);
 MUS_EXPORT mus_float_t mus_nrxycos(mus_any *ptr, mus_float_t fm);
-MUS_EXPORT bool mus_nrxycos_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_nrxycos(mus_any *ptr);
+
+MUS_EXPORT mus_any *mus_make_rxykcos(mus_float_t freq, mus_float_t phase, mus_float_t r, mus_float_t ratio);
+MUS_EXPORT mus_float_t mus_rxykcos(mus_any *ptr, mus_float_t fm);
+MUS_EXPORT bool mus_is_rxykcos(mus_any *ptr);
+
+MUS_EXPORT mus_any *mus_make_rxyksin(mus_float_t freq, mus_float_t phase, mus_float_t r, mus_float_t ratio);
+MUS_EXPORT mus_float_t mus_rxyksin(mus_any *ptr, mus_float_t fm);
+MUS_EXPORT bool mus_is_rxyksin(mus_any *ptr);
 
 MUS_EXPORT mus_float_t mus_delay(mus_any *gen, mus_float_t input, mus_float_t pm);
 MUS_EXPORT mus_float_t mus_delay_unmodulated(mus_any *ptr, mus_float_t input);
 MUS_EXPORT mus_float_t mus_tap(mus_any *gen, mus_float_t loc);
 MUS_EXPORT mus_float_t mus_tap_unmodulated(mus_any *gen);
 MUS_EXPORT mus_any *mus_make_delay(int size, mus_float_t *line, int line_size, mus_interp_t type);
-MUS_EXPORT bool mus_delay_p(mus_any *ptr);
-MUS_EXPORT bool mus_delay_line_p(mus_any *gen); /* added 2-Mar-03 for tap error checks */
+MUS_EXPORT bool mus_is_delay(mus_any *ptr);
+MUS_EXPORT bool mus_is_tap(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_delay_tick(mus_any *ptr, mus_float_t input);
-MUS_EXPORT mus_float_t mus_delay_tick_noz(mus_any *ptr, mus_float_t input);
 MUS_EXPORT mus_float_t mus_delay_unmodulated_noz(mus_any *ptr, mus_float_t input);
 
 MUS_EXPORT mus_float_t mus_comb(mus_any *gen, mus_float_t input, mus_float_t pm);
 MUS_EXPORT mus_float_t mus_comb_unmodulated(mus_any *gen, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_comb(mus_float_t scaler, int size, mus_float_t *line, int line_size, mus_interp_t type);
-MUS_EXPORT bool mus_comb_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_comb(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_comb_unmodulated_noz(mus_any *ptr, mus_float_t input);
 
+MUS_EXPORT mus_float_t mus_comb_bank(mus_any *bank, mus_float_t inval);
+MUS_EXPORT mus_any *mus_make_comb_bank(int size, mus_any **combs);
+MUS_EXPORT bool mus_is_comb_bank(mus_any *g);
+
 MUS_EXPORT mus_float_t mus_notch(mus_any *gen, mus_float_t input, mus_float_t pm);
 MUS_EXPORT mus_float_t mus_notch_unmodulated(mus_any *gen, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_notch(mus_float_t scaler, int size, mus_float_t *line, int line_size, mus_interp_t type);
-MUS_EXPORT bool mus_notch_p(mus_any *ptr);
-MUS_EXPORT mus_float_t mus_notch_unmodulated_noz(mus_any *ptr, mus_float_t input);
+MUS_EXPORT bool mus_is_notch(mus_any *ptr);
 
 MUS_EXPORT mus_float_t mus_all_pass(mus_any *gen, mus_float_t input, mus_float_t pm);
 MUS_EXPORT mus_float_t mus_all_pass_unmodulated(mus_any *gen, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_all_pass(mus_float_t backward, mus_float_t forward, int size, mus_float_t *line, int line_size, mus_interp_t type);
-MUS_EXPORT bool mus_all_pass_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_all_pass(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_all_pass_unmodulated_noz(mus_any *ptr, mus_float_t input);
 
+MUS_EXPORT mus_float_t mus_all_pass_bank(mus_any *bank, mus_float_t inval);
+MUS_EXPORT mus_any *mus_make_all_pass_bank(int size, mus_any **combs);
+MUS_EXPORT bool mus_is_all_pass_bank(mus_any *g);
+
 MUS_EXPORT mus_any *mus_make_moving_average(int size, mus_float_t *line);
-MUS_EXPORT bool mus_moving_average_p(mus_any *ptr);
+MUS_EXPORT mus_any *mus_make_moving_average_with_initial_sum(int size, mus_float_t *line, mus_float_t sum);
+MUS_EXPORT bool mus_is_moving_average(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_moving_average(mus_any *ptr, mus_float_t input);
 
+MUS_EXPORT mus_any *mus_make_moving_max(int size, mus_float_t *line);
+MUS_EXPORT bool mus_is_moving_max(mus_any *ptr);
+MUS_EXPORT mus_float_t mus_moving_max(mus_any *ptr, mus_float_t input);
+
+MUS_EXPORT mus_any *mus_make_moving_norm(int size, mus_float_t *line, mus_float_t norm);
+MUS_EXPORT bool mus_is_moving_norm(mus_any *ptr);
+MUS_EXPORT mus_float_t mus_moving_norm(mus_any *ptr, mus_float_t input);
+
 MUS_EXPORT mus_float_t mus_table_lookup(mus_any *gen, mus_float_t fm);
 MUS_EXPORT mus_float_t mus_table_lookup_unmodulated(mus_any *gen);
 MUS_EXPORT mus_any *mus_make_table_lookup(mus_float_t freq, mus_float_t phase, mus_float_t *wave, mus_long_t wave_size, mus_interp_t type);
-MUS_EXPORT bool mus_table_lookup_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_table_lookup(mus_any *ptr);
 MUS_EXPORT mus_float_t *mus_partials_to_wave(mus_float_t *partial_data, int partials, mus_float_t *table, mus_long_t table_size, bool normalize);
 MUS_EXPORT mus_float_t *mus_phase_partials_to_wave(mus_float_t *partial_data, int partials, mus_float_t *table, mus_long_t table_size, bool normalize);
 
 MUS_EXPORT mus_float_t mus_sawtooth_wave(mus_any *gen, mus_float_t fm);
 MUS_EXPORT mus_any *mus_make_sawtooth_wave(mus_float_t freq, mus_float_t amp, mus_float_t phase);
-MUS_EXPORT bool mus_sawtooth_wave_p(mus_any *gen);
+MUS_EXPORT bool mus_is_sawtooth_wave(mus_any *gen);
 
 MUS_EXPORT mus_float_t mus_square_wave(mus_any *gen, mus_float_t fm);
 MUS_EXPORT mus_any *mus_make_square_wave(mus_float_t freq, mus_float_t amp, mus_float_t phase);
-MUS_EXPORT bool mus_square_wave_p(mus_any *gen);
+MUS_EXPORT bool mus_is_square_wave(mus_any *gen);
 
 MUS_EXPORT mus_float_t mus_triangle_wave(mus_any *gen, mus_float_t fm);
 MUS_EXPORT mus_any *mus_make_triangle_wave(mus_float_t freq, mus_float_t amp, mus_float_t phase);
-MUS_EXPORT bool mus_triangle_wave_p(mus_any *gen);
-
+MUS_EXPORT bool mus_is_triangle_wave(mus_any *gen);
+MUS_EXPORT mus_float_t mus_triangle_wave_unmodulated(mus_any *ptr);
+ 
 MUS_EXPORT mus_float_t mus_pulse_train(mus_any *gen, mus_float_t fm);
 MUS_EXPORT mus_any *mus_make_pulse_train(mus_float_t freq, mus_float_t amp, mus_float_t phase);
-MUS_EXPORT bool mus_pulse_train_p(mus_any *gen);
+MUS_EXPORT bool mus_is_pulse_train(mus_any *gen);
+MUS_EXPORT mus_float_t mus_pulse_train_unmodulated(mus_any *ptr);
 
 MUS_EXPORT void mus_set_rand_seed(unsigned long seed);
 MUS_EXPORT unsigned long mus_rand_seed(void);
 MUS_EXPORT mus_float_t mus_random(mus_float_t amp);
 MUS_EXPORT mus_float_t mus_frandom(mus_float_t amp);
-MUS_EXPORT mus_float_t mus_random_no_input(void);
-MUS_EXPORT mus_float_t mus_frandom_no_input(void);
 MUS_EXPORT int mus_irandom(int amp);
 
 MUS_EXPORT mus_float_t mus_rand(mus_any *gen, mus_float_t fm);
 MUS_EXPORT mus_any *mus_make_rand(mus_float_t freq, mus_float_t base);
-MUS_EXPORT bool mus_rand_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_rand(mus_any *ptr);
 MUS_EXPORT mus_any *mus_make_rand_with_distribution(mus_float_t freq, mus_float_t base, mus_float_t *distribution, int distribution_size);
 
 MUS_EXPORT mus_float_t mus_rand_interp(mus_any *gen, mus_float_t fm);
 MUS_EXPORT mus_any *mus_make_rand_interp(mus_float_t freq, mus_float_t base);
-MUS_EXPORT bool mus_rand_interp_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_rand_interp(mus_any *ptr);
 MUS_EXPORT mus_any *mus_make_rand_interp_with_distribution(mus_float_t freq, mus_float_t base, mus_float_t *distribution, int distribution_size);
+MUS_EXPORT mus_float_t mus_rand_interp_unmodulated(mus_any *ptr);
+MUS_EXPORT mus_float_t mus_rand_unmodulated(mus_any *ptr);
 
 MUS_EXPORT mus_float_t mus_asymmetric_fm(mus_any *gen, mus_float_t index, mus_float_t fm);
 MUS_EXPORT mus_float_t mus_asymmetric_fm_unmodulated(mus_any *gen, mus_float_t index);
-MUS_EXPORT mus_float_t mus_asymmetric_fm_no_input(mus_any *gen);
 MUS_EXPORT mus_any *mus_make_asymmetric_fm(mus_float_t freq, mus_float_t phase, mus_float_t r, mus_float_t ratio);
-MUS_EXPORT bool mus_asymmetric_fm_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_asymmetric_fm(mus_any *ptr);
 
 MUS_EXPORT mus_float_t mus_one_zero(mus_any *gen, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_one_zero(mus_float_t a0, mus_float_t a1);
-MUS_EXPORT bool mus_one_zero_p(mus_any *gen);
+MUS_EXPORT bool mus_is_one_zero(mus_any *gen);
 
 MUS_EXPORT mus_float_t mus_one_pole(mus_any *gen, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_one_pole(mus_float_t a0, mus_float_t b1);
-MUS_EXPORT bool mus_one_pole_p(mus_any *gen);
+MUS_EXPORT bool mus_is_one_pole(mus_any *gen);
 
 MUS_EXPORT mus_float_t mus_two_zero(mus_any *gen, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_two_zero(mus_float_t a0, mus_float_t a1, mus_float_t a2);
-MUS_EXPORT bool mus_two_zero_p(mus_any *gen);
+MUS_EXPORT bool mus_is_two_zero(mus_any *gen);
 MUS_EXPORT mus_any *mus_make_two_zero_from_frequency_and_radius(mus_float_t frequency, mus_float_t radius);
 
 MUS_EXPORT mus_float_t mus_two_pole(mus_any *gen, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_two_pole(mus_float_t a0, mus_float_t b1, mus_float_t b2);
-MUS_EXPORT bool mus_two_pole_p(mus_any *gen);
+MUS_EXPORT bool mus_is_two_pole(mus_any *gen);
 MUS_EXPORT mus_any *mus_make_two_pole_from_frequency_and_radius(mus_float_t frequency, mus_float_t radius);
 
+MUS_EXPORT mus_float_t mus_one_pole_all_pass(mus_any *f, mus_float_t input);
+MUS_EXPORT mus_any *mus_make_one_pole_all_pass(int size, mus_float_t coeff);
+MUS_EXPORT bool mus_is_one_pole_all_pass(mus_any *ptr);
+
 MUS_EXPORT mus_float_t mus_formant(mus_any *ptr, mus_float_t input); 
 MUS_EXPORT mus_any *mus_make_formant(mus_float_t frequency, mus_float_t radius);
-MUS_EXPORT bool mus_formant_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_formant(mus_any *ptr);
+MUS_EXPORT mus_float_t mus_set_formant_frequency(mus_any *ptr, mus_float_t freq_in_hz);
 MUS_EXPORT void mus_set_formant_radius_and_frequency(mus_any *ptr, mus_float_t radius, mus_float_t frequency);
 MUS_EXPORT mus_float_t mus_formant_with_frequency(mus_any *ptr, mus_float_t input, mus_float_t freq_in_radians);
-MUS_EXPORT mus_float_t mus_formant_bank(mus_float_t *amps, mus_any **formants, mus_float_t inval, int size);
+
+MUS_EXPORT mus_float_t mus_formant_bank(mus_any *bank, mus_float_t inval);
+MUS_EXPORT mus_float_t mus_formant_bank_with_inputs(mus_any *bank, mus_float_t *inval);
+MUS_EXPORT mus_any *mus_make_formant_bank(int size, mus_any **formants, mus_float_t *amps);
+MUS_EXPORT bool mus_is_formant_bank(mus_any *g);
 
 MUS_EXPORT mus_float_t mus_firmant(mus_any *ptr, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_firmant(mus_float_t frequency, mus_float_t radius);
-MUS_EXPORT bool mus_firmant_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_firmant(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_firmant_with_frequency(mus_any *ptr, mus_float_t input, mus_float_t freq_in_radians);
 
 MUS_EXPORT mus_float_t mus_filter(mus_any *ptr, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_filter(int order, mus_float_t *xcoeffs, mus_float_t *ycoeffs, mus_float_t *state);
-MUS_EXPORT bool mus_filter_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_filter(mus_any *ptr);
 
 MUS_EXPORT mus_float_t mus_fir_filter(mus_any *ptr, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_fir_filter(int order, mus_float_t *xcoeffs, mus_float_t *state);
-MUS_EXPORT bool mus_fir_filter_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_fir_filter(mus_any *ptr);
 
 MUS_EXPORT mus_float_t mus_iir_filter(mus_any *ptr, mus_float_t input);
 MUS_EXPORT mus_any *mus_make_iir_filter(int order, mus_float_t *ycoeffs, mus_float_t *state);
-MUS_EXPORT bool mus_iir_filter_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_iir_filter(mus_any *ptr);
 MUS_EXPORT mus_float_t *mus_make_fir_coeffs(int order, mus_float_t *env, mus_float_t *aa);
 
 MUS_EXPORT mus_float_t *mus_filter_set_xcoeffs(mus_any *ptr, mus_float_t *new_data);
@@ -358,161 +382,143 @@ MUS_EXPORT int mus_filter_set_order(mus_any *ptr, int order);
 
 MUS_EXPORT mus_float_t mus_filtered_comb(mus_any *ptr, mus_float_t input, mus_float_t pm);
 MUS_EXPORT mus_float_t mus_filtered_comb_unmodulated(mus_any *ptr, mus_float_t input);
-MUS_EXPORT bool mus_filtered_comb_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_filtered_comb(mus_any *ptr);
 MUS_EXPORT mus_any *mus_make_filtered_comb(mus_float_t scaler, int size, mus_float_t *line, int line_size, mus_interp_t type, mus_any *filt);
 
+MUS_EXPORT mus_float_t mus_filtered_comb_bank(mus_any *bank, mus_float_t inval);
+MUS_EXPORT mus_any *mus_make_filtered_comb_bank(int size, mus_any **combs);
+MUS_EXPORT bool mus_is_filtered_comb_bank(mus_any *g);
+
 MUS_EXPORT mus_float_t mus_wave_train(mus_any *gen, mus_float_t fm);
 MUS_EXPORT mus_float_t mus_wave_train_unmodulated(mus_any *gen);
 MUS_EXPORT mus_any *mus_make_wave_train(mus_float_t freq, mus_float_t phase, mus_float_t *wave, mus_long_t wsize, mus_interp_t type);
-MUS_EXPORT bool mus_wave_train_p(mus_any *gen);
+MUS_EXPORT bool mus_is_wave_train(mus_any *gen);
 
 MUS_EXPORT mus_float_t *mus_partials_to_polynomial(int npartials, mus_float_t *partials, mus_polynomial_t kind);
 MUS_EXPORT mus_float_t *mus_normalize_partials(int num_partials, mus_float_t *partials);
 
 MUS_EXPORT mus_any *mus_make_polyshape(mus_float_t frequency, mus_float_t phase, mus_float_t *coeffs, int size, int cheby_choice);
 MUS_EXPORT mus_float_t mus_polyshape(mus_any *ptr, mus_float_t index, mus_float_t fm);
-#define mus_polyshape_fm(Obj, Fm) mus_polyshape(Obj, 1.0, Fm)
 MUS_EXPORT mus_float_t mus_polyshape_unmodulated(mus_any *ptr, mus_float_t index);
 #define mus_polyshape_no_input(Obj) mus_polyshape(Obj, 1.0, 0.0)
-MUS_EXPORT bool mus_polyshape_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_polyshape(mus_any *ptr);
 
 MUS_EXPORT mus_any *mus_make_polywave(mus_float_t frequency, mus_float_t *coeffs, int n, int cheby_choice);
-MUS_EXPORT bool mus_polywave_p(mus_any *ptr);
+MUS_EXPORT mus_any *mus_make_polywave_tu(mus_float_t frequency, mus_float_t *tcoeffs, mus_float_t *ucoeffs, int n);
+MUS_EXPORT bool mus_is_polywave(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_polywave_unmodulated(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_polywave(mus_any *ptr, mus_float_t fm);
 MUS_EXPORT mus_float_t mus_chebyshev_t_sum(mus_float_t x, int n, mus_float_t *tn);
 MUS_EXPORT mus_float_t mus_chebyshev_u_sum(mus_float_t x, int n, mus_float_t *un);
 MUS_EXPORT mus_float_t mus_chebyshev_tu_sum(mus_float_t x, int n, mus_float_t *tn, mus_float_t *un);
-#define mus_polywave_type(Obj) mus_channel(Obj)
+MUS_EXPORT mus_float_t (*mus_polywave_function(mus_any *g))(mus_any *gen, mus_float_t fm);
 
 MUS_EXPORT mus_float_t mus_env(mus_any *ptr);
-MUS_EXPORT mus_any *mus_make_env(mus_float_t *brkpts, int npts, double scaler, double offset, double base, double duration, mus_long_t end, mus_float_t *odata);
-MUS_EXPORT bool mus_env_p(mus_any *ptr);
-MUS_EXPORT double mus_env_interp(double x, mus_any *env);
+MUS_EXPORT mus_any *mus_make_env(mus_float_t *brkpts, int npts, mus_float_t scaler, mus_float_t offset, mus_float_t base, 
+				 mus_float_t duration, mus_long_t end, mus_float_t *odata);
+MUS_EXPORT bool mus_is_env(mus_any *ptr);
+MUS_EXPORT mus_float_t mus_env_interp(mus_float_t x, mus_any *env);
 MUS_EXPORT mus_long_t *mus_env_passes(mus_any *gen);        /* for Snd */
-MUS_EXPORT double *mus_env_rates(mus_any *gen);        /* for Snd */
-MUS_EXPORT double mus_env_offset(mus_any *gen);        /* for Snd */
-MUS_EXPORT double mus_env_scaler(mus_any *gen);        /* for Snd */
-MUS_EXPORT double mus_env_initial_power(mus_any *gen); /* for Snd */
+MUS_EXPORT mus_float_t *mus_env_rates(mus_any *gen);        /* for Snd */
+MUS_EXPORT mus_float_t mus_env_offset(mus_any *gen);        /* for Snd */
+MUS_EXPORT mus_float_t mus_env_scaler(mus_any *gen);        /* for Snd */
+MUS_EXPORT mus_float_t mus_env_initial_power(mus_any *gen); /* for Snd */
 MUS_EXPORT int mus_env_breakpoints(mus_any *gen);      /* for Snd */
 MUS_EXPORT mus_float_t mus_env_any(mus_any *e, mus_float_t (*connect_points)(mus_float_t val));
-#define mus_make_env_with_length(Brkpts, Pts, Scaler, Offset, Base, Length) mus_make_env(Brkpts, Pts, Scaler, Offset, Base, 0.0, (Length) - 1, NULL)
-MUS_EXPORT mus_float_t mus_env_linear(mus_any *ptr);
-MUS_EXPORT mus_float_t mus_env_exponential(mus_any *ptr);
-MUS_EXPORT mus_env_t mus_env_type(mus_any *ptr);
-
-MUS_EXPORT bool mus_frame_p(mus_any *ptr);
-MUS_EXPORT mus_any *mus_make_empty_frame(int chans);
-MUS_EXPORT mus_any *mus_make_frame(int chans, ...);
-MUS_EXPORT mus_any *mus_frame_add(mus_any *f1, mus_any *f2, mus_any *res);
-MUS_EXPORT mus_any *mus_frame_multiply(mus_any *f1, mus_any *f2, mus_any *res);
-MUS_EXPORT mus_any *mus_frame_scale(mus_any *uf1, mus_float_t scl, mus_any *ures);
-MUS_EXPORT mus_any *mus_frame_offset(mus_any *uf1, mus_float_t offset, mus_any *ures);
-MUS_EXPORT mus_float_t mus_frame_ref(mus_any *f, int chan);
-MUS_EXPORT mus_float_t mus_frame_set(mus_any *f, int chan, mus_float_t val);
-MUS_EXPORT mus_any *mus_frame_copy(mus_any *uf);
-MUS_EXPORT mus_float_t mus_frame_fill(mus_any *uf, mus_float_t val);
-
-MUS_EXPORT bool mus_mixer_p(mus_any *ptr);
-MUS_EXPORT mus_any *mus_make_empty_mixer(int chans);
-MUS_EXPORT mus_any *mus_make_identity_mixer(int chans);
-MUS_EXPORT mus_any *mus_make_mixer(int chans, ...);
-MUS_EXPORT mus_float_t mus_mixer_ref(mus_any *f, int in, int out);
-MUS_EXPORT mus_float_t mus_mixer_set(mus_any *f, int in, int out, mus_float_t val);
-MUS_EXPORT mus_any *mus_frame_to_frame(mus_any *f, mus_any *in, mus_any *out);
-MUS_EXPORT mus_any *mus_sample_to_frame(mus_any *f, mus_float_t in, mus_any *out);
-MUS_EXPORT mus_float_t mus_frame_to_sample(mus_any *f, mus_any *in);
-MUS_EXPORT mus_any *mus_mixer_multiply(mus_any *f1, mus_any *f2, mus_any *res);
-MUS_EXPORT mus_any *mus_mixer_add(mus_any *f1, mus_any *f2, mus_any *res);
-MUS_EXPORT mus_any *mus_mixer_scale(mus_any *uf1, mus_float_t scaler, mus_any *ures);
-MUS_EXPORT mus_any *mus_mixer_offset(mus_any *uf1, mus_float_t offset, mus_any *ures);
-MUS_EXPORT mus_any *mus_make_scalar_mixer(int chans, mus_float_t scalar);
-MUS_EXPORT mus_any *mus_mixer_copy(mus_any *uf);
-MUS_EXPORT mus_float_t mus_mixer_fill(mus_any *uf, mus_float_t val);
-
-MUS_EXPORT mus_any *mus_frame_to_frame_mono(mus_any *frame, mus_any *mix, mus_any *out);
-MUS_EXPORT mus_any *mus_frame_to_frame_stereo(mus_any *frame, mus_any *mix, mus_any *out);
-MUS_EXPORT mus_any *mus_frame_to_frame_mono_to_stereo(mus_any *frame, mus_any *mix, mus_any *out);
-
-MUS_EXPORT bool mus_file_to_sample_p(mus_any *ptr);
+MUS_EXPORT mus_float_t (*mus_env_function(mus_any *g))(mus_any *gen);
+
+MUS_EXPORT mus_any *mus_make_pulsed_env(mus_any *e, mus_any *p);
+MUS_EXPORT bool mus_is_pulsed_env(mus_any *ptr);
+MUS_EXPORT mus_float_t mus_pulsed_env(mus_any *pl, mus_float_t inval);
+MUS_EXPORT mus_float_t mus_pulsed_env_unmodulated(mus_any *pl);
+
+MUS_EXPORT bool mus_is_file_to_sample(mus_any *ptr);
 MUS_EXPORT mus_any *mus_make_file_to_sample(const char *filename);
 MUS_EXPORT mus_any *mus_make_file_to_sample_with_buffer_size(const char *filename, mus_long_t buffer_size);
 MUS_EXPORT mus_float_t mus_file_to_sample(mus_any *ptr, mus_long_t samp, int chan);
-MUS_EXPORT mus_float_t mus_in_any_from_file(mus_any *ptr, mus_long_t samp, int chan);
 
 MUS_EXPORT mus_float_t mus_readin(mus_any *rd);
 MUS_EXPORT mus_any *mus_make_readin_with_buffer_size(const char *filename, int chan, mus_long_t start, int direction, mus_long_t buffer_size);
 #define mus_make_readin(Filename, Chan, Start, Direction) mus_make_readin_with_buffer_size(Filename, Chan, Start, Direction, mus_file_buffer_size())
-MUS_EXPORT bool mus_readin_p(mus_any *ptr);
-
-MUS_EXPORT bool mus_output_p(mus_any *ptr);
-MUS_EXPORT bool mus_input_p(mus_any *ptr);
-MUS_EXPORT mus_float_t mus_in_any(mus_long_t frame, int chan, mus_any *IO);
-
-MUS_EXPORT mus_any *mus_make_file_to_frame(const char *filename);
-MUS_EXPORT bool mus_file_to_frame_p(mus_any *ptr);
-MUS_EXPORT mus_any *mus_file_to_frame(mus_any *ptr, mus_long_t samp, mus_any *f);
-MUS_EXPORT mus_any *mus_make_file_to_frame_with_buffer_size(const char *filename, mus_long_t buffer_size);
-
-MUS_EXPORT bool mus_sample_to_file_p(mus_any *ptr);
-MUS_EXPORT mus_any *mus_make_sample_to_file_with_comment(const char *filename, int out_chans, int out_format, int out_type, const char *comment);
-#define mus_make_sample_to_file(Filename, Chans, OutFormat, OutType) mus_make_sample_to_file_with_comment(Filename, Chans, OutFormat, OutType, NULL)
+MUS_EXPORT bool mus_is_readin(mus_any *ptr);
+
+MUS_EXPORT bool mus_is_output(mus_any *ptr);
+MUS_EXPORT bool mus_is_input(mus_any *ptr);
+MUS_EXPORT mus_float_t mus_in_any(mus_long_t frample, int chan, mus_any *IO);
+MUS_EXPORT bool mus_in_any_is_safe(mus_any *IO);
+
+  /* new 6.0 */
+MUS_EXPORT mus_float_t *mus_file_to_frample(mus_any *ptr, mus_long_t samp, mus_float_t *f);
+MUS_EXPORT mus_any *mus_make_file_to_frample(const char *filename);
+MUS_EXPORT bool mus_is_file_to_frample(mus_any *ptr);
+MUS_EXPORT mus_any *mus_make_file_to_frample_with_buffer_size(const char *filename, mus_long_t buffer_size);
+MUS_EXPORT mus_float_t *mus_frample_to_frample(mus_float_t *matrix, int mx_chans, mus_float_t *in_samps, int in_chans, mus_float_t *out_samps, int out_chans);
+
+MUS_EXPORT bool mus_is_frample_to_file(mus_any *ptr);
+MUS_EXPORT mus_float_t *mus_frample_to_file(mus_any *ptr, mus_long_t samp, mus_float_t *data);
+MUS_EXPORT mus_any *mus_make_frample_to_file_with_comment(const char *filename, int chans, mus_sample_t samp_type, mus_header_t head_type, const char *comment);
+#define mus_make_frample_to_file(Filename, Chans, SampType, HeadType) mus_make_frample_to_file_with_comment(Filename, Chans, SampType, HeadType, NULL)
+MUS_EXPORT mus_any *mus_continue_frample_to_file(const char *filename);
+
+MUS_EXPORT void mus_file_mix_with_reader_and_writer(mus_any *outf, mus_any *inf,
+						    mus_long_t out_start, mus_long_t out_framples, mus_long_t in_start, 
+						    mus_float_t *mx, int mx_chans, mus_any ***envs);
+MUS_EXPORT void mus_file_mix(const char *outfile, const char *infile, 
+			     mus_long_t out_start, mus_long_t out_framples, mus_long_t in_start, 
+			     mus_float_t *mx, int mx_chans, mus_any ***envs);
+
+MUS_EXPORT bool mus_is_sample_to_file(mus_any *ptr);
+MUS_EXPORT mus_any *mus_make_sample_to_file_with_comment(const char *filename, int out_chans, mus_sample_t samp_type, mus_header_t head_type, const char *comment);
+#define mus_make_sample_to_file(Filename, Chans, SampType, HeadType) mus_make_sample_to_file_with_comment(Filename, Chans, SampType, HeadType, NULL)
 MUS_EXPORT mus_float_t mus_sample_to_file(mus_any *ptr, mus_long_t samp, int chan, mus_float_t val);
 MUS_EXPORT mus_any *mus_continue_sample_to_file(const char *filename);
 MUS_EXPORT int mus_close_file(mus_any *ptr);
 MUS_EXPORT mus_any *mus_sample_to_file_add(mus_any *out1, mus_any *out2);
 
-MUS_EXPORT mus_float_t mus_out_any(mus_long_t frame, mus_float_t val, int chan, mus_any *IO);
+MUS_EXPORT mus_float_t mus_out_any(mus_long_t frample, mus_float_t val, int chan, mus_any *IO);
+MUS_EXPORT mus_float_t mus_safe_out_any_to_file(mus_long_t samp, mus_float_t val, int chan, mus_any *IO);
+MUS_EXPORT bool mus_out_any_is_safe(mus_any *IO);
 MUS_EXPORT mus_float_t mus_out_any_to_file(mus_any *ptr, mus_long_t samp, int chan, mus_float_t val);
-MUS_EXPORT bool mus_frame_to_file_p(mus_any *ptr);
-MUS_EXPORT mus_any *mus_frame_to_file(mus_any *ptr, mus_long_t samp, mus_any *data);
-MUS_EXPORT mus_any *mus_make_frame_to_file_with_comment(const char *filename, int chans, int out_format, int out_type, const char *comment);
-#define mus_make_frame_to_file(Filename, Chans, OutFormat, OutType) mus_make_frame_to_file_with_comment(Filename, Chans, OutFormat, OutType, NULL)
-MUS_EXPORT mus_any *mus_continue_frame_to_file(const char *filename);
-
-MUS_EXPORT mus_float_t mus_locsig(mus_any *ptr, mus_long_t loc, mus_float_t val);
-MUS_EXPORT mus_any *mus_make_locsig(mus_float_t degree, mus_float_t distance, mus_float_t reverb, int chans, mus_any *output, int rev_chans, mus_any *revput, mus_interp_t type);
-MUS_EXPORT bool mus_locsig_p(mus_any *ptr);
+
+MUS_EXPORT void mus_locsig(mus_any *ptr, mus_long_t loc, mus_float_t val);
+MUS_EXPORT mus_any *mus_make_locsig(mus_float_t degree, mus_float_t distance, mus_float_t reverb, int chans, 
+				    mus_any *output, int rev_chans, mus_any *revput, mus_interp_t type);
+MUS_EXPORT bool mus_is_locsig(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_locsig_ref(mus_any *ptr, int chan);
 MUS_EXPORT mus_float_t mus_locsig_set(mus_any *ptr, int chan, mus_float_t val);
 MUS_EXPORT mus_float_t mus_locsig_reverb_ref(mus_any *ptr, int chan);
 MUS_EXPORT mus_float_t mus_locsig_reverb_set(mus_any *ptr, int chan, mus_float_t val);
 MUS_EXPORT void mus_move_locsig(mus_any *ptr, mus_float_t degree, mus_float_t distance);
-MUS_EXPORT mus_any *mus_locsig_outf(mus_any *ptr);
-MUS_EXPORT mus_any *mus_locsig_revf(mus_any *ptr);
+MUS_EXPORT mus_float_t *mus_locsig_outf(mus_any *ptr);
+MUS_EXPORT mus_float_t *mus_locsig_revf(mus_any *ptr);
 MUS_EXPORT void *mus_locsig_closure(mus_any *ptr);
-
-  /* these are for the optimizer (run.c) */
-MUS_EXPORT void mus_locsig_mono_no_reverb(mus_any *ptr, mus_long_t loc, mus_float_t val);
-MUS_EXPORT void mus_locsig_mono(mus_any *ptr, mus_long_t loc, mus_float_t val);
-MUS_EXPORT void mus_locsig_stereo_no_reverb(mus_any *ptr, mus_long_t loc, mus_float_t val);
-MUS_EXPORT void mus_locsig_stereo(mus_any *ptr, mus_long_t loc, mus_float_t val);
-MUS_EXPORT void mus_locsig_safe_mono_no_reverb(mus_any *ptr, mus_long_t loc, mus_float_t val);
-MUS_EXPORT void mus_locsig_safe_mono(mus_any *ptr, mus_long_t loc, mus_float_t val);
-MUS_EXPORT void mus_locsig_safe_stereo_no_reverb(mus_any *ptr, mus_long_t loc, mus_float_t val);
-MUS_EXPORT void mus_locsig_safe_stereo(mus_any *ptr, mus_long_t loc, mus_float_t val);
+MUS_EXPORT void mus_locsig_set_detour(mus_any *ptr, void (*detour)(mus_any *ptr, mus_long_t val));
 MUS_EXPORT int mus_locsig_channels(mus_any *ptr);
 MUS_EXPORT int mus_locsig_reverb_channels(mus_any *ptr);
-MUS_EXPORT int mus_locsig_safety(mus_any *ptr);
-
 
-MUS_EXPORT bool mus_move_sound_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_move_sound(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_move_sound(mus_any *ptr, mus_long_t loc, mus_float_t val);
 MUS_EXPORT mus_any *mus_make_move_sound(mus_long_t start, mus_long_t end, int out_channels, int rev_channels,
 					mus_any *doppler_delay, mus_any *doppler_env, mus_any *rev_env,
 					mus_any **out_delays, mus_any **out_envs, mus_any **rev_envs,
 					int *out_map, mus_any *output, mus_any *revput, bool free_arrays, bool free_gens);
-MUS_EXPORT mus_any *mus_move_sound_outf(mus_any *ptr);
-MUS_EXPORT mus_any *mus_move_sound_revf(mus_any *ptr);
+MUS_EXPORT mus_float_t *mus_move_sound_outf(mus_any *ptr);
+MUS_EXPORT mus_float_t *mus_move_sound_revf(mus_any *ptr);
 MUS_EXPORT void *mus_move_sound_closure(mus_any *ptr);
+MUS_EXPORT void mus_move_sound_set_detour(mus_any *ptr, void (*detour)(mus_any *ptr, mus_long_t val));
+MUS_EXPORT int mus_move_sound_channels(mus_any *ptr);
+MUS_EXPORT int mus_move_sound_reverb_channels(mus_any *ptr);
 
 MUS_EXPORT mus_any *mus_make_src(mus_float_t (*input)(void *arg, int direction), mus_float_t srate, int width, void *closure);
+MUS_EXPORT mus_any *mus_make_src_with_init(mus_float_t (*input)(void *arg, int direction), mus_float_t srate, int width, void *closure, void (*init)(void *p, mus_any *g));
 MUS_EXPORT mus_float_t mus_src(mus_any *srptr, mus_float_t sr_change, mus_float_t (*input)(void *arg, int direction));
-MUS_EXPORT bool mus_src_p(mus_any *ptr);
-MUS_EXPORT mus_float_t mus_src_20(mus_any *srptr, mus_float_t (*input)(void *arg, int direction));
-MUS_EXPORT mus_float_t mus_src_05(mus_any *srptr, mus_float_t (*input)(void *arg, int direction));
+MUS_EXPORT bool mus_is_src(mus_any *ptr);
+MUS_EXPORT mus_float_t *mus_src_20(mus_any *srptr, mus_float_t *in_data, mus_long_t dur);
+MUS_EXPORT mus_float_t *mus_src_05(mus_any *srptr, mus_float_t *in_data, mus_long_t dur);
+MUS_EXPORT void mus_src_to_buffer(mus_any *srptr, mus_float_t (*input)(void *arg, int direction), mus_float_t *out_data, mus_long_t dur);
+MUS_EXPORT void mus_src_init(mus_any *ptr);
 
-MUS_EXPORT bool mus_convolve_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_convolve(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_convolve(mus_any *ptr, mus_float_t (*input)(void *arg, int direction));
 MUS_EXPORT mus_any *mus_make_convolve(mus_float_t (*input)(void *arg, int direction), mus_float_t *filter, mus_long_t fftsize, mus_long_t filtersize, void *closure);
 
@@ -529,7 +535,7 @@ MUS_EXPORT mus_float_t *mus_convolution(mus_float_t *rl1, mus_float_t *rl2, mus_
 MUS_EXPORT void mus_convolve_files(const char *file1, const char *file2, mus_float_t maxamp, const char *output_file);
 MUS_EXPORT mus_float_t *mus_cepstrum(mus_float_t *data, mus_long_t n);
 
-MUS_EXPORT bool mus_granulate_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_granulate(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_granulate(mus_any *ptr, mus_float_t (*input)(void *arg, int direction));
 MUS_EXPORT mus_float_t mus_granulate_with_editor(mus_any *ptr, mus_float_t (*input)(void *arg, int direction), int (*edit)(void *closure));
 MUS_EXPORT mus_any *mus_make_granulate(mus_float_t (*input)(void *arg, int direction), 
@@ -543,11 +549,9 @@ MUS_EXPORT void mus_granulate_set_edit_function(mus_any *ptr, int (*edit)(void *
 MUS_EXPORT mus_long_t mus_set_file_buffer_size(mus_long_t size);
 MUS_EXPORT mus_long_t mus_file_buffer_size(void);
 
-MUS_EXPORT void mus_mix(const char *outfile, const char *infile, mus_long_t out_start, mus_long_t out_samps, mus_long_t in_start, mus_any *mx, mus_any ***envs);
-MUS_EXPORT void mus_mix_with_reader_and_writer(mus_any *outf, mus_any *inf, mus_long_t out_start, mus_long_t out_frames, mus_long_t in_start, mus_any *umx, mus_any ***envs);
 MUS_EXPORT mus_float_t mus_apply(mus_any *gen, mus_float_t f1, mus_float_t f2);
 
-MUS_EXPORT bool mus_phase_vocoder_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_phase_vocoder(mus_any *ptr);
 MUS_EXPORT mus_any *mus_make_phase_vocoder(mus_float_t (*input)(void *arg, int direction), 
 					   int fftsize, int overlap, int interp,
 					   mus_float_t pitch,
@@ -570,19 +574,14 @@ MUS_EXPORT mus_float_t *mus_phase_vocoder_phase_increments(mus_any *ptr);
 
 
 MUS_EXPORT mus_any *mus_make_ssb_am(mus_float_t freq, int order);
-MUS_EXPORT bool mus_ssb_am_p(mus_any *ptr);
+MUS_EXPORT bool mus_is_ssb_am(mus_any *ptr);
 MUS_EXPORT mus_float_t mus_ssb_am_unmodulated(mus_any *ptr, mus_float_t insig);
 MUS_EXPORT mus_float_t mus_ssb_am(mus_any *ptr, mus_float_t insig, mus_float_t fm);
 
 MUS_EXPORT void mus_clear_sinc_tables(void);
 MUS_EXPORT void *mus_environ(mus_any *gen);
 MUS_EXPORT void *mus_set_environ(mus_any *gen, void *e);
-
-
-/* used only in run.lisp */
-MUS_EXPORT mus_any *mus_make_frame_with_data(int chans, mus_float_t *data);
-MUS_EXPORT mus_any *mus_make_mixer_with_data(int chans, mus_float_t *data);
-
+MUS_EXPORT mus_any *mus_bank_generator(mus_any *g, int i);
 #ifdef __cplusplus
 }
 #endif
@@ -592,6 +591,46 @@ MUS_EXPORT mus_any *mus_make_mixer_with_data(int chans, mus_float_t *data);
 
 /* Change log.
  *
+ * 5-Aug:      removed some now-obsolete mus_locsig functions.
+ * 5-Jul:      added stable arg to mus_make_oscil_bank.
+ * 15-Feb:     removed mus_set_name, changed mus_free to void.
+ * 31-Jan-15:  removed mus_multiply_arrays.
+ * --------
+ * 8-Nov:      mus_copy, mus_bank_generator.
+ * 24-Oct:     mus_generator_set_feeders.
+ * 10-Aug:     data-format -> sample-type.
+ * 17-Apr:     moving_norm generator.
+ * 14-Apr:     mus_frame and mus_mixer removed, "frame" replaced by "frample" in IO functions.
+ * 11-Apr:     mus_even|odd_weight|multiple.
+ * 9-Apr:      deprecate mus_is_delay_line.
+ * 2-Apr:      mus_make_moving_average_with_sum.
+ * 19-Mar:     deprecate mus_make_env_with_length.
+ * 17-Feb-14:  mus_*_p -> mus_is_*.
+ * --------
+ * 7-Dec:      mus_set_formant_frequency, mus_src_20 and mus_src_05 changed.  Removed mus_in_any_from_file.
+ * 29-Nov:     mus_make_polywave_tu.
+ * 11-Oct:     mus_vector_to_file, mus_vector_mix.
+ * 19-Apr:     rxyk!cos and rxyk!sin from generators.scm.
+ * 11-Apr:     mus_tap_p as a better name for mus_delay_line_p.
+ * 27-Mar:     comb-bank, all-pass-bank, filtered-comb-bank, pulsed-env, oscil-bank.
+ * 21-Mar:     one-pole-all-pass generator.
+ * 14-Mar:     formant-bank generator.
+ *             removed mus_delay_tick_noz.
+ * 4-Mar:      moving_max generator.
+ *             removed the unstable filter check in make_two_pole.
+ * 21-Jan-13:  changed mus_formant_bank parameters.
+ * --------
+ * 22-Dec:     removed all the safety settings.
+ * 15-Nov:     removed mus_env_t, mus_env_type, and other recently deprecated stuff.
+ * 15-Jul:     more changes for clm2xen.
+ * 4-July-12:  moved various struct definitions to clm.c
+ *             added accessors for mus_any_class etc.
+ * --------
+ * 1-Sep:      mus_type.
+ * 20-Aug:     changed type of mus_locsig to void, added mus_locsig_function_reset.
+ *             removed function-as-output-location from locsig et al.
+ * 14-Jul-11:  removed pthread stuff.
+ * --------
  * 7-Mar-10:   protect in-any and out-any from sample numbers less than 0.
  * --------
  * 14-Oct:     sine-summation, sum-of-sines, sum-of-cosines removed.
@@ -608,7 +647,7 @@ MUS_EXPORT mus_any *mus_make_mixer_with_data(int chans, mus_float_t *data);
  * 11-Dec:     deprecated the sine-summation, sum-of-cosines, and sum-of-sines generators.
  * 30-Oct:     mus_sample_to_file_add.
  *             mus_describe once again allocates a fresh output string.
- *             finally removed sine-bank (snd9.scm has replacement).
+ *             finally removed sine-bank.
  * 9-Oct:      various thread-related internal changes.
  * 14-Jul:     mus_data_format_zero.
  * 12-Jul:     mus_interp_type_p and mus_fft_window_p for C++'s benefit.
@@ -664,7 +703,7 @@ MUS_EXPORT mus_any *mus_make_mixer_with_data(int chans, mus_float_t *data);
  * 30-July:    renamed average to moving_average.
  * 28-July:    renamed make_ppolar and make_zpolar to make_two_pole|zero_from_radius_and_frequency.
  *             added mus_scaler and mus_frequency methods for two_pole and two_zero.
- * 21-July:    removed mus_wrapper field -- old way can't work since we need the original XEN object.
+ * 21-July:    removed mus_wrapper field -- old way can't work since we need the original Xen object.
  * 3-July:     mus_move_sound (dlocsig) generator.
  *             changed return type of mus_locsig to float.
  * 28-June:    mus_filtered_comb generator.