コード例 #1
0
void OpenSeq(TSequencer * s, char * n)
{
        midiFILE *      f;
        int             i;
        
 // initialisation
 
 	s->ref = MidiOpen("msMidiPlayer");
        s->state = idle;
        s->seq = MidiNewSeq();
        s->playtask = 0;
	s->looptask = 0;
		
        
 // read the midi file
        
        f = MidiFileOpen(n, MidiFileRead);
		
        if (!f) {
                printf ("Error opening MidiFile %s (%d)\n", n, MidiFile_errno);
                CloseSeq(s);
                exit(MidiFile_errno);
        }
        for (i = f->ntrks; i; i--){ MixSeq( MidiFileReadTrack(f), s->seq); }
	           
        if (smpte(f)) 
                TrsfSmpteSeq(s->seq, frame_par_sec(f), ticks_par_frame(f));
        else
                TrsfTempoSeq(s->seq, ticks_par_quarterNote(f));
	
	if (First(s->seq))
	 	printf("File : %s, Format : %d, Tracks : %d, Length : %d, Duration : %d\n",
                        n, f->format, f->ntrks, LenSeq(s->seq), Date(Last(s->seq)) );
	           
        (void) MidiFileClose(f);
       
 // installation
    	
        MidiSetInfo(s->ref, s);
        MidiSetRcvAlarm(s->ref, NullRcv);
        
        MidiConnect(s->ref, 0, 1);
        MidiConnect(0, s->ref, 1);
}
コード例 #2
0
   /**
     * Create MidiShare input device for LinuxSampler. 
	 *
     * @param AutoConnectPortID - (optional) Alsa client and port ID of a
     *                            MIDI source we should auto connect to
     *                            (e.g. "64:0")
     * @throws MidiInputException  if initialization failed
     */
    MidiInputDeviceMidiShare::MidiInputDeviceMidiShare(char* AutoConnectPortID) : MidiInputDevice(MidiInputDevice::type_midishare) 
	{
		if (!MidiShare())
			throw MidiInputException("MidiShare not installed");
			
		#if defined(MIDISHARE_DRIVER)
			OpenDriver();
		#else
			OpenAppl();
		#endif
		
		hMidiFilter = MidiNewFilter();
		
		if (hMidiFilter == 0) {
			MidiClose(hRefnum);
			throw MidiInputException("MidiShare filter can not be allocated");	
		}
		  
		for (int i = 0 ; i < 256; i++) {
			MidiAcceptPort(hMidiFilter, i, 1); /* accept all ports */
			MidiAcceptType(hMidiFilter, i, 0); /* reject all types */ 
		} 
		  
		for (int i = 0 ; i < 16; i++) {
			MidiAcceptChan(hMidiFilter, i, 1); /* accept all chan */ 
		} 
		/* accept only the following types */
		MidiAcceptType(hMidiFilter, typeNote, 1);
		MidiAcceptType(hMidiFilter, typeKeyOn, 1);
		MidiAcceptType(hMidiFilter, typeKeyOff, 1);
		MidiAcceptType(hMidiFilter, typeCtrlChange, 1);
		//MidiAcceptType(hMidiFilter, typeProgChange, 1);
		MidiAcceptType(hMidiFilter, typePitchWheel, 1);
		  
		/* set the filter */
		MidiSetFilter(hRefnum, hMidiFilter);
	
		MidiSetRcvAlarm(hRefnum,ReceiveEvents);
		MidiSetApplAlarm(hRefnum,ApplAlarm);
		MidiSetInfo(hRefnum,this);
		MidiConnect(0,hRefnum,true);
	}
コード例 #3
0
/*
 * new_fluid_midishare_midi_driver
 */
fluid_midi_driver_t*
new_fluid_midishare_midi_driver(fluid_settings_t* settings,
                                handle_midi_event_func_t handler,
                                void* data)
{
    fluid_midishare_midi_driver_t* dev;
    int i;

    /* not much use doing anything */
    if (handler == NULL) {
        FLUID_LOG(FLUID_ERR, "Invalid argument");
        return NULL;
    }

    /* allocate the device */
    dev = FLUID_NEW(fluid_midishare_midi_driver_t);
    if (dev == NULL) {
        FLUID_LOG(FLUID_ERR, "Out of memory");
        return NULL;
    }
    FLUID_MEMSET(dev, 0, sizeof(fluid_midishare_midi_driver_t));
    dev->driver.handler = handler;
    dev->driver.data = data;

    /* register to MidiShare as Application or Driver */
#if defined(MIDISHARE_DRIVER)
    if (!fluid_midishare_open_driver(dev)) goto error_recovery;
#else
    if (!fluid_midishare_open_appl(dev)) goto error_recovery;
#endif

    /*MidiSetInfo(dev->refnum, dev->router->synth); */
    MidiSetInfo(dev->refnum, dev);
    dev->filter = MidiNewFilter();
    if (dev->filter == 0) {
        FLUID_LOG(FLUID_ERR, "Can not allocate MidiShare filter");
        goto error_recovery;
    }

    for (i = 0 ; i < 256; i++) {
        MidiAcceptPort(dev->filter, i, 1); /* accept all ports */
        MidiAcceptType(dev->filter, i, 0); /* reject all types */
    }

    for (i = 0 ; i < 16; i++) {
        MidiAcceptChan(dev->filter, i, 1); /* accept all chan */
    }

    /* accept only the following types */
    MidiAcceptType(dev->filter, typeNote, 1);
    MidiAcceptType(dev->filter, typeKeyOn, 1);
    MidiAcceptType(dev->filter, typeKeyOff, 1);
    MidiAcceptType(dev->filter, typeCtrlChange, 1);
    MidiAcceptType(dev->filter, typeProgChange, 1);
    MidiAcceptType(dev->filter, typePitchWheel, 1);
    MidiAcceptType(dev->filter, typeSysEx, 1);

    /* set the filter */
    MidiSetFilter(dev->refnum, dev->filter);

    dev->status = FLUID_MIDI_READY;
    return (fluid_midi_driver_t*) dev;

error_recovery:
    delete_fluid_midishare_midi_driver((fluid_midi_driver_t*) dev);
    return NULL;
}