예제 #1
0
int MidiStopProc(void *arg)
{
	snd_rawmidi_close(midi.midiout);
	snd_rawmidi_close(midi.midiin);
	midi.midiout  = midi.midiin = NULL;    // snd_rawmidi_close() does not clear invalid pointer,

	return NULL;
}
예제 #2
0
파일: pyrawmidi.c 프로젝트: cwyss/vxc
static PyObject *pyrm_close(PyObject *self, PyObject *args) {
    if(MidiIn!=NULL) {
	snd_rawmidi_close(MidiIn);
	MidiIn = NULL;
    }
    if(MidiOut!=NULL) {
	snd_rawmidi_close(MidiOut);
	MidiOut = NULL;
    }

    Py_RETURN_NONE;
}
예제 #3
0
MidiAlsaRaw::~MidiAlsaRaw()
{
	if( isRunning() )
	{
		m_quit = true;
		wait( 1000 );
		terminate();

		snd_rawmidi_close( m_input );
		snd_rawmidi_close( m_output );
		delete[] m_pfds;
	}
}
예제 #4
0
int main(int argc, char *argv[]) {
	int status;
	int mode=0;
	pthread_t midiinthread;
	snd_rawmidi_t* midiin=NULL;
	const char* portname="hw:1,0,0";// see alsarawportlist.c example program
	if ((argc > 1) && (strncmp("hw:", argv[1], 3)==0)) {
		portname=argv[1];
	}
	if ((status=snd_rawmidi_open(&midiin, NULL, portname, mode)) < 0) {
		errormessage("Problem opening MIDI input: %s", snd_strerror(status));
		exit(EXIT_FAILURE);
	}
	// type "man pthread_create" for more information about this function:
	status=pthread_create(&midiinthread, NULL, midiinfunction, midiin);
	if (status==-1) {
		errormessage("Unable to create MIDI input thread.");
		exit(EXIT_FAILURE);
	}
	CHECK_ZERO(sleep(60));	// do nothing for a while; thread does all the work.
	snd_rawmidi_close(midiin);
	midiin=NULL;	// snd_rawmidi_close() does not clear invalid pointer,
	printf("\n");	// so might be a good idea to erase it after closing.
	return EXIT_SUCCESS;
}
예제 #5
0
static void midoalsav_done(void *arg)
{
    if (!handle_v)
	return;
    snd_rawmidi_close(handle_v);
    handle_v = NULL;
}
예제 #6
0
파일: midi.c 프로젝트: huangjs/cl
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(&params);
  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));
}
예제 #7
0
static void midoalsa_done(void)
{
    if (!handle)
	return;
    snd_rawmidi_close(handle);
    handle = NULL;
}
예제 #8
0
bool Dicer_control_process::stop()
{
    if (this->is_open == true)
    {
        // Clear all buttons for both Dicer.
        if (this->clear_dicer(DICER_LEFT) == false)
        {
            qCWarning(DS_DICER) << "can not clear Dicer left";
            return false;
        }
        if (this->clear_dicer(DICER_RIGHT) == false)
        {
            qCWarning(DS_DICER) << "can not clear Dicer right";
            return false;
        }

        // Close all MIDI handlers.
#ifdef WIN32
        // TODO: add Dicer support for Windows.
        return false;
#else
        int err = 0;
        if ((err = snd_rawmidi_close(this->midi_in)) < 0)
        {
            qCWarning(DS_DICER) << "can not close MIDI IN on Dicer: " << snd_strerror(err);
            return false;
        }
        if ((err = snd_rawmidi_close(this->midi_out)) < 0)
        {
            qCWarning(DS_DICER) << "can not close MIDI OUT on Dicer: " << snd_strerror(err);
            return false;
        }
#endif
        this->is_open = false;
    }

    // Stop the loop which reads incoming MIDI command.
    //this->reader_thread.wait();
    this->reader_thread.exit();
    //this->reader_thread.terminate();

    return true;
}
예제 #9
0
/* alsa_rawmidi_exit:
 *   Cleans up.
 */
static void alsa_rawmidi_exit(int input)
{
   if (rawmidi_handle) {
#if ALLEGRO_ALSA_VERSION == 9
      snd_rawmidi_drain(rawmidi_handle);
#else  /* ALLEGRO_ALSA_VERSION == 5 */
      snd_rawmidi_output_drain(rawmidi_handle);
#endif
      snd_rawmidi_close(rawmidi_handle);
   }

   rawmidi_handle = NULL;
}
예제 #10
0
int main(int argc, char *argv[]) {
	int status;	// for storing error codes
	int mode=SND_RAWMIDI_SYNC;	// automatic MIDI out flushing
	snd_rawmidi_t* midiin=NULL;	// structure to access MIDI input
	snd_rawmidi_t* midiout=NULL;	// structure to access MIDI output
	const char* portname="hw:1,0,0";// see alsarawportlist.c example program
	if ((argc > 1) && (strncmp("hw:", argv[1], 3)==0)) {
		portname=argv[1];
	}
	if ((status=snd_rawmidi_open(&midiin, &midiout, portname, mode)) < 0) {
		errormessage("Problem opening MIDI input: %s", snd_strerror(status));
		exit(EXIT_FAILURE);
	}
	printf("Type control-c to exit.\n");
	echomidi(midiin, midiout);
	// never gets here, but here is how to close MIDI gracefully:
	snd_rawmidi_close(midiin);
	snd_rawmidi_close(midiout);
	midiin=NULL;	// snd_rawmidi_close() does not clear invalid pointer,
	midiout=NULL;	// so might be a good idea to erase it after closing.
	return EXIT_SUCCESS;
}
예제 #11
0
파일: midi_to_lcm.c 프로젝트: 1ee7/flight
void sighandler(int dum)
{
        stop=1;

        fprintf(stderr,"Closing.\n");

        if (handle_in) {
                snd_rawmidi_drain(handle_in);
                snd_rawmidi_close(handle_in);
        }

        lcm_destroy (lcm);

        exit(0);
}
예제 #12
0
/* alsa_rawmidi_detect:
 *  ALSA RawMIDI detection.
 */
static int alsa_rawmidi_detect(int input)
{
#if ALLEGRO_ALSA_VERSION == 9
   const char *device = NULL;
#else  /* ALLEGRO_ALSA_VERSION == 5 */
   int card = -1;
   int device = -1;
#endif
   int ret = FALSE, err;
   char tmp1[128], tmp2[128], temp[256];
   snd_rawmidi_t *handle = NULL;

   if (input) {
      ret = FALSE;
   }
   else {
#if ALLEGRO_ALSA_VERSION == 9
      device = get_config_string(uconvert_ascii("sound", tmp1),
				 uconvert_ascii("alsa_rawmidi_device", tmp2),
				 "default");

      err = snd_rawmidi_open(NULL, &handle, device, 0);
#else  /* ALLEGRO_ALSA_VERSION == 5 */
      card = get_config_int(uconvert_ascii("sound", tmp1),
			    uconvert_ascii("alsa_rawmidi_card", tmp2),
			    snd_defaults_rawmidi_card());

      device = get_config_int(uconvert_ascii("sound", tmp1),
			      uconvert_ascii("alsa_rawmidi_device", tmp2),
			      snd_defaults_rawmidi_device());

      err = snd_rawmidi_open(&handle, card, device, SND_RAWMIDI_OPEN_OUTPUT_APPEND);
#endif
      if (err) {
	 snprintf(temp, sizeof(temp), "Could not open card/rawmidi device: %s", snd_strerror(err));
	 ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text(temp));
	 ret = FALSE;
      }
      else {
	 snd_rawmidi_close(handle);
	 ret = TRUE;
      }
   }

   return ret;
}
예제 #13
0
static
void midi_port_close(const alsa_rawmidi_t *midi, midi_port_t *port)
{
    if (port->data_ring) {
        jack_ringbuffer_free(port->data_ring);
        port->data_ring = NULL;
    }
    if (port->event_ring) {
        jack_ringbuffer_free(port->event_ring);
        port->event_ring = NULL;
    }
    if (port->jack) {
        jack_port_unregister(midi->client, port->jack);
        port->jack = NULL;
    }
    if (port->rawmidi) {
        snd_rawmidi_close(port->rawmidi);
        port->rawmidi = NULL;
    }
}
INT32 closeMidiDevice(MidiDeviceHandle* handle) {
    int err;

    TRACE0("> closeMidiDevice()\n");
    if (!handle) {
        ERROR0("< ERROR: closeMidiDevice(): handle is NULL\n");
        return MIDI_INVALID_HANDLE;
    }
    if (!handle->deviceHandle) {
        ERROR0("< ERROR: closeMidiDevice(): native handle is NULL\n");
        return MIDI_INVALID_HANDLE;
    }
    err = snd_rawmidi_close((snd_rawmidi_t*) handle->deviceHandle);
    TRACE1("  snd_rawmidi_close() returns %d\n", err);
    if (handle->platformData) {
        snd_midi_event_free((snd_midi_event_t*) handle->platformData);
    }
    free(handle);
    TRACE0("< closeMidiDevice: succeeded\n");
    return err;
}
예제 #15
0
파일: midi.c 프로젝트: huangjs/cl
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);
}
/*
  direction has to be either SND_RAWMIDI_STREAM_INPUT or
  SND_RAWMIDI_STREAM_OUTPUT.
  Returns 0 on success. Otherwise, MIDI_OUT_OF_MEMORY, MIDI_INVALID_ARGUMENT
   or a negative ALSA error code is returned.
*/
INT32 openMidiDevice(snd_rawmidi_stream_t direction, INT32 deviceIndex,
                     MidiDeviceHandle** handle) {
    snd_rawmidi_t* native_handle;
    snd_midi_event_t* event_parser = NULL;
    int err;
    UINT32 deviceID;
    char devicename[100];
#ifdef ALSA_MIDI_USE_PLUGHW
    int usePlugHw = 1;
#else
    int usePlugHw = 0;
#endif

    TRACE0("> openMidiDevice()\n");

    (*handle) = (MidiDeviceHandle*) calloc(sizeof(MidiDeviceHandle), 1);
    if (!(*handle)) {
        ERROR0("ERROR: openDevice: out of memory\n");
        return MIDI_OUT_OF_MEMORY;
    }

    // TODO: iterate to get dev ID from index
    err = getMidiDeviceID(direction, deviceIndex, &deviceID);
    TRACE1("  openMidiDevice(): deviceID: %d\n", (int) deviceID);
    getDeviceStringFromDeviceID(devicename, deviceID,
                                usePlugHw, ALSA_RAWMIDI);
    TRACE1("  openMidiDevice(): deviceString: %s\n", devicename);

    // finally open the device
    if (direction == SND_RAWMIDI_STREAM_INPUT) {
        err = snd_rawmidi_open(&native_handle, NULL, devicename,
                               SND_RAWMIDI_NONBLOCK);
    } else if (direction == SND_RAWMIDI_STREAM_OUTPUT) {
        err = snd_rawmidi_open(NULL, &native_handle, devicename,
                               SND_RAWMIDI_NONBLOCK);
    } else {
        ERROR0("  ERROR: openMidiDevice(): direction is neither SND_RAWMIDI_STREAM_INPUT nor SND_RAWMIDI_STREAM_OUTPUT\n");
        err = MIDI_INVALID_ARGUMENT;
    }
    if (err < 0) {
        ERROR1("<  ERROR: openMidiDevice(): snd_rawmidi_open() returned %d\n", err);
        free(*handle);
        (*handle) = NULL;
        return err;
    }
    /* We opened with non-blocking behaviour to not get hung if the device
       is used by a different process. Writing, however, should
       be blocking. So we change it here. */
    if (direction == SND_RAWMIDI_STREAM_OUTPUT) {
        err = snd_rawmidi_nonblock(native_handle, 0);
        if (err < 0) {
            ERROR1("  ERROR: openMidiDevice(): snd_rawmidi_nonblock() returned %d\n", err);
            snd_rawmidi_close(native_handle);
            free(*handle);
            (*handle) = NULL;
            return err;
        }
    }
    if (direction == SND_RAWMIDI_STREAM_INPUT) {
        err = snd_midi_event_new(EVENT_PARSER_BUFSIZE, &event_parser);
        if (err < 0) {
            ERROR1("  ERROR: openMidiDevice(): snd_midi_event_new() returned %d\n", err);
            snd_rawmidi_close(native_handle);
            free(*handle);
            (*handle) = NULL;
            return err;
        }
    }

    (*handle)->deviceHandle = (void*) native_handle;
    (*handle)->startTime = getTimeInMicroseconds();
    (*handle)->platformData = event_parser;
    TRACE0("< openMidiDevice(): succeeded\n");
    return err;
}
예제 #17
0
파일: midigrab.c 프로젝트: ZyreApps/DeMidi
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;
}
예제 #18
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;
}
예제 #19
0
파일: midiloop.c 프로젝트: KeTao/alsa-lib
int main(int argc, char** argv)
{
	int i, j, k, opos, ipos, patsize;
	int err;
	int verbose = 0;
	snd_rawmidi_t *handle_in = NULL, *handle_out = NULL;
	unsigned char ibuf[512], obuf[512];
	char *iname = "hw:0,0", *oname = "hw:0,0";
	struct timeval start, end;
	long long diff;
	snd_rawmidi_status_t *istat, *ostat;
	
	for (i = 1 ; i<argc ; i++) {
		if (argv[i][0]=='-') {
			if (!strcmp(argv[i], "--help")) {
				usage();
				return 0;
			}
			switch (argv[i][1]) {
				case 'h':
					usage();
					return 0;
				case 'v':
					verbose = 1;
					break;
				case 'i':
					if (i + 1 < argc)
						iname = argv[++i];
					break;
				case 'o':
					if (i + 1 < argc)
						oname = argv[++i];
					break;
			}			
		}
	}

	if (iname == NULL)
		iname = oname;
	if (oname == NULL)
		oname = iname;

	if (verbose) {
		fprintf(stderr, "Using: \n");
		fprintf(stderr, "  Input: %s  Output: %s\n", iname, oname);
	}
	
	err = snd_rawmidi_open(&handle_in, NULL, iname, SND_RAWMIDI_NONBLOCK);
	if (err) {
		fprintf(stderr,"snd_rawmidi_open %s failed: %d\n",iname,err);
		exit(EXIT_FAILURE);
	}

	err = snd_rawmidi_open(NULL, &handle_out, oname, 0);
	if (err) {
		fprintf(stderr,"snd_rawmidi_open %s failed: %d\n",oname,err);
		exit(EXIT_FAILURE);
	}

	signal(SIGINT, sighandler);

	i = snd_rawmidi_read(handle_in, ibuf, sizeof(ibuf));
	if (i > 0) {
		printf("Read ahead: %i\n", i);
		for (j = 0; j < i; j++)
			printf("%02x:", ibuf[j]);
		printf("\n");
		exit(EXIT_FAILURE);
	}

	snd_rawmidi_nonblock(handle_in, 0);

	patsize = writepattern(handle_out, obuf);
	gettimeofday(&start, NULL);
	patsize = writepattern(handle_out, obuf);

	k = ipos = opos = err = 0;
	while (!stop) {
		i = snd_rawmidi_read(handle_in, ibuf, sizeof(ibuf));
		for (j = 0; j < i; j++, ipos++)
			if (obuf[k] != ibuf[j]) {
				printf("ipos = %i, i[0x%x] != o[0x%x]\n", ipos, ibuf[j], obuf[k]);
				if (opos > 0)
					stop = 1;
			} else {
				printf("match success: ipos = %i, opos = %i [%i:0x%x]\n", ipos, opos, k, obuf[k]);
				k++; opos++;
				if (k >= patsize) {
					patsize = writepattern(handle_out, obuf);
					k = 0;
				}
			}
	}

	gettimeofday(&end, NULL);

	printf("End...\n");

	snd_rawmidi_status_alloca(&istat);
	snd_rawmidi_status_alloca(&ostat);
	err = snd_rawmidi_status(handle_in, istat);
	if (err < 0)
		fprintf(stderr, "input stream status error: %d\n", err);
	err = snd_rawmidi_status(handle_out, ostat);
	if (err < 0)
		fprintf(stderr, "output stream status error: %d\n", err);
	printf("input.status.avail = %zi\n", snd_rawmidi_status_get_avail(istat));
	printf("input.status.xruns = %zi\n", snd_rawmidi_status_get_xruns(istat));
	printf("output.status.avail = %zi\n", snd_rawmidi_status_get_avail(ostat));
	printf("output.status.xruns = %zi\n", snd_rawmidi_status_get_xruns(ostat));

	diff = timediff(end, start);
	printf("Time diff: %Liusec (%Li bytes/sec)\n", diff, ((long long)opos * 1000000) / diff);

	if (verbose) {
		fprintf(stderr,"Closing\n");
	}
	
	snd_rawmidi_drain(handle_in); 
	snd_rawmidi_close(handle_in);	
	snd_rawmidi_drain(handle_out); 
	snd_rawmidi_close(handle_out);	

	return 0;
}
예제 #20
0
파일: midi_to_lcm.c 프로젝트: 1ee7/flight
int main(int argc,char** argv)
{
        int i;
        int err;
        int thru=0;
        int verbose = 0;
        char *device_in = NULL;
        char *lcm_out = NULL;



        int fd_in = -1,fd_out = -1;
        snd_rawmidi_t *handle_out = 0;

        if (argc!=3) {
            usage();
            exit(0);
        }

        device_in = argv[1];
        lcm_out = argv[2];


        lcm = lcm_create ("udpm://239.255.76.67:7667?ttl=0");
        if (!lcm)
            return 1;

        struct timeval thisTime;

        fprintf(stderr,"Using: \n");
        fprintf(stderr,"Input: ");
        fprintf(stderr,"device %s\n",device_in);
        fprintf(stderr,"Output: ");
        fprintf(stderr,"LCM channel %s\n", lcm_out);
        fprintf(stderr,"Read midi in\n");
        fprintf(stderr,"Press ctrl-c to stop\n");
        fprintf(stderr,"Broadcasting LCM: %s\n", lcm_out);


        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);
                return -1;
            }
        }

        signal(SIGINT,sighandler);


        int num = 0;
        int val[10];

        int sysExclusive = 0;

        if (handle_in) {
            unsigned char ch;
            while (!stop) {
                snd_rawmidi_read(handle_in,&ch,1);

                // check to make sure this isn't a system exclusive message (begins with 0xF0. Ends with a 0xF7)
                if (ch == 0xF0)
                {
                    sysExclusive = 1;
                    //fprintf(stderr,"sys exclusive\n");
                }

                if (sysExclusive == 0)
                {
                    val[num] = (int)ch;
                    if (num >= 2)
                    {
                        //fprintf(stderr,"read %02x --> %02x --> %d\n", val[0], val[1], val[2]);
                        num = 0;

                        // send LCM message
                        lcmt_midi msg;

                        gettimeofday(&thisTime, NULL);
                        msg.timestamp = (thisTime.tv_sec * 1000.0) + (float)thisTime.tv_usec/1000.0 + 0.5;

                        msg.event[0] = val[0];
                        msg.event[1] = val[1];
                        msg.event[2] = val[2];

                        lcmt_midi_publish (lcm, lcm_out, &msg);


                    } else {
                        num ++;
                    }
                    //fprintf(stderr,"read %02x\n", ch);
                }

                if (ch == 0xF7)
                {
                    sysExclusive = 0;
                }
            }
        }


        fprintf(stderr,"Closing.\n");

        if (handle_in) {
                snd_rawmidi_drain(handle_in);
                snd_rawmidi_close(handle_in);
        }

        lcm_destroy (lcm);

        return 0;
}
예제 #21
0
//int main() {
int main(int argc, char *argv[]) {

  //initscr(); //Initialize ncurses
  //noecho();
  set_timbres();
  make_table(); //Set up note frequencies int the table freq_table[]

  Organ theOrgan;

  Reverb* rev1 = new Reverb(2500, 0.8);
  //Reverb* rev2 = new Reverb(4000, 0.8);
  //Reverb* rev3 = new Reverb(5500, 0.8);

  int rc;
  int size;
  snd_pcm_t *handle;
  snd_pcm_hw_params_t *params;
  unsigned int val;
  int dir;
  snd_pcm_uframes_t frames;
  char *buffer;

  /* Open PCM device for playback. */
  rc = snd_pcm_open(&handle, "default",
                    SND_PCM_STREAM_PLAYBACK, 0);
  if (rc < 0) {
    fprintf(stderr,
            "unable to open pcm device: %s\n",
            snd_strerror(rc));
    exit(1);
  }

  /* Allocate a hardware parameters object. */
  snd_pcm_hw_params_alloca(&params);

  /* Fill it in with default values. */
  snd_pcm_hw_params_any(handle, params);

  /* Set the desired hardware parameters. */


  /* Set period size to 32 frames. */
  frames = 16;
  snd_pcm_hw_params_set_period_size_near(handle,
                              params, &frames, &dir);

  /* Write the parameters to the driver */
  rc = snd_pcm_hw_params(handle, params);
  if (rc < 0) {
    fprintf(stderr,
            "unable to set hw parameters: %s\n",
            snd_strerror(rc));
    exit(1);
  }

  snd_pcm_uframes_t bufferSize;

  snd_pcm_hw_params_get_buffer_size( params, &bufferSize );

      fprintf(stderr,
              "alsa_buffer_size: %lu frames\n", bufferSize);


    rc = snd_pcm_set_params(handle,
    SND_PCM_FORMAT_S16_LE,
    SND_PCM_ACCESS_RW_INTERLEAVED,
    2,
    44100,
    32,
    50000); //Latency


  /* Use a buffer large enough to hold one period */
  snd_pcm_hw_params_get_period_size(params, &frames,
                                    &dir);

  size = frames * 4; /* 2 bytes/sample, 2 channels */
  buffer = (char *) malloc(size);
  int16_t* buffer_16 = (int16_t *) buffer; //Cast buffer for 16-bit values

  /* We want to loop for 5 seconds */
  snd_pcm_hw_params_get_period_time(params,
                                    &val, &dir);
  /* 5 seconds in microseconds divided by
   * period time */
  //loops = 5000000 / val;

  //rc = snd_pcm_nonblock(handle, 0);


// Make init for MIDI INPUT
   int status;
   int mode = SND_RAWMIDI_SYNC | SND_RAWMIDI_NONBLOCK;
   snd_rawmidi_t* midiin = NULL;
   const char* portname = "hw:1,0,0";  // see alsarawportlist.c example program
   if ((argc > 1) && (strncmp("hw:", argv[1], 3) == 0)) {
      portname = argv[1];
   }
   if ((status = snd_rawmidi_open(&midiin, NULL, portname, mode)) < 0) {
      errormessage("Problem opening MIDI input: %s", snd_strerror(status));
      exit(1);
   }

   int count = 0;         // Current count of bytes received.
   char mid_buffer[1];        // Storage for input buffer received
   int framesleft=0;

   //Storage for MIDI-parsing:
   int midi_cmd;
   int midi_count=0;
   int midi_channel=0;
   int midi_note;
   int midi_offset=1; //Transpose value
//

  while (true) {

    for(int i=0;i<frames;i++)
    {
      float organOut = theOrgan.next(); //Read output from organ
      float outValue = organOut*3.0
        + rev1->next(organOut)*0.5 
	//+ rev2->next(organOut)*0.25
	//+ rev3->next(organOut)*0.12
;

      buffer_16[i*2] = (int16_t)outValue;
      buffer_16[i*2+1] = (int16_t)outValue;
    }
   rc = snd_pcm_writei(handle, buffer, frames);

    if (rc == -EPIPE) {
      /* EPIPE means underrun */
      fprintf(stderr, "underrun occurred\n");
      snd_pcm_prepare(handle);
    } else if (rc < 0) {
      fprintf(stderr,
              "error from writei: %s\n",
              snd_strerror(rc));
    }  else if (rc != (int)frames) {
      fprintf(stderr,
              "short write, write %d frames\n", rc);
    }
else
{
/*
*/
}

     //MIDI code

      status = snd_rawmidi_read(midiin, mid_buffer, 1);
      if(status > 0)
      {
       unsigned char theByte = mid_buffer[0];
       //Simple MIDI parser //Blame RG 2014

                if((theByte & 0x80) == 0x80) //Is it a command?
                {
                  if((theByte & 0x90) == 0x90) //Note on
                  {
                    midi_channel = (theByte & 0x0f);
                    #ifdef debug
                      fprintf(stderr, "midi_channel: %d \n", midi_channel);
                    #endif
                    midi_count=1;
                    midi_cmd=0x90;
                  }
                  else
                  {
                   if((theByte & 0x90) == 0x80) //Note off
                   {
                    midi_channel = (theByte & 0x0f);
                    #ifdef debug
                     fprintf(stderr, "midi_channel: %d \n", midi_channel);
                    #endif
                    midi_count=1;
                    midi_cmd=0x80;
                   }
                  }
                } //End of command processing
                else
                {
                  if (midi_count==1)
                  {
                   midi_note = (theByte+midi_offset);
                   midi_count++;
                  }
                  else
                  {
                   if (midi_count==2)
                    {
                     //Velocity info here
                     midi_count=1;
                     if(midi_cmd == 0x90)
                     {
                      if(theByte!=00) //21.11.2014 (Check if note on with vel 0 is used as note off!)
                      {
                       theOrgan.noteOn(midi_channel, midi_note);
                       #ifdef debug
                        fprintf(stderr, "play note: %d \n", midi_note);
                       #endif
                      }
                      else
                      {
                       theOrgan.noteOff(midi_channel, midi_note);
                       #ifdef debug
                        fprintf(stderr, "note on, volume 0: %d \n", midi_note);
                       #endif
                      }

                     }
                     if(midi_cmd == 0x80)
                     {
                      theOrgan.noteOff(midi_channel, midi_note);
                      #ifdef debug
                       fprintf(stderr, "note off: %d \n", midi_note);
                      #endif
                     }
                   }
                  }
                 }
       //count++;
     }
      //END MIDI CODE

     char command[80];

     struct pollfd fds;
        int ret;
        fds.fd = 0; /* this is STDIN */
        fds.events = POLLIN;
        ret = poll(&fds, 1, 0);
        if(ret == 1)
        {
          read(STDIN_FILENO, command, 80);
          switch(command[0])
          {
            case '0':
                     printf("Command 0\n");
                     theOrgan.setReg(0);
                     break;
            case '1':
                     printf("Command 1\n");
                     theOrgan.setReg(1);
                     break;
            case '2':
                     printf("Command 2\n");
                     theOrgan.setReg(2);
                     break;
            case '3':
                     printf("Command 3\n");
                     theOrgan.setReg(3);
                     break;
            case '4':
                     printf("Command 4\n");
                     theOrgan.setReg(4);
                     break;
          }
        }
        else if(ret == 0)
               {
                //printf("No\n");
                }
        else
                printf("Error\n");

  }

  snd_pcm_drain(handle);
  snd_pcm_close(handle);
  free(buffer);

  snd_rawmidi_close(midiin);
  midiin  = NULL;    // snd_rawmidi_close() does not clear invalid pointer,

  return 0;
}
// for each ALSA device, call iterator. userData is passed to the iterator
// returns total number of iterations
static int iterateRawmidiDevices(snd_rawmidi_stream_t direction,
                                 DeviceIteratorPtr iterator,
                                 void* userData) {
    int count = 0;
    int subdeviceCount;
    int card, dev, subDev;
    char devname[16];
    int err;
    snd_ctl_t *handle;
    snd_rawmidi_t *rawmidi;
    snd_rawmidi_info_t *rawmidi_info;
    snd_ctl_card_info_t *card_info, *defcardinfo = NULL;
    UINT32 deviceID;
    int doContinue = TRUE;

    snd_rawmidi_info_malloc(&rawmidi_info);
    snd_ctl_card_info_malloc(&card_info);

    // 1st try "default" device
    if (direction == SND_RAWMIDI_STREAM_INPUT) {
        err = snd_rawmidi_open(&rawmidi, NULL, ALSA_DEFAULT_DEVICE_NAME,
                               SND_RAWMIDI_NONBLOCK);
    } else if (direction == SND_RAWMIDI_STREAM_OUTPUT) {
        err = snd_rawmidi_open(NULL, &rawmidi, ALSA_DEFAULT_DEVICE_NAME,
                               SND_RAWMIDI_NONBLOCK);
    } else {
        ERROR0("ERROR: iterateRawmidiDevices(): direction is neither"
               " SND_RAWMIDI_STREAM_INPUT nor SND_RAWMIDI_STREAM_OUTPUT\n");
        err = MIDI_INVALID_ARGUMENT;
    }
    if (err < 0) {
        ERROR1("ERROR: snd_rawmidi_open (\"default\"): %s\n",
               snd_strerror(err));
    } else {
        err = snd_rawmidi_info(rawmidi, rawmidi_info);

        snd_rawmidi_close(rawmidi);
        if (err < 0) {
            ERROR1("ERROR: snd_rawmidi_info (\"default\"): %s\n",
                    snd_strerror(err));
        } else {
            // try to get card info
            card = snd_rawmidi_info_get_card(rawmidi_info);
            if (card >= 0) {
                sprintf(devname, ALSA_HARDWARE_CARD, card);
                if (snd_ctl_open(&handle, devname, SND_CTL_NONBLOCK) >= 0) {
                    if (snd_ctl_card_info(handle, card_info) >= 0) {
                        defcardinfo = card_info;
                    }
                    snd_ctl_close(handle);
                }
            }
            // call calback function for the device
            if (iterator != NULL) {
                doContinue = (*iterator)(ALSA_DEFAULT_DEVICE_ID, rawmidi_info,
                                         defcardinfo, userData);
            }
            count++;
        }
    }

    // iterate cards
    card = -1;
    TRACE0("testing for cards...\n");
    if (snd_card_next(&card) >= 0) {
        TRACE1("Found card %d\n", card);
        while (doContinue && (card >= 0)) {
            sprintf(devname, ALSA_HARDWARE_CARD, card);
            TRACE1("Opening control for alsa rawmidi device \"%s\"...\n", devname);
            err = snd_ctl_open(&handle, devname, SND_CTL_NONBLOCK);
            if (err < 0) {
                ERROR2("ERROR: snd_ctl_open, card=%d: %s\n", card, snd_strerror(err));
            } else {
                TRACE0("snd_ctl_open() SUCCESS\n");
                err = snd_ctl_card_info(handle, card_info);
                if (err < 0) {
                    ERROR2("ERROR: snd_ctl_card_info, card=%d: %s\n", card, snd_strerror(err));
                } else {
                    TRACE0("snd_ctl_card_info() SUCCESS\n");
                    dev = -1;
                    while (doContinue) {
                        if (snd_ctl_rawmidi_next_device(handle, &dev) < 0) {
                            ERROR0("snd_ctl_rawmidi_next_device\n");
                        }
                        TRACE0("snd_ctl_rawmidi_next_device() SUCCESS\n");
                        if (dev < 0) {
                            break;
                        }
                        snd_rawmidi_info_set_device(rawmidi_info, dev);
                        snd_rawmidi_info_set_subdevice(rawmidi_info, 0);
                        snd_rawmidi_info_set_stream(rawmidi_info, direction);
                        err = snd_ctl_rawmidi_info(handle, rawmidi_info);
                        TRACE0("after snd_ctl_rawmidi_info()\n");
                        if (err < 0) {
                            if (err != -ENOENT) {
                                ERROR2("ERROR: snd_ctl_rawmidi_info, card=%d: %s", card, snd_strerror(err));
                            }
                        } else {
                            TRACE0("snd_ctl_rawmidi_info() SUCCESS\n");
                            subdeviceCount = needEnumerateSubdevices(ALSA_RAWMIDI)
                                ? snd_rawmidi_info_get_subdevices_count(rawmidi_info)
                                : 1;
                            if (iterator!=NULL) {
                                for (subDev = 0; subDev < subdeviceCount; subDev++) {
                                    TRACE3("  Iterating %d,%d,%d\n", card, dev, subDev);
                                    deviceID = encodeDeviceID(card, dev, subDev);
                                    doContinue = (*iterator)(deviceID, rawmidi_info,
                                                             card_info, userData);
                                    count++;
                                    TRACE0("returned from iterator\n");
                                    if (!doContinue) {
                                        break;
                                    }
                                }
                            } else {
                                count += subdeviceCount;
                            }
                        }
                    } // of while(doContinue)
                }
                snd_ctl_close(handle);
            }
            if (snd_card_next(&card) < 0) {
                break;
            }
        }
    } else {
        ERROR0("No cards found!\n");
    }
    snd_ctl_card_info_free(card_info);
    snd_rawmidi_info_free(rawmidi_info);
    return count;
}