dom
/
tonalisa
İzle 1
Yıldızla 0
Çatalla 0
Kod Sorunlar 0 Değişiklik İstekleri 0 Sürümler 0 Wiki Aktivite
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 İşle
1 Dal
Dal: master
Dallar Biçim İmleri
${ item.name }
Branş ${ searchTerm } oluştur
'master'den
${ noResults }
tonalisa/lib/sndlib/sndlib.h

436 satır
21KB
Ham Kalıcı Bağlantı Bahset Geçmiş 

  1. #ifndef SNDLIB_H

  2. #define SNDLIB_H

  3. 

  4. #define SNDLIB_VERSION 24

  5. #define SNDLIB_REVISION 4

  6. #define SNDLIB_DATE "1-Sep-15"

  7. 

  8. #include <stdio.h>

  9. #include <time.h>

  10. #include <sys/types.h>

  11. 

  12. /* not sure how to handle this one cleanly: */

  13. #ifndef __cplusplus

  14. #ifndef _MSC_VER

  15.   #include <stdbool.h>

  16. #else

  17. #ifndef true

  18.   #define bool	unsigned char

  19.   #define true	1

  20.   #define false	0

  21. #endif

  22. #endif

  23. #endif

  24. 

  25. typedef double mus_float_t;

  26. typedef long long int mus_long_t;

  27. 

  28. #if defined(__sun) && defined(__SVR4)

  29.   #define HAVE_SUN 1

  30. #endif

  31. 

  32. #ifdef _MSC_VER

  33.   /* I got these from gmp.h */

  34.   #if defined (__GNUC__)

  35.     #define MUS_EXPORT  __declspec(__dllexport__)

  36.   #else

  37.     #define MUS_EXPORT  __declspec(dllexport)

  38.   #endif

  39. #else

  40.   #define MUS_EXPORT

  41. #endif

  42. 

  43. 

  44. #ifndef MUS_LITTLE_ENDIAN

  45.   #if WORDS_BIGENDIAN

  46.     #define MUS_LITTLE_ENDIAN 0

  47.   #else

  48.     #define MUS_LITTLE_ENDIAN 1

  49.   #endif

  50. #endif

  51. 

  52. typedef enum {MUS_UNKNOWN_HEADER, MUS_NEXT, MUS_AIFC, MUS_RIFF, MUS_RF64, MUS_BICSF, MUS_NIST, MUS_INRS, MUS_ESPS, MUS_SVX, MUS_VOC, 

  53. 	      MUS_SNDT, MUS_RAW, MUS_SMP, MUS_AVR, MUS_IRCAM, MUS_SD1, MUS_SPPACK, MUS_MUS10, MUS_HCOM, MUS_PSION, MUS_MAUD,

  54. 	      MUS_IEEE, MUS_MATLAB, MUS_ADC, MUS_MIDI, MUS_SOUNDFONT, MUS_GRAVIS, MUS_COMDISCO, MUS_GOLDWAVE, MUS_SRFS,

  55. 	      MUS_MIDI_SAMPLE_DUMP, MUS_DIAMONDWARE, MUS_ADF, MUS_SBSTUDIOII, MUS_DELUSION,

  56. 	      MUS_FARANDOLE, MUS_SAMPLE_DUMP, MUS_ULTRATRACKER, MUS_YAMAHA_SY85, MUS_YAMAHA_TX16W, MUS_DIGIPLAYER,

  57. 	      MUS_COVOX, MUS_AVI, MUS_OMF, MUS_QUICKTIME, MUS_ASF, MUS_YAMAHA_SY99, MUS_KURZWEIL_2000,

  58. 	      MUS_AIFF, MUS_PAF, MUS_CSL, MUS_FILE_SAMP, MUS_PVF, MUS_SOUNDFORGE, MUS_TWINVQ, MUS_AKAI4,

  59. 	      MUS_IMPULSETRACKER, MUS_KORG, MUS_NVF, MUS_CAFF, MUS_MAUI, MUS_SDIF, MUS_OGG, MUS_FLAC, MUS_SPEEX, MUS_MPEG,

  60. 	      MUS_SHORTEN, MUS_TTA, MUS_WAVPACK, MUS_SOX,

  61. 	      MUS_NUM_HEADERS} mus_header_t;

  62. 

  63. 

  64. typedef enum {MUS_UNKNOWN_SAMPLE, MUS_BSHORT, MUS_MULAW, MUS_BYTE, MUS_BFLOAT, MUS_BINT, MUS_ALAW, MUS_UBYTE, MUS_B24INT,

  65. 	      MUS_BDOUBLE, MUS_LSHORT, MUS_LINT, MUS_LFLOAT, MUS_LDOUBLE, MUS_UBSHORT, MUS_ULSHORT, MUS_L24INT,

  66. 	      MUS_BINTN, MUS_LINTN, MUS_BFLOAT_UNSCALED, MUS_LFLOAT_UNSCALED, MUS_BDOUBLE_UNSCALED, MUS_LDOUBLE_UNSCALED,

  67. 	      MUS_NUM_SAMPLES} mus_sample_t;

  68. 

  69. #ifndef MUS_AUDIO_COMPATIBLE_SAMPLE_TYPE

  70.   #if WORDS_BIGENDIAN

  71.     #if __APPLE__

  72.       #define MUS_AUDIO_COMPATIBLE_SAMPLE_TYPE MUS_BFLOAT

  73.     #else

  74.       #define MUS_AUDIO_COMPATIBLE_SAMPLE_TYPE MUS_BSHORT

  75.     #endif

  76.   #else

  77.     #if __APPLE__

  78.       #define MUS_AUDIO_COMPATIBLE_SAMPLE_TYPE MUS_LFLOAT

  79.     #else

  80.       #define MUS_AUDIO_COMPATIBLE_SAMPLE_TYPE MUS_LSHORT

  81.     #endif

  82.   #endif

  83. #endif

  84. 

  85. #ifndef MUS_OUT_SAMPLE_TYPE

  86.   #if WORDS_BIGENDIAN

  87.     #define MUS_OUT_SAMPLE_TYPE MUS_BDOUBLE

  88.   #else

  89.     #define MUS_OUT_SAMPLE_TYPE MUS_LDOUBLE

  90.   #endif

  91. #endif

  92. 

  93. #define MUS_IGNORE_SAMPLE MUS_NUM_SAMPLES

  94. /* MUS_LINTN and MUS_BINTN refer to 32 bit ints with 31 bits of fraction -- the data is left justified */

  95. /* "unscaled" means the float value is used directly (i.e. not as -1.0 to 1.0, but (probably) -32768.0 to 32768.0) */

  96. 

  97. 

  98. #define MUS_NIST_SHORTPACK 2

  99. #define MUS_AIFF_IMA_ADPCM 99

  100. 

  101. #define MUS_AUDIO_PACK_SYSTEM(n) ((n) << 16)

  102. #define MUS_AUDIO_SYSTEM(n) (((n) >> 16) & 0xffff)

  103. #define MUS_AUDIO_DEVICE(n) ((n) & 0xffff)

  104. 

  105. 

  106. #define MUS_AUDIO_DEFAULT 0

  107. #define MUS_ERROR -1

  108. 

  109. enum {MUS_NO_ERROR, MUS_NO_FREQUENCY, MUS_NO_PHASE, MUS_NO_GEN, MUS_NO_LENGTH,

  110.       MUS_NO_DESCRIBE, MUS_NO_DATA, MUS_NO_SCALER,

  111.       MUS_MEMORY_ALLOCATION_FAILED, 

  112.       MUS_CANT_OPEN_FILE, MUS_NO_SAMPLE_INPUT, MUS_NO_SAMPLE_OUTPUT,

  113.       MUS_NO_SUCH_CHANNEL, MUS_NO_FILE_NAME_PROVIDED, MUS_NO_LOCATION, MUS_NO_CHANNEL,

  114.       MUS_NO_SUCH_FFT_WINDOW, MUS_UNSUPPORTED_SAMPLE_TYPE, MUS_HEADER_READ_FAILED,

  115.       MUS_UNSUPPORTED_HEADER_TYPE,

  116.       MUS_FILE_DESCRIPTORS_NOT_INITIALIZED, MUS_NOT_A_SOUND_FILE, MUS_FILE_CLOSED, MUS_WRITE_ERROR,

  117.       MUS_HEADER_WRITE_FAILED, MUS_CANT_OPEN_TEMP_FILE, MUS_INTERRUPTED, MUS_BAD_ENVELOPE,

  118. 

  119.       MUS_AUDIO_CHANNELS_NOT_AVAILABLE, MUS_AUDIO_SRATE_NOT_AVAILABLE, MUS_AUDIO_SAMPLE_TYPE_NOT_AVAILABLE,

  120.       MUS_AUDIO_NO_INPUT_AVAILABLE, MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, 

  121.       MUS_AUDIO_WRITE_ERROR, MUS_AUDIO_SIZE_NOT_AVAILABLE, MUS_AUDIO_DEVICE_NOT_AVAILABLE,

  122.       MUS_AUDIO_CANT_CLOSE, MUS_AUDIO_CANT_OPEN, MUS_AUDIO_READ_ERROR, 

  123.       MUS_AUDIO_CANT_WRITE, MUS_AUDIO_CANT_READ, MUS_AUDIO_NO_READ_PERMISSION,

  124. 

  125.       MUS_CANT_CLOSE_FILE, MUS_ARG_OUT_OF_RANGE, 

  126.       MUS_NO_CHANNELS, MUS_NO_HOP, MUS_NO_WIDTH, MUS_NO_FILE_NAME, MUS_NO_RAMP, MUS_NO_RUN, 

  127.       MUS_NO_INCREMENT, MUS_NO_OFFSET,

  128.       MUS_NO_XCOEFF, MUS_NO_YCOEFF, MUS_NO_XCOEFFS, MUS_NO_YCOEFFS, MUS_NO_RESET, MUS_BAD_SIZE, MUS_CANT_CONVERT,

  129.       MUS_READ_ERROR, 

  130.       MUS_NO_FEEDFORWARD, MUS_NO_FEEDBACK, MUS_NO_INTERP_TYPE, MUS_NO_POSITION, MUS_NO_ORDER, MUS_NO_COPY,

  131.       MUS_CANT_TRANSLATE,

  132.       MUS_NUM_ERRORS};

  133. 

  134. /* keep this list in sync with mus_error_names in sound.c and snd-test.scm|rb */

  135. 

  136. #define MUS_LOOP_INFO_SIZE 8

  137. 

  138. #ifdef __cplusplus

  139. extern "C" {

  140. #endif

  141. 

  142. /* -------- sound.c -------- */

  143. 

  144. #ifdef __GNUC__

  145.   MUS_EXPORT int mus_error(int error, const char *format, ...) __attribute__ ((format (printf, 2, 3)));

  146.   MUS_EXPORT void mus_print(const char *format, ...)           __attribute__ ((format (printf, 1, 2)));

  147.   MUS_EXPORT char *mus_format(const char *format, ...)         __attribute__ ((format (printf, 1, 2)));

  148. #else

  149.   MUS_EXPORT int mus_error(int error, const char *format, ...);

  150.   MUS_EXPORT void mus_print(const char *format, ...);

  151.   MUS_EXPORT char *mus_format(const char *format, ...);

  152. #endif

  153. 

  154. typedef void mus_error_handler_t(int type, char *msg);

  155. MUS_EXPORT mus_error_handler_t *mus_error_set_handler(mus_error_handler_t *new_error_handler);

  156. MUS_EXPORT const char *mus_error_type_to_string(int err);

  157. 

  158. typedef void mus_print_handler_t(char *msg);

  159. MUS_EXPORT mus_print_handler_t *mus_print_set_handler(mus_print_handler_t *new_print_handler);

  160. 

  161. typedef mus_float_t mus_clip_handler_t(mus_float_t val);

  162. MUS_EXPORT mus_clip_handler_t *mus_clip_set_handler(mus_clip_handler_t *new_clip_handler);

  163. MUS_EXPORT mus_clip_handler_t *mus_clip_set_handler_and_checker(mus_clip_handler_t *new_clip_handler, bool (*checker)(void));

  164. 

  165. MUS_EXPORT mus_long_t mus_sound_samples(const char *arg);

  166. MUS_EXPORT mus_long_t mus_sound_framples(const char *arg);

  167. MUS_EXPORT int mus_sound_datum_size(const char *arg);

  168. MUS_EXPORT mus_long_t mus_sound_data_location(const char *arg);

  169. MUS_EXPORT int mus_sound_chans(const char *arg);

  170. MUS_EXPORT int mus_sound_srate(const char *arg);

  171. MUS_EXPORT mus_header_t mus_sound_header_type(const char *arg);

  172. MUS_EXPORT mus_sample_t mus_sound_sample_type(const char *arg);

  173. MUS_EXPORT int mus_sound_original_sample_type(const char *arg);

  174. MUS_EXPORT mus_long_t mus_sound_comment_start(const char *arg);

  175. MUS_EXPORT mus_long_t mus_sound_comment_end(const char *arg);

  176. MUS_EXPORT mus_long_t mus_sound_length(const char *arg);

  177. MUS_EXPORT int mus_sound_fact_samples(const char *arg);

  178. MUS_EXPORT time_t mus_sound_write_date(const char *arg);

  179. MUS_EXPORT int mus_sound_type_specifier(const char *arg);

  180. MUS_EXPORT int mus_sound_block_align(const char *arg);

  181. MUS_EXPORT int mus_sound_bits_per_sample(const char *arg);

  182. 

  183. MUS_EXPORT int mus_sound_set_chans(const char *arg, int val);

  184. MUS_EXPORT int mus_sound_set_srate(const char *arg, int val);

  185. MUS_EXPORT mus_header_t mus_sound_set_header_type(const char *arg, mus_header_t val);

  186. MUS_EXPORT mus_sample_t mus_sound_set_sample_type(const char *arg, mus_sample_t val);

  187. MUS_EXPORT int mus_sound_set_data_location(const char *arg, mus_long_t val);

  188. MUS_EXPORT int mus_sound_set_samples(const char *arg, mus_long_t val);

  189. 

  190. MUS_EXPORT const char *mus_header_type_name(mus_header_t type);

  191. MUS_EXPORT const char *mus_header_type_to_string(mus_header_t type);

  192. MUS_EXPORT const char *mus_sample_type_name(mus_sample_t samp_type);

  193. MUS_EXPORT const char *mus_sample_type_to_string(mus_sample_t samp_type);

  194. MUS_EXPORT const char *mus_sample_type_short_name(mus_sample_t samp_type);

  195. 

  196. MUS_EXPORT char *mus_sound_comment(const char *name);

  197. MUS_EXPORT int mus_bytes_per_sample(mus_sample_t samp_type);

  198. MUS_EXPORT float mus_sound_duration(const char *arg);

  199. MUS_EXPORT int mus_sound_initialize(void);

  200. MUS_EXPORT int mus_sound_override_header(const char *arg, int srate, int chans, mus_sample_t samp_type, mus_header_t type, mus_long_t location, mus_long_t size);

  201. MUS_EXPORT int mus_sound_forget(const char *name);

  202. MUS_EXPORT int mus_sound_prune(void);

  203. MUS_EXPORT void mus_sound_report_cache(FILE *fp);

  204. MUS_EXPORT int *mus_sound_loop_info(const char *arg);

  205. MUS_EXPORT void mus_sound_set_loop_info(const char *arg, int *loop);

  206. MUS_EXPORT int mus_sound_mark_info(const char *arg, int **mark_ids, int **mark_positions);

  207. 

  208. MUS_EXPORT int mus_sound_open_input(const char *arg);

  209. MUS_EXPORT int mus_sound_open_output(const char *arg, int srate, int chans, mus_sample_t sample_type, mus_header_t header_type, const char *comment);

  210. MUS_EXPORT int mus_sound_reopen_output(const char *arg, int chans, mus_sample_t samp_type, mus_header_t type, mus_long_t data_loc);

  211. MUS_EXPORT int mus_sound_close_input(int fd);

  212. MUS_EXPORT int mus_sound_close_output(int fd, mus_long_t bytes_of_data);

  213. #define mus_sound_read(Fd, Beg, End, Chans, Bufs) mus_file_read(Fd, Beg, End, Chans, Bufs)

  214. #define mus_sound_write(Fd, Beg, End, Chans, Bufs) mus_file_write(Fd, Beg, End, Chans, Bufs)

  215. 

  216. MUS_EXPORT mus_long_t mus_sound_maxamps(const char *ifile, int chans, mus_float_t *vals, mus_long_t *times);

  217. MUS_EXPORT int mus_sound_set_maxamps(const char *ifile, int chans, mus_float_t *vals, mus_long_t *times);

  218. MUS_EXPORT bool mus_sound_maxamp_exists(const char *ifile);

  219. MUS_EXPORT bool mus_sound_channel_maxamp_exists(const char *file, int chan);

  220. MUS_EXPORT mus_float_t mus_sound_channel_maxamp(const char *file, int chan, mus_long_t *pos);

  221. MUS_EXPORT void mus_sound_channel_set_maxamp(const char *file, int chan, mus_float_t mx, mus_long_t pos);

  222. MUS_EXPORT mus_long_t mus_file_to_array(const char *filename, int chan, mus_long_t start, mus_long_t samples, mus_float_t *array);

  223. MUS_EXPORT int mus_array_to_file(const char *filename, mus_float_t *ddata, mus_long_t len, int srate, int channels);

  224. MUS_EXPORT const char *mus_array_to_file_with_error(const char *filename, mus_float_t *ddata, mus_long_t len, int srate, int channels);

  225. MUS_EXPORT mus_long_t mus_file_to_float_array(const char *filename, int chan, mus_long_t start, mus_long_t samples, mus_float_t *array);

  226. MUS_EXPORT int mus_float_array_to_file(const char *filename, mus_float_t *ddata, mus_long_t len, int srate, int channels);

  227. 

  228. MUS_EXPORT mus_float_t **mus_sound_saved_data(const char *arg);

  229. MUS_EXPORT void mus_sound_set_saved_data(const char *arg, mus_float_t **data);

  230. MUS_EXPORT void mus_file_save_data(int tfd, mus_long_t framples, mus_float_t **data);

  231. 

  232. 

  233. 

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

  235. 

  236. MUS_EXPORT int mus_audio_open_output(int dev, int srate, int chans, mus_sample_t samp_type, int size);

  237. MUS_EXPORT int mus_audio_open_input(int dev, int srate, int chans, mus_sample_t samp_type, int size);

  238. MUS_EXPORT int mus_audio_write(int line, char *buf, int bytes);

  239. MUS_EXPORT int mus_audio_close(int line);

  240. MUS_EXPORT int mus_audio_read(int line, char *buf, int bytes);

  241. 

  242. MUS_EXPORT int mus_audio_initialize(void);

  243. MUS_EXPORT char *mus_audio_moniker(void);

  244. MUS_EXPORT int mus_audio_api(void);

  245. MUS_EXPORT mus_sample_t mus_audio_compatible_sample_type(int dev);

  246. 

  247. #if HAVE_OSS || HAVE_ALSA

  248. MUS_EXPORT void mus_oss_set_buffers(int num, int size);

  249. MUS_EXPORT char *mus_alsa_playback_device(void);

  250. MUS_EXPORT char *mus_alsa_set_playback_device(const char *name);

  251. MUS_EXPORT char *mus_alsa_capture_device(void);

  252. MUS_EXPORT char *mus_alsa_set_capture_device(const char *name);

  253. MUS_EXPORT char *mus_alsa_device(void);

  254. MUS_EXPORT char *mus_alsa_set_device(const char *name);

  255. MUS_EXPORT int mus_alsa_buffer_size(void);

  256. MUS_EXPORT int mus_alsa_set_buffer_size(int size);

  257. MUS_EXPORT int mus_alsa_buffers(void);

  258. MUS_EXPORT int mus_alsa_set_buffers(int num);

  259. MUS_EXPORT bool mus_alsa_squelch_warning(void);

  260. MUS_EXPORT bool mus_alsa_set_squelch_warning(bool val);

  261. #endif

  262. 

  263. #if __APPLE__

  264.   MUS_EXPORT bool mus_audio_output_properties_mutable(bool mut);

  265. #endif

  266. 

  267. MUS_EXPORT int mus_audio_device_channels(int dev);

  268. MUS_EXPORT mus_sample_t mus_audio_device_sample_type(int dev);

  269. 

  270. 

  271. 

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

  273. 

  274. MUS_EXPORT int mus_file_open_descriptors(int tfd, const char *arg, mus_sample_t df, int ds, mus_long_t dl, int dc, mus_header_t dt);

  275. MUS_EXPORT int mus_file_open_read(const char *arg);

  276. MUS_EXPORT bool mus_file_probe(const char *arg);

  277. MUS_EXPORT int mus_file_open_write(const char *arg);

  278. MUS_EXPORT int mus_file_create(const char *arg);

  279. MUS_EXPORT int mus_file_reopen_write(const char *arg);

  280. MUS_EXPORT int mus_file_close(int fd);

  281. MUS_EXPORT mus_long_t mus_file_seek_frample(int tfd, mus_long_t frample);

  282. MUS_EXPORT mus_long_t mus_file_read(int fd, mus_long_t beg, mus_long_t end, int chans, mus_float_t **bufs);

  283. MUS_EXPORT mus_long_t mus_file_read_chans(int fd, mus_long_t beg, mus_long_t end, int chans, mus_float_t **bufs, mus_float_t **cm);

  284. MUS_EXPORT int mus_file_write(int tfd, mus_long_t beg, mus_long_t end, int chans, mus_float_t **bufs);

  285. MUS_EXPORT mus_long_t mus_file_read_any(int tfd, mus_long_t beg, int chans, mus_long_t nints, mus_float_t **bufs, mus_float_t **cm);

  286. MUS_EXPORT mus_long_t mus_file_read_file(int tfd, mus_long_t beg, int chans, mus_long_t nints, mus_float_t **bufs);

  287. MUS_EXPORT mus_long_t mus_file_read_buffer(int charbuf_sample_type, mus_long_t beg, int chans, mus_long_t nints, mus_float_t **bufs, char *charbuf);

  288. MUS_EXPORT int mus_file_write_file(int tfd, mus_long_t beg, mus_long_t end, int chans, mus_float_t **bufs);

  289. MUS_EXPORT int mus_file_write_buffer(int charbuf_sample_type, mus_long_t beg, mus_long_t end, int chans, mus_float_t **bufs, char *charbuf, bool clipped);

  290. MUS_EXPORT char *mus_expand_filename(const char *name);

  291. MUS_EXPORT char *mus_getcwd(void);

  292. 

  293. MUS_EXPORT bool mus_clipping(void);

  294. MUS_EXPORT bool mus_set_clipping(bool new_value);

  295. MUS_EXPORT bool mus_file_clipping(int tfd);

  296. MUS_EXPORT int mus_file_set_clipping(int tfd, bool clipped);

  297. 

  298. MUS_EXPORT int mus_file_set_header_type(int tfd, mus_header_t type);

  299. MUS_EXPORT mus_header_t mus_file_header_type(int tfd);

  300. MUS_EXPORT char *mus_file_fd_name(int tfd);

  301. MUS_EXPORT int mus_file_set_chans(int tfd, int chans);

  302. 

  303. MUS_EXPORT int mus_iclamp(int lo, int val, int hi);

  304. MUS_EXPORT mus_long_t mus_oclamp(mus_long_t lo, mus_long_t val, mus_long_t hi);

  305. MUS_EXPORT mus_float_t mus_fclamp(mus_float_t lo, mus_float_t val, mus_float_t hi);

  306. 

  307. /* for CLM */

  308. /* these are needed to clear a saved lisp image to the just-initialized state */

  309. MUS_EXPORT void mus_reset_io_c(void);

  310. MUS_EXPORT void mus_reset_headers_c(void);

  311. MUS_EXPORT void mus_reset_audio_c(void);

  312. 

  313. MUS_EXPORT int mus_samples_bounds(unsigned char *data, int bytes, int chan, int chans, mus_sample_t samp_type, mus_float_t *min_samp, mus_float_t *max_samp);

  314. 

  315. MUS_EXPORT mus_long_t mus_max_malloc(void);

  316. MUS_EXPORT mus_long_t mus_set_max_malloc(mus_long_t new_max);

  317. MUS_EXPORT mus_long_t mus_max_table_size(void);

  318. MUS_EXPORT mus_long_t mus_set_max_table_size(mus_long_t new_max);

  319. 

  320. MUS_EXPORT char *mus_strdup(const char *str);

  321. MUS_EXPORT int mus_strlen(const char *str);

  322. MUS_EXPORT bool mus_strcmp(const char *str1, const char *str2);

  323. MUS_EXPORT char *mus_strcat(char *errmsg, const char *str, int *err_size);

  324. 

  325. 

  326. 

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

  328. 

  329. MUS_EXPORT bool mus_is_sample_type(int n);

  330. MUS_EXPORT bool mus_is_header_type(int n);

  331. 

  332. MUS_EXPORT mus_long_t mus_header_samples(void);

  333. MUS_EXPORT mus_long_t mus_header_data_location(void);

  334. MUS_EXPORT int mus_header_chans(void);

  335. MUS_EXPORT int mus_header_srate(void);

  336. MUS_EXPORT mus_header_t mus_header_type(void);

  337. MUS_EXPORT mus_sample_t mus_header_sample_type(void);

  338. MUS_EXPORT mus_long_t mus_header_comment_start(void);

  339. MUS_EXPORT mus_long_t mus_header_comment_end(void);

  340. MUS_EXPORT int mus_header_type_specifier(void);

  341. MUS_EXPORT int mus_header_bits_per_sample(void);

  342. MUS_EXPORT int mus_header_fact_samples(void);

  343. MUS_EXPORT int mus_header_block_align(void);

  344. MUS_EXPORT int mus_header_loop_mode(int which);

  345. MUS_EXPORT int mus_header_loop_start(int which);

  346. MUS_EXPORT int mus_header_loop_end(int which);

  347. MUS_EXPORT int mus_header_mark_position(int id);

  348. MUS_EXPORT int mus_header_mark_info(int **marker_ids, int **marker_positions);

  349. MUS_EXPORT int mus_header_base_note(void);

  350. MUS_EXPORT int mus_header_base_detune(void);

  351. MUS_EXPORT void mus_header_set_raw_defaults(int sr, int chn, mus_sample_t frm);

  352. MUS_EXPORT void mus_header_raw_defaults(int *sr, int *chn, mus_sample_t *frm);

  353. MUS_EXPORT mus_long_t mus_header_true_length(void);

  354. MUS_EXPORT int mus_header_original_sample_type(void);

  355. MUS_EXPORT mus_long_t mus_samples_to_bytes(mus_sample_t samp_type, mus_long_t size);

  356. MUS_EXPORT mus_long_t mus_bytes_to_samples(mus_sample_t samp_type, mus_long_t size);

  357. MUS_EXPORT int mus_header_read(const char *name);

  358. MUS_EXPORT int mus_header_write(const char *name, mus_header_t type, int srate, int chans, mus_long_t loc, mus_long_t size_in_samples, 

  359. 				mus_sample_t samp_type, const char *comment, int len);

  360. MUS_EXPORT int mus_write_header(const char *name, mus_header_t type, int in_srate, int in_chans, mus_long_t size_in_samples, 

  361. 				mus_sample_t samp_type, const char *comment);

  362. MUS_EXPORT mus_long_t mus_header_aux_comment_start(int n);

  363. MUS_EXPORT mus_long_t mus_header_aux_comment_end(int n);

  364. MUS_EXPORT int mus_header_initialize(void);

  365. MUS_EXPORT bool mus_header_writable(mus_header_t type, mus_sample_t samp_type);

  366. MUS_EXPORT void mus_header_set_aiff_loop_info(int *data);

  367. MUS_EXPORT int mus_header_sf2_entries(void);

  368. MUS_EXPORT char *mus_header_sf2_name(int n);

  369. MUS_EXPORT int mus_header_sf2_start(int n);

  370. MUS_EXPORT int mus_header_sf2_end(int n);

  371. MUS_EXPORT int mus_header_sf2_loop_start(int n);

  372. MUS_EXPORT int mus_header_sf2_loop_end(int n);

  373. MUS_EXPORT const char *mus_header_original_sample_type_name(int samp_type, mus_header_t type);

  374. MUS_EXPORT bool mus_header_no_header(const char *name);

  375. 

  376. MUS_EXPORT char *mus_header_riff_aux_comment(const char *name, mus_long_t *starts, mus_long_t *ends);

  377. MUS_EXPORT char *mus_header_aiff_aux_comment(const char *name, mus_long_t *starts, mus_long_t *ends);

  378. 

  379. MUS_EXPORT int mus_header_change_chans(const char *filename, mus_header_t type, int new_chans);

  380. MUS_EXPORT int mus_header_change_srate(const char *filename, mus_header_t type, int new_srate);

  381. MUS_EXPORT int mus_header_change_type(const char *filename, mus_header_t new_type, mus_sample_t new_sample_type);

  382. MUS_EXPORT int mus_header_change_sample_type(const char *filename, mus_header_t type, mus_sample_t new_sample_type);

  383. MUS_EXPORT int mus_header_change_location(const char *filename, mus_header_t type, mus_long_t new_location);

  384. MUS_EXPORT int mus_header_change_comment(const char *filename, mus_header_t type, const char *new_comment);

  385. MUS_EXPORT int mus_header_change_data_size(const char *filename, mus_header_t type, mus_long_t bytes);

  386. 

  387. typedef void mus_header_write_hook_t(const char *filename);

  388. MUS_EXPORT mus_header_write_hook_t *mus_header_write_set_hook(mus_header_write_hook_t *new_hook);

  389. 

  390. 

  391.   /* these are internal to sndlib */

  392. void mus_bint_to_char(unsigned char *j, int x);

  393. void mus_lint_to_char(unsigned char *j, int x);

  394. void mus_bfloat_to_char(unsigned char *j, float x);

  395. void mus_lfloat_to_char(unsigned char *j, float x);

  396. void mus_bshort_to_char(unsigned char *j, short x);

  397. void mus_lshort_to_char(unsigned char *j, short x);

  398. void mus_bdouble_to_char(unsigned char *j, double x);

  399. void mus_blong_to_char(unsigned char *j, mus_long_t x);

  400. void mus_llong_to_char(unsigned char *j, mus_long_t x);

  401. int mus_char_to_bint(const unsigned char *inp);

  402. int mus_char_to_lint(const unsigned char *inp);

  403. mus_long_t mus_char_to_llong(const unsigned char *inp);

  404. mus_long_t mus_char_to_blong(const unsigned char *inp);

  405. int mus_char_to_uninterpreted_int(const unsigned char *inp);

  406. float mus_char_to_bfloat(const unsigned char *inp);

  407. float mus_char_to_lfloat(const unsigned char *inp);

  408. short mus_char_to_bshort(const unsigned char *inp);

  409. short mus_char_to_lshort(const unsigned char *inp);

  410. unsigned short mus_char_to_ubshort(const unsigned char *inp);

  411. unsigned short mus_char_to_ulshort(const unsigned char *inp);

  412. double mus_char_to_ldouble(const unsigned char *inp);

  413. double mus_char_to_bdouble(const unsigned char *inp);

  414. unsigned int mus_char_to_ubint(const unsigned char *inp);

  415. unsigned int mus_char_to_ulint(const unsigned char *inp);

  416. 

  417. 

  418. #ifdef __cplusplus

  419. }

  420. #endif

  421. 

  422. #if (!DISABLE_DEPRECATED)

  423. #define mus_header_format                    mus_header_sample_type

  424. #define mus_header_original_format           mus_header_original_sample_type

  425. #define mus_header_original_format_name      mus_header_original_sample_type_name

  426. #define mus_header_change_format             mus_header_change_sample_type

  427. #define mus_sound_original_format            mus_sound_original_sample_type

  428. #define MUS_AUDIO_COMPATIBLE_FORMAT          MUS_AUDIO_COMPATIBLE_SAMPLE_TYPE

  429. #define MUS_OUT_FORMAT                       MUS_OUT_SAMPLE_TYPE

  430. #define MUS_AUDIO_FORMAT_NOT_AVAILABLE       MUS_AUDIO_SAMPLE_TYPE_NOT_AVAILABLE  

  431. #define mus_audio_compatible_format          mus_audio_compatible_sample_type     

  432. #define mus_audio_device_format              mus_audio_device_sample_type         

  433. #endif

  434. 

  435. #endif