static int midi_open(const char *name, int input)
{
int err;
snd_rawmidi_t *line;
snd_rawmidi_params_t *params;
if (input == MIDI_READ)
err = snd_rawmidi_open(&line, NULL, name, SND_RAWMIDI_NONBLOCK);
else err = snd_rawmidi_open(NULL, &line, name, SND_RAWMIDI_NONBLOCK);
if (err)
{
#ifdef NO_SNDLIB
fprintf(stderr, "can't open %s: %s\n", name, strerror(err));
#else
return(mus_error(MUS_MIDI_OPEN_ERROR, "can't open %s: %s", name, strerror(err)));
#endif
return(-1);
}
snd_rawmidi_params_malloc(¶ms);
err = snd_rawmidi_params_set_buffer_size(line, params, DEV_BUFSIZE);
if (err)
{
snd_rawmidi_params_free(params);
snd_rawmidi_close(line);
#ifdef NO_SNDLIB
fprintf(stderr, "can't set %s buffer size to %d: %s\n", name, DEV_BUFSIZE, strerror(err));
#else
return(mus_error(MUS_MIDI_MISC_ERROR, "can't set %s buffer size to %d: %s", name, DEV_BUFSIZE, strerror(err)));
#endif
return(-1);
}
return(new_midi_line(name, line, params, input));
}
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_midi_write(int line, unsigned char *buffer, int bytes)
{
int i;
MDevent mdv;
if ((line < 0) || (line >= midis)) return(-1);
if (midi_directions[line] == MIDI_WRITE)
{
/* no sysex for now */
mdv.sysexmsg = NULL;
mdv.msglen = 0;
for (i = 0; i < bytes; i += 3)
{
mdv.msg[0] = buffer[i];
mdv.msg[1] = buffer[i + 1];
mdv.msg[2] = buffer[i + 2];
mdSend(midi_lines[line], &mdv, 1);
}
return(bytes);
}
#ifdef NO_SNDLIB
fprintf(stderr, "can't write to input %s\n", midi_names[line]);
return(-1);
#else
return(mus_error(MUS_MIDI_WRITE_ERROR, "can't write to input %s", midi_names[line]));
#endif
}
mus_long_t mus_file_to_array(const char *filename, int chan, mus_long_t start, mus_long_t samples, mus_float_t *array)
{
int ifd, chans;
mus_long_t total_read;
mus_float_t **bufs;
ifd = mus_sound_open_input(filename);
if (ifd == MUS_ERROR) return(MUS_ERROR);
chans = mus_sound_chans(filename);
if (chan >= chans)
{
mus_sound_close_input(ifd);
return(mus_error(MUS_NO_SUCH_CHANNEL, "mus_file_to_array can't read %s channel %d (file has %d chans)", filename, chan, chans));
}
bufs = (mus_float_t **)calloc(chans, sizeof(mus_float_t *));
bufs[chan] = array;
mus_file_seek_frame(ifd, start);
total_read = mus_file_read_any(ifd, 0, chans, samples, bufs, bufs);
mus_sound_close_input(ifd);
free(bufs);
return(total_read);
}
int mus_array_to_file(const char *filename, mus_float_t *ddata, mus_long_t len, int srate, int channels)
{
const char *errmsg;
errmsg = mus_array_to_file_with_error(filename, ddata, len, srate, channels);
if (errmsg)
return(mus_error(MUS_CANT_OPEN_FILE, "%s", errmsg));
return(MUS_NO_ERROR);
}
int mus_midi_write(int line, unsigned char *buffer, int bytes)
{
if ((line < 0) || (line >= midis)) return(-1);
if (midi_directions[line] == MIDI_WRITE)
return(snd_rawmidi_write(midi_lines[line], buffer, bytes));
#ifdef NO_SNDLIB
fprintf(stderr, "can't write to input %s\n", midi_names[line]);
#else
return(mus_error(MUS_MIDI_WRITE_ERROR, "can't write to input %s", midi_names[line]));
#endif
return(-1);
}
static void mus_midi_initialize(void)
{
if (midi_initialized == 0)
{
midi_ports = mdInit();
if (midi_ports == -1)
#ifdef NO_SNDLIB
fprintf(stderr, "startmidi not called?");
#else
mus_error(MUS_MIDI_INIT_ERROR, "startmidi not called?");
#endif
midi_initialized = 1;
}
}
int midi_open(const char *name, int input)
{
MDport md;
mus_midi_initialize();
if (input == MIDI_READ)
md = mdOpenInPort((char *)name);
else md = mdOpenOutPort((char *)name);
if (md == NULL)
{
#ifdef NO_SNDLIB
fprintf(stderr, "can't open %s\n", name);
return(-1);
#else
return(mus_error(MUS_MIDI_OPEN_ERROR, "can't open %s", name));
#endif
}
mdSetStampMode(md, MD_NOSTAMP);
return(new_midi_line(name, md, input));
}
int mus_midi_read(int line, unsigned char *buffer, int bytes)
{
MDevent mdv;
int i;
if ((line < 0) || (line >= midis)) return(-1);
if (midi_directions[line] == MIDI_READ)
{
for (i = 0; i < bytes; i += 3)
{
mdReceive(midi_lines[line], &mdv, 1);
buffer[i] = mdv.msg[0];
buffer[i + 1] = mdv.msg[1];
buffer[i + 2] = mdv.msg[2];
}
return(bytes);
}
#ifdef NO_SNDLIB
fprintf(stderr, "can't read from output %s\n", midi_names[line]);
return(-1);
#else
return(mus_error(MUS_MIDI_READ_ERROR, "can't read from output %s", midi_names[line]));
#endif
}
int mus_midi_close(int line)
{
int err = 0;
if ((line >= 0) && (line < midis))
{
free(midi_names[line]);
midi_names[line] = NULL;
snd_rawmidi_params_free(midi_params[line]);
midi_params[line] = NULL;
err = snd_rawmidi_close(midi_lines[line]);
midi_lines[line] = NULL;
}
if (err)
{
#ifdef NO_SNDLIB
fprintf(stderr, "can't close %s: %s\n", midi_names[line], strerror(err));
#else
return(mus_error(MUS_MIDI_CLOSE_ERROR, "can't close %s: %s", midi_names[line], strerror(err)));
#endif
return(-1);
}
return(0);
}
