bool Midi2UdpThread::initSeq()
{
if(snd_seq_open(&seq_handle, "default", SND_SEQ_OPEN_INPUT, 0) < 0) {
printf("midi2udp: Error opening ALSA sequencer.\n");
return false;
}
snd_seq_set_client_name(seq_handle, "DSMIDIWIFI MIDI2UDP");
char portname[64] = "DSMIDIWIFI MIDI2UDP IN";
int res = midi_in_port = snd_seq_create_simple_port(seq_handle, portname, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE,
SND_SEQ_PORT_TYPE_APPLICATION);
if(res < 0) {
printf("midi2udp: Error creating MIDI port!\n");
snd_seq_close(seq_handle);
return false;
}
res = snd_midi_event_new(MAX_MIDI_MESSAGE_LENGTH, &eventparser);
if(res != 0) {
printf("midi2udp: Error making midi event parser!\n");
snd_seq_close(seq_handle);
return false;
}
snd_midi_event_init(eventparser);
midi_event = (snd_seq_event_t*)malloc(sizeof(snd_seq_event_t));
return true;
}
void Alsa::initialize()
{
// Set up the ALSA sequencer client.
snd_seq_t *seq;
int result = snd_seq_open( &seq, "default", SND_SEQ_OPEN_OUTPUT, SND_SEQ_NONBLOCK );
if ( result < 0 ) {
std::cerr << "error: CxxMidi::Output::Alsa::initialize: error creating ALSA sequencer client object" << std::endl;
}
// Set client name.
snd_seq_set_client_name( seq, "CxxMidi (RtMidi) output" );
// Save our api-specific connection information.
_apiData= new AlsaMidiData;
_apiData->seq = seq;
_apiData->vport = -1;
_apiData->bufferSize = 32;
_apiData->coder = 0;
_apiData->buffer = 0;
result = snd_midi_event_new( _apiData->bufferSize, &_apiData->coder );
if ( result < 0 ) {
delete _apiData;
std::cerr << "error: CxxMidi::Output::Alsa::initialize: error initializing MIDI event parser" << std::endl;
return;
}
_apiData->buffer = (unsigned char *) malloc( _apiData->bufferSize );
if ( _apiData->buffer == NULL ) {
delete _apiData;
std::cerr << "error: CxxMidi::Output::Alsa::initialize: error allocating buffer memory" << std::endl;
}
snd_midi_event_init( _apiData->coder );
}
void sys_alsa_putmidibyte(int portno, int byte)
{
static snd_midi_event_t *dev = NULL;
int res;
snd_seq_event_t ev;
if (!dev) {
snd_midi_event_new(ALSA_MAX_EVENT_SIZE, &dev);
//assert(dev);
snd_midi_event_init(dev);
}
snd_seq_ev_clear(&ev);
res = snd_midi_event_encode_byte(dev, byte, &ev);
if (res > 0 && ev.type != SND_SEQ_EVENT_NONE) {
// got a complete event, output it
snd_seq_ev_set_direct(&ev);
snd_seq_ev_set_subs(&ev);
snd_seq_ev_set_source(&ev, alsa_midioutfd[portno]);
snd_seq_event_output_direct(midi_handle, &ev);
}
if (res != 0)
// reinitialize the parser
snd_midi_event_init(dev);
}
void AlsaSeqMidiInDriver::open(device_id_t device)
{
if (this->is_open())
throw std::logic_error("Device already open");
int err;
err = snd_seq_open(&m_impl->seq, "default", SND_SEQ_OPEN_INPUT,
SND_SEQ_NONBLOCK);
if ( err < 0)
{
throw std::runtime_error("Error opening ALSA sequencer.");
}
std::ostringstream os;
os << "gephex input " << device;
std::string device_name = os.str();
err = snd_seq_set_client_name(m_impl->seq, device_name.c_str());
err = snd_seq_create_simple_port(m_impl->seq, device_name.c_str(),
SND_SEQ_PORT_CAP_WRITE|
SND_SEQ_PORT_CAP_SUBS_WRITE,
SND_SEQ_PORT_TYPE_APPLICATION);
if (err < 0)
{
snd_seq_close (m_impl->seq);
throw std::runtime_error("Error creating sequencer port.");
}
else
{
m_impl->portid = err;
snd_seq_ev_clear (&m_impl->SEv);
snd_seq_ev_set_source (&m_impl->SEv, m_impl->portid);
snd_seq_ev_set_subs (&m_impl->SEv);
snd_seq_ev_set_direct (&m_impl->SEv);
}
if( snd_midi_event_new (32, &m_impl->decoder) )
throw std::runtime_error ("Error creating midi event parser");
snd_midi_event_init(m_impl->decoder);
snd_midi_event_no_status (m_impl->decoder,1);
}
/* this version uses the asynchronous "read()" ... */
void sys_alsa_poll_midi(void)
{
unsigned char buf[ALSA_MAX_EVENT_SIZE];
int count, alsa_source;
int i;
snd_seq_event_t *midievent = NULL;
if (alsa_nmidiout == 0 && alsa_nmidiin == 0) return;
snd_midi_event_init(midiev);
if (!alsa_nmidiout && !alsa_nmidiin) return;
count = snd_seq_event_input_pending(midi_handle,1);
if (count != 0)
count = snd_seq_event_input(midi_handle,&midievent);
if (midievent != NULL)
{
count = snd_midi_event_decode(midiev,buf,sizeof(buf),midievent);
alsa_source = midievent->dest.port;
for(i=0;i<count;i++)
sys_midibytein(alsa_source, (buf[i] & 0xff));
//post("received %d midi bytes\n",count);
}
}
int snd_rawmidi_virtual_open(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp,
const char *name, snd_seq_t *seq_handle, int port,
int merge, int mode)
{
int err;
snd_rawmidi_t *rmidi;
snd_rawmidi_virtual_t *virt = NULL;
struct pollfd pfd;
if (inputp)
*inputp = 0;
if (outputp)
*outputp = 0;
virt = calloc(1, sizeof(*virt));
if (virt == NULL) {
err = -ENOMEM;
goto _err;
}
virt->handle = seq_handle;
virt->port = port;
err = snd_midi_event_new(256, &virt->midi_event);
if (err < 0)
goto _err;
snd_midi_event_init(virt->midi_event);
snd_midi_event_no_status(virt->midi_event, !merge);
if (inputp) {
rmidi = calloc(1, sizeof(*rmidi));
if (rmidi == NULL) {
err = -ENOMEM;
goto _err;
}
if (name)
rmidi->name = strdup(name);
rmidi->type = SND_RAWMIDI_TYPE_VIRTUAL;
rmidi->stream = SND_RAWMIDI_STREAM_INPUT;
rmidi->mode = mode;
err = snd_seq_poll_descriptors(seq_handle, &pfd, 1, POLLIN);
if (err < 0)
goto _err;
rmidi->poll_fd = pfd.fd;
rmidi->ops = &snd_rawmidi_virtual_ops;
rmidi->private_data = virt;
virt->open++;
*inputp = rmidi;
}
if (outputp) {
rmidi = calloc(1, sizeof(*rmidi));
if (rmidi == NULL) {
err = -ENOMEM;
goto _err;
}
if (name)
rmidi->name = strdup(name);
rmidi->type = SND_RAWMIDI_TYPE_VIRTUAL;
rmidi->stream = SND_RAWMIDI_STREAM_OUTPUT;
rmidi->mode = mode;
err = snd_seq_poll_descriptors(seq_handle, &pfd, 1, POLLOUT);
if (err < 0)
goto _err;
rmidi->poll_fd = pfd.fd;
rmidi->ops = &snd_rawmidi_virtual_ops;
rmidi->private_data = virt;
virt->open++;
*outputp = rmidi;
}
return 0;
_err:
if (seq_handle)
snd_seq_close(seq_handle);
if (virt) {
if (virt->midi_event)
snd_midi_event_free(virt->midi_event);
free(virt);
}
if (inputp)
free(*inputp);
if (outputp)
free(*outputp);
return err;
}
bool midi_init() {
snd_seq_addr_t sender, receiver;
snd_seq_port_info_t *pinfo;
snd_seq_client_info_t *cinfo;
bool found = false;
if (snd_seq_open(&s_midi, "default", SND_SEQ_OPEN_OUTPUT, 0) < 0) {
Error("Failed to initialize MIDI\n");
s_midi = NULL;
return false;
}
snd_seq_set_client_name(s_midi, s_midiCaption);
/* Create a port to work on */
s_midiPort = snd_seq_create_simple_port(s_midi, s_midiCaption, SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ, SND_SEQ_PORT_TYPE_MIDI_GENERIC);
if (s_midiPort < 0) {
Error("Failed to initialize MIDI\n");
snd_seq_close(s_midi);
s_midi = NULL;
return false;
}
/* Try to find a MIDI out */
snd_seq_port_info_alloca(&pinfo);
snd_seq_client_info_alloca(&cinfo);
snd_seq_client_info_set_client(cinfo, -1);
/* Walk all clients and ports, and see if one matches our demands */
while (snd_seq_query_next_client(s_midi, cinfo) >= 0 && !found) {
int client;
client = snd_seq_client_info_get_client(cinfo);
if (client == 0) continue;
snd_seq_port_info_set_client(pinfo, client);
snd_seq_port_info_set_port(pinfo, -1);
while (snd_seq_query_next_port(s_midi, pinfo) >= 0) {
if ((snd_seq_port_info_get_capability(pinfo) & (SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE)) != (SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE)) continue;
/* Most linux installations come with a Midi Through Port.
* This is 'hardware' support that mostly ends up on your serial, which
* you most likely do not have connected. So we skip it by default. */
if (strncmp("Midi Through Port", snd_seq_port_info_get_name(pinfo), 17) == 0) continue;
found = true;
break;
}
}
if (!found) {
Error("No valid MIDI output ports.\n Please install and start Timidity++ like: timidity -iA\n");
snd_seq_delete_port(s_midi, s_midiPort);
snd_seq_close(s_midi);
s_midi = NULL;
return false;
}
/* Subscribe ourself to the port */
receiver.client = snd_seq_port_info_get_client(pinfo);
receiver.port = snd_seq_port_info_get_port(pinfo);
sender.client = snd_seq_client_id(s_midi);
sender.port = s_midiPort;
snd_seq_port_subscribe_malloc(&s_midiSubscription);
snd_seq_port_subscribe_set_sender(s_midiSubscription, &sender);
snd_seq_port_subscribe_set_dest(s_midiSubscription, &receiver);
snd_seq_port_subscribe_set_time_update(s_midiSubscription, 1);
snd_seq_port_subscribe_set_time_real(s_midiSubscription, 1);
if (snd_seq_subscribe_port(s_midi, s_midiSubscription) < 0) {
Error("Failed to subscript to MIDI output\n");
snd_seq_delete_port(s_midi, s_midiPort);
snd_seq_close(s_midi);
s_midi = NULL;
return false;
}
/* Start the MIDI decoder */
if (snd_midi_event_new(4, &s_midiCoder) < 0) {
Error("Failed to initialize MIDI decoder\n");
snd_seq_delete_port(s_midi, s_midiPort);
snd_seq_close(s_midi);
s_midi = NULL;
return false;
}
snd_midi_event_init(s_midiCoder);
return true;
}
