dom
/
tonalisa
Vērot 1
Pievienot zvaigznīti 0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
1 Revīzija
1 Atzars
Atzars: master
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'master'
${ noResults }
tonalisa/lib/sndlib/clm.h

868 rindas
49KB
Neapstrādāts Patstāvīgā saite Vainot Vēsture 

  1. #ifndef CLM_H

  2. #define CLM_H

  3. 

  4. #define MUS_VERSION 6

  5. #define MUS_REVISION 13

  6. #define MUS_DATE "5-Aug-15"

  7. 

  8. /* isn't mus_env_interp backwards? */

  9. 

  10. #include "sndlib.h"

  11. 

  12. #ifndef _MSC_VER

  13.   #include <sys/param.h>

  14. #endif

  15. #if HAVE_COMPLEX_TRIG

  16.   #include <complex.h>

  17. #endif

  18. 

  19. #if(!defined(M_PI))

  20.   #define M_PI 3.14159265358979323846264338327

  21.   #define M_PI_2 (M_PI / 2.0)

  22. #endif

  23. 

  24. #define MUS_DEFAULT_SAMPLING_RATE 44100.0

  25. #define MUS_DEFAULT_FILE_BUFFER_SIZE 8192

  26. #define MUS_DEFAULT_ARRAY_PRINT_LENGTH 8

  27. 

  28. typedef enum {MUS_NOT_SPECIAL, MUS_SIMPLE_FILTER, MUS_FULL_FILTER, MUS_OUTPUT, MUS_INPUT, MUS_DELAY_LINE} mus_clm_extended_t;

  29. 

  30. typedef struct mus_any_class mus_any_class;

  31. typedef struct {

  32.   struct mus_any_class *core;

  33. } mus_any;

  34. 

  35. 

  36. typedef enum {MUS_INTERP_NONE, MUS_INTERP_LINEAR, MUS_INTERP_SINUSOIDAL, MUS_INTERP_ALL_PASS, 

  37. 	      MUS_INTERP_LAGRANGE, MUS_INTERP_BEZIER, MUS_INTERP_HERMITE} mus_interp_t;

  38. 

  39. typedef enum {MUS_RECTANGULAR_WINDOW, MUS_HANN_WINDOW, MUS_WELCH_WINDOW, MUS_PARZEN_WINDOW, MUS_BARTLETT_WINDOW,

  40. 	      MUS_HAMMING_WINDOW, MUS_BLACKMAN2_WINDOW, MUS_BLACKMAN3_WINDOW, MUS_BLACKMAN4_WINDOW,

  41. 	      MUS_EXPONENTIAL_WINDOW, MUS_RIEMANN_WINDOW, MUS_KAISER_WINDOW, MUS_CAUCHY_WINDOW, MUS_POISSON_WINDOW,

  42. 	      MUS_GAUSSIAN_WINDOW, MUS_TUKEY_WINDOW, MUS_DOLPH_CHEBYSHEV_WINDOW, MUS_HANN_POISSON_WINDOW, 

  43. 	      MUS_CONNES_WINDOW, MUS_SAMARAKI_WINDOW, MUS_ULTRASPHERICAL_WINDOW, 

  44. 	      MUS_BARTLETT_HANN_WINDOW, MUS_BOHMAN_WINDOW, MUS_FLAT_TOP_WINDOW,

  45. 	      MUS_BLACKMAN5_WINDOW, MUS_BLACKMAN6_WINDOW, MUS_BLACKMAN7_WINDOW, MUS_BLACKMAN8_WINDOW, MUS_BLACKMAN9_WINDOW, MUS_BLACKMAN10_WINDOW,

  46. 	      MUS_RV2_WINDOW, MUS_RV3_WINDOW, MUS_RV4_WINDOW, MUS_MLT_SINE_WINDOW, MUS_PAPOULIS_WINDOW, MUS_DPSS_WINDOW, MUS_SINC_WINDOW,

  47. 	      MUS_NUM_FFT_WINDOWS} mus_fft_window_t;

  48. 

  49. typedef enum {MUS_SPECTRUM_IN_DB, MUS_SPECTRUM_NORMALIZED, MUS_SPECTRUM_RAW} mus_spectrum_t;

  50. typedef enum {MUS_CHEBYSHEV_EITHER_KIND, MUS_CHEBYSHEV_FIRST_KIND, MUS_CHEBYSHEV_SECOND_KIND, MUS_CHEBYSHEV_BOTH_KINDS} mus_polynomial_t;

  51. 

  52. #define MUS_MAX_CLM_SINC_WIDTH 65536

  53. #define MUS_MAX_CLM_SRC 65536.0

  54. 

  55. 

  56. /* this is internal -- for clm->clm2xen */

  57. typedef struct {

  58.   mus_any_class *core;

  59.   int chan;

  60.   mus_long_t loc;

  61.   char *file_name;

  62.   int chans;

  63.   mus_float_t **obufs;

  64.   mus_float_t *obuf0, *obuf1;

  65.   mus_long_t data_start, data_end;

  66.   mus_long_t out_end;

  67.   mus_sample_t output_sample_type;

  68.   mus_header_t output_header_type;

  69. } rdout;

  70. /* end internal stuff */

  71. 

  72. 

  73. #ifdef __cplusplus

  74. extern "C" {

  75. #endif

  76. 

  77. MUS_EXPORT void mus_initialize(void);

  78. 

  79. MUS_EXPORT int mus_make_generator_type(void);

  80. 

  81. MUS_EXPORT mus_any_class *mus_generator_class(mus_any *ptr);

  82. MUS_EXPORT mus_any_class *mus_make_generator(int type, char *name, 

  83. 					     void (*release)(mus_any *ptr), 

  84. 					     char *(*describe)(mus_any *ptr), 

  85. 					     bool (*equalp)(mus_any *gen1, mus_any *gen2));

  86. 

  87. MUS_EXPORT void mus_generator_set_length(mus_any_class *p, mus_long_t (*length)(mus_any *ptr));

  88. MUS_EXPORT void mus_generator_set_scaler(mus_any_class *p, mus_float_t (*scaler)(mus_any *ptr));

  89. MUS_EXPORT void mus_generator_set_channels(mus_any_class *p, int (*channels)(mus_any *ptr));

  90. MUS_EXPORT void mus_generator_set_location(mus_any_class *p, mus_long_t (*location)(mus_any *ptr));

  91. MUS_EXPORT void mus_generator_set_set_location(mus_any_class *p, mus_long_t (*set_location)(mus_any *ptr, mus_long_t loc));

  92. MUS_EXPORT void mus_generator_set_channel(mus_any_class *p, int (*channel)(mus_any *ptr));

  93. MUS_EXPORT void mus_generator_set_file_name(mus_any_class *p, char *(*file_name)(mus_any *ptr));

  94. MUS_EXPORT void mus_generator_set_extended_type(mus_any_class *p, mus_clm_extended_t extended_type);

  95. 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));

  96. MUS_EXPORT void mus_generator_set_feeders(mus_any *g, 

  97. 					  mus_float_t (*feed)(void *arg, int direction),

  98. 					  mus_float_t (*block_feed)(void *arg, int direction, mus_float_t *block, mus_long_t start, mus_long_t end));

  99. MUS_EXPORT void mus_generator_copy_feeders(mus_any *dest, mus_any *source);

  100. 

  101. MUS_EXPORT mus_float_t mus_radians_to_hz(mus_float_t radians);

  102. MUS_EXPORT mus_float_t mus_hz_to_radians(mus_float_t hz);

  103. MUS_EXPORT mus_float_t mus_degrees_to_radians(mus_float_t degrees);

  104. MUS_EXPORT mus_float_t mus_radians_to_degrees(mus_float_t radians);

  105. MUS_EXPORT mus_float_t mus_db_to_linear(mus_float_t x);

  106. MUS_EXPORT mus_float_t mus_linear_to_db(mus_float_t x);

  107. MUS_EXPORT mus_float_t mus_odd_multiple(mus_float_t x, mus_float_t y);

  108. MUS_EXPORT mus_float_t mus_even_multiple(mus_float_t x, mus_float_t y);

  109. MUS_EXPORT mus_float_t mus_odd_weight(mus_float_t x);

  110. MUS_EXPORT mus_float_t mus_even_weight(mus_float_t x);

  111. 

  112. MUS_EXPORT mus_float_t mus_srate(void);

  113. MUS_EXPORT mus_float_t mus_set_srate(mus_float_t val);

  114. MUS_EXPORT mus_long_t mus_seconds_to_samples(mus_float_t secs);

  115. MUS_EXPORT mus_float_t mus_samples_to_seconds(mus_long_t samps);

  116. MUS_EXPORT int mus_array_print_length(void);

  117. MUS_EXPORT int mus_set_array_print_length(int val);

  118. MUS_EXPORT mus_float_t mus_float_equal_fudge_factor(void);

  119. MUS_EXPORT mus_float_t mus_set_float_equal_fudge_factor(mus_float_t val);

  120. 

  121. MUS_EXPORT mus_float_t mus_ring_modulate(mus_float_t s1, mus_float_t s2);

  122. MUS_EXPORT mus_float_t mus_amplitude_modulate(mus_float_t s1, mus_float_t s2, mus_float_t s3);

  123. MUS_EXPORT mus_float_t mus_contrast_enhancement(mus_float_t sig, mus_float_t index);

  124. MUS_EXPORT mus_float_t mus_dot_product(mus_float_t *data1, mus_float_t *data2, mus_long_t size);

  125. #if HAVE_COMPLEX_TRIG

  126.   MUS_EXPORT complex double mus_edot_product(complex double freq, complex double *data, mus_long_t size);

  127. #endif

  128. 

  129. MUS_EXPORT bool mus_arrays_are_equal(mus_float_t *arr1, mus_float_t *arr2, mus_float_t fudge, mus_long_t len);

  130. MUS_EXPORT mus_float_t mus_polynomial(mus_float_t *coeffs, mus_float_t x, int ncoeffs);

  131. MUS_EXPORT void mus_rectangular_to_polar(mus_float_t *rl, mus_float_t *im, mus_long_t size);

  132. MUS_EXPORT void mus_rectangular_to_magnitudes(mus_float_t *rl, mus_float_t *im, mus_long_t size);

  133. MUS_EXPORT void mus_polar_to_rectangular(mus_float_t *rl, mus_float_t *im, mus_long_t size);

  134. MUS_EXPORT mus_float_t mus_array_interp(mus_float_t *wave, mus_float_t phase, mus_long_t size);

  135. MUS_EXPORT mus_float_t mus_bessi0(mus_float_t x);

  136. 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);

  137. MUS_EXPORT bool mus_is_interp_type(int val);

  138. MUS_EXPORT bool mus_is_fft_window(int val);

  139. 

  140. MUS_EXPORT int mus_sample_type_zero(mus_sample_t samp_type);

  141. MUS_EXPORT mus_float_t (*mus_run_function(mus_any *g))(mus_any *gen, mus_float_t arg1, mus_float_t arg2);

  142. 

  143. 

  144. /* -------- generic functions -------- */

  145. 

  146. MUS_EXPORT int mus_type(mus_any *ptr);

  147. MUS_EXPORT void mus_free(mus_any *ptr);

  148. MUS_EXPORT char *mus_describe(mus_any *gen);

  149. MUS_EXPORT bool mus_equalp(mus_any *g1, mus_any *g2);

  150. MUS_EXPORT mus_float_t mus_phase(mus_any *gen);

  151. MUS_EXPORT mus_float_t mus_set_phase(mus_any *gen, mus_float_t val);

  152. MUS_EXPORT mus_float_t mus_set_frequency(mus_any *gen, mus_float_t val);

  153. MUS_EXPORT mus_float_t mus_frequency(mus_any *gen);

  154. MUS_EXPORT mus_float_t mus_run(mus_any *gen, mus_float_t arg1, mus_float_t arg2);

  155. MUS_EXPORT mus_long_t mus_length(mus_any *gen);

  156. MUS_EXPORT mus_long_t mus_set_length(mus_any *gen, mus_long_t len);

  157. MUS_EXPORT mus_long_t mus_order(mus_any *gen);

  158. MUS_EXPORT mus_float_t *mus_data(mus_any *gen);

  159. MUS_EXPORT mus_float_t *mus_set_data(mus_any *gen, mus_float_t *data);

  160. MUS_EXPORT const char *mus_name(mus_any *ptr);

  161. MUS_EXPORT mus_float_t mus_scaler(mus_any *gen);

  162. MUS_EXPORT mus_float_t mus_set_scaler(mus_any *gen, mus_float_t val);

  163. MUS_EXPORT mus_float_t mus_offset(mus_any *gen);

  164. MUS_EXPORT mus_float_t mus_set_offset(mus_any *gen, mus_float_t val);

  165. MUS_EXPORT mus_float_t mus_width(mus_any *gen);

  166. MUS_EXPORT mus_float_t mus_set_width(mus_any *gen, mus_float_t val);

  167. MUS_EXPORT char *mus_file_name(mus_any *ptr);

  168. MUS_EXPORT void mus_reset(mus_any *ptr);

  169. MUS_EXPORT mus_any *mus_copy(mus_any *gen);

  170. MUS_EXPORT mus_float_t *mus_xcoeffs(mus_any *ptr);

  171. MUS_EXPORT mus_float_t *mus_ycoeffs(mus_any *ptr);

  172. MUS_EXPORT mus_float_t mus_xcoeff(mus_any *ptr, int index);

  173. MUS_EXPORT mus_float_t mus_set_xcoeff(mus_any *ptr, int index, mus_float_t val);

  174. MUS_EXPORT mus_float_t mus_ycoeff(mus_any *ptr, int index);

  175. MUS_EXPORT mus_float_t mus_set_ycoeff(mus_any *ptr, int index, mus_float_t val);

  176. MUS_EXPORT mus_float_t mus_increment(mus_any *rd);

  177. MUS_EXPORT mus_float_t mus_set_increment(mus_any *rd, mus_float_t dir);

  178. MUS_EXPORT mus_long_t mus_location(mus_any *rd);

  179. MUS_EXPORT mus_long_t mus_set_location(mus_any *rd, mus_long_t loc);

  180. MUS_EXPORT int mus_channel(mus_any *rd);

  181. MUS_EXPORT int mus_channels(mus_any *ptr);

  182. MUS_EXPORT int mus_position(mus_any *ptr); /* only C, envs (snd-env.c), shares slot with mus_channels */

  183. MUS_EXPORT int mus_interp_type(mus_any *ptr);

  184. MUS_EXPORT mus_long_t mus_ramp(mus_any *ptr);

  185. MUS_EXPORT mus_long_t mus_set_ramp(mus_any *ptr, mus_long_t val);

  186. MUS_EXPORT mus_long_t mus_hop(mus_any *ptr);

  187. MUS_EXPORT mus_long_t mus_set_hop(mus_any *ptr, mus_long_t val);

  188. MUS_EXPORT mus_float_t mus_feedforward(mus_any *gen);

  189. MUS_EXPORT mus_float_t mus_set_feedforward(mus_any *gen, mus_float_t val);

  190. MUS_EXPORT mus_float_t mus_feedback(mus_any *rd);

  191. MUS_EXPORT mus_float_t mus_set_feedback(mus_any *rd, mus_float_t dir);

  192. 

  193. 

  194. /* -------- generators -------- */

  195. 

  196. MUS_EXPORT mus_float_t mus_oscil(mus_any *o, mus_float_t fm, mus_float_t pm);

  197. MUS_EXPORT mus_float_t mus_oscil_unmodulated(mus_any *ptr);

  198. MUS_EXPORT mus_float_t mus_oscil_fm(mus_any *ptr, mus_float_t fm);

  199. MUS_EXPORT mus_float_t mus_oscil_pm(mus_any *ptr, mus_float_t pm);

  200. MUS_EXPORT bool mus_is_oscil(mus_any *ptr);

  201. MUS_EXPORT mus_any *mus_make_oscil(mus_float_t freq, mus_float_t phase);

  202. 

  203. MUS_EXPORT bool mus_is_oscil_bank(mus_any *ptr);

  204. MUS_EXPORT mus_float_t mus_oscil_bank(mus_any *ptr);

  205. MUS_EXPORT mus_any *mus_make_oscil_bank(int size, mus_float_t *freqs, mus_float_t *phases, mus_float_t *amps, bool stable);

  206. 

  207. MUS_EXPORT mus_any *mus_make_ncos(mus_float_t freq, int n);

  208. MUS_EXPORT mus_float_t mus_ncos(mus_any *ptr, mus_float_t fm);

  209. MUS_EXPORT bool mus_is_ncos(mus_any *ptr);

  210. 

  211. MUS_EXPORT mus_any *mus_make_nsin(mus_float_t freq, int n);

  212. MUS_EXPORT mus_float_t mus_nsin(mus_any *ptr, mus_float_t fm);

  213. MUS_EXPORT bool mus_is_nsin(mus_any *ptr);

  214. 

  215. MUS_EXPORT mus_any *mus_make_nrxysin(mus_float_t frequency, mus_float_t y_over_x, int n, mus_float_t r);

  216. MUS_EXPORT mus_float_t mus_nrxysin(mus_any *ptr, mus_float_t fm);

  217. MUS_EXPORT bool mus_is_nrxysin(mus_any *ptr);

  218. 

  219. MUS_EXPORT mus_any *mus_make_nrxycos(mus_float_t frequency, mus_float_t y_over_x, int n, mus_float_t r);

  220. MUS_EXPORT mus_float_t mus_nrxycos(mus_any *ptr, mus_float_t fm);

  221. MUS_EXPORT bool mus_is_nrxycos(mus_any *ptr);

  222. 

  223. MUS_EXPORT mus_any *mus_make_rxykcos(mus_float_t freq, mus_float_t phase, mus_float_t r, mus_float_t ratio);

  224. MUS_EXPORT mus_float_t mus_rxykcos(mus_any *ptr, mus_float_t fm);

  225. MUS_EXPORT bool mus_is_rxykcos(mus_any *ptr);

  226. 

  227. MUS_EXPORT mus_any *mus_make_rxyksin(mus_float_t freq, mus_float_t phase, mus_float_t r, mus_float_t ratio);

  228. MUS_EXPORT mus_float_t mus_rxyksin(mus_any *ptr, mus_float_t fm);

  229. MUS_EXPORT bool mus_is_rxyksin(mus_any *ptr);

  230. 

  231. MUS_EXPORT mus_float_t mus_delay(mus_any *gen, mus_float_t input, mus_float_t pm);

  232. MUS_EXPORT mus_float_t mus_delay_unmodulated(mus_any *ptr, mus_float_t input);

  233. MUS_EXPORT mus_float_t mus_tap(mus_any *gen, mus_float_t loc);

  234. MUS_EXPORT mus_float_t mus_tap_unmodulated(mus_any *gen);

  235. MUS_EXPORT mus_any *mus_make_delay(int size, mus_float_t *line, int line_size, mus_interp_t type);

  236. MUS_EXPORT bool mus_is_delay(mus_any *ptr);

  237. MUS_EXPORT bool mus_is_tap(mus_any *ptr);

  238. MUS_EXPORT mus_float_t mus_delay_tick(mus_any *ptr, mus_float_t input);

  239. MUS_EXPORT mus_float_t mus_delay_unmodulated_noz(mus_any *ptr, mus_float_t input);

  240. 

  241. MUS_EXPORT mus_float_t mus_comb(mus_any *gen, mus_float_t input, mus_float_t pm);

  242. MUS_EXPORT mus_float_t mus_comb_unmodulated(mus_any *gen, mus_float_t input);

  243. MUS_EXPORT mus_any *mus_make_comb(mus_float_t scaler, int size, mus_float_t *line, int line_size, mus_interp_t type);

  244. MUS_EXPORT bool mus_is_comb(mus_any *ptr);

  245. MUS_EXPORT mus_float_t mus_comb_unmodulated_noz(mus_any *ptr, mus_float_t input);

  246. 

  247. MUS_EXPORT mus_float_t mus_comb_bank(mus_any *bank, mus_float_t inval);

  248. MUS_EXPORT mus_any *mus_make_comb_bank(int size, mus_any **combs);

  249. MUS_EXPORT bool mus_is_comb_bank(mus_any *g);

  250. 

  251. MUS_EXPORT mus_float_t mus_notch(mus_any *gen, mus_float_t input, mus_float_t pm);

  252. MUS_EXPORT mus_float_t mus_notch_unmodulated(mus_any *gen, mus_float_t input);

  253. MUS_EXPORT mus_any *mus_make_notch(mus_float_t scaler, int size, mus_float_t *line, int line_size, mus_interp_t type);

  254. MUS_EXPORT bool mus_is_notch(mus_any *ptr);

  255. 

  256. MUS_EXPORT mus_float_t mus_all_pass(mus_any *gen, mus_float_t input, mus_float_t pm);

  257. MUS_EXPORT mus_float_t mus_all_pass_unmodulated(mus_any *gen, mus_float_t input);

  258. 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);

  259. MUS_EXPORT bool mus_is_all_pass(mus_any *ptr);

  260. MUS_EXPORT mus_float_t mus_all_pass_unmodulated_noz(mus_any *ptr, mus_float_t input);

  261. 

  262. MUS_EXPORT mus_float_t mus_all_pass_bank(mus_any *bank, mus_float_t inval);

  263. MUS_EXPORT mus_any *mus_make_all_pass_bank(int size, mus_any **combs);

  264. MUS_EXPORT bool mus_is_all_pass_bank(mus_any *g);

  265. 

  266. MUS_EXPORT mus_any *mus_make_moving_average(int size, mus_float_t *line);

  267. MUS_EXPORT mus_any *mus_make_moving_average_with_initial_sum(int size, mus_float_t *line, mus_float_t sum);

  268. MUS_EXPORT bool mus_is_moving_average(mus_any *ptr);

  269. MUS_EXPORT mus_float_t mus_moving_average(mus_any *ptr, mus_float_t input);

  270. 

  271. MUS_EXPORT mus_any *mus_make_moving_max(int size, mus_float_t *line);

  272. MUS_EXPORT bool mus_is_moving_max(mus_any *ptr);

  273. MUS_EXPORT mus_float_t mus_moving_max(mus_any *ptr, mus_float_t input);

  274. 

  275. MUS_EXPORT mus_any *mus_make_moving_norm(int size, mus_float_t *line, mus_float_t norm);

  276. MUS_EXPORT bool mus_is_moving_norm(mus_any *ptr);

  277. MUS_EXPORT mus_float_t mus_moving_norm(mus_any *ptr, mus_float_t input);

  278. 

  279. MUS_EXPORT mus_float_t mus_table_lookup(mus_any *gen, mus_float_t fm);

  280. MUS_EXPORT mus_float_t mus_table_lookup_unmodulated(mus_any *gen);

  281. 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);

  282. MUS_EXPORT bool mus_is_table_lookup(mus_any *ptr);

  283. 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);

  284. 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);

  285. 

  286. MUS_EXPORT mus_float_t mus_sawtooth_wave(mus_any *gen, mus_float_t fm);

  287. MUS_EXPORT mus_any *mus_make_sawtooth_wave(mus_float_t freq, mus_float_t amp, mus_float_t phase);

  288. MUS_EXPORT bool mus_is_sawtooth_wave(mus_any *gen);

  289. 

  290. MUS_EXPORT mus_float_t mus_square_wave(mus_any *gen, mus_float_t fm);

  291. MUS_EXPORT mus_any *mus_make_square_wave(mus_float_t freq, mus_float_t amp, mus_float_t phase);

  292. MUS_EXPORT bool mus_is_square_wave(mus_any *gen);

  293. 

  294. MUS_EXPORT mus_float_t mus_triangle_wave(mus_any *gen, mus_float_t fm);

  295. MUS_EXPORT mus_any *mus_make_triangle_wave(mus_float_t freq, mus_float_t amp, mus_float_t phase);

  296. MUS_EXPORT bool mus_is_triangle_wave(mus_any *gen);

  297. MUS_EXPORT mus_float_t mus_triangle_wave_unmodulated(mus_any *ptr);

  298.  

  299. MUS_EXPORT mus_float_t mus_pulse_train(mus_any *gen, mus_float_t fm);

  300. MUS_EXPORT mus_any *mus_make_pulse_train(mus_float_t freq, mus_float_t amp, mus_float_t phase);

  301. MUS_EXPORT bool mus_is_pulse_train(mus_any *gen);

  302. MUS_EXPORT mus_float_t mus_pulse_train_unmodulated(mus_any *ptr);

  303. 

  304. MUS_EXPORT void mus_set_rand_seed(unsigned long seed);

  305. MUS_EXPORT unsigned long mus_rand_seed(void);

  306. MUS_EXPORT mus_float_t mus_random(mus_float_t amp);

  307. MUS_EXPORT mus_float_t mus_frandom(mus_float_t amp);

  308. MUS_EXPORT int mus_irandom(int amp);

  309. 

  310. MUS_EXPORT mus_float_t mus_rand(mus_any *gen, mus_float_t fm);

  311. MUS_EXPORT mus_any *mus_make_rand(mus_float_t freq, mus_float_t base);

  312. MUS_EXPORT bool mus_is_rand(mus_any *ptr);

  313. MUS_EXPORT mus_any *mus_make_rand_with_distribution(mus_float_t freq, mus_float_t base, mus_float_t *distribution, int distribution_size);

  314. 

  315. MUS_EXPORT mus_float_t mus_rand_interp(mus_any *gen, mus_float_t fm);

  316. MUS_EXPORT mus_any *mus_make_rand_interp(mus_float_t freq, mus_float_t base);

  317. MUS_EXPORT bool mus_is_rand_interp(mus_any *ptr);

  318. 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);

  319. MUS_EXPORT mus_float_t mus_rand_interp_unmodulated(mus_any *ptr);

  320. MUS_EXPORT mus_float_t mus_rand_unmodulated(mus_any *ptr);

  321. 

  322. MUS_EXPORT mus_float_t mus_asymmetric_fm(mus_any *gen, mus_float_t index, mus_float_t fm);

  323. MUS_EXPORT mus_float_t mus_asymmetric_fm_unmodulated(mus_any *gen, mus_float_t index);

  324. MUS_EXPORT mus_any *mus_make_asymmetric_fm(mus_float_t freq, mus_float_t phase, mus_float_t r, mus_float_t ratio);

  325. MUS_EXPORT bool mus_is_asymmetric_fm(mus_any *ptr);

  326. 

  327. MUS_EXPORT mus_float_t mus_one_zero(mus_any *gen, mus_float_t input);

  328. MUS_EXPORT mus_any *mus_make_one_zero(mus_float_t a0, mus_float_t a1);

  329. MUS_EXPORT bool mus_is_one_zero(mus_any *gen);

  330. 

  331. MUS_EXPORT mus_float_t mus_one_pole(mus_any *gen, mus_float_t input);

  332. MUS_EXPORT mus_any *mus_make_one_pole(mus_float_t a0, mus_float_t b1);

  333. MUS_EXPORT bool mus_is_one_pole(mus_any *gen);

  334. 

  335. MUS_EXPORT mus_float_t mus_two_zero(mus_any *gen, mus_float_t input);

  336. MUS_EXPORT mus_any *mus_make_two_zero(mus_float_t a0, mus_float_t a1, mus_float_t a2);

  337. MUS_EXPORT bool mus_is_two_zero(mus_any *gen);

  338. MUS_EXPORT mus_any *mus_make_two_zero_from_frequency_and_radius(mus_float_t frequency, mus_float_t radius);

  339. 

  340. MUS_EXPORT mus_float_t mus_two_pole(mus_any *gen, mus_float_t input);

  341. MUS_EXPORT mus_any *mus_make_two_pole(mus_float_t a0, mus_float_t b1, mus_float_t b2);

  342. MUS_EXPORT bool mus_is_two_pole(mus_any *gen);

  343. MUS_EXPORT mus_any *mus_make_two_pole_from_frequency_and_radius(mus_float_t frequency, mus_float_t radius);

  344. 

  345. MUS_EXPORT mus_float_t mus_one_pole_all_pass(mus_any *f, mus_float_t input);

  346. MUS_EXPORT mus_any *mus_make_one_pole_all_pass(int size, mus_float_t coeff);

  347. MUS_EXPORT bool mus_is_one_pole_all_pass(mus_any *ptr);

  348. 

  349. MUS_EXPORT mus_float_t mus_formant(mus_any *ptr, mus_float_t input); 

  350. MUS_EXPORT mus_any *mus_make_formant(mus_float_t frequency, mus_float_t radius);

  351. MUS_EXPORT bool mus_is_formant(mus_any *ptr);

  352. MUS_EXPORT mus_float_t mus_set_formant_frequency(mus_any *ptr, mus_float_t freq_in_hz);

  353. MUS_EXPORT void mus_set_formant_radius_and_frequency(mus_any *ptr, mus_float_t radius, mus_float_t frequency);

  354. MUS_EXPORT mus_float_t mus_formant_with_frequency(mus_any *ptr, mus_float_t input, mus_float_t freq_in_radians);

  355. 

  356. MUS_EXPORT mus_float_t mus_formant_bank(mus_any *bank, mus_float_t inval);

  357. MUS_EXPORT mus_float_t mus_formant_bank_with_inputs(mus_any *bank, mus_float_t *inval);

  358. MUS_EXPORT mus_any *mus_make_formant_bank(int size, mus_any **formants, mus_float_t *amps);

  359. MUS_EXPORT bool mus_is_formant_bank(mus_any *g);

  360. 

  361. MUS_EXPORT mus_float_t mus_firmant(mus_any *ptr, mus_float_t input);

  362. MUS_EXPORT mus_any *mus_make_firmant(mus_float_t frequency, mus_float_t radius);

  363. MUS_EXPORT bool mus_is_firmant(mus_any *ptr);

  364. MUS_EXPORT mus_float_t mus_firmant_with_frequency(mus_any *ptr, mus_float_t input, mus_float_t freq_in_radians);

  365. 

  366. MUS_EXPORT mus_float_t mus_filter(mus_any *ptr, mus_float_t input);

  367. MUS_EXPORT mus_any *mus_make_filter(int order, mus_float_t *xcoeffs, mus_float_t *ycoeffs, mus_float_t *state);

  368. MUS_EXPORT bool mus_is_filter(mus_any *ptr);

  369. 

  370. MUS_EXPORT mus_float_t mus_fir_filter(mus_any *ptr, mus_float_t input);

  371. MUS_EXPORT mus_any *mus_make_fir_filter(int order, mus_float_t *xcoeffs, mus_float_t *state);

  372. MUS_EXPORT bool mus_is_fir_filter(mus_any *ptr);

  373. 

  374. MUS_EXPORT mus_float_t mus_iir_filter(mus_any *ptr, mus_float_t input);

  375. MUS_EXPORT mus_any *mus_make_iir_filter(int order, mus_float_t *ycoeffs, mus_float_t *state);

  376. MUS_EXPORT bool mus_is_iir_filter(mus_any *ptr);

  377. MUS_EXPORT mus_float_t *mus_make_fir_coeffs(int order, mus_float_t *env, mus_float_t *aa);

  378. 

  379. MUS_EXPORT mus_float_t *mus_filter_set_xcoeffs(mus_any *ptr, mus_float_t *new_data);

  380. MUS_EXPORT mus_float_t *mus_filter_set_ycoeffs(mus_any *ptr, mus_float_t *new_data);

  381. MUS_EXPORT int mus_filter_set_order(mus_any *ptr, int order);

  382. 

  383. MUS_EXPORT mus_float_t mus_filtered_comb(mus_any *ptr, mus_float_t input, mus_float_t pm);

  384. MUS_EXPORT mus_float_t mus_filtered_comb_unmodulated(mus_any *ptr, mus_float_t input);

  385. MUS_EXPORT bool mus_is_filtered_comb(mus_any *ptr);

  386. 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);

  387. 

  388. MUS_EXPORT mus_float_t mus_filtered_comb_bank(mus_any *bank, mus_float_t inval);

  389. MUS_EXPORT mus_any *mus_make_filtered_comb_bank(int size, mus_any **combs);

  390. MUS_EXPORT bool mus_is_filtered_comb_bank(mus_any *g);

  391. 

  392. MUS_EXPORT mus_float_t mus_wave_train(mus_any *gen, mus_float_t fm);

  393. MUS_EXPORT mus_float_t mus_wave_train_unmodulated(mus_any *gen);

  394. 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);

  395. MUS_EXPORT bool mus_is_wave_train(mus_any *gen);

  396. 

  397. MUS_EXPORT mus_float_t *mus_partials_to_polynomial(int npartials, mus_float_t *partials, mus_polynomial_t kind);

  398. MUS_EXPORT mus_float_t *mus_normalize_partials(int num_partials, mus_float_t *partials);

  399. 

  400. MUS_EXPORT mus_any *mus_make_polyshape(mus_float_t frequency, mus_float_t phase, mus_float_t *coeffs, int size, int cheby_choice);

  401. MUS_EXPORT mus_float_t mus_polyshape(mus_any *ptr, mus_float_t index, mus_float_t fm);

  402. MUS_EXPORT mus_float_t mus_polyshape_unmodulated(mus_any *ptr, mus_float_t index);

  403. #define mus_polyshape_no_input(Obj) mus_polyshape(Obj, 1.0, 0.0)

  404. MUS_EXPORT bool mus_is_polyshape(mus_any *ptr);

  405. 

  406. MUS_EXPORT mus_any *mus_make_polywave(mus_float_t frequency, mus_float_t *coeffs, int n, int cheby_choice);

  407. MUS_EXPORT mus_any *mus_make_polywave_tu(mus_float_t frequency, mus_float_t *tcoeffs, mus_float_t *ucoeffs, int n);

  408. MUS_EXPORT bool mus_is_polywave(mus_any *ptr);

  409. MUS_EXPORT mus_float_t mus_polywave_unmodulated(mus_any *ptr);

  410. MUS_EXPORT mus_float_t mus_polywave(mus_any *ptr, mus_float_t fm);

  411. MUS_EXPORT mus_float_t mus_chebyshev_t_sum(mus_float_t x, int n, mus_float_t *tn);

  412. MUS_EXPORT mus_float_t mus_chebyshev_u_sum(mus_float_t x, int n, mus_float_t *un);

  413. MUS_EXPORT mus_float_t mus_chebyshev_tu_sum(mus_float_t x, int n, mus_float_t *tn, mus_float_t *un);

  414. MUS_EXPORT mus_float_t (*mus_polywave_function(mus_any *g))(mus_any *gen, mus_float_t fm);

  415. 

  416. MUS_EXPORT mus_float_t mus_env(mus_any *ptr);

  417. 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, 

  418. 				 mus_float_t duration, mus_long_t end, mus_float_t *odata);

  419. MUS_EXPORT bool mus_is_env(mus_any *ptr);

  420. MUS_EXPORT mus_float_t mus_env_interp(mus_float_t x, mus_any *env);

  421. MUS_EXPORT mus_long_t *mus_env_passes(mus_any *gen);        /* for Snd */

  422. MUS_EXPORT mus_float_t *mus_env_rates(mus_any *gen);        /* for Snd */

  423. MUS_EXPORT mus_float_t mus_env_offset(mus_any *gen);        /* for Snd */

  424. MUS_EXPORT mus_float_t mus_env_scaler(mus_any *gen);        /* for Snd */

  425. MUS_EXPORT mus_float_t mus_env_initial_power(mus_any *gen); /* for Snd */

  426. MUS_EXPORT int mus_env_breakpoints(mus_any *gen);      /* for Snd */

  427. MUS_EXPORT mus_float_t mus_env_any(mus_any *e, mus_float_t (*connect_points)(mus_float_t val));

  428. MUS_EXPORT mus_float_t (*mus_env_function(mus_any *g))(mus_any *gen);

  429. 

  430. MUS_EXPORT mus_any *mus_make_pulsed_env(mus_any *e, mus_any *p);

  431. MUS_EXPORT bool mus_is_pulsed_env(mus_any *ptr);

  432. MUS_EXPORT mus_float_t mus_pulsed_env(mus_any *pl, mus_float_t inval);

  433. MUS_EXPORT mus_float_t mus_pulsed_env_unmodulated(mus_any *pl);

  434. 

  435. MUS_EXPORT bool mus_is_file_to_sample(mus_any *ptr);

  436. MUS_EXPORT mus_any *mus_make_file_to_sample(const char *filename);

  437. MUS_EXPORT mus_any *mus_make_file_to_sample_with_buffer_size(const char *filename, mus_long_t buffer_size);

  438. MUS_EXPORT mus_float_t mus_file_to_sample(mus_any *ptr, mus_long_t samp, int chan);

  439. 

  440. MUS_EXPORT mus_float_t mus_readin(mus_any *rd);

  441. 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);

  442. #define mus_make_readin(Filename, Chan, Start, Direction) mus_make_readin_with_buffer_size(Filename, Chan, Start, Direction, mus_file_buffer_size())

  443. MUS_EXPORT bool mus_is_readin(mus_any *ptr);

  444. 

  445. MUS_EXPORT bool mus_is_output(mus_any *ptr);

  446. MUS_EXPORT bool mus_is_input(mus_any *ptr);

  447. MUS_EXPORT mus_float_t mus_in_any(mus_long_t frample, int chan, mus_any *IO);

  448. MUS_EXPORT bool mus_in_any_is_safe(mus_any *IO);

  449. 

  450.   /* new 6.0 */

  451. MUS_EXPORT mus_float_t *mus_file_to_frample(mus_any *ptr, mus_long_t samp, mus_float_t *f);

  452. MUS_EXPORT mus_any *mus_make_file_to_frample(const char *filename);

  453. MUS_EXPORT bool mus_is_file_to_frample(mus_any *ptr);

  454. MUS_EXPORT mus_any *mus_make_file_to_frample_with_buffer_size(const char *filename, mus_long_t buffer_size);

  455. 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);

  456. 

  457. MUS_EXPORT bool mus_is_frample_to_file(mus_any *ptr);

  458. MUS_EXPORT mus_float_t *mus_frample_to_file(mus_any *ptr, mus_long_t samp, mus_float_t *data);

  459. 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);

  460. #define mus_make_frample_to_file(Filename, Chans, SampType, HeadType) mus_make_frample_to_file_with_comment(Filename, Chans, SampType, HeadType, NULL)

  461. MUS_EXPORT mus_any *mus_continue_frample_to_file(const char *filename);

  462. 

  463. MUS_EXPORT void mus_file_mix_with_reader_and_writer(mus_any *outf, mus_any *inf,

  464. 						    mus_long_t out_start, mus_long_t out_framples, mus_long_t in_start, 

  465. 						    mus_float_t *mx, int mx_chans, mus_any ***envs);

  466. MUS_EXPORT void mus_file_mix(const char *outfile, const char *infile, 

  467. 			     mus_long_t out_start, mus_long_t out_framples, mus_long_t in_start, 

  468. 			     mus_float_t *mx, int mx_chans, mus_any ***envs);

  469. 

  470. MUS_EXPORT bool mus_is_sample_to_file(mus_any *ptr);

  471. 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);

  472. #define mus_make_sample_to_file(Filename, Chans, SampType, HeadType) mus_make_sample_to_file_with_comment(Filename, Chans, SampType, HeadType, NULL)

  473. MUS_EXPORT mus_float_t mus_sample_to_file(mus_any *ptr, mus_long_t samp, int chan, mus_float_t val);

  474. MUS_EXPORT mus_any *mus_continue_sample_to_file(const char *filename);

  475. MUS_EXPORT int mus_close_file(mus_any *ptr);

  476. MUS_EXPORT mus_any *mus_sample_to_file_add(mus_any *out1, mus_any *out2);

  477. 

  478. MUS_EXPORT mus_float_t mus_out_any(mus_long_t frample, mus_float_t val, int chan, mus_any *IO);

  479. MUS_EXPORT mus_float_t mus_safe_out_any_to_file(mus_long_t samp, mus_float_t val, int chan, mus_any *IO);

  480. MUS_EXPORT bool mus_out_any_is_safe(mus_any *IO);

  481. MUS_EXPORT mus_float_t mus_out_any_to_file(mus_any *ptr, mus_long_t samp, int chan, mus_float_t val);

  482. 

  483. MUS_EXPORT void mus_locsig(mus_any *ptr, mus_long_t loc, mus_float_t val);

  484. MUS_EXPORT mus_any *mus_make_locsig(mus_float_t degree, mus_float_t distance, mus_float_t reverb, int chans, 

  485. 				    mus_any *output, int rev_chans, mus_any *revput, mus_interp_t type);

  486. MUS_EXPORT bool mus_is_locsig(mus_any *ptr);

  487. MUS_EXPORT mus_float_t mus_locsig_ref(mus_any *ptr, int chan);

  488. MUS_EXPORT mus_float_t mus_locsig_set(mus_any *ptr, int chan, mus_float_t val);

  489. MUS_EXPORT mus_float_t mus_locsig_reverb_ref(mus_any *ptr, int chan);

  490. MUS_EXPORT mus_float_t mus_locsig_reverb_set(mus_any *ptr, int chan, mus_float_t val);

  491. MUS_EXPORT void mus_move_locsig(mus_any *ptr, mus_float_t degree, mus_float_t distance);

  492. MUS_EXPORT mus_float_t *mus_locsig_outf(mus_any *ptr);

  493. MUS_EXPORT mus_float_t *mus_locsig_revf(mus_any *ptr);

  494. MUS_EXPORT void *mus_locsig_closure(mus_any *ptr);

  495. MUS_EXPORT void mus_locsig_set_detour(mus_any *ptr, void (*detour)(mus_any *ptr, mus_long_t val));

  496. MUS_EXPORT int mus_locsig_channels(mus_any *ptr);

  497. MUS_EXPORT int mus_locsig_reverb_channels(mus_any *ptr);

  498. 

  499. MUS_EXPORT bool mus_is_move_sound(mus_any *ptr);

  500. MUS_EXPORT mus_float_t mus_move_sound(mus_any *ptr, mus_long_t loc, mus_float_t val);

  501. MUS_EXPORT mus_any *mus_make_move_sound(mus_long_t start, mus_long_t end, int out_channels, int rev_channels,

  502. 					mus_any *doppler_delay, mus_any *doppler_env, mus_any *rev_env,

  503. 					mus_any **out_delays, mus_any **out_envs, mus_any **rev_envs,

  504. 					int *out_map, mus_any *output, mus_any *revput, bool free_arrays, bool free_gens);

  505. MUS_EXPORT mus_float_t *mus_move_sound_outf(mus_any *ptr);

  506. MUS_EXPORT mus_float_t *mus_move_sound_revf(mus_any *ptr);

  507. MUS_EXPORT void *mus_move_sound_closure(mus_any *ptr);

  508. MUS_EXPORT void mus_move_sound_set_detour(mus_any *ptr, void (*detour)(mus_any *ptr, mus_long_t val));

  509. MUS_EXPORT int mus_move_sound_channels(mus_any *ptr);

  510. MUS_EXPORT int mus_move_sound_reverb_channels(mus_any *ptr);

  511. 

  512. MUS_EXPORT mus_any *mus_make_src(mus_float_t (*input)(void *arg, int direction), mus_float_t srate, int width, void *closure);

  513. 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));

  514. MUS_EXPORT mus_float_t mus_src(mus_any *srptr, mus_float_t sr_change, mus_float_t (*input)(void *arg, int direction));

  515. MUS_EXPORT bool mus_is_src(mus_any *ptr);

  516. MUS_EXPORT mus_float_t *mus_src_20(mus_any *srptr, mus_float_t *in_data, mus_long_t dur);

  517. MUS_EXPORT mus_float_t *mus_src_05(mus_any *srptr, mus_float_t *in_data, mus_long_t dur);

  518. 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);

  519. MUS_EXPORT void mus_src_init(mus_any *ptr);

  520. 

  521. MUS_EXPORT bool mus_is_convolve(mus_any *ptr);

  522. MUS_EXPORT mus_float_t mus_convolve(mus_any *ptr, mus_float_t (*input)(void *arg, int direction));

  523. 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);

  524. 

  525. MUS_EXPORT mus_float_t *mus_spectrum(mus_float_t *rdat, mus_float_t *idat, mus_float_t *window, mus_long_t n, mus_spectrum_t type);

  526. MUS_EXPORT void mus_fft(mus_float_t *rl, mus_float_t *im, mus_long_t n, int is);

  527. MUS_EXPORT mus_float_t *mus_make_fft_window(mus_fft_window_t type, mus_long_t size, mus_float_t beta);

  528. MUS_EXPORT mus_float_t *mus_make_fft_window_with_window(mus_fft_window_t type, mus_long_t size, mus_float_t beta, mus_float_t mu, mus_float_t *window);

  529. MUS_EXPORT const char *mus_fft_window_name(mus_fft_window_t win);

  530. MUS_EXPORT const char **mus_fft_window_names(void);

  531. 

  532. MUS_EXPORT mus_float_t *mus_autocorrelate(mus_float_t *data, mus_long_t n);

  533. MUS_EXPORT mus_float_t *mus_correlate(mus_float_t *data1, mus_float_t *data2, mus_long_t n);

  534. MUS_EXPORT mus_float_t *mus_convolution(mus_float_t *rl1, mus_float_t *rl2, mus_long_t n);

  535. MUS_EXPORT void mus_convolve_files(const char *file1, const char *file2, mus_float_t maxamp, const char *output_file);

  536. MUS_EXPORT mus_float_t *mus_cepstrum(mus_float_t *data, mus_long_t n);

  537. 

  538. MUS_EXPORT bool mus_is_granulate(mus_any *ptr);

  539. MUS_EXPORT mus_float_t mus_granulate(mus_any *ptr, mus_float_t (*input)(void *arg, int direction));

  540. MUS_EXPORT mus_float_t mus_granulate_with_editor(mus_any *ptr, mus_float_t (*input)(void *arg, int direction), int (*edit)(void *closure));

  541. MUS_EXPORT mus_any *mus_make_granulate(mus_float_t (*input)(void *arg, int direction), 

  542. 				       mus_float_t expansion, mus_float_t length, mus_float_t scaler, 

  543. 				       mus_float_t hop, mus_float_t ramp, mus_float_t jitter, int max_size, 

  544. 				       int (*edit)(void *closure),

  545. 				       void *closure);

  546. MUS_EXPORT int mus_granulate_grain_max_length(mus_any *ptr);

  547. MUS_EXPORT void mus_granulate_set_edit_function(mus_any *ptr, int (*edit)(void *closure));

  548. 

  549. MUS_EXPORT mus_long_t mus_set_file_buffer_size(mus_long_t size);

  550. MUS_EXPORT mus_long_t mus_file_buffer_size(void);

  551. 

  552. MUS_EXPORT mus_float_t mus_apply(mus_any *gen, mus_float_t f1, mus_float_t f2);

  553. 

  554. MUS_EXPORT bool mus_is_phase_vocoder(mus_any *ptr);

  555. MUS_EXPORT mus_any *mus_make_phase_vocoder(mus_float_t (*input)(void *arg, int direction), 

  556. 					   int fftsize, int overlap, int interp,

  557. 					   mus_float_t pitch,

  558. 					   bool (*analyze)(void *arg, mus_float_t (*input)(void *arg1, int direction)),

  559. 					   int (*edit)(void *arg), /* return value is ignored (int return type is intended to be consistent with granulate) */

  560. 					   mus_float_t (*synthesize)(void *arg), 

  561. 					   void *closure);

  562. MUS_EXPORT mus_float_t mus_phase_vocoder(mus_any *ptr, mus_float_t (*input)(void *arg, int direction));

  563. MUS_EXPORT mus_float_t mus_phase_vocoder_with_editors(mus_any *ptr, 

  564. 						mus_float_t (*input)(void *arg, int direction),

  565. 						bool (*analyze)(void *arg, mus_float_t (*input)(void *arg1, int direction)),

  566. 						int (*edit)(void *arg), 

  567. 						mus_float_t (*synthesize)(void *arg));

  568. 

  569. MUS_EXPORT mus_float_t *mus_phase_vocoder_amp_increments(mus_any *ptr);

  570. MUS_EXPORT mus_float_t *mus_phase_vocoder_amps(mus_any *ptr);

  571. MUS_EXPORT mus_float_t *mus_phase_vocoder_freqs(mus_any *ptr);

  572. MUS_EXPORT mus_float_t *mus_phase_vocoder_phases(mus_any *ptr);

  573. MUS_EXPORT mus_float_t *mus_phase_vocoder_phase_increments(mus_any *ptr);

  574. 

  575. 

  576. MUS_EXPORT mus_any *mus_make_ssb_am(mus_float_t freq, int order);

  577. MUS_EXPORT bool mus_is_ssb_am(mus_any *ptr);

  578. MUS_EXPORT mus_float_t mus_ssb_am_unmodulated(mus_any *ptr, mus_float_t insig);

  579. MUS_EXPORT mus_float_t mus_ssb_am(mus_any *ptr, mus_float_t insig, mus_float_t fm);

  580. 

  581. MUS_EXPORT void mus_clear_sinc_tables(void);

  582. MUS_EXPORT void *mus_environ(mus_any *gen);

  583. MUS_EXPORT void *mus_set_environ(mus_any *gen, void *e);

  584. MUS_EXPORT mus_any *mus_bank_generator(mus_any *g, int i);

  585. #ifdef __cplusplus

  586. }

  587. #endif

  588. 

  589. #endif

  590. 

  591. 

  592. /* Change log.

  593.  *

  594.  * 5-Aug:      removed some now-obsolete mus_locsig functions.

  595.  * 5-Jul:      added stable arg to mus_make_oscil_bank.

  596.  * 15-Feb:     removed mus_set_name, changed mus_free to void.

  597.  * 31-Jan-15:  removed mus_multiply_arrays.

  598.  * --------

  599.  * 8-Nov:      mus_copy, mus_bank_generator.

  600.  * 24-Oct:     mus_generator_set_feeders.

  601.  * 10-Aug:     data-format -> sample-type.

  602.  * 17-Apr:     moving_norm generator.

  603.  * 14-Apr:     mus_frame and mus_mixer removed, "frame" replaced by "frample" in IO functions.

  604.  * 11-Apr:     mus_even|odd_weight|multiple.

  605.  * 9-Apr:      deprecate mus_is_delay_line.

  606.  * 2-Apr:      mus_make_moving_average_with_sum.

  607.  * 19-Mar:     deprecate mus_make_env_with_length.

  608.  * 17-Feb-14:  mus_*_p -> mus_is_*.

  609.  * --------

  610.  * 7-Dec:      mus_set_formant_frequency, mus_src_20 and mus_src_05 changed.  Removed mus_in_any_from_file.

  611.  * 29-Nov:     mus_make_polywave_tu.

  612.  * 11-Oct:     mus_vector_to_file, mus_vector_mix.

  613.  * 19-Apr:     rxyk!cos and rxyk!sin from generators.scm.

  614.  * 11-Apr:     mus_tap_p as a better name for mus_delay_line_p.

  615.  * 27-Mar:     comb-bank, all-pass-bank, filtered-comb-bank, pulsed-env, oscil-bank.

  616.  * 21-Mar:     one-pole-all-pass generator.

  617.  * 14-Mar:     formant-bank generator.

  618.  *             removed mus_delay_tick_noz.

  619.  * 4-Mar:      moving_max generator.

  620.  *             removed the unstable filter check in make_two_pole.

  621.  * 21-Jan-13:  changed mus_formant_bank parameters.

  622.  * --------

  623.  * 22-Dec:     removed all the safety settings.

  624.  * 15-Nov:     removed mus_env_t, mus_env_type, and other recently deprecated stuff.

  625.  * 15-Jul:     more changes for clm2xen.

  626.  * 4-July-12:  moved various struct definitions to clm.c

  627.  *             added accessors for mus_any_class etc.

  628.  * --------

  629.  * 1-Sep:      mus_type.

  630.  * 20-Aug:     changed type of mus_locsig to void, added mus_locsig_function_reset.

  631.  *             removed function-as-output-location from locsig et al.

  632.  * 14-Jul-11:  removed pthread stuff.

  633.  * --------

  634.  * 7-Mar-10:   protect in-any and out-any from sample numbers less than 0.

  635.  * --------

  636.  * 14-Oct:     sine-summation, sum-of-sines, sum-of-cosines removed.

  637.  * 28-Aug:     changed some fft-related sizes from int to mus_long_t.

  638.  * 17-Aug:     mus_frame|mixer_copy|fill.

  639.  * 27-Jul:     mus_float_t for Float, and mus_long_t for off_t.

  640.  * 15-Jun:     mus_rectangular_to_magnitudes (polar, but ignore phases).

  641.  * 11-Jun:     mus_cepstrum.

  642.  * 11-May:     MUS_ENV_LINEAR and friends, also mus_env_linear|exponential.

  643.  *             mus_frame_to_frame_mono|stereo.

  644.  * 12-Mar:     sinc, papoulis and dpss (slepian windows).

  645.  * 1-Jan-09:   added MUS_EXPORT.

  646.  * --------

  647.  * 11-Dec:     deprecated the sine-summation, sum-of-cosines, and sum-of-sines generators.

  648.  * 30-Oct:     mus_sample_to_file_add.

  649.  *             mus_describe once again allocates a fresh output string.

  650.  *             finally removed sine-bank.

  651.  * 9-Oct:      various thread-related internal changes.

  652.  * 14-Jul:     mus_data_format_zero.

  653.  * 12-Jul:     mus_interp_type_p and mus_fft_window_p for C++'s benefit.

  654.  * 1-July:     mus-safety and various ints changed to mus_long_t.

  655.  * 20-Jun:     support for pthreads.

  656.  * 16-Jun:     changed init_mus_module to mus_initialize.

  657.  * 30-May:     changed polyshape to use cos and added cheby_choice arg to mus_make_polyshape.

  658.  * 27-May:     mus_waveshape retired -- generators.scm has a wrapper for it.

  659.  *             clm_free, clm_realloc etc for rt work.

  660.  *             mus_chebyshev_tu_sum.

  661.  * 25-May:     mus_polywave algorithm changed.

  662.  * 17-May:     mus_normalize_partials.

  663.  * 12-Apr:     added choice arg to mus_make_polywave.

  664.  * 8-Apr:      polywave uses sine-bank if highest harmonic out of Chebyshev range.

  665.  * 1-Mar:      mus_set_name.

  666.  * 26-Feb:     removed mus_cosines (use mus_length)

  667.  * 24-Feb:     removed mus_make_env_with_start, added mus_make_env_with_length

  668.  * 20-Feb:     clm 4:

  669.  *             polywave for polyshape and waveshape.  

  670.  *             mus_formant_with_frequency. 

  671.  *             firmant generator.

  672.  *             removed mus_formant_radius and mus_set_formant_radius.

  673.  *             removed "gain" arg from mus_make_formant.

  674.  *             reversed the order of the arguments to mus_make_formant.

  675.  *             fixed long-standing bug in gain calculation in mus_formant.

  676.  *             mus_env_any for arbitrary connecting functions.

  677.  * 15-Feb:     nrxysin and nrxycos for sine-summation.

  678.  * 12-Feb:     nsin for sum_of_sines, ncos for sum_of_cosines.

  679.  * 4-Feb:      clm_default_frequency (clm2xen) and *clm-default-frequency* (ws.scm).

  680.  * 7-Jan-08:   :dur replaced by :length in make-env.

  681.  * --------

  682.  * 19-Oct:     all *_0 *_1 *_2 names now use _fm|_pm|_unmodulated|_no_input.

  683.  * 17-Oct:     replace some method macros with functions (def-clm-struct local methods need true names).

  684.  * 15-Oct:     mus_oscil_1 -> _fm, _2->_pm.

  685.  *             mus_phase_vocoder_outctr accessors changed to use mus_location.

  686.  * 11-Oct:     changed default srate to 44100.

  687.  * 5-Oct:      mus_oscil_2.

  688.  * 6-Sep:      changed asymmetric-fm to use cos(sin) and added amplitude normalization.

  689.  * 6-Aug:      mus_autocorrelate, mus_correlate.

  690.  * 3-Aug:      blackman5..10 and Rife-Vincent (RV2..4 fft), mlt-sine windows.

  691.  * 16-July:    removed start arg from mus_make_env (see mus_make_env_with_start).

  692.  * 5-July:     changed some mus_float_ts to doubles in env funcs.

  693.  *               exp envs now use repeated multiplies rather than direct exp call.

  694.  * 19-June:    mus-increment on gens with a notion of frequency (phase increment); 

  695.  *               to make room for this, asymmetric-fm ratio and sine-summation b moved to mus-offset.

  696.  * 22-Feb:     mus_big_fft and mus_spectrum_t.

  697.  * 21-Feb:     mus_fft_window_name.

  698.  * 14-Feb-07:  three more fft window choices.

  699.  * --------

  700.  * 27-Nov:     move-sound array access parallel to locsig.

  701.  * 22-Nov:     had to add non-backwards-compatible reverb chans arg to mus_make_locsig.

  702.  * 21-Nov:     mus_float_equal_fudge_factor, mus_arrays_are_equal.

  703.  * 30-July:    renamed average to moving_average.

  704.  * 28-July:    renamed make_ppolar and make_zpolar to make_two_pole|zero_from_radius_and_frequency.

  705.  *             added mus_scaler and mus_frequency methods for two_pole and two_zero.

  706.  * 21-July:    removed mus_wrapper field -- old way can't work since we need the original Xen object.

  707.  * 3-July:     mus_move_sound (dlocsig) generator.

  708.  *             changed return type of mus_locsig to float.

  709.  * 28-June:    mus_filtered_comb generator.

  710.  * 8-May:      mus_apply now takes 3 args: gen, two doubles (rather than bug-prone varargs).

  711.  * 1-Mar-06:   granulate now has a local random number seed (settable via the mus-location method).

  712.  * --------

  713.  * 20-Dec:     samaraki and ultraspherical windows.

  714.  *               this required a non-backwards-compatible additional argument in mus_make_fft_window_with_window.

  715.  * 1-Nov:      mus_filter_set_x|ycoeffs, mus_filter_set_order (needed by Snd).

  716.  * 1-May:      mus-scaler|feedback ok with delay and average.

  717.  * 18-Apr:     mus_set_environ.

  718.  * 11-Apr:     mus_mixer|frame_offset, mus_frame_scale (for higher level generic functions).

  719.  * 23-Mar:     frame_to_frame arg interpretation changed.

  720.  * 21-Mar:     mus_make_readin|file_to_sample|file_to_frame_with_buffer_size.

  721.  * 16-Mar:     polyshape generator (waveshaper as polynomial + oscil)

  722.  *             mus_chebyshev_first|second_kind.

  723.  *             mus_partials_to_waveshape no longer normalizes the partials.

  724.  * 18-Feb:     mus_interpolate.

  725.  * 14-Feb:     deprecated mus_restart_env and mus_clear_filter_state.

  726.  * 7-Feb-05:   mus_reset method, replaces mus_restart_env and mus_clear_filter_state.

  727.  * --------

  728.  * 20-Dec:     changed "jitter" handling if hop < .05 in granulate.

  729.  * 15-Dec:     mus_generator? for type checks (clm2xen).

  730.  * 11-Sep:     removed buffer generator.

  731.  * 6-Sep:      removed mus_oscil_bank, mus_bank.

  732.  * 24-Aug:     removed mus_inspect method -- overlaps mus_describe and is useless given gdb capabilities.

  733.  * 27-July:    mus_granulate_with_editor and mus_phase_vocoder_with_editors.

  734.  * 21-July:    edit-func as run-time arg to granulate (for CL/clm compatibility)

  735.  * 19-July:    clm 3:

  736.  *             deprecated mus_ina|b, mus-outa|b|c|d.

  737.  *             mus_make_frame_to_file_with_comment, mus_mixer_scale, mus_make_frame|mixer_with_data.

  738.  *             mus_make_scalar_mixer, mus_mixer_add, mus_continue_frame_to_file.

  739.  *             changed pv_* to phase_vocoder_*

  740.  * 28-June:    ssb_am + added fm arg (ssb_am_1 is the previous form).

  741.  * 21-June:    wrapper method.

  742.  * 14-June:    ssb_am generator.

  743.  *             deprecated mus-a*|b*, replaced by mus-x|ycoeff.

  744.  * 9-June:     mus_edot_product.

  745.  * 7-June:     removed mus-x*|y* generic functions.

  746.  * 24-May:     distribution arg to make-rand, make-rand-interp.

  747.  * 11-May:     type arg to mus_make_table_lookup|wave_train, MUS_INTERP_NONE, MUS_INTERP_HERMITE.

  748.  *             mus-interp-type.

  749.  * 10-May:     changed MUS_LINEAR and MUS_SINUSOIDAL to MUS_INTERP_LINEAR and MUS_INTERP_SINUSOIDAL.

  750.  *             mus-linear renamed mus-interp-linear, mus-sinusoidal renamed mus-interp-sinusoidal.

  751.  *             added type arg to mus_make_delay|all_pass|comb|notch.

  752.  *             added mus_delay_tick, all-pass delay line interpolation.

  753.  * 3-May:      envelope arg to make-rand and make-rand-interp to give any arbitrary random number distribution.

  754.  *             added mus_make_rand_with_distribution and mus_make_rand_interp_with_distribution.

  755.  *             rand/rand-interp mus-data returns distribution (weight) function, mus-length its length.

  756.  *             locsig mus-data returns output scalers, mus-xcoeffs returns reverb scalers

  757.  * 26-Apr:     mus_sum_of_sines changed to mus_sine_bank.

  758.  *             new mus_sum_of_sines parallels mus_sum_of_cosines.

  759.  *             deprecated mus_sin.

  760.  * 14-Apr:     changed "2" to "_to_" in several function names.

  761.  * 12-Apr:     mus_average, mus_average_p, mus_make_average.

  762.  * 17-Mar:     edit function added to mus_granulate.

  763.  *             replaced MUS_DATA_POSITION with MUS_DATA_WRAPPER.

  764.  * 22-Jan:     various "environ" variables renamed for Windows' benefit.

  765.  * 5-Jan-04:   env_interp bugfix.

  766.  * --------

  767.  * 29-Sep:     removed length arg from spectrum in clm2xen.

  768.  * 24-Aug:     changed mus_length|ramp|hop type to mus_long_t.

  769.  * 21-Aug:     export MUS_INPUT and friends (needed for specialized INA handlers).

  770.  * 11-Aug:     int -> bool.

  771.  * 7-Aug:      removed mus_type.

  772.  * 20-July:    more run methods.

  773.  * 15-July:    linear->dB check for 0.0 arg.

  774.  * 27-June:    mus_samples_to_seconds and mus_seconds_to_samples.

  775.  * 9-June:     mus_mix_with_reader_and_writer.

  776.  * 27-May:     bugfix: interpolating all-pass ("zall-pass") had an extra delay.

  777.  * 25-Apr:     mus_spectrum and mus_convolution now return mus_float_t*.

  778.  * 9-Apr:      removed MUS_HANNING_WINDOW (use MUS_HANN_WINDOW).

  779.  * 3-Mar:      mus_delay_line_p for tap error checking.

  780.  * 27-Feb:     mus_length for env -> original duration in samples.

  781.  * 21-Feb:     mus_set_cosines added, mus_cosines moved to hop slot.

  782.  *             mus_[set_]x1/x2/y1/y2.

  783.  * 10-Feb:     mus_file_name moved into the mus_input|output structs.

  784.  *             folded mus_input|output into mus_any.

  785.  *             moved mus_frame|mixer declarations into clm.c.

  786.  *             all mus_input|output|frame|mixer pointers->mus_any.

  787.  *             all method void pointers->mus_any.

  788.  * 7-Feb:      split strings out of clm2xen.c into clm-strings.h.

  789.  * 3-Feb:      mus_offset for envs, mus_width for square_wave et al.

  790.  *             new core class fields(10) for various methods.

  791.  * 7-Jan-03:   mus_src with very large sr_change segfault bugfix.

  792.  * --------

  793.  * 17-Dec:     mus_env_offset|initial_power for Snd exp env optimizations.

  794.  * 13-Sep:     mus_frandom and mus_irandom(for Snd optimizer).

  795.  * 19-Aug:     changed internal phase-vocoder array accessor names

  796.  * 13-Aug:     set!(*-ref) for frame, locsig, mixer, locsig-reverb.

  797.  * 29-Jul:     various *_1 cases for the optimizer.

  798.  * 15-Jul:     mus_continue_sample2file.

  799.  * 10-Jul:     mus_file_name.

  800.  * 7-Jun:      fftw support added.

  801.  * 31-May:     changed mus_any_class.

  802.  * 3-May:      many int->mus_long_t changes for large files.

  803.  * 8-Apr:      off-by-1 env bug(Lisp/C are now identical), env_interp of exp env beyond end bugfix.

  804.  * 1-Apr:      sine-summation n=0 bugfix.

  805.  * 27-Mar:     negative degree locsig bugfix.

  806.  * 18-Mar:     mus_move_locsig.

  807.  * 15-Mar:     n-chan locsig(and reverb scalers), 'type' arg to mus_make_locsig.

  808.  * 6-Mar:      mus_scaler in asymmetric-fm now refers to the "r" parameter, "a" in sine-summation.

  809.  * 5-Mar:      dumb typo in asymmetric-fm generator fixed.

  810.  * 19-Feb:     buffer reallocation redundant free bugfix.

  811.  * 25-Jan-02:  mus_increment of env returns base.

  812.  * --------

  813.  * 10-Dec:     add outctr calls, phase-vocoder bugfixes, thanks to Scott Wilson.

  814.  * 21-Oct:     fill in some set-data methods.

  815.  * 1-Sep:      mus_polar2rectangular.

  816.  * 6-July:     scm -> xen.

  817.  * 26-May:     mus_rand_seed.

  818.  * 22-May:     locsig reverb distance calc was upside down.

  819.  * 18-May:     mus_describe and mus_inspect returned string should not be freed any more.

  820.  * 7-May:      filled in some leftover equal_p methods.

  821.  * 1-Apr:      mus_make_file2sample_with_comment and mus_length for file->sample/sample->file.

  822.  *             mus_file_buffer_size.

  823.  * 26-Mar:     extended_type field added to mus_any_class for more robust type checking.

  824.  * 16-Mar:     mus_phase of env -> current_value.

  825.  * 28-Feb:     added mus_position(currently only for envs).

  826.  * 8-Feb:      clm2scm.h.

  827.  * 24-Jan:     mus-bank in clm2scm.

  828.  * 5-Jan:      clm2scm gens are applicable.

  829.  * 4-Jan:      mus_bank.

  830.  * 2-Jan-01:   mus_run method.

  831.  * --------

  832.  * 28-Dec:     mus_clear_filter_state and other minor tweaks for Snd.

  833.  * 28-Nov:     Dolph-Chebyshev window(under HAVE_GSL flag -- needs complex trig support).

  834.  * 8-Nov:      mus_clear_sinc_tables.

  835.  * 12-Oct:     mus_formant_bank takes one input(can't remember why I had an array here)

  836.  * 27-Sep:     mus_array_interp bugfix(imitates mus.lisp now).

  837.  * 18-Sep:     clm now assumes it's used as a part of sndlib.

  838.  * 11-Sep:     generalized set! to generic functions in clm2scm.c.

  839.  * 31-Aug:     changed formant field setters(thanks to Anders Vinjar).

  840.  * 10-Aug:     removed built-in setf support(clm2scm.c).

  841.  * 31-Jul:     mus_granulate tries to protect against illegal length and ramp values.

  842.  * 24-Jul:     mus_make_fir_coeffs.

  843.  * 20-Jul:     sum_of_sines, atan2 to rectangular->polar, phase_vocoder gen.

  844.  * 22-June:    made mus_bessi0 local again.

  845.  * 1-June:     bugfixes for linuxppc 2000.

  846.  * 19-May:     mus_apply.

  847.  * 8-May:      added "const" and XEN_PROCEDURE_CAST(for c++), made mus_bessi0 global.

  848.  * 24-Apr:     changed formant radius to match lisp version(it's now 1-old_radius)

  849.  * 20-Apr:     mus_convolve_files

  850.  * 7-Apr:      src width bug fixed

  851.  * 31-Mar:     finally implemented set-location for envs.

  852.  * 14-Feb:     buffer-full?.

  853.  * 1-Feb:      removed mus_phasepartials2waveshape.

  854.  * 3-Jan-00:   format and type args added to make_sample2file, 

  855.  *             mus_file_close. 

  856.  *             removed make_file_input and make_file_output.

  857.  * --------

  858.  * 29-Dec:     various bugfixes especially in envelope handlers.

  859.  * 19-Nov:     mus_oscil_bank and mus_formant_bank.

  860.  * 5-Nov:      mus_sin exported.

  861.  * 4-Oct:(scm) make-env arg order changed to reflect mus.lisp.

  862.  * 29-Sep:     implemented mus-increment and mus-frequency for granulate(as in mus.lisp).

  863.  *             clm's fft renamed mus-fft to avoid collision with snd's version.

  864.  *             added max_size arg to make_granulate(to reflect mus.lisp).

  865.  * 25-Sep-99:  added width arg to make_src -- forgot this somehow in first pass.

  866.  *             decided to make mus_inspect return char* like mus_describe.

  867.  */