int mus_sound_open_input(const char *arg)
{
int fd = -1;
if (!(mus_file_probe(arg)))
mus_error(MUS_CANT_OPEN_FILE, "mus_sound_open_input: can't open %s: %s", arg, STRERROR(errno));
else
{
sound_file *sf = NULL;
mus_sound_initialize();
sf = get_sf(arg);
if (sf)
{
fd = mus_file_open_read(arg);
if (fd == -1)
mus_error(MUS_CANT_OPEN_FILE, "mus_sound_open_input: can't open %s: %s", arg, STRERROR(errno));
else
{
mus_file_open_descriptors(fd, arg, sf->sample_type, sf->datum_size, sf->data_location, sf->chans, sf->header_type);
lseek(fd, sf->data_location, SEEK_SET);
if (sf->saved_data)
mus_file_save_data(fd, sf->samples / sf->chans, sf->saved_data);
}
}
}
return(fd);
}
int mus_sound_reopen_output(const char *arg, int chans, int format, int type, mus_long_t data_loc)
{
int fd;
mus_sound_initialize();
fd = mus_file_reopen_write(arg);
if (fd != -1)
mus_file_open_descriptors(fd, arg, format, mus_bytes_per_sample(format), data_loc, chans, type);
return(fd);
}
static sound_file *read_sound_file_header(const char *name) /* 2 calls on this: mus_sound_open_input and get_sf */
{
int result;
mus_sound_initialize();
result = mus_header_read(name);
/* this portion won't trigger mus_error */
if (result != MUS_ERROR)
return(fill_sf_record(name, add_to_sound_table(name))); /* only call on fill_sf_record and add_to_sound_table */
return(NULL);
}
int main(int argc, char *argv[])
{
if (argc == 1)
{
printf("usage: sndplay file [-start 1.0] [-end 1.0] [-bufsize %d] [-buffers 2x12] [-volume 1.0] [-describe]\n", BUFFER_SIZE);
exit(0);
}
mus_sound_initialize();
#if HAVE_ALSA
if (mus_audio_api() == ALSA_API)
{
main_alsa(argc, argv);
return(0);
}
#endif
main_not_alsa(argc, argv);
return(0);
}
int mus_sound_open_output(const char *arg, int srate, int chans, int data_format, int header_type, const char *comment)
{
int fd = MUS_ERROR, err;
mus_sound_initialize();
mus_sound_forget(arg);
err = mus_write_header(arg, header_type, srate, chans, 0, data_format, comment);
if (err != MUS_ERROR)
{
fd = mus_file_open_write(arg);
if (fd != -1)
mus_file_open_descriptors(fd,
arg,
data_format,
mus_bytes_per_sample(data_format),
mus_header_data_location(),
chans,
header_type);
}
return(fd);
}
void mus_sndlib_xen_initialize(void)
{
mus_sound_initialize();
sound_path = Xen_empty_list;
#if HAVE_RUBY
Init_Hook();
#endif
Xen_define_constant(S_mus_out_format, MUS_OUT_SAMPLE_TYPE, "sample type for fastest IO");
Xen_define_constant(S_mus_unknown_header, MUS_UNKNOWN_HEADER, "unknown header type");
Xen_define_constant(S_mus_next, MUS_NEXT, "NeXT (Sun) sound header id");
Xen_define_constant(S_mus_aifc, MUS_AIFC, "AIFC sound header id");
Xen_define_constant(S_mus_rf64, MUS_RF64, "RF64 sound header id");
Xen_define_constant(S_mus_riff, MUS_RIFF, "RIFF (MS wave) sound header id");
Xen_define_constant(S_mus_nist, MUS_NIST, "NIST (Sphere) sound header id");
Xen_define_constant(S_mus_raw, MUS_RAW, "raw (headerless) sound header id");
Xen_define_constant(S_mus_ircam, MUS_IRCAM, "IRCAM sound header id");
Xen_define_constant(S_mus_aiff, MUS_AIFF, "AIFF (old-style) sound header id");
Xen_define_constant(S_mus_bicsf, MUS_BICSF, "BICSF header id");
Xen_define_constant(S_mus_voc, MUS_VOC, "VOC header id");
Xen_define_constant(S_mus_svx, MUS_SVX, "SVX (IFF) header id");
Xen_define_constant(S_mus_soundfont, MUS_SOUNDFONT, "soundfont header id");
Xen_define_constant(S_mus_caff, MUS_CAFF, "Apple Core Audio File Format header id");
Xen_define_constant(S_mus_unknown_sample, MUS_UNKNOWN_SAMPLE, "unknown sample type");
Xen_define_constant(S_mus_bshort, MUS_BSHORT, "big-endian short sample type id");
Xen_define_constant(S_mus_lshort, MUS_LSHORT, "little-endian short sample type id");
Xen_define_constant(S_mus_mulaw, MUS_MULAW, "mulaw (8-bit) sample type id");
Xen_define_constant(S_mus_alaw, MUS_ALAW, "alaw (8-bit) sample type id");
Xen_define_constant(S_mus_byte, MUS_BYTE, "signed byte sample type id");
Xen_define_constant(S_mus_ubyte, MUS_UBYTE, "unsigned byte sample type id");
Xen_define_constant(S_mus_bfloat, MUS_BFLOAT, "big-endian float sample type id");
Xen_define_constant(S_mus_lfloat, MUS_LFLOAT, "little-endian float sample type id");
Xen_define_constant(S_mus_bint, MUS_BINT, "big-endian int sample type id");
Xen_define_constant(S_mus_lint, MUS_LINT, "little-endian int sample type id");
Xen_define_constant(S_mus_bintn, MUS_BINTN, "normalized big-endian int sample type id");
Xen_define_constant(S_mus_lintn, MUS_LINTN, "normalized little-endian int sample type id");
Xen_define_constant(S_mus_b24int, MUS_B24INT, "big-endian 24-bit sample type id");
Xen_define_constant(S_mus_l24int, MUS_L24INT, "little-endian 24-bit sample type id");
Xen_define_constant(S_mus_bdouble, MUS_BDOUBLE, "big-endian double sample type id");
Xen_define_constant(S_mus_ldouble, MUS_LDOUBLE, "little-endian double sample type id");
Xen_define_constant(S_mus_ubshort, MUS_UBSHORT, "unsigned big-endian short sample type id");
Xen_define_constant(S_mus_ulshort, MUS_ULSHORT, "unsigned little-endian short sample type id");
Xen_define_constant(S_mus_bdouble_unscaled, MUS_BDOUBLE_UNSCALED, "unscaled big-endian double sample type id");
Xen_define_constant(S_mus_ldouble_unscaled, MUS_LDOUBLE_UNSCALED, "unscaled little-endian double sample type id");
Xen_define_constant(S_mus_bfloat_unscaled, MUS_BFLOAT_UNSCALED, "unscaled big-endian float sample type id");
Xen_define_constant(S_mus_lfloat_unscaled, MUS_LFLOAT_UNSCALED, "unscaled little-endian float sample type id");
Xen_define_dilambda(S_mus_sound_samples, g_mus_sound_samples_w, H_mus_sound_samples, S_set S_mus_sound_samples, g_mus_sound_set_samples_w, 1, 0, 2, 0);
Xen_define_dilambda(S_mus_sound_data_location, g_mus_sound_data_location_w, H_mus_sound_data_location,
S_set S_mus_sound_data_location, g_mus_sound_set_data_location_w, 1, 0, 2, 0);
Xen_define_dilambda(S_mus_sound_chans, g_mus_sound_chans_w, H_mus_sound_chans, S_set S_mus_sound_chans, g_mus_sound_set_chans_w, 1, 0, 2, 0);
Xen_define_dilambda(S_mus_sound_srate, g_mus_sound_srate_w, H_mus_sound_srate, S_set S_mus_sound_srate, g_mus_sound_set_srate_w, 1, 0, 2, 0);
Xen_define_dilambda(S_mus_sound_header_type, g_mus_sound_header_type_w, H_mus_sound_header_type,
S_set S_mus_sound_header_type, g_mus_sound_set_header_type_w, 1, 0, 2, 0);
Xen_define_dilambda(S_mus_sound_sample_type, g_mus_sound_sample_type_w, H_mus_sound_sample_type,
S_set S_mus_sound_sample_type, g_mus_sound_set_sample_type_w, 1, 0, 2, 0);
/* -------------------------------------------------------------------------------- */
Xen_define_safe_procedure(S_mus_sound_framples, g_mus_sound_framples_w, 1, 0, 0, H_mus_sound_framples);
Xen_define_safe_procedure("mus-sound-frames", g_mus_sound_framples_w, 1, 0, 0, H_mus_sound_framples);
Xen_define_safe_procedure(S_mus_sound_duration, g_mus_sound_duration_w, 1, 0, 0, H_mus_sound_duration);
Xen_define_safe_procedure(S_mus_sound_datum_size, g_mus_sound_datum_size_w, 1, 0, 0, H_mus_sound_datum_size);
Xen_define_safe_procedure(S_mus_sound_length, g_mus_sound_length_w, 1, 0, 0, H_mus_sound_length);
Xen_define_safe_procedure(S_mus_sound_type_specifier, g_mus_sound_type_specifier_w, 1, 0, 0, H_mus_sound_type_specifier);
Xen_define_safe_procedure(S_mus_header_type_name, g_mus_header_type_name_w, 1, 0, 0, H_mus_header_type_name);
Xen_define_safe_procedure(S_mus_header_type_to_string,g_mus_header_type_to_string_w, 1, 0, 0, H_mus_header_type_to_string);
Xen_define_safe_procedure(S_mus_header_writable, g_mus_header_writable_w, 2, 0, 0, H_mus_header_writable);
Xen_define_safe_procedure(S_mus_sample_type_name, g_mus_sample_type_name_w, 1, 0, 0, H_mus_sample_type_name);
Xen_define_safe_procedure(S_mus_sample_type_to_string,g_mus_sample_type_to_string_w, 1, 0, 0, H_mus_sample_type_to_string);
#if HAVE_SCHEME
Xen_define_dilambda(S_mus_sound_sample_type, g_mus_sound_sample_type_w, H_mus_sound_sample_type,
S_set S_mus_sound_sample_type, g_mus_sound_set_sample_type_w, 1, 0, 2, 0);
#endif
Xen_define_safe_procedure(S_mus_sound_comment, g_mus_sound_comment_w, 1, 0, 0, H_mus_sound_comment);
Xen_define_safe_procedure(S_mus_sound_write_date, g_mus_sound_write_date_w, 1, 0, 0, H_mus_sound_write_date);
Xen_define_safe_procedure(S_mus_bytes_per_sample, g_mus_bytes_per_sample_w, 1, 0, 0, H_mus_bytes_per_sample);
Xen_define_safe_procedure(S_mus_sound_loop_info, g_mus_sound_loop_info_w, 1, 0, 0, H_mus_sound_loop_info);
Xen_define_safe_procedure(S_mus_sound_mark_info, g_mus_sound_mark_info_w, 1, 0, 0, H_mus_sound_mark_info);
Xen_define_safe_procedure(S_mus_sound_maxamp_exists, g_mus_sound_maxamp_exists_w, 1, 0, 0, H_mus_sound_maxamp_exists);
Xen_define_safe_procedure(S_mus_sound_forget, g_mus_sound_forget_w, 1, 0, 0, H_mus_sound_forget);
Xen_define_safe_procedure(S_mus_sound_prune, g_mus_sound_prune_w, 0, 0, 0, H_mus_sound_prune);
Xen_define_safe_procedure(S_mus_expand_filename, g_mus_expand_filename_w, 1, 0, 0, H_mus_expand_filename);
Xen_define_safe_procedure(S_mus_sound_report_cache, g_mus_sound_report_cache_w, 0, 1, 0, H_mus_sound_report_cache);
Xen_define_safe_procedure(S_mus_error_type_to_string, g_mus_error_type_to_string_w, 1, 0, 0, H_mus_error_type_to_string);
Xen_define_safe_procedure(S_mus_oss_set_buffers, g_mus_oss_set_buffers_w, 2, 0, 0, H_mus_oss_set_buffers);
Xen_define_safe_procedure(S_array_to_file, g_array_to_file_w, 5, 0, 0, H_array_to_file);
Xen_define_safe_procedure(S_file_to_array, g_file_to_array_w, 5, 0, 0, H_file_to_array);
Xen_define_safe_procedure(S_mus_sound_preload, g_mus_sound_preload_w, 1, 0, 0, H_mus_sound_preload);
Xen_define_dilambda(S_mus_header_raw_defaults, g_mus_header_raw_defaults_w, H_mus_header_raw_defaults,
S_set S_mus_header_raw_defaults, g_mus_header_set_raw_defaults_w, 0, 0, 1, 0);
Xen_define_dilambda(S_mus_clipping, g_mus_clipping_w, H_mus_clipping, S_set S_mus_clipping, g_mus_set_clipping_w, 0, 0, 1, 0);
Xen_define_dilambda(S_mus_file_clipping, g_mus_file_clipping_w, H_mus_file_clipping, S_set S_mus_file_clipping, g_mus_file_set_clipping_w, 1, 0, 2, 0);
Xen_define_dilambda(S_mus_sound_maxamp, g_mus_sound_maxamp_w, H_mus_sound_maxamp, S_set S_mus_sound_maxamp, g_mus_sound_set_maxamp_w, 1, 0, 2, 0);
/* these are no-ops if not ALSA, but that makes it easier to maintain global initialization files */
Xen_define_dilambda(S_mus_alsa_buffers, g_mus_alsa_buffers_w, H_mus_alsa_buffers, S_set S_mus_alsa_buffers, g_mus_alsa_set_buffers_w, 0, 0, 1, 0);
Xen_define_dilambda(S_mus_alsa_buffer_size, g_mus_alsa_buffer_size_w, H_mus_alsa_buffer_size, S_set S_mus_alsa_buffer_size, g_mus_alsa_set_buffer_size_w, 0, 0, 1, 0);
Xen_define_dilambda(S_mus_alsa_device, g_mus_alsa_device_w, H_mus_alsa_device, S_set S_mus_alsa_device, g_mus_alsa_set_device_w, 0, 0, 1, 0);
Xen_define_dilambda(S_mus_alsa_playback_device, g_mus_alsa_playback_device_w, H_mus_alsa_playback_device,
S_set S_mus_alsa_playback_device, g_mus_alsa_set_playback_device_w, 0, 0, 1, 0);
Xen_define_dilambda(S_mus_alsa_capture_device, g_mus_alsa_capture_device_w, H_mus_alsa_capture_device,
S_set S_mus_alsa_capture_device, g_mus_alsa_set_capture_device_w, 0, 0, 1, 0);
Xen_define_dilambda(S_mus_alsa_squelch_warning, g_mus_alsa_squelch_warning_w, H_mus_alsa_squelch_warning,
S_set S_mus_alsa_squelch_warning, g_mus_alsa_set_squelch_warning_w, 0, 0, 1, 0);
Xen_define_dilambda(S_mus_max_malloc, g_mus_max_malloc_w, H_mus_max_malloc, S_set S_mus_max_malloc, g_mus_set_max_malloc_w, 0, 0, 1, 0);
Xen_define_dilambda(S_mus_max_table_size, g_mus_max_table_size_w, H_mus_max_table_size, S_set S_mus_max_table_size, g_mus_set_max_table_size_w, 0, 0, 1, 0);
Xen_define_dilambda(S_mus_sound_path, g_mus_sound_path_w, H_mus_sound_path, S_set S_mus_sound_path, g_mus_set_sound_path_w, 0, 0, 1, 0);
#if HAVE_SCHEME
mus_max_table_size_symbol = s7_define_variable(s7, "*" S_mus_max_table_size "*", s7_make_integer(s7, MUS_MAX_TABLE_SIZE_DEFAULT));
s7_symbol_set_documentation(s7, mus_max_table_size_symbol, "*mus-max-table-size*: maximum table size.");
s7_symbol_set_access(s7, mus_max_table_size_symbol, s7_make_function(s7, "[acc-mus-max-table-size]", acc_mus_max_table_size, 2, 0, false, "accessor"));
mus_max_malloc_symbol = s7_define_variable(s7, "*" S_mus_max_malloc "*", s7_make_integer(s7, MUS_MAX_MALLOC_DEFAULT));
s7_symbol_set_documentation(s7, mus_max_malloc_symbol, "*mus-max-malloc*: maximum number of bytes we will try to malloc.");
s7_symbol_set_access(s7, mus_max_malloc_symbol, s7_make_function(s7, "[acc-mus-max-malloc]", acc_mus_max_malloc, 2, 0, false, "accessor"));
mus_sound_path_symbol = s7_define_variable(s7, "*" S_mus_sound_path "*", s7_nil(s7));
s7_symbol_set_documentation(s7, mus_sound_path_symbol, "*" S_mus_sound_path "* is a list of directories to search for sound files");
s7_symbol_set_access(s7, mus_sound_path_symbol, s7_make_function(s7, "[acc-mus-sound-path]", acc_mus_sound_path, 2, 0, false, "accessor"));
#endif
#if __APPLE__
Xen_define_procedure(S_mus_audio_output_properties_mutable, g_mus_audio_output_properties_mutable_w, 1, 0, 0, H_mus_audio_output_properties_mutable);
#endif
#define H_new_sound_hook S_new_sound_hook "(name): called when a new sound file is being created"
new_sound_hook = Xen_define_hook(S_new_sound_hook, "(make-hook 'name)", 1, H_new_sound_hook);
mus_header_write_set_hook(g_new_sound_hook);
Xen_provide_feature("sndlib");
}
int main(int argc, char **argv)
#endif
#endif
{
int i;
#if HAVE_GSL
/* if HAVE_GSL and the environment variable GSL_IEEE_MODE exists, use it */
/* GSL_IEEE_MODE=double-precision,mask-underflow,mask-denormalized */
if (getenv("GSL_IEEE_MODE") != NULL)
gsl_ieee_env_setup();
gsl_set_error_handler(snd_gsl_error);
#endif
#if ENABLE_NLS && HAVE_GETTEXT && defined(LOCALE_DIR)
/* both flags needed to avoid idiotic confusion on the Sun */
#if HAVE_SETLOCALE
setlocale (LC_ALL, "");
#endif
bindtextdomain (PACKAGE, LOCALE_DIR);
textdomain (PACKAGE);
/*
(bindtextdomain "snd" "/usr/local/share/locale")
(textdomain "snd")
(define _ gettext)
(display (_ "no selection"))
but that is limited to Snd's messages
*/
#endif
ss = (snd_state *)CALLOC(1, sizeof(snd_state));
ss->fam_ok = false;
ss->startup_errors = NULL;
mus_sound_initialize(); /* has to precede version check (mus_audio_moniker needs to be setup in Alsa/Oss) */
#if HAVE_FORTH || HAVE_GAUCHE || HAVE_RUBY
xen_initialize();
#endif
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "--version") == 0)
{
fprintf(stdout, version_info());
snd_exit(0);
}
else
{
if (strcmp(argv[i], "--help") == 0)
{
fprintf(stdout, _("Snd is a sound editor; see http://ccrma.stanford.edu/software/snd/.\n"));
fprintf(stdout, version_info());
snd_exit(0);
}
}
}
initialize_format_lists();
snd_set_global_defaults(false);
#if MUS_DEBUGGING
ss->Trap_Segfault = false;
#else
ss->Trap_Segfault = DEFAULT_TRAP_SEGFAULT;
#endif
ss->jump_ok = false;
allocate_regions(max_regions(ss));
ss->init_window_x = DEFAULT_INIT_WINDOW_X;
ss->init_window_y = DEFAULT_INIT_WINDOW_Y;
ss->init_window_width = DEFAULT_INIT_WINDOW_WIDTH;
ss->init_window_height = DEFAULT_INIT_WINDOW_HEIGHT;
ss->click_time = 100;
init_sound_file_extensions();
ss->max_sounds = 4; /* expands to accommodate any number of files */
ss->sound_sync_max = 0;
ss->stopped_explicitly = false; /* C-g sets this flag so that we can interrupt various loops */
ss->checking_explicitly = false;
ss->reloading_updated_file = 0;
ss->selected_sound = NO_SELECTION;
ss->sounds = (snd_info **)CALLOC(ss->max_sounds, sizeof(snd_info *));
ss->print_choice = PRINT_SND;
ss->graph_hook_active = false;
ss->lisp_graph_hook_active = false;
ss->error_lock = false;
ss->exiting = false;
ss->deferred_regions = 0;
ss->fam_connection = NULL;
ss->snd_error_data = NULL;
ss->snd_error_handler = NULL;
ss->snd_warning_data = NULL;
ss->snd_warning_handler = NULL;
ss->xen_error_data = NULL;
ss->xen_error_handler = NULL;
#if USE_NO_GUI || HAVE_RUBY || HAVE_FORTH || HAVE_GAUCHE
ss->catch_exists = 1; /* scm_shell for USE_NO_GUI case */
#else
ss->catch_exists = 0;
#endif
#if HAVE_GL && MUS_WITH_GL2PS
ss->gl_printing = false;
#endif
g_xen_initialize();
ss->search_proc = XEN_UNDEFINED;
ss->search_expr = NULL;
ss->search_tree = NULL;
mus_error_set_handler(mus_error_to_snd);
mus_print_set_handler(mus_print_to_snd);
initialize_load_path(); /* merge SND_PATH entries into the load-path */
#ifdef SND_AS_PD_EXTERNAL
return;
#else
#ifdef SND_AS_WIDGET
return(ss);
#else
snd_doit(argc, argv);
#if (!HAVE_GUILE)
return(0);
#endif
#endif
#endif
}
int main(int argc, char *argv[])
{
int fd, afd, i, j, n, k, chans, srate;
mus_long_t frames, m;
mus_sample_t **bufs;
OutSample *obuf;
int buffer_size = BUFFER_SIZE, curframes, sample_size, out_chans, outbytes;
char *name = NULL;
mus_long_t start = 0, end = 0;
double begin_time = 0.0, end_time = 0.0;
int mutate = 1, include_mutate = 0;
if (argc == 1)
{
printf("usage: sndplay file [-start 1.0] [-end 1.0] [-bufsize %d] [-buffers 2x12] [-describe]\n", BUFFER_SIZE);
exit(0);
}
mus_sound_initialize();
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "-buffers") == 0)
{
#if (HAVE_OSS || HAVE_ALSA)
static char x_string[2] = {'x','\0'};
char *arg;
int a, b;
arg = strtok(argv[i + 1], x_string);
a = atoi(arg);
arg = strtok(NULL, x_string);
b = atoi(arg);
mus_oss_set_buffers(a, b);
#endif
i++;
}
else
{
if (strcmp(argv[i], "-bufsize") == 0)
{
buffer_size = atoi(argv[i + 1]);
i++;
}
else
{
if (strcmp(argv[i], "-start") == 0)
{
begin_time = atof(argv[i + 1]);
i++;
}
else
{
if (strcmp(argv[i], "-end") == 0)
{
end_time = atof(argv[i + 1]);
i++;
}
else
{
if (strcmp(argv[i], "-mutable") == 0)
{
mutate = atoi(argv[i + 1]);
include_mutate = 1;
i++;
}
else name = argv[i];
}}}}}
if (name == NULL)
{
printf("usage: sndplay file [-start 1.0] [-end 1.0] [-bufsize %d] [-buffers 2x12] [-mutable 1]\n", BUFFER_SIZE);
exit(0);
}
afd = -1;
if (!(mus_header_type_p(mus_sound_header_type(name))))
{
fprintf(stderr, "can't play %s (header type: %s?)\n",
name,
mus_header_type_name(mus_header_type()));
exit(0);
}
if (!(mus_data_format_p(mus_sound_data_format(name))))
{
fprintf(stderr, "can't play %s (data format: %s (%s)?)\n",
name,
mus_data_format_name(mus_sound_data_format(name)),
mus_header_original_format_name(mus_sound_original_format(name),
mus_sound_header_type(name)));
exit(0);
}
fd = mus_sound_open_input(name);
if (fd != -1)
{
chans = mus_sound_chans(name);
if (chans > 2)
{
int available_chans;
available_chans = mus_audio_device_channels(MUS_AUDIO_DEFAULT);
if (available_chans < chans)
{
fprintf(stderr, "%s has %d channels, but we can only handle %d\n", name, chans, available_chans);
exit(1);
}
}
out_chans = chans;
srate = mus_sound_srate(name);
frames = mus_sound_frames(name);
sample_size = mus_bytes_per_sample(MUS_AUDIO_COMPATIBLE_FORMAT);
start = (mus_long_t)(begin_time * srate);
if (start > 0)
mus_file_seek_frame(fd, start);
if (end_time > 0.0)
end = (mus_long_t)(end_time * srate);
else end = frames;
if ((end - start) < frames)
frames = end - start;
bufs = (mus_sample_t **)calloc(chans, sizeof(mus_sample_t *));
for (i = 0; i < chans; i++) bufs[i] = (mus_sample_t *)calloc(buffer_size, sizeof(mus_sample_t));
obuf = (OutSample *)calloc(buffer_size * out_chans, sizeof(OutSample));
outbytes = buffer_size * out_chans * sample_size;
for (m = 0; m < frames; m += buffer_size)
{
if ((m + buffer_size) <= frames)
curframes = buffer_size;
else curframes = frames - m;
mus_file_read(fd, 0, curframes - 1, chans, bufs);
/* some systems are happier if we read the file before opening the dac */
/* at this point the data is in separate arrays of mus_sample_t's */
if (chans == 1)
{
for (k = 0; k < curframes; k++)
obuf[k] = MUS_CONVERT(bufs[0][k]);
}
else
{
if (chans == 2)
{
for (k = 0, n = 0; k < curframes; k++, n += 2)
{
obuf[n] = MUS_CONVERT(bufs[0][k]);
obuf[n + 1] = MUS_CONVERT(bufs[1][k]);
}
}
else
{
for (k = 0, j = 0; k < curframes; k++, j += chans)
{
for (n = 0; n < chans; n++)
obuf[j + n] = MUS_CONVERT(bufs[n][k]);
}
}
}
#if MUS_MAC_OSX
if (include_mutate == 1)
mus_audio_output_properties_mutable(mutate);
#endif
if (afd == -1)
{
afd = mus_audio_open_output(MUS_AUDIO_DEFAULT, srate, out_chans, MUS_AUDIO_COMPATIBLE_FORMAT, outbytes);
if (afd == -1) break;
}
outbytes = curframes * out_chans * sample_size;
mus_audio_write(afd, (char *)obuf, outbytes);
}
if (afd != -1) mus_audio_close(afd);
mus_sound_close_input(fd);
for (i = 0; i < chans; i++) free(bufs[i]);
free(bufs);
free(obuf);
}
return(0);
}
int main(int argc, char *argv[])
{
int chans, srate, ctr;
mus_sample_t samp_type;
mus_header_t type;
mus_long_t samples;
float length = 0.0;
time_t date;
int *loops = NULL;
char *comment, *header_name;
char *samp_type_info = NULL, *samp_type_name, *ampstr = NULL;
char timestr[64];
if (argc == 1) {printf("usage: sndinfo file\n"); exit(0);}
mus_sound_initialize();
for (ctr = 1; ctr < argc; ctr++)
{
if (mus_file_probe(argv[ctr])) /* see if it exists */
{
date = mus_sound_write_date(argv[ctr]);
srate = mus_sound_srate(argv[ctr]);
if (srate == MUS_ERROR)
{
fprintf(stdout, "%s: not a sound file?\n", argv[ctr]);
continue;
}
chans = mus_sound_chans(argv[ctr]);
samples = mus_sound_samples(argv[ctr]);
comment = mus_sound_comment(argv[ctr]);
if ((chans > 0) && (srate > 0))
length = (float)((double)samples / (double)(chans * srate));
loops = mus_sound_loop_info(argv[ctr]);
type = mus_sound_header_type(argv[ctr]);
header_name = (char *)mus_header_type_name(type);
samp_type = mus_sound_sample_type(argv[ctr]);
if (samp_type != MUS_UNKNOWN_SAMPLE)
samp_type_info = (char *)mus_sample_type_name(samp_type);
else
{
int orig_type;
if (samp_type_info == NULL) samp_type_info = (char *)calloc(64, sizeof(char));
orig_type = mus_sound_original_sample_type(argv[ctr]);
samp_type_name = (char *)mus_header_original_sample_type_name(orig_type, type);
if (samp_type_name)
snprintf(samp_type_info, 64, "%d (%s)", orig_type, samp_type_name);
else snprintf(samp_type_info, 64, "%d", orig_type);
}
fprintf(stdout, "%s:\n srate: %d\n chans: %d\n length: %f",
argv[ctr], srate, chans, length);
if (length < 10.0)
{
int samps;
samps = mus_sound_framples(argv[ctr]);
fprintf(stdout, " (%d sample%s)", samps, (samps != 1) ? "s" : "");
}
fprintf(stdout, "\n");
fprintf(stdout, " header type: %s\n sample type: %s\n ",
header_name,
samp_type_info);
strftime(timestr, 64, "%a %d-%b-%Y %H:%M %Z", localtime(&date));
fprintf(stdout, "written: %s", timestr);
if ((chans > 0) && (mus_sound_maxamp_exists(argv[ctr])))
{
ampstr = display_maxamps(argv[ctr], chans);
if (ampstr) fprintf(stdout, "%s", ampstr);
}
fprintf(stdout, "\n");
if (comment) fprintf(stdout, " comment: %s\n", comment);
if (loops)
{
fprintf(stdout, " loop: %d to %d\n", loops[0], loops[1]);
if (loops[2] != 0)
fprintf(stdout, " loop: %d to %d\n", loops[2], loops[3]);
if (loops[0] != 0)
fprintf(stdout, " base: %d, detune: %d\n", loops[4], loops[5]);
}
}
else
fprintf(stderr, "%s: %s\n", argv[ctr], strerror(errno));
if (ctr < argc - 1) fprintf(stdout, "\n");
}
return(0);
}