int MidiInit(void *arg) { int status; int mode = SND_RAWMIDI_SYNC; char *portname = arg; midi.midiin = NULL; midi.midiout = NULL; char resetPad[3] = {0xB0, 0x00, 0x00}; char setDrumMapping[3] = {0xB0, 0x00, 0x02}; // configure drum rack layout // open in/out if ((status = snd_rawmidi_open(&(midi.midiin), &(midi.midiout), portname, mode)) < 0) { errormessage("Problem opening MIDI input: %s", snd_strerror(status)); exit(1); } // reset launchpad (replace with generic reset) if ((status = snd_rawmidi_write(midi.midiout, resetPad, 3)) < 0) { errormessage("Problem writing to MIDI output: %s", snd_strerror(status)); exit(1); } // reset launchpad (replace with generic reset) if ((status = snd_rawmidi_write(midi.midiout, setDrumMapping, 3)) < 0) { errormessage("Problem writing to MIDI output: %s", snd_strerror(status)); exit(1); } return NULL; }
int writepattern(snd_rawmidi_t *handle_out, unsigned char *obuf) { int patsize, i; patsize = 0; for (i = 0; i < 15; i++) { obuf[patsize++] = 0x90 + i; obuf[patsize++] = 0x40; obuf[patsize++] = 0x3f; obuf[patsize++] = 0xb0 + i; obuf[patsize++] = 0x2e; obuf[patsize++] = 0x7a; obuf[patsize++] = 0x80 + i; obuf[patsize++] = 0x23; obuf[patsize++] = 0x24; obuf[patsize++] = 0xf0; obuf[patsize++] = i; obuf[patsize++] = 0xf7; } i = snd_rawmidi_write(handle_out, obuf, patsize); if (i != patsize) { printf("Written only %i bytes from %i bytes\n", i, patsize); exit(EXIT_FAILURE); } return patsize; }
bool Dicer_control_process::set_button_state(const dicer_t &dicer_index, const dicer_mode_t &mode, const dicer_button_t &button_index, const dicer_button_state_t &state) { if (this->is_open == true) { unsigned char midi_buf[3] = {0x0, 0x0, 0x0}; // Build the MIDI command which changes the state of a button on the Dicer. this->build_midi_buffer(dicer_index, mode, button_index, state, midi_buf); #if 0 cout << "write" << "\tl/r+mode:" << hex << "0x"<< static_cast<unsigned int>(static_cast<unsigned char>(midi_buf[0])) << "\tbutton:" << hex << "0x"<< static_cast<unsigned int>(static_cast<unsigned char>(midi_buf[1])) << "\tlit+color::" << hex << "0x"<< static_cast<unsigned int>(static_cast<unsigned char>(midi_buf[2])) << endl; #endif // Send the MIDI command to the Dicer. #ifdef WIN32 // TODO: add Dicer support for Windows. return false; #else int err = 0; if ((err = snd_rawmidi_write(this->midi_out, midi_buf, sizeof(midi_buf))) < 0) { qCWarning(DS_DICER) << "can not set button state to Dicer: " << snd_strerror(err); return false; } #endif } return true; }
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); }
void *midifunction(void *arg) { // this is the parameter passed via last argument of pthread_create(): struct midinodes *midi = (struct midinodes*)arg; char buffer[1]; int count = 0; int status; int byteNum = 0; char outBuffer[3] = {0x90, 0x00, 15}; note currentNote; printf("midi thread start\n"); while (1) { if ((status = snd_rawmidi_read(midi->midiin, buffer, 1)) < 0) { errormessage("Problem reading MIDI input: %s", snd_strerror(status)); } count++; // determine part of message if(byteNum == 0) { // note outBuffer[1] = currentNote.key = buffer[0]; byteNum = 1; } else { if(buffer[0] > 0) outBuffer[2] = currentNote.vel = NOTE_ON; else outBuffer[2] = currentNote.vel = NOTE_OFF; byteNum = 0; } // after velocity, write if(byteNum == 0) { if ((status = snd_rawmidi_write(midi->midiout, outBuffer, 3)) < 0) { errormessage("Problem writing to MIDI output: %s", snd_strerror(status)); exit(1); } printf("Note: %d %d %d \n", outBuffer[0], currentNote.key, currentNote.vel); SynthNoteStart(currentNote); } fflush(stdout); } return NULL; }
static int midiwrite(unsigned char *buffer, int buflen) { int status; if(MidiOut==NULL) { midiexcept("midi not opened", 0); return 0; } status = snd_rawmidi_write(MidiOut, buffer, buflen); if(status<0) { midiexcept("error writing midi: %s", status); return 0; } return 1; }
int main(void) { snd_rawmidi_open(&midi_in, &midi_out, "virtual", SND_RAWMIDI_NONBLOCK); //snd_rawmidi_open(&midi_in, &midi_out, "virtual", 0); if (ftdi_init( &ftdi )) { fprintf(stderr, "usb - init error !\n"); return 1; } if (ftdi_usb_open(&ftdi, 0x0403, 0x6001)) { fprintf(stderr, "usb - open error (cannot find?) !\n"); fprintf(stderr, "ftdi_usb_open failed, error (%s)\n", ftdi_get_error_string(&ftdi)); ftdi_deinit( &ftdi ); return 2; } if (ftdi_usb_reset( &ftdi )) { fprintf(stderr, "usb - reset error !\n"); ftdi_usb_close( &ftdi ); ftdi_deinit( &ftdi ); return 3; } ftdi_disable_bitbang( &ftdi ); ftdi_set_baudrate(&ftdi, BAUD); unsigned char buf[BUFFER_SIZE]; int ret; while(1) { //FTDI2MIDI ret = ftdi_read_data(&ftdi, buf, BUFFER_SIZE); if(ret < 0) break; if(ret > 0) snd_rawmidi_write(midi_out, buf, BUFFER_SIZE); //MIDI2FTDI /* ret = snd_rawmidi_read(midi_in, buf,BUFFER_SIZE); if(ret < 0 && ret != -EAGAIN) break; if(ret > 0) ftdi_write_data(&ftdi, buf,BUFFER_SIZE); */ usleep(LATENCY); } exit(0); }
/* alsa_rawmidi_output: * Outputs MIDI data. */ static void alsa_rawmidi_output(int data) { int err; /* If there are too many errors, just give up. Otherwise the calling thread * can end up consuming CPU time for no reason. It probably means the user * hasn't configured ALSA properly. */ if (alsa_rawmidi_errors > ALSA_RAWMIDI_MAX_ERRORS) { return; } err = snd_rawmidi_write(rawmidi_handle, &data, sizeof(char)); if (err) { alsa_rawmidi_errors++; if (alsa_rawmidi_errors == ALSA_RAWMIDI_MAX_ERRORS) { TRACE("al-alsamidi: too many errors, giving up\n"); } } }
void echomidi(snd_rawmidi_t* midiin, snd_rawmidi_t* midiout) { unsigned char readbuffer; // storage for input MIDI byte stream unsigned char buffer[1024]={0}; // storage space for incoming commands int dataptr=0; // writing index in buffer int argsLeft=0; // bytes left to read for a command int transpose=6;// transposition for note out int newnote; // temp storage for output note int status; // storage for error codes while(true) { if ((status=snd_rawmidi_read(midiin, &readbuffer, 1)) < 0) { errormessage("Problem reading MIDI input: %s", snd_strerror(status)); } if (readbuffer & 0x80) {// a command byte has arrived argsLeft=getArgsExpected(readbuffer); dataptr=0; buffer[dataptr++]=readbuffer; } else {// a data byte has arrived if ((dataptr==0) || (argsLeft <=0)) { argsLeft=getArgsExpected(buffer[0]); dataptr=1; } buffer[dataptr++]=readbuffer; argsLeft--; } if ((argsLeft==0) && (((buffer[0] & 0xf0)==0x90) || ((buffer[0] & 0xf0)==0x80))) { newnote=buffer[1] + transpose; if ((newnote > 0) && (newnote < 128)) { buffer[1]=(unsigned char)newnote; if ((status=snd_rawmidi_write(midiout, buffer, 3)) < 0) { errormessage("Problem with MIDI out: %s", snd_strerror(status)); exit(EXIT_FAILURE); } else if (((buffer[0] & 0xf0)==0x90) && ((buffer[2] & 0x0f)!=0)) { printf("New note: %d\n", newnote); } } } if (dataptr > 1000) { dataptr=0; } } }
int main(int argc,char** argv) { int i; int err; int thru=0; int verbose = 0; char *device_in = NULL; char *device_out = NULL; char *node_in = NULL; char *node_out = NULL; int fd_in = -1,fd_out = -1; snd_rawmidi_t *handle_in = 0,*handle_out = 0; if (argc==1) { usage(); exit(0); } for (i = 1 ; i<argc ; i++) { if (argv[i][0]=='-') { switch (argv[i][1]) { case 'h': usage(); break; case 'v': verbose = 1; break; case 't': thru = 1; break; case 'i': if (i + 1 < argc) device_in = argv[++i]; break; case 'I': if (i + 1 < argc) node_in = argv[++i]; break; case 'o': if (i + 1 < argc) device_out = argv[++i]; break; case 'O': if (i + 1 < argc) node_out = argv[++i]; break; } } } if (verbose) { fprintf(stderr,"Using: \n"); fprintf(stderr,"Input: "); if (device_in) { fprintf(stderr,"device %s\n",device_in); }else if (node_in){ fprintf(stderr,"%s\n",node_in); }else{ fprintf(stderr,"NONE\n"); } fprintf(stderr,"Output: "); if (device_out) { fprintf(stderr,"device %s\n",device_out); }else if (node_out){ fprintf(stderr,"%s\n",node_out); }else{ fprintf(stderr,"NONE\n"); } } if (device_in) { err = snd_rawmidi_open(&handle_in,NULL,device_in,0); if (err) { fprintf(stderr,"snd_rawmidi_open %s failed: %d\n",device_in,err); } } if (node_in && (!node_out || strcmp(node_out,node_in))) { fd_in = open(node_in,O_RDONLY); if (fd_in<0) { fprintf(stderr,"open %s for input failed\n",node_in); } } signal(SIGINT,sighandler); if (device_out) { err = snd_rawmidi_open(NULL,&handle_out,device_out,0); if (err) { fprintf(stderr,"snd_rawmidi_open %s failed: %d\n",device_out,err); } } if (node_out && (!node_in || strcmp(node_out,node_in))) { fd_out = open(node_out,O_WRONLY); if (fd_out<0) { fprintf(stderr,"open %s for output failed\n",node_out); } } if (node_in && node_out && strcmp(node_out,node_in)==0) { fd_in = fd_out = open(node_out,O_RDWR); if (fd_out<0) { fprintf(stderr,"open %s for input and output failed\n",node_out); } } if (!thru) { if (handle_in || fd_in!=-1) { fprintf(stderr,"Read midi in\n"); fprintf(stderr,"Press ctrl-c to stop\n"); } if (handle_in) { unsigned char ch; while (!stop) { snd_rawmidi_read(handle_in,&ch,1); if (verbose) { fprintf(stderr,"read %02x\n",ch); } } } if (fd_in!=-1) { unsigned char ch; while (!stop) { read(fd_in,&ch,1); if (verbose) { fprintf(stderr,"read %02x\n",ch); } } } if (handle_out || fd_out!=-1) { fprintf(stderr,"Writing note on / note off\n"); } if (handle_out) { unsigned char ch; ch=0x90; snd_rawmidi_write(handle_out,&ch,1); ch=60; snd_rawmidi_write(handle_out,&ch,1); ch=100; snd_rawmidi_write(handle_out,&ch,1); snd_rawmidi_drain(handle_out); sleep(1); ch=0x90; snd_rawmidi_write(handle_out,&ch,1); ch=60; snd_rawmidi_write(handle_out,&ch,1); ch=0; snd_rawmidi_write(handle_out,&ch,1); snd_rawmidi_drain(handle_out); } if (fd_out!=-1) { unsigned char ch; ch=0x90; write(fd_out,&ch,1); ch=60; write(fd_out,&ch,1); ch=100; write(fd_out,&ch,1); sleep(1); ch=0x90; write(fd_out,&ch,1); ch=60; write(fd_out,&ch,1); ch=0; write(fd_out,&ch,1); } } else { if ((handle_in || fd_in!=-1) && (handle_out || fd_out!=-1)) { if (verbose) { fprintf(stderr,"Testing midi thru in\n"); } while (!stop) { unsigned char ch; if (handle_in) { snd_rawmidi_read(handle_in,&ch,1); } if (fd_in!=-1) { read(fd_in,&ch,1); } if (verbose) { fprintf(stderr,"thru: %02x\n",ch); } if (handle_out) { snd_rawmidi_write(handle_out,&ch,1); snd_rawmidi_drain(handle_out); } if (fd_out!=-1) { write(fd_out,&ch,1); } } }else{ fprintf(stderr,"Testing midi thru needs both input and output\n"); exit(-1); } } if (verbose) { fprintf(stderr,"Closing\n"); } if (handle_in) { snd_rawmidi_drain(handle_in); snd_rawmidi_close(handle_in); } if (handle_out) { snd_rawmidi_drain(handle_out); snd_rawmidi_close(handle_out); } if (fd_in!=-1) { close(fd_in); } if (fd_out!=-1) { close(fd_out); } return 0; }
int main(int argc, char **argv) { int inputf, e, err; int sock; struct input_event buffer; int npfds; struct pollfd *pfds; struct sockaddr_in si_me, si_other; int len, slen = sizeof(si_other); int optval = 1; if(argc < 2) { fprintf(stderr, "%s <device>\n", argv[0]); exit(-1); } e = snd_rawmidi_open(&input, &output, argv[1], SND_RAWMIDI_NONBLOCK); if (e == -1) { fprintf(stderr, "snd:rawmidi:open-%X\n", e); return 1; } if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) { perror("udp socket"); return 1; } memset((void *) &si_me, 0, sizeof(si_me)); si_me.sin_family = AF_INET; si_me.sin_port = htons(UDPMIDI_PORT); si_me.sin_addr.s_addr = htonl(INADDR_ANY); memset((void *) &si_other, 0, sizeof(si_me)); si_other.sin_family = AF_INET; si_other.sin_port = htons(UDPMIDI_PORT); si_other.sin_addr.s_addr = htonl(INADDR_BROADCAST); if (bind(sock, (const struct sockaddr*)&si_me, sizeof(si_me)) == -1) { perror("udp port"); close(sock); return 1; } if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &optval, sizeof (optval)) ==- 1) { perror("udp broadcast"); close(sock); return 1; } npfds = snd_rawmidi_poll_descriptors_count(input) + 1; pfds = malloc((npfds + 1) * sizeof(struct pollfd)); snd_rawmidi_poll_descriptors(input, pfds, npfds); pfds[npfds-1].fd = sock; pfds[npfds-1].events = POLLRDNORM; setvbuf (stdout, NULL, _IONBF, BUFSIZ); while(1) { int i,rlen, midiin; err = poll(pfds, npfds, 200); midiin = 0; for (i = 0; i < npfds; ++i) { if (pfds[i].revents & POLLIN) midiin = 1; } if (midiin) { unsigned char buf[10]; unsigned char outbuf[12]; printf("m"); rlen = snd_rawmidi_read(input, buf, sizeof(buf)); if (rlen == -EAGAIN) continue; if (rlen < 0) { fprintf(stderr, "Cannot read from port \"%s\": %s", argv[1], snd_strerror(err)); break; } // UDP broadcast memcpy(outbuf, packet_signature, 2); if (rlen > 10) continue; memcpy(outbuf + 2, buf, rlen); if (sendto(sock, outbuf, 2 + rlen, 0, (struct sockaddr *)&si_other, sizeof(si_other)) == -1) { fprintf(stderr, "Error sending broadcast packet.\n"); } memcpy(last_packet, outbuf, rlen + 2); } if (pfds[npfds-1].revents & POLLRDNORM) { int len,slen; unsigned char buffer[10]; slen = sizeof(si_other); len = recvfrom(sock, buffer, 10, 0, (struct sockaddr *)&si_other, &slen); // Drop our own broadcast packets if (memcmp(last_packet, buffer, len) == 0) continue; printf("u"); if (len > 2 && memcmp(buffer, packet_signature, 2) == 0) { int wlen = snd_rawmidi_write(output, buffer + 2, len - 2); if (wlen < len - 2) { fprintf(stderr, "Midi out: Wrote %d of %d bytes\n", wlen, len - 2); } } } } return 0; }
static void midoalsav_write(unsigned char val) { if (!handle_v) return; snd_rawmidi_write(handle_v, &val, 1); }
void launchpad_write(char note[3]) { snd_rawmidi_write(out, note, 3); }
static int do_midi_output(process_midi_t *proc) { int worked = 0; output_port_t *port = (output_port_t*) proc->port; if (!midi_is_ready(proc)) return 0; // eat events while (port->next_event.time <= proc->cur_time) { port->todo += port->next_event.size; if (jack_ringbuffer_read(port->base.event_ring, (char*)&port->next_event, sizeof(port->next_event))!=sizeof(port->next_event)) { port->next_event.time = 0; port->next_event.size = 0; break; } else debug_log("midi_out: at %ld got %d bytes for %ld", (long)proc->cur_time, (int)port->next_event.size, (long)port->next_event.time); } if (port->todo) debug_log("midi_out: todo = %d at %ld", (int)port->todo, (long)proc->cur_time); // calc next wakeup time if (!port->todo && port->next_event.time && port->next_event.time < proc->next_time) { proc->next_time = port->next_event.time; debug_log("midi_out: next_time = %ld", (long)proc->next_time); } if (port->todo && port->base.is_ready) { // write data int size = port->todo; int res; jack_ringbuffer_data_t vec[2]; jack_ringbuffer_get_read_vector(port->base.data_ring, vec); if (size > vec[0].len) { size = vec[0].len; assert (size > 0); } res = snd_rawmidi_write(port->base.rawmidi, vec[0].buf, size); if (res > 0) { jack_ringbuffer_read_advance(port->base.data_ring, res); debug_log("midi_out: written %d bytes to %s", res, port->base.name); port->todo -= res; worked = 1; } else if (res == -EWOULDBLOCK) { port->base.is_ready = 0; debug_log("midi_out: -EWOULDBLOCK on %s", port->base.name); return 1; } else { error_log("midi_out: writing to port %s failed: %s", port->base.name, snd_strerror(res)); return 0; } snd_rawmidi_drain(port->base.rawmidi); } // update pfds for this port if (!midi_update_pfds(proc)) return 0; if (!port->todo) { int i; if (worked) debug_log("midi_out: relaxing on %s", port->base.name); for (i=0; i<port->base.npfds; ++i) proc->wpfds[i].events &= ~POLLOUT; } else { int i; for (i=0; i<port->base.npfds; ++i) proc->wpfds[i].events |= POLLOUT; } return 1; }
int main (int argc, char *argv []) { int argn = 1; if (argn == argc || streq (argv [argn], "-h") || streq (argv [argn], "--help")) { puts ("midicast [-v] [-p port] [-i interface]"); puts ("Reads MIDI events from port and sends to Zyre MIDI group"); puts (" -h, --help: this help"); puts (" -v, --verbose: trace events as they happen"); puts (" -p, --port: specify port name, e.g. '-p hw:1,0,0'"); puts (" -i, --interface: specify WiFi interface, e.g. '-i wlan0'"); return 0; } char *midi_port_name = "hw:2,0"; char *wifi_interface = NULL; bool verbose = false; while (argn < argc) { if (streq (argv [argn], "-p") || streq (argv [argn], "--port")) midi_port_name = argv [++argn]; else if (streq (argv [argn], "-i") || streq (argv [argn], "--interface")) wifi_interface = argv [++argn]; else if (streq (argv [argn], "-v") || streq (argv [argn], "--verbose")) verbose = true; argn++; } snd_rawmidi_t *output; int rc = snd_rawmidi_open (NULL, &output, midi_port_name, SND_RAWMIDI_SYNC); if (rc < 0) { zsys_error ("cannot open port \"%s\": %s", midi_port_name, snd_strerror (rc)); return 0; } zsys_info ("forwarding MIDI cast to %s", midi_port_name); zyre_t *zyre = zyre_new (NULL); if (wifi_interface) zyre_set_interface (zyre, wifi_interface); zyre_start (zyre); zyre_join (zyre, "MIDI"); zsys_info ("this player is %s", zyre_name (zyre)); while (!zsys_interrupted) { zyre_event_t *event = zyre_event_new (zyre); if (!event) { printf (" interrupted\n"); break; } if (zyre_event_type (event) == ZYRE_EVENT_JOIN) zsys_info ("[%s] player joined", zyre_event_peer_name (event)); else if (zyre_event_type (event) == ZYRE_EVENT_LEAVE) zsys_info ("[%s] player left", zyre_event_peer_name (event)); else if (zyre_event_type (event) == ZYRE_EVENT_SHOUT) { if (streq (zyre_event_group (event), "MIDI")) { zframe_t *frame = zmsg_first (zyre_event_msg (event)); // Forward the MIDI event snd_rawmidi_write (output, zframe_data (frame), zframe_size (frame)); if (verbose) { printf ("%zd:", zframe_size (frame)); int byte_nbr; for (byte_nbr = 0; byte_nbr < zframe_size (frame); byte_nbr++) printf (" %02X", zframe_data (frame) [byte_nbr]); printf ("\n"); } } } zyre_event_destroy (&event); } snd_rawmidi_close (output); zyre_destroy (&zyre); return 0; }
/** * \param data data to be sent * \param length data length * * Sends data to device. This function uses global output variable. **/ void send_data(char *data, int length) { snd_rawmidi_write(output, data, length); }
void MidiAlsaRaw::sendByte( unsigned char c ) { snd_rawmidi_write( m_output, &c, sizeof( c ) ); }
int main(int argc, char *argv[]) { fd_set rfds; int res; int err; int version = -1, ioret = -1; unsigned numevs, c; unsigned char read_buffer[sizeof(struct input_event)*3]; /* max 3 events per read */ unsigned char ch; unsigned char cCommand[3]; unsigned char cStates[255]; struct input_event *currev; char device_name[1024]; char *device_out = NULL; device_out = argv[2]; int fd_in = -1,fd_out = -1; snd_rawmidi_t *handle_in = 0,*handle_out = 0; memset(&cStates, 0, sizeof(cStates)); /* struct sigaction sighandler; memset(&sighandler, 0, sizeof(sighandler)); sighandler.sa_handler = catch_signal; sigaction(SIGINT, &sighandler, NULL); sigaction(SIGQUIT, &sighandler, NULL); */ signal(SIGINT,catch_signal); if ( argc < 2 ) { fprintf(stderr, "Device needed\n"); return -1; } FD_ZERO(&rfds); fd = open(argv[1], O_RDONLY); if ( -1 == fd ) { fprintf(stderr, "unable to read from mice - please give me a keyboard.\n"); return -1; } ioret = ioctl(fd, EVIOCGVERSION, &version); ioret = ioctl(fd, EVIOCGNAME(sizeof(device_name)), device_name); ioret = ioctl(fd, EVIOCGRAB, &grab); if ( -1 == ioret ) { perror("ioctl()"); } fprintf(stdout, "ver: %d, ret = %d\n", version, ioret); printf("device name is: %s\n", device_name); printf("EVIOCGRAB is: %lu\n", EVIOCGRAB); if (device_out) { err = snd_rawmidi_open(NULL,&handle_out,device_out,0); if (err) { fprintf(stderr,"snd_rawmidi_open %s failed: %d\n",device_out,err); } } /* to read the config file: char *option; char *value; fscanf( "%20[^#=]s=%80[^\n]", &option, &value ); */ FD_SET(fd, &rfds); while ( 1 ) { res = select(fd + 1, &rfds, NULL, NULL, NULL); if ( -1 == res && EINTR == errno ) { continue; } if ( -1 == res ) { perror("select() failed"); fprintf(stderr, "failed to select, fd is %d\n", fd); return -1; } if ( FD_ISSET(fd, &rfds) ) { // fprintf(stdout, "got some data\n"); res = read(fd, read_buffer, sizeof(read_buffer)); if ( -1 == res) { fprintf(stderr, "error reading data\n"); return -1; } // fprintf(stdout, "got %d bytes\n", res); numevs = ( res / sizeof(struct input_event) ); /* get how many input events we got */ // fprintf(stdout, "got %u events\n", numevs); for ( c = 0; c < numevs; c++ ) { currev = (struct input_event *)(read_buffer + (sizeof(struct input_event) * c)); // fprintf(stdout, "event time %ld/%ld\n", currev->time.tv_sec, currev->time.tv_usec); // fprintf(stdout, "event type = %hd, code = %hd, value = %d\n", currev->type, currev->code, currev->value); if ( 1 == currev->type ) { if ( 1 == currev->value ) { // press fprintf(stdout, " %hd \n", currev->code); // note on ch=0x90; snd_rawmidi_write(handle_out,&ch,1); ch=currev->code; snd_rawmidi_write(handle_out,&ch,1); ch=127; snd_rawmidi_write(handle_out,&ch,1); // controller up ch=0xB0; snd_rawmidi_write(handle_out,&ch,1); ch=currev->code; snd_rawmidi_write(handle_out,&ch,1); ch=127; snd_rawmidi_write(handle_out,&ch,1); if ( 1 == cStates[currev->code] ) { // toggle was on already cStates[currev->code] = 0; // send a note-off ch=0x91; snd_rawmidi_write(handle_out,&ch,1); ch=currev->code; snd_rawmidi_write(handle_out,&ch,1); ch=0; snd_rawmidi_write(handle_out,&ch,1); // and a controller down ch=0xB1; snd_rawmidi_write(handle_out,&ch,1); ch=currev->code; snd_rawmidi_write(handle_out,&ch,1); ch=0; snd_rawmidi_write(handle_out,&ch,1); } else { // toggle was off or uninitialised cStates[currev->code] = 1; // send a note-on ch=0x91; snd_rawmidi_write(handle_out,&ch,1); ch=currev->code; snd_rawmidi_write(handle_out,&ch,1); ch=127; snd_rawmidi_write(handle_out,&ch,1); // and controller up ch=0xB1; snd_rawmidi_write(handle_out,&ch,1); ch=currev->code; snd_rawmidi_write(handle_out,&ch,1); ch=127; snd_rawmidi_write(handle_out,&ch,1); } snd_rawmidi_drain(handle_out); } else if ( 2 == currev->value ) { // repeat fprintf(stdout, "*%hd*\n", currev->code); } else if ( 0 == currev->value ) { // release fprintf(stdout, "[%hd]\n", currev->code); // note off ch=0x90; snd_rawmidi_write(handle_out,&ch,1); ch=currev->code; snd_rawmidi_write(handle_out,&ch,1); ch=0; snd_rawmidi_write(handle_out,&ch,1); // controller down ch=0xB0; snd_rawmidi_write(handle_out,&ch,1); ch=currev->code; snd_rawmidi_write(handle_out,&ch,1); ch=0; snd_rawmidi_write(handle_out,&ch,1); snd_rawmidi_drain(handle_out); // sleep(1); } else { // dunno fprintf(stdout, "?%hd? - What is value %d?\n", currev->code, currev->value); } } } } else { fprintf(stderr, "odd ... no data and we only listen in 1 fd\n"); } } return 0; }