static int8_t Midi_Receive(uint8_t *msg, uint32_t len) { uint8_t chan = msg[1] & 0xf; uint8_t msgtype = msg[1] & 0xf0; uint8_t b1 = msg[2]; uint8_t b2 = msg[3]; uint16_t b = ((b2 & 0x7f) << 7) | (b1 & 0x7f); switch (msgtype) { case 0x80: fluid_synth_noteoff(synth, chan, b1); break; case 0x90: fluid_synth_noteon(synth, chan, b1, b2); break; case 0xB0: fluid_synth_cc(synth, chan, b1, b2); break; case 0xC0: fluid_synth_program_change(synth, chan, b1); break; case 0xD0: fluid_synth_channel_pressure(synth, chan, b1); break; case 0xE0: fluid_synth_pitch_bend(synth, chan, b); break; default: break; } return 0; }
int noteoff(CSOUND *csound) { #pragma omp critical (critical_section_fluid_noteoff) { fluid_synth_noteoff(fluidSynth, channel, key); } return OK; }
JNIEXPORT void JNICALL Java_org_herac_tuxguitar_player_impl_midiport_fluidsynth_MidiSynth_noteOff(JNIEnv* env, jobject ojb, jlong ptr, jint channel, jint note, jint velocity) { fluid_handle_t *handle = NULL; memcpy(&handle, &ptr, sizeof(handle)); if(handle != NULL && handle->synth != NULL){ fluid_synth_noteoff(handle->synth, channel, note); } }
static void fluid_all_notes_off_channel (gint chan) { // fluid_event_all_sounds_off (fluid_event_t *evt, int channel)!!!!!!!!!!! // fluid_event_t evt; // fluid_event_all_notes_off (&evt, chan) gint i; for (i = 0; i < 128; i++) fluid_synth_noteoff (synth, chan, i); }
/* * Class: org_tritonus_midi_device_fluidsynth_FluidSynthesizer * Method: noteOff * Signature: (III)V */ JNIEXPORT void JNICALL Java_org_tritonus_midi_device_fluidsynth_FluidSynthesizer_noteOff (JNIEnv *env, jobject obj, jint channel, jint key, jint velocity) { fluid_synth_t* synth = get_synth(env, obj); if (synth) { /* There is no method noteoff that takes a velocity param. */ //fluid_synth_noteoff(synth, channel, key, velocity); fluid_synth_noteoff(synth, channel, key); } }
static void Flush (decoder_t *p_dec) { decoder_sys_t *p_sys = p_dec->p_sys; date_Set (&p_sys->end_date, VLC_TS_INVALID); //fluid_synth_system_reset (p_sys->synth); fluid_synth_program_reset (p_sys->synth); for (unsigned channel = 0; channel < 16; channel++) for (unsigned note = 0; note < 128; note++) fluid_synth_noteoff (p_sys->synth, channel, note); }
void sf2Instrument::noteOff( SF2PluginData * n ) { n->noteOffSent = true; m_notesRunningMutex.lock(); const int notes = --m_notesRunning[n->midiNote]; m_notesRunningMutex.unlock(); if( notes <= 0 ) { m_synthMutex.lock(); fluid_synth_noteoff( m_synth, m_channel, n->midiNote ); m_synthMutex.unlock(); } }
void sf2Instrument::deleteNotePluginData( NotePlayHandle * _n ) { SF2PluginData * pluginData = static_cast<SF2PluginData *>( _n->m_pluginData ); m_notesRunningMutex.lock(); const int n = --m_notesRunning[pluginData->midiNote]; m_notesRunningMutex.unlock(); if( n <= 0 ) { m_synthMutex.lock(); fluid_synth_noteoff( m_synth, m_channel, pluginData->midiNote ); m_synthMutex.unlock(); } delete pluginData; }
bool ISynth::playNote(int channel, int pitch, int velo) { if (_busy) { // printf("fluid: playNote(): busy!\n"); return true; } if (velo) { int err = fluid_synth_noteon(_fluidsynth, channel, pitch, velo); if (err) { printf("ISynth: noteon error, channel %d pitch %d<%s>\n", channel, pitch, fluid_synth_error(_fluidsynth)); } } else fluid_synth_noteoff(_fluidsynth, channel, pitch); return false; }
int main(int argc, char** argv) { fluid_settings_t* settings; fluid_synth_t* synth; fluid_audio_driver_t* adriver1, *adriver2, *adriver3; int sfont_id; int i, key; /* Create the settings. */ settings = new_fluid_settings(); /* Change the settings if necessary*/ /* Create the synthesizer. */ synth = new_fluid_synth(settings); /* Create the audio driver. The synthesizer starts playing as soon as the driver is created. */ adriver1 = new_fluid_audio_driver(settings, synth); fluid_settings_setstr(settings, "audio.driver", "pulseaudio"); adriver2 = new_fluid_audio_driver(settings, synth); fluid_settings_setstr(settings, "audio.driver", "alsa"); adriver3 = new_fluid_audio_driver(settings, synth); /* Load a SoundFont and reset presets (so that new instruments * get used from the SoundFont) */ sfont_id = fluid_synth_sfload(synth, "/usr/share/soundfonts/SGM-V2.01.sf2", 1); /* Initialize the random number generator */ srand(time(NULL)); for (i = 0; i < 12; i++) { /* Generate a random key */ key = 60 + (int) (12.0f * rand() / (float) RAND_MAX); /* Play a note */ fluid_synth_noteon(synth, 0, key, 80); /* Sleep for 1 second */ sleep(1); /* Stop the note */ fluid_synth_noteoff(synth, 0, key); } /* Clean up */ delete_fluid_audio_driver(adriver1); delete_fluid_audio_driver(adriver2); delete_fluid_audio_driver(adriver3); delete_fluid_synth(synth); delete_fluid_settings(settings); return 0; }
void fluidsynth_feed_midi (unsigned char *event_data, size_t event_length) { int channel = (event_data[0] & 0x0f); int type = (event_data[0] & 0xf0); switch (type) { case MIDI_NOTE_ON: { int velocity = ((int) (Denemo.project->movement->master_volume * event_data[2])); if (velocity > 0x7F) velocity = 0x7F; fluid_synth_noteon (synth, channel, event_data[1], velocity); } break; case MIDI_NOTE_OFF: fluid_synth_noteoff (synth, channel, event_data[1]); break; case MIDI_CONTROL_CHANGE: fluid_synth_cc (synth, channel, event_data[1], event_data[2]); break; case MIDI_PROGRAM_CHANGE: fluid_synth_program_change (synth, channel, event_data[1]); break; case MIDI_PITCH_BEND: fluid_synth_pitch_bend (synth, channel, event_data[1] + (event_data[2] << 7)); break; case SYS_EXCLUSIVE_MESSAGE1: //g_debug("length %d\n", event_length); fluid_synth_sysex (synth, (const char*) event_data + 1, event_length - 1, NULL, 0, NULL, FALSE); break; default: g_warning ("MIDI message type %x not handled", type); } }
static block_t *DecodeBlock (decoder_t *p_dec, block_t **pp_block) { block_t *p_block; decoder_sys_t *p_sys = p_dec->p_sys; block_t *p_out = NULL; if (pp_block == NULL) return NULL; p_block = *pp_block; if (p_block == NULL) return NULL; *pp_block = NULL; if (p_block->i_pts > VLC_TS_INVALID && !date_Get (&p_sys->end_date)) date_Set (&p_sys->end_date, p_block->i_pts); else if (p_block->i_pts < date_Get (&p_sys->end_date)) { msg_Warn (p_dec, "MIDI message in the past?"); goto drop; } if (p_block->i_buffer < 1) goto drop; uint8_t event = p_block->p_buffer[0]; uint8_t channel = p_block->p_buffer[0] & 0xf; event &= 0xF0; if (event == 0xF0) switch (channel) { case 0: if (p_block->p_buffer[p_block->i_buffer - 1] != 0xF7) { case 7: msg_Warn (p_dec, "fragmented SysEx not implemented"); goto drop; } fluid_synth_sysex (p_sys->synth, (char *)p_block->p_buffer + 1, p_block->i_buffer - 2, NULL, NULL, NULL, 0); break; case 0xF: fluid_synth_system_reset (p_sys->synth); break; } uint8_t p1 = (p_block->i_buffer > 1) ? (p_block->p_buffer[1] & 0x7f) : 0; uint8_t p2 = (p_block->i_buffer > 2) ? (p_block->p_buffer[2] & 0x7f) : 0; switch (event & 0xF0) { case 0x80: fluid_synth_noteoff (p_sys->synth, channel, p1); break; case 0x90: fluid_synth_noteon (p_sys->synth, channel, p1, p2); break; /*case 0xA0: note aftertouch not implemented */ case 0xB0: fluid_synth_cc (p_sys->synth, channel, p1, p2); break; case 0xC0: fluid_synth_program_change (p_sys->synth, channel, p1); break; case 0xD0: fluid_synth_channel_pressure (p_sys->synth, channel, p1); break; case 0xE0: fluid_synth_pitch_bend (p_sys->synth, channel, (p2 << 7) | p1); break; } unsigned samples = (p_block->i_pts - date_Get (&p_sys->end_date)) * 441 / 10000; if (samples == 0) goto drop; p_out = decoder_NewAudioBuffer (p_dec, samples); if (p_out == NULL) goto drop; p_out->i_pts = date_Get (&p_sys->end_date ); p_out->i_length = date_Increment (&p_sys->end_date, samples) - p_out->i_pts; fluid_synth_write_float (p_sys->synth, samples, p_out->p_buffer, 0, 2, p_out->p_buffer, 1, 2); drop: block_Release (p_block); return p_out; }
static void handle_buffer (GstFluidDec * fluiddec, GstBuffer * buffer) { GstMapInfo info; guint8 event; gst_buffer_map (buffer, &info, GST_MAP_READ); event = info.data[0]; switch (event & 0xf0) { case 0xf0: switch (event) { case 0xff: GST_DEBUG_OBJECT (fluiddec, "system reset"); fluid_synth_system_reset (fluiddec->synth); break; case 0xf0: case 0xf7: GST_DEBUG_OBJECT (fluiddec, "sysex 0x%02x", event); GST_MEMDUMP_OBJECT (fluiddec, "bytes ", info.data + 1, info.size - 1); fluid_synth_sysex (fluiddec->synth, (char *) info.data + 1, info.size - 1, NULL, NULL, NULL, 0); break; case 0xf9: GST_LOG_OBJECT (fluiddec, "midi tick"); break; default: GST_WARNING_OBJECT (fluiddec, "unhandled event 0x%02x", event); break; } break; default: { guint8 channel, p1, p2; channel = event & 0x0f; p1 = info.size > 1 ? info.data[1] & 0x7f : 0; p2 = info.size > 2 ? info.data[2] & 0x7f : 0; GST_DEBUG_OBJECT (fluiddec, "event 0x%02x channel %d, 0x%02x 0x%02x", event, channel, p1, p2); switch (event & 0xf0) { case 0x80: fluid_synth_noteoff (fluiddec->synth, channel, p1); break; case 0x90: fluid_synth_noteon (fluiddec->synth, channel, p1, p2); break; case 0xA0: /* aftertouch */ break; case 0xB0: fluid_synth_cc (fluiddec->synth, channel, p1, p2); break; case 0xC0: fluid_synth_program_change (fluiddec->synth, channel, p1); break; case 0xD0: fluid_synth_channel_pressure (fluiddec->synth, channel, p1); break; case 0xE0: fluid_synth_pitch_bend (fluiddec->synth, channel, (p2 << 7) | p1); break; default: break; } break; } } gst_buffer_unmap (buffer, &info); }
static aout_buffer_t *DecodeBlock (decoder_t *p_dec, block_t **pp_block) { block_t *p_block; decoder_sys_t *p_sys = p_dec->p_sys; aout_buffer_t *p_out = NULL; if (pp_block == NULL) return NULL; p_block = *pp_block; if (p_block == NULL) return NULL; *pp_block = NULL; if (p_block->i_pts && !date_Get (&p_sys->end_date)) date_Set (&p_sys->end_date, p_block->i_pts); else if (p_block->i_pts < date_Get (&p_sys->end_date)) { msg_Warn (p_dec, "MIDI message in the past?"); goto drop; } if (p_block->i_buffer < 1) goto drop; uint8_t channel = p_block->p_buffer[0] & 0xf; uint8_t p1 = (p_block->i_buffer > 1) ? (p_block->p_buffer[1] & 0x7f) : 0; uint8_t p2 = (p_block->i_buffer > 2) ? (p_block->p_buffer[2] & 0x7f) : 0; switch (p_block->p_buffer[0] & 0xf0) { case 0x80: fluid_synth_noteoff (p_sys->synth, channel, p1); break; case 0x90: fluid_synth_noteon (p_sys->synth, channel, p1, p2); break; case 0xB0: fluid_synth_cc (p_sys->synth, channel, p1, p2); break; case 0xC0: fluid_synth_program_change (p_sys->synth, channel, p1); break; case 0xE0: fluid_synth_pitch_bend (p_sys->synth, channel, (p1 << 7) | p2); break; } unsigned samples = (p_block->i_pts - date_Get (&p_sys->end_date)) * 441 / 10000; if (samples == 0) return NULL; p_out = decoder_NewAudioBuffer (p_dec, samples); if (p_out == NULL) goto drop; p_out->i_pts = date_Get (&p_sys->end_date ); p_out->i_length = date_Increment (&p_sys->end_date, samples) - p_out->i_pts; if (!p_sys->fixed) fluid_synth_write_float (p_sys->synth, samples, p_out->p_buffer, 0, 2, p_out->p_buffer, 1, 2); else fluid_synth_write_s16 (p_sys->synth, samples, (int16_t *)p_out->p_buffer, 0, 2, (int16_t *)p_out->p_buffer, 1, 2); drop: block_Release (p_block); return p_out; }
void note_off(seq_context_t *seq, uint32_t ch, uint32_t note) { fluid_synth_noteoff(seq->f_synth, ch, note); }
int kontrol(CSOUND *csound) { #pragma omp critical (critical_section_fluidopcodes) { midiStatus = 0xF0 & (int) *kMidiStatus; midiChannel = (int) *kMidiChannel; midiData1 = (int) *kMidiData1; midiData2 = (int) *kMidiData2; int result = -1; if (midiData2 != priorMidiData2 || midiData1 != priorMidiData1 || midiChannel != priorMidiChannel || midiStatus != priorMidiStatus) { switch (midiStatus) { case (int) 0x80: noteOff: result = fluid_synth_noteoff(fluidSynth, midiChannel, midiData1); if (printMsgs) csound->Message(csound, Str("result: %d \n Note off: c:%3d k:%3d\n"), result, midiChannel, midiData1); break; case (int) 0x90: if (!midiData2) { goto noteOff; } result = fluid_synth_noteon(fluidSynth, midiChannel, midiData1, midiData2); if (printMsgs) log(csound, "result: %d \nNote on: c:%3d k:%3d v:%3d\n",result, midiChannel, midiData1, midiData2); break; case (int) 0xA0: if (printMsgs) log(csound, "Key pressure (not handled): " "c:%3d k:%3d v:%3d\n", midiChannel, midiData1, midiData2); break; case (int) 0xB0: result = fluid_synth_cc(fluidSynth, midiChannel, midiData1, midiData2); if (printMsgs) log(csound, "Result: %d Control change: c:%3d c:%3d v:%3d\n",result, midiChannel, midiData1, midiData2); break; case (int) 0xC0: result = fluid_synth_program_change(fluidSynth, midiChannel, midiData1); if (printMsgs) log(csound, "Result: %d Program change: c:%3d p:%3d\n",result, midiChannel, midiData1); break; case (int) 0xD0: if (printMsgs) log(csound, "After touch (not handled): c:%3d v:%3d\n", midiChannel, midiData1); break; case (int) 0xE0: { int pbVal = midiData1 + (midiData2 << 7); fluid_synth_pitch_bend(fluidSynth, midiChannel, pbVal); if (printMsgs) log(csound, "Result: %d, Pitch bend: c:%d b:%d\n", result, midiChannel, pbVal); } break; case (int) 0xF0: if (printMsgs) log(csound, "System exclusive (not handled): " "c:%3d v1:%3d v2:%3d\n", midiChannel, midiData1, midiData2); break; } priorMidiStatus = midiStatus; priorMidiChannel = midiChannel; priorMidiData1 = midiData1; priorMidiData2 = midiData2; } } return OK; }
void ProcessMidi() { ALuint newtempo = 0; // Process more events std::vector<MidiTrack>::iterator i=Tracks.begin(), end=Tracks.end(); while(i != end) { if(i->Offset >= i->data.size() || i->SamplesLeft >= 1.) { i++; continue; } if(i->data.size() - i->Offset < 3) { i->Offset = i->data.size(); i++; continue; } ALubyte event = i->data[i->Offset++]; ALubyte parm1, parm2; if(!(event&0x80)) { event = i->LastEvent; i->Offset--; } if((event&MIDI_EVENT_MASK) != MIDI_SPECIAL) i->LastEvent = event; parm1 = i->data[i->Offset]; parm2 = i->data[i->Offset+1]; int channel = event&MIDI_CHANNEL_MASK; switch(event&MIDI_EVENT_MASK) { case MIDI_NOTEOFF: fluid_synth_noteoff(fluidSynth, channel, parm1); i->Offset += 2; break; case MIDI_NOTEON: fluid_synth_noteon(fluidSynth, channel, parm1, parm2); i->Offset += 2; break; case MIDI_POLYPRESS: i->Offset += 2; break; case MIDI_CTRLCHANGE: fluid_synth_cc(fluidSynth, channel, parm1, parm2); i->Offset += 2; break; case MIDI_PRGMCHANGE: fluid_synth_program_change(fluidSynth, channel, parm1); i->Offset += 1; break; case MIDI_CHANPRESS: fluid_synth_channel_pressure(fluidSynth, channel, parm1); i->Offset += 1; break; case MIDI_PITCHBEND: fluid_synth_pitch_bend(fluidSynth, channel, (parm1&0x7F) | ((parm2&0x7F)<<7)); i->Offset += 2; break; case MIDI_SPECIAL: switch(event) { case MIDI_SYSEX: { unsigned long len = i->ReadVarLen(); if(i->data.size() - i->Offset < len) { i->Offset = i->data.size(); break; } if(i->data[i->Offset+len-1] == MIDI_SYSEXEND) { char *data = reinterpret_cast<char*>(&i->data[i->Offset]); fluid_synth_sysex(fluidSynth, data, len-1, NULL, NULL, NULL, false); } i->Offset += len; break; } case MIDI_SYSEXEND: { unsigned long len = i->ReadVarLen(); if(i->data.size() - i->Offset < len) { i->Offset = i->data.size(); break; } i->Offset += len; break; } case MIDI_SONGPOS: i->Offset += 2; break; case MIDI_SONGSEL: i->Offset += 1; break; case MIDI_META: { ALubyte metatype = i->data[i->Offset++]; unsigned long val = i->ReadVarLen(); if(i->data.size() - i->Offset < val) { i->Offset = i->data.size(); break; } if(metatype == MIDI_META_EOT) { i->Offset = i->data.size(); break; } if(metatype == MIDI_META_TEMPO && val >= 3) { newtempo = (i->data[i->Offset] << 16) | (i->data[i->Offset+1] << 8) | (i->data[i->Offset+2]); } i->Offset += val; break; } default: /* The rest of the special events don't have any * data bytes */ break; } break; default: /* Shouldn't ever get to here */ break; } unsigned long val = i->ReadVarLen(); i->SamplesLeft += val * samplesPerTick; } if(newtempo) UpdateTempo(newtempo); }
/* Callback for midi events */ void fluid_seq_fluidsynth_callback(unsigned int time, fluid_event_t* evt, fluid_sequencer_t* seq, void* data) { fluid_synth_t* synth; fluid_seqbind_t* seqbind = (fluid_seqbind_t *) data; synth = seqbind->synth; switch (fluid_event_get_type(evt)) { case FLUID_SEQ_NOTEON: fluid_synth_noteon(synth, fluid_event_get_channel(evt), fluid_event_get_key(evt), fluid_event_get_velocity(evt)); break; case FLUID_SEQ_NOTEOFF: fluid_synth_noteoff(synth, fluid_event_get_channel(evt), fluid_event_get_key(evt)); break; case FLUID_SEQ_NOTE: { unsigned int dur; fluid_synth_noteon(synth, fluid_event_get_channel(evt), fluid_event_get_key(evt), fluid_event_get_velocity(evt)); dur = fluid_event_get_duration(evt); fluid_event_noteoff(evt, fluid_event_get_channel(evt), fluid_event_get_key(evt)); fluid_sequencer_send_at(seq, evt, dur, 0); } break; case FLUID_SEQ_ALLSOUNDSOFF: /* NYI */ break; case FLUID_SEQ_ALLNOTESOFF: fluid_synth_cc(synth, fluid_event_get_channel(evt), 0x7B, 0); break; case FLUID_SEQ_BANKSELECT: fluid_synth_bank_select(synth, fluid_event_get_channel(evt), fluid_event_get_bank(evt)); break; case FLUID_SEQ_PROGRAMCHANGE: fluid_synth_program_change(synth, fluid_event_get_channel(evt), fluid_event_get_program(evt)); break; case FLUID_SEQ_PROGRAMSELECT: fluid_synth_program_select(synth, fluid_event_get_channel(evt), fluid_event_get_sfont_id(evt), fluid_event_get_bank(evt), fluid_event_get_program(evt)); break; case FLUID_SEQ_ANYCONTROLCHANGE: /* nothing = only used by remove_events */ break; case FLUID_SEQ_PITCHBEND: fluid_synth_pitch_bend(synth, fluid_event_get_channel(evt), fluid_event_get_pitch(evt)); break; case FLUID_SEQ_PITCHWHHELSENS: fluid_synth_pitch_wheel_sens(synth, fluid_event_get_channel(evt), fluid_event_get_value(evt)); break; case FLUID_SEQ_CONTROLCHANGE: fluid_synth_cc(synth, fluid_event_get_channel(evt), fluid_event_get_control(evt), fluid_event_get_value(evt)); break; case FLUID_SEQ_MODULATION: { short ctrl = 0x01; // MODULATION_MSB fluid_synth_cc(synth, fluid_event_get_channel(evt), ctrl, fluid_event_get_value(evt)); } break; case FLUID_SEQ_SUSTAIN: { short ctrl = 0x40; // SUSTAIN_SWITCH fluid_synth_cc(synth, fluid_event_get_channel(evt), ctrl, fluid_event_get_value(evt)); } break; case FLUID_SEQ_PAN: { short ctrl = 0x0A; // PAN_MSB fluid_synth_cc(synth, fluid_event_get_channel(evt), ctrl, fluid_event_get_value(evt)); } break; case FLUID_SEQ_VOLUME: { short ctrl = 0x07; // VOLUME_MSB fluid_synth_cc(synth, fluid_event_get_channel(evt), ctrl, fluid_event_get_value(evt)); } break; case FLUID_SEQ_REVERBSEND: { short ctrl = 0x5B; // EFFECTS_DEPTH1 fluid_synth_cc(synth, fluid_event_get_channel(evt), ctrl, fluid_event_get_value(evt)); } break; case FLUID_SEQ_CHORUSSEND: { short ctrl = 0x5D; // EFFECTS_DEPTH3 fluid_synth_cc(synth, fluid_event_get_channel(evt), ctrl, fluid_event_get_value(evt)); } break; case FLUID_SEQ_CHANNELPRESSURE: { fluid_synth_channel_pressure(synth, fluid_event_get_channel(evt), fluid_event_get_value(evt)); } break; case FLUID_SEQ_SYSTEMRESET: { fluid_synth_system_reset(synth); } break; case FLUID_SEQ_UNREGISTERING: /* free ourselves */ { seqbind->client_id = -1; /* avoid recursive call to fluid_sequencer_unregister_client */ delete_fluid_seqbind(seqbind); } break; case FLUID_SEQ_TIMER: /* nothing in fluidsynth */ break; default: break; } }
static void FSynth_processQueue(FSynth *self, ALuint64 time) { EvtQueue *queue = &STATIC_CAST(MidiSynth, self)->EventQueue; while(queue->pos < queue->size && queue->events[queue->pos].time <= time) { const MidiEvent *evt = &queue->events[queue->pos]; if(evt->event == SYSEX_EVENT) { static const ALbyte gm2_on[] = { 0x7E, 0x7F, 0x09, 0x03 }; static const ALbyte gm2_off[] = { 0x7E, 0x7F, 0x09, 0x02 }; int handled = 0; fluid_synth_sysex(self->Synth, evt->param.sysex.data, evt->param.sysex.size, NULL, NULL, &handled, 0); if(!handled && evt->param.sysex.size >= (ALsizei)sizeof(gm2_on)) { if(memcmp(evt->param.sysex.data, gm2_on, sizeof(gm2_on)) == 0) self->ForceGM2BankSelect = AL_TRUE; else if(memcmp(evt->param.sysex.data, gm2_off, sizeof(gm2_off)) == 0) self->ForceGM2BankSelect = AL_FALSE; } } else switch((evt->event&0xF0)) { case AL_NOTEOFF_SOFT: fluid_synth_noteoff(self->Synth, (evt->event&0x0F), evt->param.val[0]); break; case AL_NOTEON_SOFT: fluid_synth_noteon(self->Synth, (evt->event&0x0F), evt->param.val[0], evt->param.val[1]); break; case AL_AFTERTOUCH_SOFT: break; case AL_CONTROLLERCHANGE_SOFT: if(self->ForceGM2BankSelect) { int chan = (evt->event&0x0F); if(evt->param.val[0] == 0) { if(evt->param.val[1] == 120 && (chan == 9 || chan == 10)) fluid_synth_set_channel_type(self->Synth, chan, CHANNEL_TYPE_DRUM); else if(evt->param.val[1] == 121) fluid_synth_set_channel_type(self->Synth, chan, CHANNEL_TYPE_MELODIC); break; } if(evt->param.val[0] == 32) { fluid_synth_bank_select(self->Synth, chan, evt->param.val[1]); break; } } fluid_synth_cc(self->Synth, (evt->event&0x0F), evt->param.val[0], evt->param.val[1]); break; case AL_PROGRAMCHANGE_SOFT: fluid_synth_program_change(self->Synth, (evt->event&0x0F), evt->param.val[0]); break; case AL_CHANNELPRESSURE_SOFT: fluid_synth_channel_pressure(self->Synth, (evt->event&0x0F), evt->param.val[0]); break; case AL_PITCHBEND_SOFT: fluid_synth_pitch_bend(self->Synth, (evt->event&0x0F), (evt->param.val[0]&0x7F) | ((evt->param.val[1]&0x7F)<<7)); break; } queue->pos++; } }
static int fluidsynth_midi_write(struct _midi_writer *self, unsigned char *buf, int len) { if (buf[0] == 0xf0) sciprintf("FluidSynth: Skipping sysex message.\n"); else if (len == 2) { guint8 command, channel; command = buf[0] & 0xf0; channel = buf[0] & 0x0f; switch(command) { case 0xc0: fluid_synth_program_change(synth, channel, buf[1]); break; default: printf("FluidSynth: MIDI command [%02x %02x] not supported\n", buf[0], buf[1]); } } else if (len == 3) { guint8 command, channel; command = buf[0] & 0xf0; channel = buf[0] & 0x0f; switch(command) { case 0x80: fluid_synth_noteoff(synth, channel, buf[1]); break; case 0x90: fluid_synth_noteon(synth, channel, buf[1], buf[2]); break; case 0xb0: switch (buf[1]) { case 0x06: /* Data Entry Slider - course */ if (rpn[channel] == 0) fluid_synth_pitch_wheel_sens(synth, channel, buf[2]); else sciprintf("FluidSynth: RPN %i not supported\n", rpn[channel]); case 0x64: /* Registered Parameter Number (RPN) - fine */ rpn[channel] &= ~0x7f; rpn[channel] |= buf[2] & 0x7f; break; case 0x65: /* Registered Parameter Number (RPN) - course */ rpn[channel] &= ~0x3f80; rpn[channel] |= (buf[2] & 0x7f) << 7; break; default: fluid_synth_cc(synth, channel, buf[1], buf[2]); } break; case 0xe0: fluid_synth_pitch_bend(synth, channel, (buf[2] << 7) | buf[1]); break; default: sciprintf("FluidSynth: MIDI command [%02x %02x %02x] not supported\n", buf[0], buf[1], buf[2]); } } else sciprintf("FluidSynth: Skipping invalid message of %i bytes.\n", len); return SFX_OK; }
void noteOff(int chan, int key) { fluid_synth_noteoff(m_synth, chan, key); }