2015 lines
61 KiB
C++
2015 lines
61 KiB
C++
#include "cwCommon.h"
|
|
#include "cwLog.h"
|
|
#include "cwCommonImpl.h"
|
|
#include "cwMem.h"
|
|
#include "cwText.h"
|
|
#include "cwObject.h"
|
|
#include "cwFileSys.h"
|
|
#include "cwFile.h"
|
|
#include "cwTime.h"
|
|
#include "cwMidiDecls.h"
|
|
#include "cwMidi.h"
|
|
#include "cwMidiFile.h"
|
|
#include "cwUiDecls.h"
|
|
#include "cwIo.h"
|
|
#include "cwIoMidiRecordPlay.h"
|
|
#include "cwMidiState.h"
|
|
#include "cwSvgMidi.h"
|
|
|
|
#define TIMER_LABEL "midi_record_play_timer"
|
|
|
|
namespace cw
|
|
{
|
|
namespace midi_record_play
|
|
{
|
|
enum {
|
|
kStoppedMidiStateId = 0,
|
|
kPlayingMidiStateId,
|
|
kStoppingMidiStateId
|
|
};
|
|
|
|
typedef struct midi_state_str
|
|
{
|
|
uint8_t keyVel[ midi::kMidiNoteCnt ];
|
|
uint8_t ctlVal[ midi::kMidiCtlCnt ];
|
|
unsigned state;
|
|
} midi_state_t;
|
|
|
|
typedef struct am_midi_msg_str
|
|
{
|
|
unsigned devIdx;
|
|
unsigned portIdx;
|
|
unsigned microsec;
|
|
|
|
unsigned id;
|
|
time::spec_t timestamp;
|
|
unsigned loc;
|
|
uint8_t ch;
|
|
uint8_t status;
|
|
uint8_t d0;
|
|
uint8_t d1;
|
|
|
|
unsigned chordNoteCnt; // count of notes in same chord as this note (only set on Note-on messages)
|
|
|
|
} am_midi_msg_t;
|
|
|
|
typedef struct midi_device_str
|
|
{
|
|
char* midiOutDevLabel;
|
|
char* midiOutPortLabel;
|
|
unsigned midiOutDevIdx;
|
|
unsigned midiOutPortIdx;
|
|
bool enableFl;
|
|
unsigned velTableN;
|
|
uint8_t* velTableArray;
|
|
bool pedalMapEnableFl;
|
|
|
|
unsigned pedalDownVelId;
|
|
unsigned pedalDownVel;
|
|
|
|
unsigned pedalUpVelId;
|
|
unsigned pedalUpVel;
|
|
|
|
unsigned pedalDownHalfVelId;
|
|
unsigned pedalDownHalfVel;
|
|
|
|
unsigned pedalUpHalfVelId;
|
|
unsigned pedalUpHalfVel;
|
|
|
|
unsigned velHistogram[ midi::kMidiVelCnt ];
|
|
|
|
bool force_damper_down_fl;
|
|
unsigned force_damper_down_threshold;
|
|
unsigned force_damper_down_velocity;
|
|
|
|
bool damper_dead_band_enable_fl;
|
|
unsigned damper_dead_band_min_value;
|
|
unsigned damper_dead_band_max_value;
|
|
|
|
bool scale_chord_notes_enable_fl;
|
|
double scale_chord_notes_factor;
|
|
|
|
midi_state_t midi_state;
|
|
|
|
} midi_device_t;
|
|
|
|
enum
|
|
{
|
|
kHalfPedalDone,
|
|
kWaitForBegin,
|
|
kWaitForNoteOn,
|
|
kWaitForNoteOff,
|
|
kWaitForPedalUp,
|
|
kWaitForPedalDown,
|
|
};
|
|
|
|
|
|
typedef struct midi_record_play_str
|
|
{
|
|
io::handle_t ioH;
|
|
|
|
am_midi_msg_t* msgArray; // msgArray[ msgArrayN ]
|
|
unsigned msgArrayN; // Count of messages allocated in msgArray.
|
|
unsigned msgArrayInIdx; // Next available space for loaded MIDI messages (also the current count of msgs in msgArray[])
|
|
unsigned msgArrayOutIdx; // Next message to transmit in msgArray[]
|
|
unsigned midi_timer_period_micro_sec; // Timer period in microseconds
|
|
unsigned all_off_delay_ms; // Wait this long before turning all notes off after the last note-on has played
|
|
|
|
am_midi_msg_t* iMsgArray; // msgArray[ msgArrayN ]
|
|
unsigned iMsgArrayN; // Count of messages allocated in msgArray.
|
|
unsigned iMsgArrayInIdx; // Next available space for incoming MIDI messages (also the current count of msgs in msgArray[])
|
|
|
|
|
|
midi_device_t* midiDevA;
|
|
unsigned midiDevN;
|
|
|
|
bool startedFl;
|
|
bool recordFl;
|
|
bool muteFl;
|
|
bool thruFl;
|
|
bool logInFl; // log incoming message when not in 'record' mode.
|
|
bool logOutFl; // log outgoing messages
|
|
bool supressMidiXmitFl; // don't transmit MIDI
|
|
|
|
unsigned minDamperDownMs;
|
|
bool velHistogramEnableFl;
|
|
|
|
bool halfPedalFl;
|
|
unsigned halfPedalState;
|
|
unsigned halfPedalNextUs;
|
|
unsigned halfPedalNoteDelayUs;
|
|
unsigned halfPedalNoteDurUs;
|
|
unsigned halfPedalUpDelayUs;
|
|
unsigned halfPedalDownDelayUs;
|
|
uint8_t halfPedalMidiPitch;
|
|
uint8_t halfPedalMidiNoteVel;
|
|
uint8_t halfPedalMidiPedalVel;
|
|
|
|
time::spec_t play_time;
|
|
time::spec_t start_time;
|
|
time::spec_t end_play_event_timestamp;
|
|
time::spec_t all_off_timestamp;
|
|
time::spec_t store_time;
|
|
|
|
event_callback_t cb;
|
|
void* cb_arg;
|
|
|
|
} midi_record_play_t;
|
|
|
|
enum
|
|
{
|
|
kMidiRecordPlayTimerId
|
|
};
|
|
|
|
midi_record_play_t* _handleToPtr( handle_t h )
|
|
{ return handleToPtr<handle_t,midi_record_play_t>(h); }
|
|
|
|
rc_t _destroy( midi_record_play_t* p )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
unsigned timerIdx;
|
|
|
|
if((timerIdx = io::timerLabelToIndex( p->ioH, TIMER_LABEL )) != kInvalidIdx )
|
|
io::timerDestroy( p->ioH, timerIdx);
|
|
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
{
|
|
mem::release(p->midiDevA[i].midiOutDevLabel);
|
|
mem::release(p->midiDevA[i].midiOutPortLabel);
|
|
mem::release(p->midiDevA[i].velTableArray);
|
|
}
|
|
|
|
mem::release(p->midiDevA);
|
|
mem::release(p->msgArray);
|
|
mem::release(p->iMsgArray);
|
|
mem::release(p);
|
|
|
|
return rc;
|
|
}
|
|
|
|
void _xmit_midi( midi_record_play_t* p, unsigned devIdx, uint8_t ch, uint8_t status, uint8_t d0, uint8_t d1 )
|
|
{
|
|
if( !p->supressMidiXmitFl )
|
|
io::midiDeviceSend( p->ioH, p->midiDevA[devIdx].midiOutDevIdx, p->midiDevA[devIdx].midiOutPortIdx, status + ch, d0, d1 );
|
|
}
|
|
|
|
|
|
// initialze the midi state to all-notes-off and all controllers=0
|
|
void _midi_state_clear( midi_record_play_t* p)
|
|
{
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
{
|
|
for(unsigned j=0; j<midi::kMidiNoteCnt; ++j)
|
|
p->midiDevA[i].midi_state.keyVel[j] = 0;
|
|
|
|
for(unsigned j=0; j<midi::kMidiCtlCnt; ++j)
|
|
p->midiDevA[i].midi_state.ctlVal[j] = 0;
|
|
|
|
p->midiDevA[i].midi_state.state = kPlayingMidiStateId;
|
|
}
|
|
}
|
|
|
|
void _midi_state_set_state( midi_record_play_t* p, unsigned stateId )
|
|
{
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
p->midiDevA[i].midi_state.state = stateId;
|
|
}
|
|
|
|
bool _midi_state_is_state( midi_record_play_t* p, unsigned stateId )
|
|
{
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
if( p->midiDevA[i].midi_state.state != stateId )
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
void _midi_state_set_stopping( midi_record_play_t* p )
|
|
{ _midi_state_set_state(p,kStoppingMidiStateId); }
|
|
|
|
bool _midi_state_is_stopping( midi_record_play_t* p )
|
|
{ return _midi_state_is_state(p,kStoppingMidiStateId); }
|
|
|
|
bool _midi_state_is_stopped( midi_record_play_t* p )
|
|
{ return _midi_state_is_state(p,kStoppedMidiStateId); }
|
|
|
|
unsigned _midi_state_active_note_count( midi_record_play_t* p )
|
|
{
|
|
unsigned n = 0;
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
for(unsigned j=0; j<midi::kMidiNoteCnt; ++j)
|
|
n += p->midiDevA[i].midi_state.keyVel[j] > 0 ? 1 : 0;
|
|
|
|
return n;
|
|
}
|
|
|
|
rc_t _midi_state_update( midi_record_play_t* p, midi_device_t& dev, uint8_t ch, uint8_t status, uint8_t d0, uint8_t d1 )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
|
|
if( ch != 0 )
|
|
{
|
|
rc = cwLogError(kInvalidArgRC,"Only the state of MIDI channel 0 tracked.");
|
|
goto errLabel;
|
|
}
|
|
|
|
if( d0 > 127 || d1 > 127 )
|
|
{
|
|
rc = cwLogError(kInvalidArgRC,"Illegal MIDI byte value: st:%i d0:%i d1:%i",status,d0,d1);
|
|
goto errLabel;
|
|
}
|
|
|
|
if( midi::isNoteOn(status,d1) )
|
|
{
|
|
if( dev.midi_state.state == kPlayingMidiStateId )
|
|
dev.midi_state.keyVel[ d0 ] = d1;
|
|
goto errLabel;
|
|
}
|
|
|
|
if( midi::isNoteOff(status,d1))
|
|
{
|
|
dev.midi_state.keyVel[ d0 ] = 0;
|
|
goto errLabel;
|
|
}
|
|
|
|
if( midi::isCtl(status) )
|
|
{
|
|
dev.midi_state.ctlVal[ d0 ] = d1;
|
|
goto errLabel;
|
|
}
|
|
|
|
errLabel:
|
|
|
|
|
|
return rc;
|
|
}
|
|
|
|
bool _midi_state_are_all_notes_off( midi_record_play_t* p )
|
|
{
|
|
if( _midi_state_is_stopped( p ) )
|
|
return true;
|
|
|
|
if( _midi_state_is_stopping( p ) )
|
|
if( _midi_state_active_note_count( p ) == 0 )
|
|
{
|
|
_midi_state_set_state(p,kStoppedMidiStateId);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
uint8_t _midi_state_ctl_value( midi_record_play_t* p, midi_device_t& dev, uint8_t d0 )
|
|
{
|
|
return dev.midi_state.ctlVal[d0];
|
|
}
|
|
|
|
void _midi_state_xmit_pedals( midi_record_play_t* p )
|
|
{
|
|
uint8_t ctlA[] = { midi::kSustainCtlMdId, midi::kSostenutoCtlMdId, midi::kSoftPedalCtlMdId };
|
|
unsigned ctlN = sizeof(ctlA)/sizeof(ctlA[0]);
|
|
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
for(unsigned j=0; j<ctlN; ++j)
|
|
{
|
|
uint8_t d1 = _midi_state_ctl_value( p, p->midiDevA[i], ctlA[j] );
|
|
_xmit_midi(p, i, 0, midi::kCtlMdId, ctlA[j], d1 );
|
|
}
|
|
|
|
}
|
|
|
|
void _set_chord_note_count( am_midi_msg_t* m0, const am_midi_msg_t* m, unsigned chordNoteCnt )
|
|
{
|
|
for(; m0<m; ++m0)
|
|
if( midi::isNoteOn(m0->status,m0->d1) )
|
|
m0->chordNoteCnt = chordNoteCnt;
|
|
|
|
}
|
|
|
|
void _set_chord_note_count( midi_record_play_t* p )
|
|
{
|
|
unsigned chordNoteCnt = 1;
|
|
am_midi_msg_t* m0 = p->msgArray;
|
|
am_midi_msg_t* m = nullptr;
|
|
|
|
for(unsigned i=1; i<p->msgArrayN; ++i)
|
|
{
|
|
m = p->msgArray + i;
|
|
if( midi::isNoteOn(m->status,m->d1) )
|
|
{
|
|
if( time::isEqual(m0->timestamp, m->timestamp) )
|
|
++chordNoteCnt;
|
|
else
|
|
{
|
|
_set_chord_note_count(m0,m,chordNoteCnt);
|
|
|
|
chordNoteCnt=1;
|
|
m0 = m;
|
|
}
|
|
}
|
|
}
|
|
|
|
_set_chord_note_count(m0,m,chordNoteCnt);
|
|
|
|
}
|
|
|
|
rc_t _parseCfg(midi_record_play_t* p, const object_t& cfg )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
const object_t* midiDevL = nullptr;
|
|
if((rc = cfg.getv(
|
|
"max_midi_msg_count", p->msgArrayN,
|
|
"midi_timer_period_micro_sec", p->midi_timer_period_micro_sec,
|
|
"all_off_delay_ms", p->all_off_delay_ms,
|
|
"midi_device_list", midiDevL,
|
|
"log_in_flag", p->logInFl,
|
|
"log_out_flag", p->logOutFl,
|
|
"min_damper_down_time_ms", p->minDamperDownMs,
|
|
"half_pedal_flag", p->halfPedalFl)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kSyntaxErrorRC,"MIDI record play configuration parse failed.");
|
|
goto errLabel;
|
|
}
|
|
|
|
p->iMsgArrayN = p->msgArrayN;
|
|
|
|
if( midiDevL->child_count() > 0 )
|
|
{
|
|
p->midiDevN = midiDevL->child_count();
|
|
p->midiDevA = mem::allocZ<midi_device_t>(p->midiDevN);
|
|
|
|
printf("Midi record play devices:%i\n",p->midiDevN);
|
|
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
{
|
|
const object_t* ele = midiDevL->child_ele(i);
|
|
const char* midiOutDevLabel = nullptr;
|
|
const char* midiOutPortLabel = nullptr;
|
|
const object_t* velTable = nullptr;
|
|
const object_t* pedalRecd = nullptr;
|
|
bool enableFl = false;
|
|
|
|
if((rc = ele->getv( "midi_out_device", midiOutDevLabel,
|
|
"midi_out_port", midiOutPortLabel,
|
|
"enableFl", enableFl)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kSyntaxErrorRC,"MIDI record play device list configuration parse failed.");
|
|
goto errLabel;
|
|
}
|
|
|
|
|
|
if((rc = ele->getv_opt(
|
|
"vel_table", velTable,
|
|
"pedal", pedalRecd,
|
|
"force_damper_down_fl",p->midiDevA[i].force_damper_down_fl,
|
|
"force_damper_down_threshold",p->midiDevA[i].force_damper_down_threshold,
|
|
"force_damper_down_velocity", p->midiDevA[i].force_damper_down_velocity,
|
|
"damper_dead_band_enable_fl", p->midiDevA[i].damper_dead_band_enable_fl,
|
|
"damper_dead_band_min_value", p->midiDevA[i].damper_dead_band_min_value,
|
|
"damper_dead_band_max_value", p->midiDevA[i].damper_dead_band_max_value,
|
|
"scale_chord_notes_enable_fl",p->midiDevA[i].scale_chord_notes_enable_fl,
|
|
"scale_chord_notes_factor", p->midiDevA[i].scale_chord_notes_factor)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kSyntaxErrorRC,"MIDI record play device optional argument parsing failed.");
|
|
goto errLabel;
|
|
}
|
|
|
|
cwLogInfo("Force Pedal: enabled:%i thresh:%i veloc:%i dead band: enable:%i min:%i max:%i",
|
|
p->midiDevA[i].force_damper_down_fl,
|
|
p->midiDevA[i].force_damper_down_threshold,
|
|
p->midiDevA[i].force_damper_down_velocity,
|
|
p->midiDevA[i].damper_dead_band_enable_fl,
|
|
p->midiDevA[i].damper_dead_band_min_value,
|
|
p->midiDevA[i].damper_dead_band_max_value );
|
|
|
|
p->midiDevA[i].midiOutDevLabel = mem::duplStr( midiOutDevLabel);
|
|
p->midiDevA[i].midiOutPortLabel = mem::duplStr( midiOutPortLabel);
|
|
p->midiDevA[i].enableFl = enableFl;
|
|
|
|
/*
|
|
if( velTable != nullptr )
|
|
{
|
|
p->midiDevA[i].velTableN = velTable->child_count();
|
|
p->midiDevA[i].velTableArray = mem::allocZ<uint8_t>(p->midiDevA[i].velTableN);
|
|
|
|
|
|
for(unsigned j=0; j<p->midiDevA[i].velTableN; ++j)
|
|
{
|
|
if((rc = velTable->child_ele(j)->value( p->midiDevA[i].velTableArray[j] )) != kOkRC )
|
|
{
|
|
rc = cwLogError(kSyntaxErrorRC,"An error occured while parsing the velocity table for MIDI device:'%s' port:'%s'.",midiOutDevLabel,midiOutPortLabel);
|
|
goto errLabel;
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
if( pedalRecd != nullptr )
|
|
{
|
|
if((rc = pedalRecd->getv( "down_id", p->midiDevA[i].pedalDownVelId,
|
|
"down_vel", p->midiDevA[i].pedalDownVel,
|
|
"up_id", p->midiDevA[i].pedalUpVelId,
|
|
"up_vel", p->midiDevA[i].pedalUpVel,
|
|
"half_down_id", p->midiDevA[i].pedalDownHalfVelId,
|
|
"half_down_vel", p->midiDevA[i].pedalDownHalfVel,
|
|
"half_up_id", p->midiDevA[i].pedalUpHalfVelId,
|
|
"half_up_vel", p->midiDevA[i].pedalUpHalfVel
|
|
)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kSyntaxErrorRC,"An error occured while parsing the pedal record for MIDI device:'%s' port:'%s'.",midiOutDevLabel,midiOutPortLabel);
|
|
goto errLabel;
|
|
}
|
|
else
|
|
{
|
|
p->midiDevA[i].pedalMapEnableFl = true;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
// allocate the MIDI msg buffer
|
|
p->msgArray = mem::allocZ<am_midi_msg_t>( p->msgArrayN );
|
|
p->iMsgArray = mem::allocZ<am_midi_msg_t>( p->iMsgArrayN );
|
|
|
|
errLabel:
|
|
return rc;
|
|
}
|
|
|
|
rc_t _stop( midi_record_play_t* p );
|
|
|
|
|
|
const am_midi_msg_t* _midi_store( midi_record_play_t* p, unsigned devIdx, unsigned portIdx, const time::spec_t& ts, uint8_t ch, uint8_t status, uint8_t d0, uint8_t d1 )
|
|
{
|
|
am_midi_msg_t* am = nullptr;
|
|
|
|
//if( !midi::isPedal(status,d0) )
|
|
// printf("MIDI store: %i : ch:%i st:%i d0:%i d1:%i\n",p->iMsgArrayInIdx,ch,status,d0,d1);
|
|
|
|
// verify that space exists in the record buffer
|
|
if( p->iMsgArrayInIdx < p->iMsgArrayN )
|
|
{
|
|
// MAKE THIS ATOMIC
|
|
unsigned id = p->iMsgArrayInIdx;
|
|
++p->iMsgArrayInIdx;
|
|
|
|
am = p->iMsgArray + id;
|
|
|
|
am->id = id;
|
|
am->devIdx = devIdx;
|
|
am->portIdx = portIdx;
|
|
am->timestamp = ts;
|
|
am->ch = ch;
|
|
am->status = status;
|
|
am->d0 = d0;
|
|
am->d1 = d1;
|
|
|
|
}
|
|
|
|
return am;
|
|
}
|
|
|
|
rc_t _event_callback( midi_record_play_t* p, unsigned id, const time::spec_t timestamp, unsigned loc, uint8_t ch, uint8_t status, uint8_t d0, uint8_t d1, unsigned chordNoteCnt, bool log_fl=true )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
// if we have arrived at the stop time (but we may still be waiting for note-end messages)
|
|
bool after_stop_time_fl = !time::isZero(p->end_play_event_timestamp) && time::isGT(timestamp,p->end_play_event_timestamp);
|
|
|
|
if( after_stop_time_fl )
|
|
_midi_state_set_stopping(p);
|
|
|
|
// if we are after the stop time and after the all-notes-off time
|
|
// bool after_all_off_fl = after_stop_time_fl && time::isGT(timestamp,p->all_off_timestamp);
|
|
|
|
// if we are after the stop time and there are no more active notes
|
|
bool after_all_off_fl = after_stop_time_fl && _midi_state_are_all_notes_off(p);
|
|
|
|
bool is_note_on_fl = midi::isNoteOn(status,d1);
|
|
bool is_damper_fl = midi::isSustainPedal(status,d0);
|
|
bool supress_fl = (is_note_on_fl && after_stop_time_fl) || p->muteFl;
|
|
bool is_pedal_fl = midi::isPedal( status, d0 );
|
|
|
|
if( after_all_off_fl )
|
|
{
|
|
rc = _stop(p);
|
|
}
|
|
else
|
|
{
|
|
|
|
if( p->halfPedalFl )
|
|
{
|
|
if( status==midi::kCtlMdId && d0 == midi::kSustainCtlMdId && d1 != 0 )
|
|
d1 = p->halfPedalMidiPedalVel;
|
|
}
|
|
|
|
|
|
// for each midi device
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
if(p->midiDevA[i].enableFl )
|
|
{
|
|
uint8_t out_d1 = d1;
|
|
|
|
if( !p->halfPedalFl )
|
|
{
|
|
// if this is a note-on and a vel. table exists
|
|
if( is_note_on_fl and p->midiDevA[i].velTableArray != nullptr )
|
|
{
|
|
// verify that the vel. is legal given the table
|
|
if( d1 >= p->midiDevA[i].velTableN )
|
|
cwLogError(kInvalidIdRC,"A MIDI note-on velocity (%i) outside the velocity table range was encountered.",d1);
|
|
else
|
|
out_d1 = p->midiDevA[i].velTableArray[ d1 ];
|
|
|
|
// scale the note velocities of chords to account for their combined volumes
|
|
if( p->midiDevA[i].scale_chord_notes_enable_fl && chordNoteCnt>1 )
|
|
{
|
|
uint8_t delta = (uint8_t)lround(out_d1 * p->midiDevA[i].scale_chord_notes_factor * (chordNoteCnt-1) );
|
|
if( delta < out_d1 )
|
|
{
|
|
//printf("%i %i %i %i\n",chordNoteCnt,delta,out_d1,out_d1-delta);
|
|
out_d1 -= delta;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// store the note-on velocity histogram data
|
|
if( p->velHistogramEnableFl && is_note_on_fl && out_d1 < midi::kMidiVelCnt )
|
|
p->midiDevA[i].velHistogram[ out_d1 ] += 1;
|
|
|
|
// if the damper pedal velocity is in the dead band then don't send it
|
|
if( p->midiDevA[i].damper_dead_band_enable_fl && is_pedal_fl && p->midiDevA[i].damper_dead_band_min_value <= out_d1 && out_d1 <= p->midiDevA[i].damper_dead_band_max_value )
|
|
out_d1 = 0;
|
|
|
|
// if the damper pedal velocity is over the 'forcing' threshold then force the damper down
|
|
if( p->midiDevA[i].force_damper_down_fl && is_damper_fl && out_d1>p->midiDevA[i].force_damper_down_threshold )
|
|
out_d1 = p->midiDevA[i].force_damper_down_velocity;
|
|
|
|
// map the pedal velocity
|
|
if( status==midi::kCtlMdId && d0 == midi::kSustainCtlMdId && p->midiDevA[i].pedalMapEnableFl )
|
|
{
|
|
if( d1 == p->midiDevA[i].pedalUpVelId )
|
|
out_d1 = p->midiDevA[i].pedalUpVel;
|
|
else
|
|
if( d1 == p->midiDevA[i].pedalDownVelId )
|
|
out_d1 = p->midiDevA[i].pedalDownVel;
|
|
else
|
|
if( d1 == p->midiDevA[i].pedalDownHalfVelId )
|
|
out_d1 = p->midiDevA[i].pedalDownHalfVel;
|
|
else
|
|
{
|
|
cwLogError(kInvalidIdRC,"Unexpected pedal down velocity (%i) during pedal velocity mapping. Remove the 'pedal' stanza from the MIDI device cfg to prevent pedal mapping.",d1);
|
|
}
|
|
}
|
|
}
|
|
|
|
_midi_state_update(p, p->midiDevA[i], ch, status, d0, out_d1 );
|
|
|
|
if( !supress_fl )
|
|
{
|
|
_xmit_midi( p, i, ch, status, d0, out_d1 );
|
|
|
|
}
|
|
}
|
|
|
|
// don't inform the app if we are past the end time
|
|
if( !after_stop_time_fl and p->cb )
|
|
p->cb( p->cb_arg, kMidiEventActionId, id, timestamp, loc, ch, status, d0, d1 );
|
|
|
|
if( log_fl && p->logOutFl )
|
|
{
|
|
// Note: The device of outgoing messages is set to p->midiDevN + 1 to distinguish it from
|
|
// incoming messages.
|
|
_midi_store( p, p->midiDevN, 0, timestamp, ch, status, d0, d1 );
|
|
}
|
|
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
rc_t _transmit_msg( midi_record_play_t* p, const am_midi_msg_t* am, bool log_fl=true )
|
|
{
|
|
return _event_callback( p, am->id, am->timestamp, am->loc, am->ch, am->status, am->d0, am->d1, am->chordNoteCnt, log_fl );
|
|
}
|
|
|
|
rc_t _transmit_note( midi_record_play_t* p, unsigned ch, unsigned pitch, unsigned vel, unsigned microsecs )
|
|
{
|
|
time::spec_t ts = {0};
|
|
time::microsecondsToSpec( ts, microsecs );
|
|
return _event_callback( p, kInvalidId, ts, kInvalidId, ch, midi::kNoteOnMdId, pitch, vel, 0 );
|
|
}
|
|
|
|
rc_t _transmit_ctl( midi_record_play_t* p, unsigned ch, unsigned ctlId, unsigned ctlVal, unsigned microsecs )
|
|
{
|
|
time::spec_t ts = {0};
|
|
time::microsecondsToSpec( ts, microsecs );
|
|
return _event_callback( p, kInvalidId, ts, kInvalidId, ch, midi::kCtlMdId, ctlId, ctlVal, 0 );
|
|
}
|
|
|
|
rc_t _transmit_pedal( midi_record_play_t* p, unsigned ch, unsigned pedalCtlId, bool pedalDownFl, unsigned microsecs )
|
|
{
|
|
return _transmit_ctl( p, ch, pedalCtlId, pedalDownFl ? 127 : 0, microsecs);
|
|
}
|
|
|
|
void _half_pedal_update( midi_record_play_t* p, unsigned cur_time_us )
|
|
{
|
|
if( cur_time_us >= p->halfPedalNextUs )
|
|
{
|
|
unsigned midi_ch = 0;
|
|
switch( p->halfPedalState )
|
|
{
|
|
|
|
case kWaitForBegin:
|
|
printf("down: %i %i\n",cur_time_us/1000,p->halfPedalMidiPedalVel);
|
|
_transmit_ctl( p, midi_ch, midi::kSustainCtlMdId, p->halfPedalMidiPedalVel, cur_time_us);
|
|
p->halfPedalState = kWaitForNoteOn;
|
|
p->halfPedalNextUs += p->halfPedalNoteDelayUs;
|
|
break;
|
|
|
|
case kWaitForNoteOn:
|
|
printf("note: %i\n",cur_time_us/1000);
|
|
_transmit_note( p, midi_ch, p->halfPedalMidiPitch, p->halfPedalMidiNoteVel, cur_time_us );
|
|
p->halfPedalNextUs += p->halfPedalNoteDurUs;
|
|
p->halfPedalState = kWaitForNoteOff;
|
|
break;
|
|
|
|
case kWaitForNoteOff:
|
|
printf("off: %i\n",cur_time_us/1000);
|
|
_transmit_note( p, midi_ch, p->halfPedalMidiPitch, 0, cur_time_us );
|
|
p->halfPedalNextUs += p->halfPedalUpDelayUs;
|
|
p->halfPedalState = kWaitForPedalUp;
|
|
break;
|
|
|
|
case kWaitForPedalUp:
|
|
printf("up: %i\n",cur_time_us/1000);
|
|
_transmit_ctl( p, midi_ch, midi::kSustainCtlMdId, 0, cur_time_us);
|
|
p->halfPedalNextUs += p->halfPedalDownDelayUs;
|
|
p->halfPedalState = kWaitForPedalDown;
|
|
break;
|
|
|
|
case kWaitForPedalDown:
|
|
//printf("down: %i\n",cur_time_us/1000);
|
|
//_transmit_ctl( p, midi_ch, midi::kSustainCtlMdId, p->halfPedalMidiPedalVel, cur_time_us);
|
|
//_stop(p);
|
|
p->halfPedalState = kHalfPedalDone;
|
|
break;
|
|
|
|
|
|
case kHalfPedalDone:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the next location to store an incoming MIDI message
|
|
void _set_midi_msg_next_index( midi_record_play_t* p, unsigned next_idx )
|
|
{
|
|
p->iMsgArrayInIdx = next_idx;
|
|
}
|
|
|
|
// Set the next index of the next MIDI message to transmit
|
|
void _set_midi_msg_next_play_index(midi_record_play_t* p, unsigned next_idx)
|
|
{
|
|
p->msgArrayOutIdx = next_idx;
|
|
}
|
|
|
|
|
|
cw::rc_t _am_file_read_version_0( const char* fn, file::handle_t fH, am_midi_msg_t* amMsgArray, unsigned msgN )
|
|
{
|
|
// version 0 record type
|
|
typedef struct msg_str
|
|
{
|
|
unsigned dev_idx;
|
|
unsigned port_idx;
|
|
time::spec_t timestamp;
|
|
uint8_t ch;
|
|
uint8_t st;
|
|
uint8_t d0;
|
|
uint8_t d1;
|
|
unsigned microsecs;
|
|
} zero_msg_t;
|
|
|
|
cw::rc_t rc = kOkRC;
|
|
zero_msg_t* zMsgArray = mem::allocZ<zero_msg_t>(msgN);
|
|
unsigned fileByteN = msgN * sizeof(zero_msg_t);
|
|
|
|
if((rc = file::read(fH,zMsgArray,fileByteN)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kReadFailRC,"Data read failed on Audio-MIDI file: '%s'.", fn );
|
|
goto errLabel;
|
|
}
|
|
|
|
for(unsigned i=0; i<msgN; ++i)
|
|
{
|
|
am_midi_msg_t* am = amMsgArray + i;
|
|
zero_msg_t* zm = zMsgArray + i;
|
|
|
|
am->devIdx = zm->dev_idx;
|
|
am->portIdx = zm->port_idx;
|
|
am->microsec = zm->microsecs;
|
|
am->id = i;
|
|
am->timestamp = zm->timestamp;
|
|
am->loc = i;
|
|
am->ch = zm->ch;
|
|
am->status = zm->st;
|
|
am->d0 = zm->d0;
|
|
am->d1 = zm->d1;
|
|
}
|
|
|
|
errLabel:
|
|
mem::release(zMsgArray);
|
|
return rc;
|
|
}
|
|
|
|
// Read the am_midi_msg_t records from a file written by _midi_write()
|
|
// If msgArrayCntRef==0 and msgArrayRef==NULL then an array will be allocated and it is up
|
|
// to the caller to release it, otherwise the msgArrayCntRef should be set to the count
|
|
// of available records in msgArrayRef[]. Note the if there are more records in the file
|
|
// than there are record in msgArrayRef[] then a warning will be issued and only
|
|
// msgArrayCntRef records will be returned.
|
|
cw::rc_t _am_file_read( const char* fn, unsigned& msgArrayCntRef, am_midi_msg_t*& msgArrayRef )
|
|
{
|
|
|
|
rc_t rc = kOkRC;
|
|
unsigned recordN = 0; // count of records in the ifle
|
|
unsigned fileByteN = 0; // count of bytes in the file
|
|
int version = 0; // version id (always a negative number)
|
|
bool alloc_fl = false;
|
|
bool print_fl = false;
|
|
file::handle_t fH;
|
|
|
|
if((rc = file::open(fH,fn,file::kReadFl)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kOpenFailRC,"Unable to locate the AM file: '%s'.", fn );
|
|
goto errLabel;
|
|
}
|
|
|
|
// read the first word - which is either a version id or the count of records in the file
|
|
// if this is a version 0 file
|
|
if((rc = file::read(fH,version)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kReadFailRC,"Version read failed on Audio-MIDI file: '%s'.", fn );
|
|
goto errLabel;
|
|
}
|
|
|
|
// if the version is greater than 0 then this is a version 0 file (and 'version' holds the record count.
|
|
if( version > 0 )
|
|
{
|
|
recordN = (unsigned)version;
|
|
version = 0;
|
|
}
|
|
else // otherwise the second word in the file holds the size of the file
|
|
{
|
|
if((rc = file::read(fH,recordN)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kReadFailRC,"Header read failed on Audio-MIDI file: '%s'.", fn );
|
|
goto errLabel;
|
|
}
|
|
}
|
|
|
|
// if the output msg array was not allocated - then allocate it here
|
|
if( msgArrayCntRef == 0 || msgArrayRef == nullptr )
|
|
{
|
|
alloc_fl = true;
|
|
msgArrayRef = mem::allocZ<am_midi_msg_t>(recordN);
|
|
}
|
|
else // if the msg array was allocated but is too small - then decrease the count of records to be read from the file
|
|
{
|
|
if( recordN > msgArrayCntRef )
|
|
{
|
|
cwLogWarning("The count of message in Audio-MIDI file '%s' reduced from %i to %i.", fn, recordN, msgArrayCntRef );
|
|
recordN = msgArrayCntRef;
|
|
}
|
|
}
|
|
|
|
if( version == 0 )
|
|
{
|
|
// read the version 0 file into a temporary buffer then translate to am_midi_msg_t records
|
|
if((rc = _am_file_read_version_0( fn, fH, msgArrayRef, recordN )) != kOkRC )
|
|
goto errLabel;
|
|
}
|
|
else
|
|
{
|
|
fileByteN = recordN * sizeof(am_midi_msg_t);
|
|
if((rc = file::read(fH,msgArrayRef,fileByteN)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kReadFailRC,"Data read failed on Audio-MIDI file: '%s'.", fn );
|
|
goto errLabel;
|
|
}
|
|
}
|
|
|
|
if( print_fl )
|
|
{
|
|
for(unsigned i=0; i<recordN; ++i)
|
|
{
|
|
am_midi_msg_t* m = msgArrayRef;
|
|
double dt = time::elapsedSecs( m[0].timestamp, m[i].timestamp );
|
|
printf("%4i %4i : %6.2f %2x %2x %2x %2x : %6.2f\n", m[i].devIdx, m[i].portIdx, dt, m[i].ch, m[i].status, m[i].d0, m[i].d1, m[i].microsec/(1000.0*1000.0) );
|
|
}
|
|
}
|
|
|
|
msgArrayCntRef = recordN;
|
|
|
|
errLabel:
|
|
|
|
if( rc != kOkRC and alloc_fl )
|
|
{
|
|
mem::release(msgArrayRef);
|
|
msgArrayRef = nullptr;
|
|
msgArrayCntRef = 0;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
// Fill the play buffer from a previously store AM file.
|
|
rc_t _midi_read( midi_record_play_t* p, const char* fn )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
unsigned n = 0;
|
|
int version;
|
|
file::handle_t fH;
|
|
|
|
if((rc = file::open(fH,fn,file::kReadFl)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kOpenFailRC,"Unable to locate the file: '%s'.", fn );
|
|
goto errLabel;
|
|
}
|
|
|
|
if((rc = file::read(fH,version)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kReadFailRC,"Version read failed on Audio-MIDI file: '%s'.", fn );
|
|
goto errLabel;
|
|
}
|
|
|
|
if((rc = file::read(fH,n)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kReadFailRC,"Header read failed on Audio-MIDI file: '%s'.", fn );
|
|
goto errLabel;
|
|
}
|
|
|
|
if( n > p->msgArrayN )
|
|
{
|
|
cwLogWarning("The count of message in Audio-MIDI file '%s' reduced from %i to %i.", fn, n, p->msgArrayN );
|
|
n = p->msgArrayN;
|
|
}
|
|
|
|
if((rc = file::read(fH,p->msgArray,n*sizeof(am_midi_msg_t))) != kOkRC )
|
|
{
|
|
rc = cwLogError(kReadFailRC,"Data read failed on Audio-MIDI file: '%s'.", fn );
|
|
goto errLabel;
|
|
}
|
|
|
|
p->msgArrayInIdx = n;
|
|
|
|
cwLogInfo("Read %i from '%s'.",n,fn);
|
|
|
|
errLabel:
|
|
|
|
file::close(fH);
|
|
|
|
return rc;
|
|
}
|
|
|
|
// Write the record buffer to an AM file
|
|
rc_t _midi_write( midi_record_play_t* p, const char* fn )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
file::handle_t fH;
|
|
// NOTE: version must be a small negative number to differentiate from file version that
|
|
// whose first word is the count of records in the file, rather than the version number
|
|
int version = -1;
|
|
|
|
if( p->iMsgArrayInIdx == 0 )
|
|
{
|
|
cwLogWarning("Nothing to write.");
|
|
return rc;
|
|
}
|
|
|
|
// open the file
|
|
if((rc = file::open(fH,fn,file::kWriteFl)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kOpenFailRC,"Unable to create the file '%s'.",cwStringNullGuard(fn));
|
|
goto errLabel;
|
|
}
|
|
|
|
// write the file version
|
|
if((rc = write(fH,version)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kWriteFailRC,"Version write to '%s' failed.",cwStringNullGuard(fn));
|
|
goto errLabel;
|
|
}
|
|
|
|
// write the file header
|
|
if((rc = write(fH,p->iMsgArrayInIdx)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kWriteFailRC,"Header write to '%s' failed.",cwStringNullGuard(fn));
|
|
goto errLabel;
|
|
}
|
|
|
|
// write the file data
|
|
if((rc = write(fH,p->iMsgArray,sizeof(am_midi_msg_t)*p->iMsgArrayInIdx)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kWriteFailRC,"Data write to '%s' failed.",cwStringNullGuard(fn));
|
|
goto errLabel;
|
|
}
|
|
|
|
errLabel:
|
|
file::close(fH);
|
|
|
|
cwLogInfo("Saved %i events to '%s'.", p->iMsgArrayInIdx, fn );
|
|
|
|
return rc;
|
|
}
|
|
|
|
rc_t _write_csv( midi_record_play_t* p, const char* fn )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
file::handle_t fH;
|
|
|
|
if( p->iMsgArrayInIdx == 0 )
|
|
{
|
|
cwLogWarning("Nothing to write.");
|
|
return rc;
|
|
}
|
|
|
|
// open the file
|
|
if((rc = file::open(fH,fn,file::kWriteFl)) != kOkRC )
|
|
{
|
|
rc = cwLogError(kOpenFailRC,"Unable to create the file '%s'.",cwStringNullGuard(fn));
|
|
goto errLabel;
|
|
}
|
|
|
|
file::printf(fH,"dev,port,microsec,id,sec,ch,status,sci_pitch,d0,d1\n");
|
|
|
|
for(unsigned i=0; i<p->iMsgArrayInIdx; ++i)
|
|
{
|
|
const am_midi_msg_t* m = p->iMsgArray + i;
|
|
|
|
double secs = time::elapsedSecs( p->iMsgArray[0].timestamp, p->iMsgArray[i].timestamp );
|
|
|
|
char sciPitch[ midi::kMidiSciPitchCharCnt + 1 ];
|
|
if( m->status == midi::kNoteOnMdId )
|
|
midi::midiToSciPitch( m->d0, sciPitch, midi::kMidiSciPitchCharCnt );
|
|
else
|
|
strcpy(sciPitch,"");
|
|
|
|
if((rc = file::printf(fH, "%3i,%3i,%8i,%3i,%8.4f,%2i,0x%2x,%5s,%3i,%3i\n",
|
|
m->devIdx, m->portIdx, m->microsec, m->id, secs,
|
|
m->ch, m->status, sciPitch, m->d0, m->d1 )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"Write failed on line:%i", i+1 );
|
|
goto errLabel;
|
|
}
|
|
}
|
|
|
|
errLabel:
|
|
file::close(fH);
|
|
|
|
cwLogInfo("Saved %i events to '%s'.", p->iMsgArrayInIdx, fn );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
rc_t _midi_file_write( const char* fn, const am_midi_msg_t* msgArray, unsigned msgArrayCnt )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
const unsigned midiFileTrackCnt = 1;
|
|
const unsigned midiFileTicksPerQN = 192;
|
|
const unsigned midiFileTempoBpm = 120;
|
|
const unsigned midiFileTrkIdx = 0;
|
|
file::handle_t fH;
|
|
midi::file::handle_t mfH;
|
|
time::spec_t t0;
|
|
|
|
|
|
if( msgArrayCnt == 0 )
|
|
{
|
|
cwLogWarning("Nothing to write.");
|
|
return rc;
|
|
}
|
|
|
|
if((rc = midi::file::create( mfH, midiFileTrackCnt, midiFileTicksPerQN )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"MIDI file create failed. File:'%s'", cwStringNullGuard(fn));
|
|
goto errLabel;
|
|
}
|
|
|
|
if((rc = midi::file::insertTrackTempoMsg( mfH, midiFileTrkIdx, 0, midiFileTempoBpm )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"MIDI file tempo message insert failed. File:'%s'", cwStringNullGuard(fn));
|
|
goto errLabel;
|
|
}
|
|
|
|
t0 = msgArray[0].timestamp;
|
|
|
|
for(unsigned i=0; i<msgArrayCnt; ++i)
|
|
{
|
|
|
|
double secs = time::elapsedMicros( t0, msgArray[i].timestamp ) / 1000000.0;
|
|
unsigned atick = secs * midiFileTicksPerQN * midiFileTempoBpm / 60.0;
|
|
|
|
if((rc = insertTrackChMsg( mfH, midiFileTrkIdx, atick, msgArray[i].ch + msgArray[i].status, msgArray[i].d0, msgArray[i].d1 )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"MIDI file message insert failed. File: '%s'.",cwStringNullGuard(fn));
|
|
goto errLabel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if((rc = midi::file::write( mfH, fn )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"MIDI file write failed on '%s'.",cwStringNullGuard(fn));
|
|
goto errLabel;
|
|
}
|
|
|
|
if((rc = midi::file::close( mfH )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"MIDI file close failed on '%s'.",cwStringNullGuard(fn));
|
|
goto errLabel;
|
|
}
|
|
|
|
errLabel:
|
|
return rc;
|
|
}
|
|
|
|
|
|
void _print_midi_msg( const am_midi_msg_t* mm )
|
|
{
|
|
printf("%i %i : %10i : %2i 0x%02x 0x%02x 0x%02x %i\n", mm->devIdx, mm->portIdx, mm->microsec, mm->ch, mm->status, mm->d0, mm->d1, mm->chordNoteCnt );
|
|
}
|
|
|
|
void _report_midi( midi_record_play_t* p )
|
|
{
|
|
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
{
|
|
printf("vel table: %s:%s\n", cwStringNullGuard(p->midiDevA[i].midiOutDevLabel),cwStringNullGuard(p->midiDevA[i].midiOutPortLabel));
|
|
for(unsigned j=0; j<p->midiDevA[i].velTableN; ++j)
|
|
printf("%i ",(unsigned)p->midiDevA[i].velTableArray[j]);
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
printf("omsg cnt:%i\n",p->msgArrayInIdx);
|
|
for(unsigned i=0; i<p->msgArrayInIdx; ++i)
|
|
{
|
|
am_midi_msg_t* mm = p->msgArray + i;
|
|
_print_midi_msg(mm);
|
|
}
|
|
|
|
|
|
printf("imsg cnt:%i\n",p->iMsgArrayInIdx);
|
|
for(unsigned i=0; i<p->iMsgArrayInIdx; ++i)
|
|
{
|
|
am_midi_msg_t* mm = p->iMsgArray + i;
|
|
_print_midi_msg(mm);
|
|
}
|
|
|
|
}
|
|
|
|
rc_t _write_vel_histogram( midi_record_play_t* p )
|
|
{
|
|
const char* fname = "/home/kevin/temp/vel_histogram.txt";
|
|
rc_t rc = kOkRC;
|
|
|
|
if( !p->velHistogramEnableFl )
|
|
return rc;
|
|
|
|
file::handle_t h;
|
|
if((rc = file::open(h,fname,file::kWriteFl)) != kOkRC )
|
|
return rc;
|
|
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
if(p->midiDevA[i].enableFl )
|
|
{
|
|
for(unsigned j=0; j<midi::kMidiVelCnt; ++j)
|
|
if((rc = file::printf(h,"%i,",p->midiDevA[i].velHistogram[j])) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"Histogram output file (%s) write failed.",fname);
|
|
goto errLabel;
|
|
}
|
|
|
|
file::printf(h,"\n");
|
|
}
|
|
|
|
errLabel:
|
|
file::close(h);
|
|
return rc;
|
|
}
|
|
|
|
// Fill the play buffer (msgArray) from the record buffer (iMsgArray)
|
|
void _iMsgArray_to_msgArray(midi_record_play_t* p)
|
|
{
|
|
if( p->msgArrayN < p->iMsgArrayN)
|
|
{
|
|
mem::resize(p->msgArray,p->iMsgArrayN,mem::kZeroAllFl);
|
|
p->msgArrayN = p->iMsgArrayN;
|
|
}
|
|
p->msgArrayOutIdx = 0;
|
|
p->msgArrayInIdx = p->iMsgArrayInIdx;
|
|
memcpy(p->msgArray,p->iMsgArray,p->iMsgArrayInIdx*sizeof(am_midi_msg_t));
|
|
}
|
|
|
|
|
|
rc_t _stop( midi_record_play_t* p )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
|
|
if( p->startedFl )
|
|
{
|
|
p->startedFl = false;
|
|
|
|
time::spec_t t1;
|
|
time::get(t1);
|
|
|
|
_write_vel_histogram( p );
|
|
|
|
// if we were recording
|
|
if( p->recordFl )
|
|
{
|
|
|
|
// set the 'microsec' value for each MIDI msg as an offset from the first message[]
|
|
for(unsigned i=0; i<p->iMsgArrayInIdx; ++i)
|
|
{
|
|
p->iMsgArray[i].microsec = time::elapsedMicros(p->iMsgArray[0].timestamp,p->iMsgArray[i].timestamp);
|
|
}
|
|
|
|
// copy the recorded messages from the input buffer to the output buffer
|
|
_iMsgArray_to_msgArray(p);
|
|
|
|
cwLogInfo("MIDI messages recorded: %i",p->msgArrayInIdx );
|
|
|
|
}
|
|
else
|
|
{
|
|
io::timerStop( p->ioH, io::timerIdToIndex(p->ioH, kMidiRecordPlayTimerId) );
|
|
|
|
// TODO:
|
|
// BUG BUG BUG: should work for all channels
|
|
|
|
// all notes off
|
|
_transmit_ctl( p, 0, 121, 0, 0 ); // reset all controllers
|
|
_transmit_ctl( p, 0, 123, 0, 0 ); // all notes off
|
|
_transmit_ctl( p, 0, 0, 0, 0 ); // switch to bank 0
|
|
|
|
}
|
|
|
|
_midi_state_clear(p);
|
|
|
|
if( p->cb != nullptr )
|
|
p->cb( p->cb_arg, kPlayerStoppedActionId, kInvalidId, t1, kInvalidId, 0, 0, 0, 0 );
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
rc_t _midi_receive( midi_record_play_t* p, const io::midi_msg_t& m )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
const midi::packet_t* pkt = m.pkt;
|
|
|
|
// for each midi msg
|
|
for(unsigned j=0; j<pkt->msgCnt; ++j)
|
|
{
|
|
// if this is a sys-ex msg
|
|
if( pkt->msgArray == NULL )
|
|
{
|
|
cwLogError(kNotImplementedRC,"Sys-ex recording not implemented.");
|
|
}
|
|
else // this is a triple
|
|
{
|
|
|
|
//if( !midi::isPedal(pkt->msgArray[j].status,pkt->msgArray[j].d0) )
|
|
// printf("IN: st:%i rec:%i : 0x%x 0x%x 0x%x\n", p->startedFl, p->recordFl, pkt->msgArray[j].status, pkt->msgArray[j].d0, pkt->msgArray[j].d1 );
|
|
|
|
if( (p->recordFl || p->logInFl) && p->startedFl )
|
|
{
|
|
|
|
// verify that space exists in the record buffer
|
|
if( p->iMsgArrayInIdx >= p->iMsgArrayN )
|
|
{
|
|
_stop(p);
|
|
rc = cwLogError(kBufTooSmallRC,"MIDI message record buffer is full. % messages.",p->iMsgArrayN);
|
|
goto errLabel;
|
|
}
|
|
else
|
|
{
|
|
// copy the msg into the record buffer
|
|
midi::msg_t* mm = pkt->msgArray + j;
|
|
|
|
if( midi::isChStatus(mm->status) )
|
|
{
|
|
const am_midi_msg_t* am = _midi_store( p, pkt->devIdx, pkt->portIdx, mm->timeStamp, mm->status & 0x0f, mm->status & 0xf0, mm->d0, mm->d1 );
|
|
|
|
if( p->thruFl && am != nullptr )
|
|
_transmit_msg( p, am, false );
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
errLabel:
|
|
return rc;
|
|
}
|
|
|
|
|
|
rc_t _timer_callback(midi_record_play_t* p, io::timer_msg_t& m)
|
|
{
|
|
rc_t rc = kOkRC;
|
|
|
|
// if the MIDI player is started and in 'play' mode and msg remain to be played
|
|
if( p->startedFl && (p->recordFl==false) && (p->msgArrayOutIdx < p->msgArrayInIdx))
|
|
{
|
|
time::spec_t t;
|
|
time::get(t);
|
|
|
|
unsigned cur_time_us = time::elapsedMicros(p->play_time,t);
|
|
|
|
if( p->halfPedalFl )
|
|
_half_pedal_update( p, cur_time_us );
|
|
else
|
|
while( p->msgArray[ p->msgArrayOutIdx ].microsec <= cur_time_us )
|
|
{
|
|
|
|
|
|
am_midi_msg_t* mm = p->msgArray + p->msgArrayOutIdx;
|
|
|
|
//_print_midi_msg(mm);
|
|
|
|
_transmit_msg( p, mm );
|
|
|
|
_set_midi_msg_next_play_index(p, p->msgArrayOutIdx+1 );
|
|
|
|
// if all MIDI messages have been played
|
|
if( p->msgArrayOutIdx >= p->msgArrayInIdx )
|
|
{
|
|
_stop(p);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
rc_t _loadVelTable( midi_record_play_t* p, const object_t* cfg, midi_device_t* dev, unsigned devIdx )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
const char* refDevLabel = nullptr;
|
|
const object_t* tables = nullptr;
|
|
unsigned i = 0;
|
|
|
|
// get the textual name the device
|
|
switch( devIdx )
|
|
{
|
|
case kSampler_MRP_DevIdx: refDevLabel="sampler"; break;
|
|
case kPiano_MRP_DevIdx: refDevLabel="piano"; break;
|
|
}
|
|
|
|
// verify that the device has a label
|
|
if( refDevLabel == nullptr )
|
|
{
|
|
rc = cwLogError(kInvalidStateRC,"The MIDI record-play unit device '%i' does not have a device label.",devIdx);
|
|
goto errLabel;
|
|
}
|
|
|
|
// get the 'tables' node
|
|
if((rc = cfg->getv("tables",tables)) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"The 'tables' field could not be read from the vel. table cfg. object.");
|
|
goto errLabel;
|
|
}
|
|
|
|
// for each table
|
|
for(i=0; i<tables->child_count(); ++i)
|
|
{
|
|
const object_t* tbl = tables->child_ele(i);
|
|
const object_t* array = nullptr;
|
|
bool enableFl = false;
|
|
bool defaultFl = false;
|
|
const char* deviceLabel = nullptr;
|
|
|
|
// read the table record
|
|
if((rc = tbl->getv("table",array,
|
|
"enableFl",enableFl,
|
|
"defaultFl",defaultFl,
|
|
"device",deviceLabel)) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"Parsing failed on the velocity table at index '%i'.",i);
|
|
goto errLabel;
|
|
}
|
|
|
|
// if this table is enabled and the 'default' for this device
|
|
if( enableFl && defaultFl && textCompare(refDevLabel,deviceLabel) == 0 )
|
|
{
|
|
// allocate the actual velocity table
|
|
dev->velTableN = array->child_count();
|
|
dev->velTableArray = mem::allocZ<uint8_t>(dev->velTableN);
|
|
|
|
// for each velocity entry
|
|
for(unsigned j=0; j<dev->velTableN; ++j)
|
|
{
|
|
// read the velocity value
|
|
unsigned v;
|
|
if((rc = array->child_ele(j)->value(v)) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"Parsing failed on the velocity at index '%i'.",j);
|
|
goto errLabel;
|
|
}
|
|
|
|
// validate the velocity range
|
|
if( 0 <= v && v <= 127 )
|
|
dev->velTableArray[j] = (uint8_t)v;
|
|
else
|
|
{
|
|
rc = cwLogError(kInvalidArgRC,"A velocity table entry outside the range 0-127 was encountered at index %i.",j);
|
|
goto errLabel;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if no enabled and default table was found for this device
|
|
if( i >= tables->child_count() )
|
|
{
|
|
cwLogError(kInvalidStateRC,"A velocity table was not found for MIDI device index '%i'.",devIdx );
|
|
goto errLabel;
|
|
}
|
|
|
|
errLabel:
|
|
|
|
return rc;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::create( handle_t& hRef,
|
|
io::handle_t ioH,
|
|
const object_t& cfg,
|
|
const char* velTableFname,
|
|
event_callback_t cb,
|
|
void* cb_arg )
|
|
{
|
|
bool asyncFl = true;
|
|
midi_record_play_t* p = nullptr;
|
|
rc_t rc;
|
|
object_t* velTblCfg = nullptr;
|
|
|
|
if((rc = destroy(hRef)) != kOkRC )
|
|
return rc;
|
|
|
|
p = mem::allocZ<midi_record_play_t>();
|
|
|
|
p->ioH = ioH; // p->ioH is used in _destory() so initialize it here
|
|
|
|
// parse the cfg
|
|
if((rc = _parseCfg(p,cfg)) != kOkRC )
|
|
goto errLabel;
|
|
|
|
// parse the vel table cfg
|
|
if(velTableFname != nullptr )
|
|
if((rc = objectFromFile(velTableFname,velTblCfg)) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"Parsing the velocity table cfg. failed on '%s'.",cwStringNullGuard(velTableFname));
|
|
goto errLabel;
|
|
}
|
|
|
|
p->cb = cb;
|
|
p->cb_arg = cb_arg;
|
|
p->halfPedalState = kHalfPedalDone;
|
|
p->halfPedalNextUs = 0;
|
|
p->halfPedalNoteDelayUs = 100 * 1000;
|
|
p->halfPedalNoteDurUs = 1000 * 1000;
|
|
p->halfPedalUpDelayUs = 1000 * 1000;
|
|
p->halfPedalDownDelayUs = 1000 * 1000;
|
|
p->halfPedalMidiPitch = 64;
|
|
p->halfPedalMidiNoteVel = 64;
|
|
p->halfPedalMidiPedalVel = 127;
|
|
p->velHistogramEnableFl = true;
|
|
|
|
for( unsigned i=0; i<p->midiDevN; ++i)
|
|
{
|
|
midi_device_t* dev = p->midiDevA + i;
|
|
|
|
if( !p->midiDevA[i].enableFl )
|
|
continue;
|
|
|
|
if((dev->midiOutDevIdx = io::midiDeviceIndex(p->ioH,dev->midiOutDevLabel)) == kInvalidIdx )
|
|
{
|
|
rc = cwLogError(kInvalidArgRC,"The MIDI output device: '%s' was not found.", cwStringNullGuard(dev->midiOutDevLabel) );
|
|
goto errLabel;
|
|
}
|
|
|
|
if((dev->midiOutPortIdx = io::midiDevicePortIndex(p->ioH,dev->midiOutDevIdx,false,dev->midiOutPortLabel)) == kInvalidIdx )
|
|
{
|
|
rc = cwLogError(kInvalidArgRC,"The MIDI output port: '%s' was not found.", cwStringNullGuard(dev->midiOutPortLabel) );
|
|
goto errLabel;
|
|
}
|
|
|
|
if( velTblCfg != nullptr )
|
|
if((rc = _loadVelTable( p, velTblCfg, dev, i )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"MIDI record-play velocity table setup failed.");
|
|
goto errLabel;
|
|
}
|
|
|
|
printf("%s %s : %i %i\n",dev->midiOutDevLabel, dev->midiOutPortLabel, dev->midiOutDevIdx, dev->midiOutPortIdx );
|
|
}
|
|
|
|
// create the MIDI playback timer
|
|
if((rc = timerCreate( p->ioH, TIMER_LABEL, kMidiRecordPlayTimerId, p->midi_timer_period_micro_sec, asyncFl)) != kOkRC )
|
|
{
|
|
cwLogError(rc,"Audio-MIDI timer create failed.");
|
|
goto errLabel;
|
|
}
|
|
|
|
_midi_state_clear(p);
|
|
|
|
errLabel:
|
|
if( rc == kOkRC )
|
|
hRef.set(p);
|
|
else
|
|
_destroy(p);
|
|
|
|
if(velTblCfg != nullptr )
|
|
velTblCfg->free();
|
|
|
|
return rc;
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::destroy( handle_t& hRef )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
|
|
if( !hRef.isValid() )
|
|
return kOkRC;
|
|
|
|
midi_record_play_t* p = _handleToPtr(hRef);
|
|
|
|
if((rc = _destroy(p)) != kOkRC )
|
|
return rc;
|
|
|
|
hRef.clear();
|
|
|
|
return rc;
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::start( handle_t h, bool rewindFl, const time::spec_t* end_play_event_timestamp )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
p->startedFl = true;
|
|
|
|
if( p->velHistogramEnableFl )
|
|
for(unsigned i=0; i<p->midiDevN; ++i)
|
|
if(p->midiDevA[i].enableFl )
|
|
memset(p->midiDevA[i].velHistogram,0,sizeof(p->midiDevA[i].velHistogram));
|
|
|
|
|
|
// set the end play time
|
|
if( end_play_event_timestamp == nullptr or time::isZero(*end_play_event_timestamp) )
|
|
time::setZero(p->end_play_event_timestamp);
|
|
else
|
|
{
|
|
p->end_play_event_timestamp = *end_play_event_timestamp;
|
|
//p->all_off_timestamp = *end_play_event_timestamp;
|
|
//time::advanceMs( p->all_off_timestamp, p->all_off_delay_ms); }
|
|
}
|
|
|
|
time::get(p->start_time);
|
|
|
|
if( p->recordFl || p->logInFl or p->logOutFl )
|
|
{
|
|
_set_midi_msg_next_index(p, 0 );
|
|
}
|
|
|
|
if( !p->recordFl )
|
|
{
|
|
time::get(p->play_time);
|
|
|
|
if( rewindFl )
|
|
_set_midi_msg_next_play_index(p,0);
|
|
else
|
|
{
|
|
// Set the begin play time back by the time offset of the current output event.
|
|
// This will cause that event to be played back immediately.
|
|
time::subtractMicros(p->play_time, p->msgArray[ p->msgArrayOutIdx ].microsec );
|
|
}
|
|
|
|
if( p->halfPedalFl )
|
|
{
|
|
p->halfPedalNextUs = 0;
|
|
p->halfPedalState = kWaitForBegin;
|
|
}
|
|
|
|
io::timerStart( p->ioH, io::timerIdToIndex(p->ioH, kMidiRecordPlayTimerId) );
|
|
}
|
|
|
|
|
|
return kOkRC;
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::stop( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return _stop(p);
|
|
}
|
|
|
|
bool cw::midi_record_play::is_started( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return p->startedFl;
|
|
}
|
|
|
|
|
|
cw::rc_t cw::midi_record_play::clear( handle_t h )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
_set_midi_msg_next_index(p,0);
|
|
return rc;
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::set_record_state( handle_t h, bool record_fl )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
p->recordFl = record_fl;
|
|
return rc;
|
|
}
|
|
|
|
bool cw::midi_record_play::record_state( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return p->recordFl;
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::set_mute_state( handle_t h, bool mute_fl )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
p->muteFl = mute_fl;
|
|
return rc;
|
|
}
|
|
|
|
bool cw::midi_record_play::mute_state( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return p->muteFl;
|
|
}
|
|
|
|
|
|
cw::rc_t cw::midi_record_play::set_thru_state( handle_t h, bool thru_fl )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
p->thruFl = thru_fl;
|
|
return rc;
|
|
}
|
|
|
|
bool cw::midi_record_play::thru_state( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return p->thruFl;
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::save( handle_t h, const char* fn )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return _midi_write(p,fn);
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::save_csv( handle_t h, const char* fn )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return _write_csv(p,fn);
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::write_svg( handle_t h, const char* fn )
|
|
{
|
|
rc_t rc;
|
|
svg_midi::handle_t svgH;
|
|
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
|
|
if((rc = svg_midi::create( svgH )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"svg_midi object create failed.");
|
|
goto errLabel;
|
|
}
|
|
|
|
for(unsigned i=0; i<p->iMsgArrayInIdx; ++i)
|
|
{
|
|
const am_midi_msg_t* m = p->iMsgArray + i;
|
|
|
|
double sec = time::specToSeconds( m->timestamp );
|
|
|
|
if((rc = svg_midi::setMidiMsg(svgH,sec,m->id,m->ch,m->status,m->d0,m->d1)) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"svg_midi set midi msg failed.");
|
|
goto errLabel;
|
|
}
|
|
}
|
|
|
|
errLabel:
|
|
svg_midi::destroy(svgH);
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
cw::rc_t cw::midi_record_play::open( handle_t h, const char* fn )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return _midi_read(p,fn);
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::load( handle_t h, const midi_msg_t* msg, unsigned msg_count )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
|
|
unsigned extraMs = 0;
|
|
unsigned curMicros = 0;
|
|
|
|
|
|
if( msg_count > p->msgArrayN )
|
|
{
|
|
mem::release(p->msgArray);
|
|
p->msgArray = mem::allocZ<am_midi_msg_t>( msg_count );
|
|
p->msgArrayN = msg_count;
|
|
}
|
|
|
|
for(unsigned i=0; i<msg_count; ++i)
|
|
{
|
|
|
|
if( i> 0)
|
|
{
|
|
unsigned deltaMicros = time::elapsedMicros(msg[i-1].timestamp,msg[i].timestamp);
|
|
curMicros += deltaMicros + (extraMs*1000);
|
|
}
|
|
|
|
p->msgArray[i].id = msg[i].id;
|
|
p->msgArray[i].timestamp = msg[i].timestamp;
|
|
p->msgArray[i].loc = msg[i].loc;
|
|
p->msgArray[i].ch = msg[i].ch;
|
|
p->msgArray[i].status = msg[i].status;
|
|
p->msgArray[i].d0 = msg[i].d0;
|
|
p->msgArray[i].d1 = msg[i].d1;
|
|
p->msgArray[i].devIdx = kInvalidIdx;
|
|
p->msgArray[i].portIdx = kInvalidIdx;
|
|
//p->msgArray[i].microsec = time::elapsedMicros(p->msgArray[0].timestamp,p->msgArray[i].timestamp);
|
|
p->msgArray[i].microsec = curMicros;
|
|
|
|
//hprintf("%i %i\n",curMicros,time::elapsedMicros(p->msgArray[0].timestamp,p->msgArray[i].timestamp) );
|
|
|
|
extraMs = 0;
|
|
if( midi::isSustainPedalUp(msg[i].status,msg[i].d0,msg[i].d1))
|
|
extraMs = p->minDamperDownMs;
|
|
|
|
}
|
|
|
|
p->msgArrayInIdx = msg_count;
|
|
p->msgArrayOutIdx = 0;
|
|
|
|
_set_chord_note_count(p);
|
|
|
|
return rc;
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::seek( handle_t h, time::spec_t seek_timestamp )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
|
|
// clear the MIDI state
|
|
_midi_state_clear(p);
|
|
|
|
// supress MIDI transmission during the seek
|
|
p->supressMidiXmitFl = true;
|
|
|
|
// iterate throught the MIDI msg array
|
|
for(unsigned i=0; i<p->msgArrayInIdx; ++i)
|
|
{
|
|
am_midi_msg_t* mm = p->msgArray + i;
|
|
|
|
// if this msg is prior to or equal to the seek target
|
|
if( time::isLTE(seek_timestamp,mm->timestamp) )
|
|
{
|
|
p->msgArrayOutIdx = i;
|
|
break;
|
|
}
|
|
|
|
// transmit the msg so that the dev._midi_state is updated,
|
|
// but 'supressMidiXmitFl' is set so no MIDI will actually
|
|
// be transmitted
|
|
_transmit_msg( p, mm, false );
|
|
}
|
|
|
|
p->supressMidiXmitFl = false;
|
|
|
|
_midi_state_xmit_pedals(p);
|
|
|
|
|
|
return rc;
|
|
}
|
|
|
|
unsigned cw::midi_record_play::elapsed_micros( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
time::spec_t t;
|
|
time::get(t);
|
|
|
|
return time::elapsedMicros( p->start_time, t );
|
|
}
|
|
|
|
unsigned cw::midi_record_play::event_count( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return p->msgArrayInIdx;
|
|
}
|
|
|
|
unsigned cw::midi_record_play::event_index( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return p->recordFl ? p->iMsgArrayInIdx : p->msgArrayOutIdx;
|
|
}
|
|
|
|
unsigned cw::midi_record_play::event_loc( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
|
|
if( !p->recordFl && 0 <= p->msgArrayOutIdx && p->msgArrayOutIdx < p->msgArrayN )
|
|
return p->msgArray[ p->msgArrayOutIdx ].loc;
|
|
|
|
return kInvalidId;
|
|
}
|
|
|
|
|
|
cw::rc_t cw::midi_record_play::exec( handle_t h, const io::msg_t& m )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
|
|
switch( m.tid )
|
|
{
|
|
case io::kTimerTId:
|
|
if( m.u.timer != nullptr )
|
|
rc = _timer_callback(p,*m.u.timer);
|
|
break;
|
|
|
|
case io::kMidiTId:
|
|
if( m.u.midi != nullptr )
|
|
_midi_receive(p,*m.u.midi);
|
|
break;
|
|
|
|
default:
|
|
rc = kOkRC;
|
|
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
unsigned cw::midi_record_play::device_count( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return p->midiDevN;
|
|
}
|
|
|
|
bool cw::midi_record_play::is_device_enabled( handle_t h, unsigned devIdx )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
bool fl = false;
|
|
|
|
if( devIdx >= p->midiDevN )
|
|
cwLogError(kInvalidArgRC,"The MIDI record-play device index '%i' is invalid.",devIdx );
|
|
else
|
|
fl = p->midiDevA[devIdx].enableFl;
|
|
|
|
return fl;
|
|
}
|
|
|
|
void cw::midi_record_play::enable_device( handle_t h, unsigned devIdx, bool enableFl )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
|
|
if( devIdx >= p->midiDevN )
|
|
cwLogError(kInvalidArgRC,"The MIDI record-play device index '%i' is invalid.",devIdx );
|
|
else
|
|
{
|
|
p->midiDevA[devIdx].enableFl = enableFl;
|
|
//printf("Enable: %i = %i\n",devIdx,enableFl);
|
|
}
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::send_midi_msg( handle_t h, unsigned devIdx, uint8_t ch, uint8_t status, uint8_t d0, uint8_t d1 )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
|
|
if( devIdx >= p->midiDevN )
|
|
return cwLogError(kInvalidArgRC,"The MIDI record-play device index '%i' is invalid.",devIdx );
|
|
|
|
if( p->midiDevA[devIdx].enableFl )
|
|
io::midiDeviceSend( p->ioH, p->midiDevA[devIdx].midiOutDevIdx, p->midiDevA[devIdx].midiOutPortIdx, status + ch, d0, d1 );
|
|
|
|
return kOkRC;
|
|
}
|
|
|
|
|
|
void cw::midi_record_play::half_pedal_params( handle_t h, unsigned noteDelayMs, unsigned pitch, unsigned vel, unsigned pedal_vel, unsigned noteDurMs, unsigned downDelayMs )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
p->halfPedalNoteDelayUs = noteDelayMs * 1000;
|
|
p->halfPedalNoteDurUs = noteDurMs * 1000;
|
|
p->halfPedalDownDelayUs = downDelayMs * 1000;
|
|
p->halfPedalMidiPitch = pitch;
|
|
p->halfPedalMidiNoteVel = vel;
|
|
p->halfPedalMidiPedalVel= pedal_vel;
|
|
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::am_to_midi_file( const char* am_filename, const char* midi_filename )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
unsigned msgArrayCnt = 0;
|
|
am_midi_msg_t* msgArray = nullptr;
|
|
|
|
if(!filesys::isFile(am_filename))
|
|
{
|
|
cwLogError(kOpenFailRC,"The AM file '%s' does not exist.",am_filename);
|
|
goto errLabel;
|
|
}
|
|
|
|
if((rc = _am_file_read( am_filename, msgArrayCnt, msgArray )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"Unable to read AM file '%s'.", cwStringNullGuard(am_filename));
|
|
goto errLabel;
|
|
}
|
|
|
|
if((rc = _midi_file_write( midi_filename, msgArray, msgArrayCnt )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"Unable to write AM file '%s' to '%s'.", cwStringNullGuard(am_filename),cwStringNullGuard(midi_filename));
|
|
goto errLabel;
|
|
}
|
|
|
|
errLabel:
|
|
mem::release(msgArray);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::am_to_midi_dir( const char* inDir )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
filesys::dirEntry_t* dirEntryArray = nullptr;
|
|
unsigned dirEntryCnt = 0;
|
|
|
|
if(( dirEntryArray = filesys::dirEntries( inDir, filesys::kDirFsFl | filesys::kFullPathFsFl, &dirEntryCnt )) == nullptr )
|
|
goto errLabel;
|
|
|
|
for(unsigned i=0; i<dirEntryCnt and rc==kOkRC; ++i)
|
|
{
|
|
char* am_fn = filesys::makeFn( dirEntryArray[i].name, "midi", "am", NULL);
|
|
char* midi_fn = filesys::makeFn( dirEntryArray[i].name, "midi", "mid", NULL);
|
|
|
|
cwLogInfo("0x%x AM:%s MIDI:%s", dirEntryArray[i].flags, dirEntryArray[i].name, midi_fn);
|
|
|
|
rc = am_to_midi_file( am_fn, midi_fn );
|
|
|
|
mem::release(am_fn);
|
|
mem::release(midi_fn);
|
|
|
|
}
|
|
|
|
errLabel:
|
|
mem::release(dirEntryArray);
|
|
|
|
return rc;
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::am_to_midi_file( const object_t* cfg )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
const char* inDir = nullptr;
|
|
//
|
|
if( cfg == nullptr )
|
|
{
|
|
rc = cwLogError(kInvalidArgRC,"AM to MIDI file: No input directory.");
|
|
goto errLabel;
|
|
}
|
|
|
|
//
|
|
if((rc = cfg->getv("inDir",inDir)) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"AM to MIDI file: Unable to parse input arg's.");
|
|
goto errLabel;
|
|
}
|
|
|
|
//
|
|
if((rc = am_to_midi_dir(inDir)) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"AM to MIDI file conversion on directory:'%s' failed.", cwStringNullGuard(inDir));
|
|
goto errLabel;
|
|
}
|
|
|
|
errLabel:
|
|
return rc;
|
|
|
|
}
|
|
|
|
void cw::midi_record_play::report( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
_report_midi(p);
|
|
}
|
|
|
|
|
|
unsigned cw::midi_record_play::dev_count( handle_t h )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return p->midiDevN;
|
|
}
|
|
|
|
unsigned cw::midi_record_play::vel_table_count( handle_t h, unsigned devIdx )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return p->midiDevA[ devIdx ].velTableN;
|
|
}
|
|
|
|
const uint8_t* cw::midi_record_play::vel_table( handle_t h, unsigned devIdx )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
return p->midiDevA[ devIdx ].velTableArray;
|
|
}
|
|
|
|
cw::rc_t cw::midi_record_play::vel_table_set( handle_t h, unsigned devIdx, const uint8_t* tbl, unsigned tblN )
|
|
{
|
|
midi_record_play_t* p = _handleToPtr(h);
|
|
|
|
midi_device_t* dev = p->midiDevA + devIdx;
|
|
|
|
if( tblN != dev->velTableN )
|
|
{
|
|
dev->velTableArray = mem::resize<uint8_t>(dev->velTableArray,tblN);
|
|
dev->velTableN = tblN;
|
|
}
|
|
|
|
for(unsigned i=0; i<tblN; ++i)
|
|
dev->velTableArray[i] = tbl[i];
|
|
|
|
return kOkRC;
|
|
}
|