static Xen g_mus_bytes_per_sample(Xen samp_type)
{
#define H_mus_bytes_per_sample "(" S_mus_bytes_per_sample " sample-type): number of bytes per sample in \
sample-type (e.g. " S_mus_bshort " = 2)"
Xen_check_type(Xen_is_integer(samp_type), samp_type, 1, S_mus_bytes_per_sample, "an integer (sample-type id)");
return(C_int_to_Xen_integer(mus_bytes_per_sample((mus_sample_t)Xen_integer_to_C_int(samp_type))));
}
const char *mus_array_to_file_with_error(const char *filename, mus_float_t *ddata, mus_long_t len, int srate, int channels)
{
/* put ddata into a sound file, taking byte order into account */
/* assume ddata is interleaved already if more than one channel */
int fd, err = MUS_NO_ERROR;
mus_long_t oloc;
mus_float_t *bufs[1];
mus_sound_forget(filename);
err = mus_write_header(filename, MUS_NEXT, srate, channels, len * channels, MUS_OUT_FORMAT, "array->file");
if (err != MUS_NO_ERROR)
return("mus_array_to_file can't create output file");
oloc = mus_header_data_location();
fd = mus_file_reopen_write(filename);
lseek(fd, oloc, SEEK_SET);
err = mus_file_open_descriptors(fd, filename,
MUS_OUT_FORMAT,
mus_bytes_per_sample(MUS_OUT_FORMAT),
oloc, channels, MUS_NEXT);
if (err != MUS_ERROR)
{
bufs[0] = ddata;
err = mus_file_write(fd, 0, len - 1, 1, bufs); /* 1 = chans?? */
}
mus_file_close(fd);
if (err == MUS_ERROR)
return("mus_array_to_file write error");
return(NULL);
}
static int mus_sound_set_field(const char *arg, sf_field_t field, int val)
{
sound_file *sf;
int result = MUS_NO_ERROR;
sf = get_sf(arg);
if (sf)
{
switch (field)
{
case SF_CHANS:
sf->chans = val;
break;
case SF_SRATE:
sf->srate = val;
break;
case SF_TYPE:
sf->header_type = val;
break;
case SF_FORMAT:
sf->data_format = val;
sf->datum_size = mus_bytes_per_sample(val);
break;
default:
result = MUS_ERROR;
break;
}
}
else result = MUS_ERROR;
return(result);
}
int snd_file_open_descriptors(int fd, const char *name, int format, mus_long_t location, int chans, int type)
{
int sl_err = MUS_NO_ERROR;
sl_err = mus_file_open_descriptors(fd, name, format, mus_bytes_per_sample(format), location, chans, type);
if (sl_err != MUS_NO_ERROR)
snd_warning("%s: open file descriptors: %s", name, mus_error_type_to_string(sl_err));
return(sl_err);
}
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);
}
snd_data *make_snd_data_file(const char *name, snd_io *io, file_info *hdr, file_delete_t temp, int ctr, int temp_chan)
{
snd_data *sd;
sd = (snd_data *)calloc(1, sizeof(snd_data));
sd->type = SND_DATA_FILE;
sd->buffered_data = io->arrays[temp_chan];
sd->io = io;
sd->filename = mus_strdup(name);
sd->hdr = hdr;
sd->temporary = temp;
if ((temp == MULTICHANNEL_DELETION) || (temp == MULTICHANNEL_DELETION_IF_FILE)) tick_temp(name, temp_chan);
sd->edit_ctr = ctr;
sd->open = FD_OPEN;
sd->inuse = false;
sd->copy = false;
sd->chan = temp_chan;
sd->data_bytes = (hdr->samples) * (mus_bytes_per_sample(hdr->format)) + hdr->data_location;
return(sd);
}
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);
}
int mus_sound_override_header(const char *arg, int srate, int chans, int format, int type, mus_long_t location, mus_long_t size)
{
sound_file *sf;
int result = MUS_NO_ERROR;
/* perhaps once a header has been over-ridden, we should not reset the relevant fields upon re-read? */
sf = get_sf(arg);
if (sf)
{
if (location != -1) sf->data_location = location;
if (size != -1) sf->samples = size;
if (format != -1)
{
sf->data_format = format;
sf->datum_size = mus_bytes_per_sample(format);
}
if (srate != -1) sf->srate = srate;
if (chans != -1) sf->chans = chans;
if (type != -1) sf->header_type = type;
}
else result = MUS_ERROR;
return(result);
}
static int main_not_alsa(int argc, char *argv[])
{
int fd, afd, i, j, n, k, chans, srate;
off_t frames, m;
mus_sample_t **bufs;
OutSample *obuf;
int use_multi_card_code = 0, use_volume = 0;
int afd0, afd1, buffer_size = BUFFER_SIZE, curframes, sample_size, out_chans, outbytes;
mus_sample_t **qbufs;
short *obuf0, *obuf1;
char *name = NULL;
off_t start = 0, end = 0;
double begin_time = 0.0, end_time = 0.0, volume = 1.0;
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "-describe") == 0)
{
mus_audio_describe();
exit(0);
}
else
{
if (strcmp(argv[i], "-buffers") == 0)
{
set_buffers(argv[i + 1]);
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], "-volume") == 0)
{
volume = atof(argv[i + 1]);
use_volume = 1;
i++;
}
else name = argv[i];
}}}}}}
if (name == NULL)
{
printf("usage: sndplay file [-start 1.0] [-end 1.0] [-bufsize %d] [-buffers 2x12] [-volume 1.0] [-describe]\n", BUFFER_SIZE);
exit(0);
}
afd = -1;
afd0 = -1;
afd1 = -1;
if (!(MUS_HEADER_TYPE_OK(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_OK(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)
{
float val[8];
mus_audio_mixer_read(MUS_AUDIO_DEFAULT, MUS_AUDIO_CHANNEL, 0, val);
if (val[0] < chans)
{
if (mus_audio_systems() > 1)
use_multi_card_code = 1;
/* I suppose we could count up all the channels here */
else
{
fprintf(stderr, "%s has %d channels, but we can only handle %d\n", name, chans, (int)(val[0]));
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 = (off_t)(begin_time * srate);
if (start > 0)
mus_file_seek_frame(fd, start);
if (end_time > 0.0)
end = (off_t)(end_time * srate);
else end = frames;
if ((end - start) < frames)
frames = end - start;
if (!use_multi_card_code)
{
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 (use_volume)
set_volume(bufs, chans, curframes, volume);
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 (afd == -1)
{
#if defined(MUS_LINUX) && defined(PPC)
afd = mus_audio_open_output(MUS_AUDIO_DEFAULT, srate, chans, MUS_AUDIO_COMPATIBLE_FORMAT, 0);
#else
afd = mus_audio_open_output(MUS_AUDIO_DEFAULT, srate, out_chans, MUS_AUDIO_COMPATIBLE_FORMAT, outbytes);
#endif
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);
}
else
{
/* code is essentially the same as above, but since this is supposed
* to be a working example of sndlib, I didn't want the basic stuff
* to be complicated by one special case.
*
* in my test case, I was using a Sound Blaster and an Ensoniq clone.
* they had slightly different start-up latencies (not really audible),
* and the Ensoniq's dac was running ca. 1 sample per second faster than
* the SB's, so by 5 minutes into a sound, the stereo pairs had drifted
* .01 seconds apart -- this is probably acceptable in many cases.
* In a second test, with two Ensoniq's in one machine, they started
* together and drifted apart at about 1 sample per 8 seconds -- about
* .001 secs apart after 5 minutes. ("Ensoniq" was SoundWave Pro PCI
* from SIIG Inc -- some sort of clone.)
*/
buffer_size = 256; /* 128 probably better */
outbytes = buffer_size * 2 * 2;
qbufs = (mus_sample_t **)calloc(chans, sizeof(mus_sample_t *));
for (i = 0; i < chans; i++) qbufs[i] = (mus_sample_t *)calloc(buffer_size, sizeof(mus_sample_t));
obuf0 = (short *)calloc(buffer_size * 2, sizeof(short));
obuf1 = (short *)calloc(buffer_size * 2, sizeof(short));
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, qbufs);
if (use_volume)
set_volume(qbufs, chans, curframes, volume);
for (k = 0, n = 0; k < buffer_size; k++, n += 2)
{
obuf0[n] = MUS_SAMPLE_TO_SHORT(qbufs[0][k]);
obuf0[n + 1] = MUS_SAMPLE_TO_SHORT(qbufs[1][k]);
obuf1[n] = MUS_SAMPLE_TO_SHORT(qbufs[2][k]);
obuf1[n + 1] = MUS_SAMPLE_TO_SHORT(qbufs[3][k]);
}
if (afd0 == -1)
{
afd0 = mus_audio_open_output(MUS_AUDIO_PACK_SYSTEM(0) | MUS_AUDIO_DEFAULT, srate, 2, MUS_AUDIO_COMPATIBLE_FORMAT, outbytes);
afd1 = mus_audio_open_output(MUS_AUDIO_PACK_SYSTEM(1) | MUS_AUDIO_DEFAULT, srate, 2, MUS_AUDIO_COMPATIBLE_FORMAT, outbytes);
if ((afd0 == -1) || (afd1 == -1)) break;
}
mus_audio_write(afd0, (char *)obuf0, outbytes);
mus_audio_write(afd1, (char *)obuf1, outbytes);
}
mus_audio_close(afd0);
mus_audio_close(afd1);
mus_sound_close_input(fd);
for (i = 0; i < chans; i++) free(qbufs[i]);
free(qbufs);
free(obuf0);
free(obuf1);
}
}
return(0);
}
static int main_alsa(int argc, char *argv[])
{
int fd, i, chans, srate;
off_t frames, ioff;
mus_sample_t **read_bufs;
int afd[MAX_SLOTS];
short *out_buf[MAX_SLOTS];
float val[MAX_SLOTS];
int ival[MAX_SLOTS];
int afd0, afd1;
char *name;
int base, curframes;
int allocated;
int out_devs[MAX_SLOTS];
int out_chans[MAX_SLOTS];
int out_format[MAX_SLOTS];
int out_bytes[MAX_SLOTS];
int samples_per_chan;
int last_device;
int devices[MAX_SLOTS];
int available_chans[MAX_SLOTS];
int min_chans[MAX_SLOTS];
int max_chans[MAX_SLOTS];
int alloc_chans;
off_t start = 0, end = 0;
double begin_time = 0.0, end_time = 0.0, volume = 1.0;
int use_volume = 0;
/* -describe => call mus_audio_describe and exit
* -buffers axb => set OSS fragment numbers
*/
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "-describe") == 0)
{
mus_audio_describe();
exit(0);
}
else
{
if (strcmp(argv[i], "-buffers") == 0)
{
set_buffers(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], "-volume") == 0)
{
volume = atof(argv[i + 1]);
use_volume = 1;
i++;
}
else name = argv[i];
}}}}}
afd0 = -1;
afd1 = -1;
if (!(MUS_HEADER_TYPE_OK(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_OK(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)
{
/* try to select proper device */
float dir;
int cards, card;
int sysdev, devs, dev, d, i, im;
int first_samples_per_chan = -1;
cards = mus_audio_systems();
/* deselect all devices */
for (d = 0; d < MAX_SLOTS; d++)
{
out_devs[d] = -1;
afd[d] = -1;
}
/* Scan all cards and build a list of available output devices.
This is evil because it second guesses the intentions of the
user, best would be to have a command line parameter that
points to the device or devices to be used. For things to
work under alsa .5 and multichannel cards it has to be here.
Hopefully the need will go away (in alsa .6 it will definitely
not be needed).
*/
i = 0;
im = 0;
for (card = 0; card < cards; card++)
{
/* get the list of all available devices */
mus_audio_mixer_read(MUS_AUDIO_PACK_SYSTEM(card), MUS_AUDIO_PORT, MAX_SLOTS, val);
devs = (int)(val[0]);
for (d = 0; d < devs; d++)
{
dev = (int)(val[d + 1]);
sysdev = MUS_AUDIO_PACK_SYSTEM(card)|dev;
mus_audio_mixer_read(sysdev, MUS_AUDIO_DIRECTION, 0, &dir);
/* only consider output devices */
if ((int)dir == 0)
{
float ch[4];
/* get the number of channels the device supports */
mus_audio_mixer_read(sysdev, MUS_AUDIO_CHANNEL, 4, ch);
available_chans[i] = (int)(ch[0]);
if ((int)ch[2] != 0) /* alsa also sets min and max channels */
{
min_chans[i] = (int)(ch[1]);
max_chans[i] = (int)(ch[2]);
}
if (max_chans[i] > max_chans[im]) im = i;
/* find out what format we can use with the device */
out_format[i] = mus_audio_compatible_format(sysdev);
/* find out what buffer size the device wants */
mus_audio_mixer_read(sysdev, MUS_AUDIO_SAMPLES_PER_CHANNEL, 2, ch);
samples_per_chan = (int)ch[0];
/* skip device if it has different buffer size, all must match */
if (first_samples_per_chan == -1)
first_samples_per_chan = samples_per_chan;
else
if (samples_per_chan != first_samples_per_chan)
continue;
devices[i++] = sysdev;
if (i >= MAX_SLOTS)
goto NO_MORE_DEVICES;
}
}
}
NO_MORE_DEVICES:
last_device = i;
chans = mus_sound_chans(name);
allocated = 0;
if (available_chans[im] >= chans)
{
/* the widest device is wide enough to play all channels so we use it */
out_devs[allocated] = im;
out_chans[allocated] = chans;
if (chans < min_chans[im])
out_chans[allocated] = min_chans[im];
alloc_chans = out_chans[allocated];
allocated++;
}
else
{
alloc_chans = 0;
if (use_one_device == 0)
{
/* allocate devices until all channels can be played */
for (i = 0; i < last_device; i++)
{
out_devs[allocated] = i;
out_chans[allocated] = available_chans[i];
alloc_chans += available_chans[out_devs[allocated]];
allocated++;
if (alloc_chans >= chans)
break;
}
}
if (alloc_chans < chans)
{
/* FOR NOW, fail the program, not enough channels... */
fprintf(stderr, "not enough channels, %d available, %d needed\n",
available_chans[0], chans);
exit(1);
/* either not enough channels found or have to use just
one device and the widest can't do it, so fold all of
them into whatever the first device can do */
allocated = 0;
out_devs[allocated] = 0;
out_chans[allocated] = available_chans[0];
alloc_chans = out_chans[allocated];
allocated++;
}
}
srate = mus_sound_srate(name);
frames = mus_sound_frames(name);
base = 0;
start = (off_t)(begin_time * srate);
if (start > 0)
mus_file_seek_frame(fd, start);
if (end_time > 0.0)
end = (off_t)(end_time * srate);
else end = frames;
if ((end - start) < frames)
frames = end - start;
/* allocate the list of read buffers, each buffer will hold one channel
of the input soundfile, each sample is going to be mus_sample_t
*/
read_bufs = (mus_sample_t **)calloc(alloc_chans, sizeof(mus_sample_t *));
for (d = 0; d < allocated; d++)
{
int dev = out_devs[d];
for (i = 0; i < out_chans[d]; i++)
read_bufs[base + i] = (mus_sample_t *)calloc(samples_per_chan, sizeof(mus_sample_t));
base += out_chans[d];
out_bytes[dev] = samples_per_chan * out_chans[d] * mus_bytes_per_sample(out_format[dev]);
out_buf[dev] = (short *)calloc(out_bytes[dev], 1);
}
for (ioff = 0; ioff < frames; ioff += samples_per_chan)
{
mus_sample_t **dev_bufs = read_bufs;
if ((ioff + samples_per_chan) <= frames)
curframes = samples_per_chan;
else
{
curframes = frames - ioff;
for (d = 0; d < allocated; d++)
{
int f, dev = out_devs[d];
#if 1
/* try to kludge around an ALSA bug... */
for (f = 0; f < chans; f++)
memset(read_bufs[f], 0, samples_per_chan * sizeof(mus_sample_t));
#endif
out_bytes[dev] = curframes * out_chans[d] * mus_bytes_per_sample(out_format[dev]);
}
}
mus_file_read(fd, 0, curframes - 1, chans, read_bufs);
if (use_volume)
set_volume(read_bufs, chans, curframes, volume);
/* 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 */
for (d = 0; d < allocated; d++)
{
int dev = out_devs[d];
mus_file_write_buffer(out_format[dev],
0, curframes - 1,
out_chans[d],
dev_bufs,
(char *)(out_buf[dev]),
0);
if (afd[dev] == -1)
{
#if defined(PPC)
afd[dev] = mus_audio_open_output(devices[dev], srate, out_chans[d], out_format[dev], 0);
#else
afd[dev] = mus_audio_open_output(devices[dev], srate, out_chans[d], out_format[dev], out_bytes[dev]);
#endif
if (afd[dev] == -1) break;
}
mus_audio_write(afd[dev], (char *)out_buf[dev], out_bytes[dev]);
dev_bufs += out_chans[d];
}
}
for (d = 0; d < allocated; d++)
{
int dev = out_devs[d];
if (afd[dev] != -1) mus_audio_close(afd[dev]);
}
mus_sound_close_input(fd);
for (i = 0; i < alloc_chans; i++) free(read_bufs[i]);
free(read_bufs);
for (d = 0; d < allocated; d++)
{
int dev = out_devs[d];
free(out_buf[dev]);
}
}
return(0);
}
static sound_file *fill_sf_record(const char *name, sound_file *sf)
{
int i;
sf->data_location = mus_header_data_location();
sf->samples = mus_header_samples();
sf->data_format = mus_header_format();
sf->srate = mus_header_srate();
/* if (sf->srate < 0) sf->srate = 0; */
sf->chans = mus_header_chans();
/* if (sf->chans < 0) sf->chans = 0; */
sf->datum_size = mus_bytes_per_sample(sf->data_format);
sf->header_type = mus_header_type();
sf->original_sound_format = mus_header_original_format();
sf->true_file_length = mus_header_true_length();
sf->comment_start = mus_header_comment_start();
sf->comment_end = mus_header_comment_end();
if (((sf->header_type == MUS_AIFC) ||
(sf->header_type == MUS_AIFF) ||
(sf->header_type == MUS_RF64) ||
(sf->header_type == MUS_RIFF)) &&
(mus_header_aux_comment_start(0) != 0))
{
sf->aux_comment_start = (mus_long_t *)calloc(4, sizeof(mus_long_t));
sf->aux_comment_end = (mus_long_t *)calloc(4, sizeof(mus_long_t));
for (i = 0; i < 4; i++)
{
sf->aux_comment_start[i] = mus_header_aux_comment_start(i);
sf->aux_comment_end[i] = mus_header_aux_comment_end(i);
}
}
sf->type_specifier = mus_header_type_specifier();
sf->bits_per_sample = mus_header_bits_per_sample();
sf->fact_samples = mus_header_fact_samples();
sf->block_align = mus_header_block_align();
sf->write_date = local_file_write_date(name);
if ((sf->header_type == MUS_AIFF) || (sf->header_type == MUS_AIFC))
{
int *marker_ids, *marker_positions;
sf->markers = mus_header_mark_info(&marker_ids, &marker_positions);
if (sf->markers > 0)
{
sf->marker_ids = (int *)malloc(sf->markers * sizeof(int));
sf->marker_positions = (int *)malloc(sf->markers * sizeof(int));
memcpy((void *)(sf->marker_ids), (void *)marker_ids, sizeof(int) * sf->markers);
memcpy((void *)(sf->marker_positions), (void *)marker_positions, sizeof(int) * sf->markers);
}
}
if (mus_header_loop_mode(0) > 0)
{
sf->loop_modes = (int *)calloc(2, sizeof(int));
sf->loop_starts = (int *)calloc(2, sizeof(int));
sf->loop_ends = (int *)calloc(2, sizeof(int));
for (i = 0; i < 2; i++)
{
sf->loop_modes[i] = mus_header_loop_mode(i);
if ((sf->header_type == MUS_AIFF) ||
(sf->header_type == MUS_AIFC))
{
sf->loop_starts[i] = mus_header_mark_position(mus_header_loop_start(i));
sf->loop_ends[i] = mus_header_mark_position(mus_header_loop_end(i));
}
else
{
sf->loop_starts[i] = mus_header_loop_start(i);
sf->loop_ends[i] = mus_header_loop_end(i);
}
}
sf->base_detune = mus_header_base_detune();
sf->base_note = mus_header_base_note();
}
return(sf);
}
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);
}