void soundfonts_pitchbend(t_soundfonts *instance, t_floatarg bend)
{
if ((bend <= 127) && (bend >= 0) ){
// Fluidsynth pitchbend values go from 0 to 16383
fluid_synth_pitch_bend(instance->synth, 0, bend * 129);
}
}
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;
}
// Could we get iph-based instruments support sample-exact models by using a
// frame-length of 1 while rendering?
void sf2Instrument::play( sampleFrame * _working_buffer )
{
const fpp_t frames = engine::mixer()->framesPerPeriod();
m_synthMutex.lock();
const int currentMidiPitch = instrumentTrack()->midiPitch();
if( m_lastMidiPitch != currentMidiPitch )
{
m_lastMidiPitch = currentMidiPitch;
fluid_synth_pitch_bend( m_synth, m_channel, m_lastMidiPitch );
}
const int currentMidiPitchRange = instrumentTrack()->midiPitchRange();
if( m_lastMidiPitchRange != currentMidiPitchRange )
{
m_lastMidiPitchRange = currentMidiPitchRange;
fluid_synth_pitch_wheel_sens( m_synth, m_channel, m_lastMidiPitchRange );
}
if( m_internalSampleRate < engine::mixer()->processingSampleRate() &&
m_srcState != NULL )
{
const fpp_t f = frames * m_internalSampleRate / engine::mixer()->processingSampleRate();
#ifdef __GNUC__
sampleFrame tmp[f];
#else
sampleFrame * tmp = new sampleFrame[f];
#endif
fluid_synth_write_float( m_synth, f, tmp, 0, 2, tmp, 1, 2 );
SRC_DATA src_data;
src_data.data_in = tmp[0];
src_data.data_out = _working_buffer[0];
src_data.input_frames = f;
src_data.output_frames = frames;
src_data.src_ratio = (double) frames / f;
src_data.end_of_input = 0;
int error = src_process( m_srcState, &src_data );
#ifndef __GNUC__
delete[] tmp;
#endif
if( error )
{
qCritical( "sf2Instrument: error while resampling: %s", src_strerror( error ) );
}
if( src_data.output_frames_gen > frames )
{
qCritical( "sf2Instrument: not enough frames: %ld / %d", src_data.output_frames_gen, frames );
}
}
else
{
fluid_synth_write_float( m_synth, frames, _working_buffer, 0, 2, _working_buffer, 1, 2 );
}
m_synthMutex.unlock();
instrumentTrack()->processAudioBuffer( _working_buffer, frames, NULL );
}
void FluidSynthSoundController::setPitch(qint8 pitch)
{
m_pitch = pitch;
fluid_synth_cc(m_synth, 1, 101, 0);
fluid_synth_cc(m_synth, 1, 6, 12);
float accurate_pitch = (m_pitch + 12) * (2.0 / 3) * 1024;
fluid_synth_pitch_bend(m_synth, 1, qMin(qRound(accurate_pitch), 16 * 1024 - 1));
}
JNIEXPORT void JNICALL Java_org_herac_tuxguitar_player_impl_midiport_fluidsynth_MidiSynth_pitchBend(JNIEnv* env, jobject ojb, jlong ptr, jint channel, jint value)
{
fluid_handle_t *handle = NULL;
memcpy(&handle, &ptr, sizeof(handle));
if(handle != NULL && handle->synth != NULL){
fluid_synth_pitch_bend(handle->synth, channel, ((value * 128)));
}
}
/*
* Class: org_tritonus_midi_device_fluidsynth_FluidSynthesizer
* Method: setPitchBend
* Signature: (II)V
*/
JNIEXPORT void JNICALL Java_org_tritonus_midi_device_fluidsynth_FluidSynthesizer_setPitchBend
(JNIEnv *env, jobject obj, jint channel, jint bend)
{
fluid_synth_t* synth = get_synth(env, obj);
if (synth)
{
fluid_synth_pitch_bend(synth, channel, bend);
}
}
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);
}
}
bool ISynth::setController(int ch, int ctrl, int val)
{
if (_busy) {
// printf("fluid: setController(): busy!\n");
return true;
}
switch(ctrl) {
case MusECore::CTRL_PROGRAM:
{
int hbank = (val & 0xff0000) >> 16;
int lbank = (val & 0xff00) >> 8;
if (hbank > 127) // map "dont care" to 0
hbank = 0;
if (lbank > 127)
lbank = 0;
if (lbank == 127 || ch == 9) // drum HACK
lbank = 128;
int prog = val & 0x7f;
fluid_synth_program_select(_fluidsynth, ch,
hbank, lbank, prog);
}
break;
case MusECore::CTRL_PITCH:
// MusE's range is from -8192 to +8191, fluidsynth seems to be [0, 16384]
val +=8192;
fluid_synth_pitch_bend (_fluidsynth, ch, val);
break;
default:
// printf("controller %x val %x\n", ctrl & 0x3fff, val);
fluid_synth_cc(_fluidsynth, ch, ctrl & 0x3fff, val);
break;
}
return false;
}
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;
}
/* 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;
}
}
void sf2Instrument::play( sampleFrame * _working_buffer )
{
const fpp_t frames = Engine::mixer()->framesPerPeriod();
// set midi pitch for this period
const int currentMidiPitch = instrumentTrack()->midiPitch();
if( m_lastMidiPitch != currentMidiPitch )
{
m_lastMidiPitch = currentMidiPitch;
m_synthMutex.lock();
fluid_synth_pitch_bend( m_synth, m_channel, m_lastMidiPitch );
m_synthMutex.unlock();
}
const int currentMidiPitchRange = instrumentTrack()->midiPitchRange();
if( m_lastMidiPitchRange != currentMidiPitchRange )
{
m_lastMidiPitchRange = currentMidiPitchRange;
m_synthMutex.lock();
fluid_synth_pitch_wheel_sens( m_synth, m_channel, m_lastMidiPitchRange );
m_synthMutex.unlock();
}
// if we have no new noteons/noteoffs, just render a period and call it a day
if( m_playingNotes.isEmpty() )
{
renderFrames( frames, _working_buffer );
instrumentTrack()->processAudioBuffer( _working_buffer, frames, NULL );
return;
}
// processing loop
// go through noteplayhandles in processing order
f_cnt_t currentFrame = 0;
while( ! m_playingNotes.isEmpty() )
{
// find the note with lowest offset
NotePlayHandle * currentNote = m_playingNotes[0];
for( int i = 1; i < m_playingNotes.size(); ++i )
{
SF2PluginData * currentData = static_cast<SF2PluginData *>( currentNote->m_pluginData );
SF2PluginData * iData = static_cast<SF2PluginData *>( m_playingNotes[i]->m_pluginData );
if( currentData->offset > iData->offset )
{
currentNote = m_playingNotes[i];
}
}
// process the current note:
// first see if we're synced in frame count
SF2PluginData * currentData = static_cast<SF2PluginData *>( currentNote->m_pluginData );
if( currentData->offset > currentFrame )
{
renderFrames( currentData->offset - currentFrame, _working_buffer + currentFrame );
currentFrame = currentData->offset;
}
if( currentData->isNew )
{
noteOn( currentData );
if( currentNote->isReleased() ) // if the note is released during the same period, we have to process it again for noteoff
{
currentData->isNew = false;
currentData->offset = currentNote->framesBeforeRelease();
}
else // otherwise remove the handle
{
m_playingNotesMutex.lock();
m_playingNotes.remove( m_playingNotes.indexOf( currentNote ) );
m_playingNotesMutex.unlock();
}
}
else
{
noteOff( currentData );
m_playingNotesMutex.lock();
m_playingNotes.remove( m_playingNotes.indexOf( currentNote ) );
m_playingNotesMutex.unlock();
}
}
if( currentFrame < frames )
{
renderFrames( frames - currentFrame, _working_buffer + currentFrame );
}
instrumentTrack()->processAudioBuffer( _working_buffer, frames, NULL );
}
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 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 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);
}
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;
}