/**
* The handleAction method is the heard of the MidiActionManager class.
* It executes the operations that are needed to carry the desired action.
*/
bool MidiActionManager::handleAction( MidiAction * pAction ){
Hydrogen *pEngine = Hydrogen::get_instance();
/*
return false if action is null
(for example if no Action exists for an event)
*/
if( pAction == NULL ) return false;
QString sActionString = pAction->getType();
if( sActionString == "PLAY" )
{
int nState = pEngine->getState();
if ( nState == STATE_READY ){
pEngine->sequencer_play();
}
return true;
}
if( sActionString == "PLAY/STOP_TOGGLE" || sActionString == "PLAY/PAUSE_TOGGLE" )
{
int nState = pEngine->getState();
switch ( nState )
{
case STATE_READY:
pEngine->sequencer_play();
break;
case STATE_PLAYING:
if( sActionString == "PLAY/STOP_TOGGLE" ) pEngine->setPatternPos( 0 );
pEngine->sequencer_stop();
pEngine->setTimelineBpm();
break;
default:
ERRORLOG( "[Hydrogen::ActionManager(PLAY): Unhandled case" );
}
return true;
}
if( sActionString == "PAUSE" )
{
pEngine->sequencer_stop();
return true;
}
if( sActionString == "STOP" )
{
pEngine->sequencer_stop();
pEngine->setPatternPos( 0 );
pEngine->setTimelineBpm();
return true;
}
if( sActionString == "MUTE" ){
//mutes the master, not a single strip
pEngine->getSong()->__is_muted = true;
return true;
}
if( sActionString == "UNMUTE" ){
pEngine->getSong()->__is_muted = false;
return true;
}
if( sActionString == "MUTE_TOGGLE" ){
pEngine->getSong()->__is_muted = !Hydrogen::get_instance()->getSong()->__is_muted;
return true;
}
if( sActionString == "BEATCOUNTER" ){
pEngine->handleBeatCounter();
return true;
}
if( sActionString == "TAP_TEMPO" ){
pEngine->onTapTempoAccelEvent();
return true;
}
if( sActionString == "SELECT_NEXT_PATTERN" ){
bool ok;
int row = pAction->getParameter1().toInt(&ok,10);
if( row> pEngine->getSong()->get_pattern_list()->size() -1 )
return false;
if(Preferences::get_instance()->patternModePlaysSelected())
pEngine->setSelectedPatternNumber( row );
else
pEngine->sequencer_setNextPattern( row, false, true );
return true;
}
if( sActionString == "SELECT_NEXT_PATTERN_RELATIVE" ){
bool ok;
if(!Preferences::get_instance()->patternModePlaysSelected())
{
return true;
}
int row = pEngine->getSelectedPatternNumber() + pAction->getParameter1().toInt(&ok,10);
if( row> pEngine->getSong()->get_pattern_list()->size() -1 )
{
return false;
}
pEngine->setSelectedPatternNumber( row );
return true;
}
if( sActionString == "SELECT_PREV_PATTERN_RELATIVE" ){
bool ok;
if(!Preferences::get_instance()->patternModePlaysSelected())
return true;
int row = pEngine->getSelectedPatternNumber() - pAction->getParameter1().toInt(&ok,10);
if( row < 0 )
return false;
pEngine->setSelectedPatternNumber( row );
return true;
}
if( sActionString == "SELECT_NEXT_PATTERN_CC_ABSOLUT" ){
bool ok;
int row = pAction->getParameter2().toInt(&ok,10);
if( row> pEngine->getSong()->get_pattern_list()->size() -1 )
return false;
if(Preferences::get_instance()->patternModePlaysSelected())
pEngine->setSelectedPatternNumber( row );
else
return true;// only usefully in normal pattern mode
return true;
}
if( sActionString == "SELECT_NEXT_PATTERN_PROMPTLY" ){// obsolete, use SELECT_NEXT_PATTERN_CC_ABSOLUT instead
bool ok;
int row = pAction->getParameter2().toInt(&ok,10);
pEngine->setSelectedPatternNumberWithoutGuiEvent( row );
return true;
}
if( sActionString == "SELECT_AND_PLAY_PATTERN"){
bool ok;
int row = pAction->getParameter1().toInt(&ok,10);
pEngine->setSelectedPatternNumber( row );
pEngine->sequencer_setNextPattern( row, false, true );
int nState = pEngine->getState();
if ( nState == STATE_READY ){
pEngine->sequencer_play();
}
return true;
}
if( sActionString == "SELECT_INSTRUMENT" ){
bool ok;
int instrument_number = pAction->getParameter2().toInt(&ok,10) ;
if ( pEngine->getSong()->get_instrument_list()->size() < instrument_number )
instrument_number = pEngine->getSong()->get_instrument_list()->size() -1;
pEngine->setSelectedInstrumentNumber( instrument_number );
return true;
}
if( sActionString == "EFFECT1_LEVEL_ABSOLUTE" ){
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int fx_param = pAction->getParameter2().toInt(&ok,10);
setAbsoluteFXLevel( nLine, 0 , fx_param );
}
if( sActionString == "EFFECT2_LEVEL_ABSOLUTE" ){
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int fx_param = pAction->getParameter2().toInt(&ok,10);
setAbsoluteFXLevel( nLine, 1 , fx_param );
}
if( sActionString == "EFFECT3_LEVEL_ABSOLUTE" ){
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int fx_param = pAction->getParameter2().toInt(&ok,10);
setAbsoluteFXLevel( nLine, 2 , fx_param );
}
if( sActionString == "EFFECT4_LEVEL_ABSOLUTE" ){
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int fx_param = pAction->getParameter2().toInt(&ok,10);
setAbsoluteFXLevel( nLine, 3 , fx_param );
}
if( sActionString == "MASTER_VOLUME_RELATIVE" ){
//increments/decrements the volume of the whole song
bool ok;
int vol_param = pAction->getParameter2().toInt(&ok,10);
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
if( vol_param != 0 ){
if ( vol_param == 1 && song->get_volume() < 1.5 ){
song->set_volume( song->get_volume() + 0.05 );
} else {
if( song->get_volume() >= 0.0 ){
song->set_volume( song->get_volume() - 0.05 );
}
}
} else {
song->set_volume( 0 );
}
}
if( sActionString == "MASTER_VOLUME_ABSOLUTE" ){
//sets the volume of a master output to a given level (percentage)
bool ok;
int vol_param = pAction->getParameter2().toInt(&ok,10);
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
if( vol_param != 0 ){
song->set_volume( 1.5* ( (float) (vol_param / 127.0 ) ));
} else {
song->set_volume( 0 );
}
}
if( sActionString == "STRIP_VOLUME_RELATIVE" ){
//increments/decrements the volume of one mixer strip
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int vol_param = pAction->getParameter2().toInt(&ok,10);
Hydrogen::get_instance()->setSelectedInstrumentNumber( nLine );
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *instr = instrList->get( nLine );
if ( instr == NULL) return 0;
if( vol_param != 0 ){
if ( vol_param == 1 && instr->get_volume() < 1.5 ){
instr->set_volume( instr->get_volume() + 0.1 );
} else {
if( instr->get_volume() >= 0.0 ){
instr->set_volume( instr->get_volume() - 0.1 );
}
}
} else {
instr->set_volume( 0 );
}
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
if( sActionString == "STRIP_VOLUME_ABSOLUTE" ){
//sets the volume of a mixer strip to a given level (percentage)
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int vol_param = pAction->getParameter2().toInt(&ok,10);
Hydrogen::get_instance()->setSelectedInstrumentNumber( nLine );
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *instr = instrList->get( nLine );
if ( instr == NULL) return 0;
if( vol_param != 0 ){
instr->set_volume( 1.5* ( (float) (vol_param / 127.0 ) ));
} else {
instr->set_volume( 0 );
}
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
if( sActionString == "PAN_ABSOLUTE" ){
// sets the absolute panning of a given mixer channel
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int pan_param = pAction->getParameter2().toInt(&ok,10);
float pan_L;
float pan_R;
Hydrogen *engine = Hydrogen::get_instance();
engine->setSelectedInstrumentNumber( nLine );
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *instr = instrList->get( nLine );
if( instr == NULL )
return false;
pan_L = instr->get_pan_l();
pan_R = instr->get_pan_r();
// pan
float fPanValue = 0.0;
if (pan_R == 1.0) {
fPanValue = 1.0 - (pan_L / 2.0);
}
else {
fPanValue = pan_R / 2.0;
}
fPanValue = 1 * ( ((float) pan_param) / 127.0 );
if (fPanValue >= 0.5) {
pan_L = (1.0 - fPanValue) * 2;
pan_R = 1.0;
}
else {
pan_L = 1.0;
pan_R = fPanValue * 2;
}
instr->set_pan_l( pan_L );
instr->set_pan_r( pan_R );
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
return true;
}
if( sActionString == "PAN_RELATIVE" ){
// changes the panning of a given mixer channel
// this is useful if the panning is set by a rotary control knob
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int pan_param = pAction->getParameter2().toInt(&ok,10);
float pan_L;
float pan_R;
Hydrogen *engine = Hydrogen::get_instance();
engine->setSelectedInstrumentNumber( nLine );
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *instr = instrList->get( nLine );
if( instr == NULL )
return false;
pan_L = instr->get_pan_l();
pan_R = instr->get_pan_r();
// pan
float fPanValue = 0.0;
if (pan_R == 1.0) {
fPanValue = 1.0 - (pan_L / 2.0);
}
else {
fPanValue = pan_R / 2.0;
}
if( pan_param == 1 && fPanValue < 1 ){
fPanValue += 0.05;
}
if( pan_param != 1 && fPanValue > 0 ){
fPanValue -= 0.05;
}
if (fPanValue >= 0.5) {
pan_L = (1.0 - fPanValue) * 2;
pan_R = 1.0;
}
else {
pan_L = 1.0;
pan_R = fPanValue * 2;
}
instr->set_pan_l( pan_L );
instr->set_pan_r( pan_R );
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
return true;
}
if( sActionString == "BPM_CC_RELATIVE" ){
/*
* increments/decrements the BPM
* this is useful if the bpm is set by a rotary control knob
*/
AudioEngine::get_instance()->lock( RIGHT_HERE );
int mult = 1;
//second parameter of cc command
//this value should be 1 to decrement and something other then 1 to increment the bpm
int cc_param = 1;
//this Action should be triggered only by CC commands
bool ok;
mult = pAction->getParameter1().toInt(&ok,10);
cc_param = pAction->getParameter2().toInt(&ok,10);
if( lastBpmChangeCCParameter == -1)
{
lastBpmChangeCCParameter = cc_param;
}
Song* pSong = pEngine->getSong();
if ( lastBpmChangeCCParameter >= cc_param && pSong->__bpm < 300) {
pEngine->setBPM( pSong->__bpm - 1*mult );
}
if ( lastBpmChangeCCParameter < cc_param && pSong->__bpm > 40 ) {
pEngine->setBPM( pSong->__bpm + 1*mult );
}
lastBpmChangeCCParameter = cc_param;
AudioEngine::get_instance()->unlock();
return true;
}
if( sActionString == "BPM_FINE_CC_RELATIVE" ){
/*
* increments/decrements the BPM
* this is useful if the bpm is set by a rotary control knob
*/
AudioEngine::get_instance()->lock( RIGHT_HERE );
int mult = 1;
//second parameter of cc command
//this value should be 1 to decrement and something other then 1 to increment the bpm
int cc_param = 1;
//this Action should be triggered only by CC commands
bool ok;
mult = pAction->getParameter1().toInt(&ok,10);
cc_param = pAction->getParameter2().toInt(&ok,10);
if( lastBpmChangeCCParameter == -1)
{
lastBpmChangeCCParameter = cc_param;
}
Song* pSong = pEngine->getSong();
if ( lastBpmChangeCCParameter >= cc_param && pSong->__bpm < 300) {
pEngine->setBPM( pSong->__bpm - 0.01*mult );
}
if ( lastBpmChangeCCParameter < cc_param && pSong->__bpm > 40 ) {
pEngine->setBPM( pSong->__bpm + 0.01*mult );
}
lastBpmChangeCCParameter = cc_param;
AudioEngine::get_instance()->unlock();
return true;
}
if( sActionString == "BPM_INCR" ){
AudioEngine::get_instance()->lock( RIGHT_HERE );
int mult = 1;
bool ok;
mult = pAction->getParameter1().toInt(&ok,10);
Song* pSong = pEngine->getSong();
if (pSong->__bpm < 300) {
pEngine->setBPM( pSong->__bpm + 1*mult );
}
AudioEngine::get_instance()->unlock();
return true;
}
if( sActionString == "BPM_DECR" ){
AudioEngine::get_instance()->lock( RIGHT_HERE );
int mult = 1;
bool ok;
mult = pAction->getParameter1().toInt(&ok,10);
Song* pSong = pEngine->getSong();
if (pSong->__bpm > 40 ) {
pEngine->setBPM( pSong->__bpm - 1*mult );
}
AudioEngine::get_instance()->unlock();
return true;
}
if( sActionString == ">>_NEXT_BAR"){
pEngine->setPatternPos(pEngine->getPatternPos() +1 );
pEngine->setTimelineBpm();
return true;
}
if( sActionString == "<<_PREVIOUS_BAR"){
pEngine->setPatternPos(pEngine->getPatternPos() -1 );
pEngine->setTimelineBpm();
return true;
}
if( sActionString == "PLAYLIST_SONG"){
bool ok;
int songnumber = pAction->getParameter2().toInt(&ok,10);
return setSong( songnumber );
}
if( sActionString == "PLAYLIST_NEXT_SONG"){
int songnumber = Playlist::get_instance()->getActiveSongNumber();
return setSong( ++songnumber );
}
if( sActionString == "PLAYLIST_PREV_SONG"){
int songnumber = Playlist::get_instance()->getActiveSongNumber();
return setSong( --songnumber );
}
if( sActionString == "RECORD_READY"){
if ( pEngine->getState() != STATE_PLAYING ) {
if (!Preferences::get_instance()->getRecordEvents()) {
Preferences::get_instance()->setRecordEvents(true);
}
else {
Preferences::get_instance()->setRecordEvents(false);
}
}
return true;
}
if( sActionString == "RECORD/STROBE_TOGGLE"){
if (!Preferences::get_instance()->getRecordEvents()) {
Preferences::get_instance()->setRecordEvents(true);
}
else {
Preferences::get_instance()->setRecordEvents(false);
}
return true;
}
if( sActionString == "RECORD_STROBE"){
if (!Preferences::get_instance()->getRecordEvents()) {
Preferences::get_instance()->setRecordEvents(true);
}
return true;
}
if( sActionString == "RECORD_EXIT"){
if (Preferences::get_instance()->getRecordEvents()) {
Preferences::get_instance()->setRecordEvents(false);
}
return true;
}
if( sActionString == "TOGGLE_METRONOME"){
Preferences::get_instance()->m_bUseMetronome = !Preferences::get_instance()->m_bUseMetronome;
return true;
}
if( sActionString == "UNDO_ACTION"){
EventQueue::get_instance()->push_event( EVENT_UNDO_REDO, 0);// 0 = undo
return true;
}
if( sActionString == "REDO_ACTION"){
EventQueue::get_instance()->push_event( EVENT_UNDO_REDO, 1);// 1 = redo
return true;
}
return false;
}
/// Render a note
/// Return 0: the note is not ended
/// Return 1: the note is ended
unsigned Sampler::__render_note( Note* pNote, unsigned nBufferSize, Song* pSong )
{
//infoLog( "[renderNote] instr: " + pNote->getInstrument()->m_sName );
assert( pSong );
unsigned int nFramepos;
Hydrogen* pEngine = Hydrogen::get_instance();
AudioOutput* audio_output = pEngine->getAudioOutput();
if ( pEngine->getState() == STATE_PLAYING ) {
nFramepos = audio_output->m_transport.m_nFrames;
} else {
// use this to support realtime events when not playing
nFramepos = pEngine->getRealtimeFrames();
}
Instrument *pInstr = pNote->get_instrument();
if ( !pInstr ) {
ERRORLOG( "NULL instrument" );
return 1;
}
float fLayerGain = 1.0;
float fLayerPitch = 0.0;
// scelgo il sample da usare in base alla velocity
Sample *pSample = NULL;
for ( unsigned nLayer = 0; nLayer < MAX_LAYERS; ++nLayer ) {
InstrumentLayer *pLayer = pInstr->get_layer( nLayer );
if ( pLayer == NULL ) continue;
if ( ( pNote->get_velocity() >= pLayer->get_start_velocity() ) && ( pNote->get_velocity() <= pLayer->get_end_velocity() ) ) {
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
break;
}
}
if ( !pSample ) {
QString dummy = QString( "NULL sample for instrument %1. Note velocity: %2" ).arg( pInstr->get_name() ).arg( pNote->get_velocity() );
WARNINGLOG( dummy );
return 1;
}
if ( pNote->get_sample_position() >= pSample->get_frames() ) {
WARNINGLOG( "sample position out of bounds. The layer has been resized during note play?" );
return 1;
}
int noteStartInFrames = ( int ) ( pNote->get_position() * audio_output->m_transport.m_nTickSize ) + pNote->get_humanize_delay();
int nInitialSilence = 0;
if ( noteStartInFrames > ( int ) nFramepos ) { // scrivo silenzio prima dell'inizio della nota
nInitialSilence = noteStartInFrames - nFramepos;
int nFrames = nBufferSize - nInitialSilence;
if ( nFrames < 0 ) {
int noteStartInFramesNoHumanize = ( int )pNote->get_position() * audio_output->m_transport.m_nTickSize;
if ( noteStartInFramesNoHumanize > ( int )( nFramepos + nBufferSize ) ) {
// this note is not valid. it's in the future...let's skip it....
ERRORLOG( QString( "Note pos in the future?? Current frames: %1, note frame pos: %2" ).arg( nFramepos ).arg(noteStartInFramesNoHumanize ) );
//pNote->dumpInfo();
return 1;
}
// delay note execution
//INFOLOG( "Delaying note execution. noteStartInFrames: " + to_string( noteStartInFrames ) + ", nFramePos: " + to_string( nFramepos ) );
return 0;
}
}
float cost_L = 1.0f;
float cost_R = 1.0f;
float cost_track_L = 1.0f;
float cost_track_R = 1.0f;
if ( pInstr->is_muted() || pSong->__is_muted ) { // is instrument muted?
cost_L = 0.0;
cost_R = 0.0;
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_L = 0.0;
cost_track_R = 0.0;
}
} else { // Precompute some values...
cost_L = cost_L * pNote->get_velocity(); // note velocity
cost_L = cost_L * pNote->get_pan_l(); // note pan
cost_L = cost_L * fLayerGain; // layer gain
cost_L = cost_L * pInstr->get_pan_l(); // instrument pan
cost_L = cost_L * pInstr->get_gain(); // instrument gain
cost_L = cost_L * pInstr->get_volume(); // instrument volume
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_L = cost_L * 2;
}
cost_L = cost_L * pSong->get_volume(); // song volume
cost_L = cost_L * 2; // max pan is 0.5
cost_R = cost_R * pNote->get_velocity(); // note velocity
cost_R = cost_R * pNote->get_pan_r(); // note pan
cost_R = cost_R * fLayerGain; // layer gain
cost_R = cost_R * pInstr->get_pan_r(); // instrument pan
cost_R = cost_R * pInstr->get_gain(); // instrument gain
cost_R = cost_R * pInstr->get_volume(); // instrument volume
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_R = cost_R * 2;
}
cost_R = cost_R * pSong->get_volume(); // song pan
cost_R = cost_R * 2; // max pan is 0.5
}
// direct track outputs only use velocity
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 1 ) {
cost_track_L = cost_track_L * pNote->get_velocity();
cost_track_L = cost_track_L * fLayerGain;
cost_track_R = cost_track_L;
}
// Se non devo fare resample (drumkit) posso evitare di utilizzare i float e gestire il tutto in
// maniera ottimizzata
// constant^12 = 2, so constant = 2^(1/12) = 1.059463.
// float nStep = 1.0;1.0594630943593
float fTotalPitch = pNote->get_total_pitch() + fLayerPitch;
//_INFOLOG( "total pitch: " + to_string( fTotalPitch ) );
if( ( int )pNote->get_sample_position() == 0 )
{
if( Hydrogen::get_instance()->getMidiOutput() != NULL ){
Hydrogen::get_instance()->getMidiOutput()->handleQueueNote( pNote );
}
}
if ( fTotalPitch == 0.0 && pSample->get_sample_rate() == audio_output->getSampleRate() ) { // NO RESAMPLE
return __render_note_no_resample( pSample, pNote, nBufferSize, nInitialSilence, cost_L, cost_R, cost_track_L, cost_track_R, pSong );
} else { // RESAMPLE
return __render_note_resample( pSample, pNote, nBufferSize, nInitialSilence, cost_L, cost_R, cost_track_L, cost_track_R, fLayerPitch, pSong );
}
}
// Returns 0 on success, passes the TinyXml error code otherwise.
int SongWriter::writeSong( Song *song, const QString& filename )
{
INFOLOG( "Saving song " + filename );
int rv = 0; // return value
// FIXME: has the file write-permssion?
// FIXME: verificare che il file non sia gia' esistente
// FIXME: effettuare copia di backup per il file gia' esistente
QDomDocument doc;
QDomProcessingInstruction header = doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"");
doc.appendChild( header );
QDomNode songNode = doc.createElement( "song" );
LocalFileMng::writeXmlString( songNode, "version", QString( get_version().c_str() ) );
LocalFileMng::writeXmlString( songNode, "bpm", QString("%1").arg( song->__bpm ) );
LocalFileMng::writeXmlString( songNode, "volume", QString("%1").arg( song->get_volume() ) );
LocalFileMng::writeXmlString( songNode, "metronomeVolume", QString("%1").arg( song->get_metronome_volume() ) );
LocalFileMng::writeXmlString( songNode, "name", song->__name );
LocalFileMng::writeXmlString( songNode, "author", song->__author );
LocalFileMng::writeXmlString( songNode, "notes", song->get_notes() );
LocalFileMng::writeXmlString( songNode, "license", song->get_license() );
LocalFileMng::writeXmlBool( songNode, "loopEnabled", song->is_loop_enabled() );
LocalFileMng::writeXmlBool( songNode, "patternModeMode", Preferences::get_instance()->patternModePlaysSelected());
LocalFileMng::writeXmlString( songNode, "playbackTrackFilename", QString("%1").arg( song->get_playback_track_filename() ) );
LocalFileMng::writeXmlBool( songNode, "playbackTrackEnabled", song->get_playback_track_enabled() );
LocalFileMng::writeXmlString( songNode, "playbackTrackVolume", QString("%1").arg( song->get_playback_track_volume() ) );
if ( song->get_mode() == Song::SONG_MODE ) {
LocalFileMng::writeXmlString( songNode, "mode", QString( "song" ) );
} else {
LocalFileMng::writeXmlString( songNode, "mode", QString( "pattern" ) );
}
LocalFileMng::writeXmlString( songNode, "humanize_time", QString("%1").arg( song->get_humanize_time_value() ) );
LocalFileMng::writeXmlString( songNode, "humanize_velocity", QString("%1").arg( song->get_humanize_velocity_value() ) );
LocalFileMng::writeXmlString( songNode, "swing_factor", QString("%1").arg( song->get_swing_factor() ) );
// component List
QDomNode componentListNode = doc.createElement( "componentList" );
for (std::vector<DrumkitComponent*>::iterator it = song->get_components()->begin() ; it != song->get_components()->end(); ++it) {
DrumkitComponent* pCompo = *it;
QDomNode componentNode = doc.createElement( "drumkitComponent" );
LocalFileMng::writeXmlString( componentNode, "id", QString("%1").arg( pCompo->get_id() ) );
LocalFileMng::writeXmlString( componentNode, "name", pCompo->get_name() );
LocalFileMng::writeXmlString( componentNode, "volume", QString("%1").arg( pCompo->get_volume() ) );
componentListNode.appendChild( componentNode );
}
songNode.appendChild( componentListNode );
// instrument list
QDomNode instrumentListNode = doc.createElement( "instrumentList" );
unsigned nInstrument = song->get_instrument_list()->size();
// INSTRUMENT NODE
for ( unsigned i = 0; i < nInstrument; i++ ) {
Instrument *instr = song->get_instrument_list()->get( i );
assert( instr );
QDomNode instrumentNode = doc.createElement( "instrument" );
LocalFileMng::writeXmlString( instrumentNode, "id", QString("%1").arg( instr->get_id() ) );
LocalFileMng::writeXmlString( instrumentNode, "name", instr->get_name() );
LocalFileMng::writeXmlString( instrumentNode, "drumkit", instr->get_drumkit_name() );
LocalFileMng::writeXmlString( instrumentNode, "volume", QString("%1").arg( instr->get_volume() ) );
LocalFileMng::writeXmlBool( instrumentNode, "isMuted", instr->is_muted() );
LocalFileMng::writeXmlString( instrumentNode, "pan_L", QString("%1").arg( instr->get_pan_l() ) );
LocalFileMng::writeXmlString( instrumentNode, "pan_R", QString("%1").arg( instr->get_pan_r() ) );
LocalFileMng::writeXmlString( instrumentNode, "gain", QString("%1").arg( instr->get_gain() ) );
LocalFileMng::writeXmlBool( instrumentNode, "applyVelocity", instr->get_apply_velocity() );
LocalFileMng::writeXmlBool( instrumentNode, "filterActive", instr->is_filter_active() );
LocalFileMng::writeXmlString( instrumentNode, "filterCutoff", QString("%1").arg( instr->get_filter_cutoff() ) );
LocalFileMng::writeXmlString( instrumentNode, "filterResonance", QString("%1").arg( instr->get_filter_resonance() ) );
LocalFileMng::writeXmlString( instrumentNode, "FX1Level", QString("%1").arg( instr->get_fx_level( 0 ) ) );
LocalFileMng::writeXmlString( instrumentNode, "FX2Level", QString("%1").arg( instr->get_fx_level( 1 ) ) );
LocalFileMng::writeXmlString( instrumentNode, "FX3Level", QString("%1").arg( instr->get_fx_level( 2 ) ) );
LocalFileMng::writeXmlString( instrumentNode, "FX4Level", QString("%1").arg( instr->get_fx_level( 3 ) ) );
assert( instr->get_adsr() );
LocalFileMng::writeXmlString( instrumentNode, "Attack", QString("%1").arg( instr->get_adsr()->get_attack() ) );
LocalFileMng::writeXmlString( instrumentNode, "Decay", QString("%1").arg( instr->get_adsr()->get_decay() ) );
LocalFileMng::writeXmlString( instrumentNode, "Sustain", QString("%1").arg( instr->get_adsr()->get_sustain() ) );
LocalFileMng::writeXmlString( instrumentNode, "Release", QString("%1").arg( instr->get_adsr()->get_release() ) );
LocalFileMng::writeXmlString( instrumentNode, "randomPitchFactor", QString("%1").arg( instr->get_random_pitch_factor() ) );
LocalFileMng::writeXmlString( instrumentNode, "muteGroup", QString("%1").arg( instr->get_mute_group() ) );
LocalFileMng::writeXmlBool( instrumentNode, "isStopNote", instr->is_stop_notes() );
switch ( instr->sample_selection_alg() ) {
case Instrument::VELOCITY:
LocalFileMng::writeXmlString( instrumentNode, "sampleSelectionAlgo", "VELOCITY" );
break;
case Instrument::RANDOM:
LocalFileMng::writeXmlString( instrumentNode, "sampleSelectionAlgo", "RANDOM" );
break;
case Instrument::ROUND_ROBIN:
LocalFileMng::writeXmlString( instrumentNode, "sampleSelectionAlgo", "ROUND_ROBIN" );
break;
}
LocalFileMng::writeXmlString( instrumentNode, "midiOutChannel", QString("%1").arg( instr->get_midi_out_channel() ) );
LocalFileMng::writeXmlString( instrumentNode, "midiOutNote", QString("%1").arg( instr->get_midi_out_note() ) );
LocalFileMng::writeXmlString( instrumentNode, "isHihat", QString("%1").arg( instr->get_hihat_grp() ) );
LocalFileMng::writeXmlString( instrumentNode, "lower_cc", QString("%1").arg( instr->get_lower_cc() ) );
LocalFileMng::writeXmlString( instrumentNode, "higher_cc", QString("%1").arg( instr->get_higher_cc() ) );
for (std::vector<InstrumentComponent*>::iterator it = instr->get_components()->begin() ; it != instr->get_components()->end(); ++it) {
InstrumentComponent* pComponent = *it;
QDomNode componentNode = doc.createElement( "instrumentComponent" );
LocalFileMng::writeXmlString( componentNode, "component_id", QString("%1").arg( pComponent->get_drumkit_componentID() ) );
LocalFileMng::writeXmlString( componentNode, "gain", QString("%1").arg( pComponent->get_gain() ) );
for ( unsigned nLayer = 0; nLayer < InstrumentComponent::getMaxLayers(); nLayer++ ) {
InstrumentLayer *pLayer = pComponent->get_layer( nLayer );
if ( pLayer == NULL ) continue;
Sample *pSample = pLayer->get_sample();
if ( pSample == NULL ) continue;
bool sIsModified = pSample->get_is_modified();
Sample::Loops lo = pSample->get_loops();
Sample::Rubberband ro = pSample->get_rubberband();
QString sMode = pSample->get_loop_mode_string();
QDomNode layerNode = doc.createElement( "layer" );
LocalFileMng::writeXmlString( layerNode, "filename", Filesystem::prepare_sample_path( pSample->get_filepath() ) );
LocalFileMng::writeXmlBool( layerNode, "ismodified", sIsModified);
LocalFileMng::writeXmlString( layerNode, "smode", pSample->get_loop_mode_string() );
LocalFileMng::writeXmlString( layerNode, "startframe", QString("%1").arg( lo.start_frame ) );
LocalFileMng::writeXmlString( layerNode, "loopframe", QString("%1").arg( lo.loop_frame ) );
LocalFileMng::writeXmlString( layerNode, "loops", QString("%1").arg( lo.count ) );
LocalFileMng::writeXmlString( layerNode, "endframe", QString("%1").arg( lo.end_frame ) );
LocalFileMng::writeXmlString( layerNode, "userubber", QString("%1").arg( ro.use ) );
LocalFileMng::writeXmlString( layerNode, "rubberdivider", QString("%1").arg( ro.divider ) );
LocalFileMng::writeXmlString( layerNode, "rubberCsettings", QString("%1").arg( ro.c_settings ) );
LocalFileMng::writeXmlString( layerNode, "rubberPitch", QString("%1").arg( ro.pitch ) );
LocalFileMng::writeXmlString( layerNode, "min", QString("%1").arg( pLayer->get_start_velocity() ) );
LocalFileMng::writeXmlString( layerNode, "max", QString("%1").arg( pLayer->get_end_velocity() ) );
LocalFileMng::writeXmlString( layerNode, "gain", QString("%1").arg( pLayer->get_gain() ) );
LocalFileMng::writeXmlString( layerNode, "pitch", QString("%1").arg( pLayer->get_pitch() ) );
Sample::VelocityEnvelope* velocity = pSample->get_velocity_envelope();
for (int y = 0; y < velocity->size(); y++){
QDomNode volumeNode = doc.createElement( "volume" );
LocalFileMng::writeXmlString( volumeNode, "volume-position", QString("%1").arg( velocity->at(y).frame ) );
LocalFileMng::writeXmlString( volumeNode, "volume-value", QString("%1").arg( velocity->at(y).value ) );
layerNode.appendChild( volumeNode );
}
Sample::PanEnvelope* pan = pSample->get_pan_envelope();
for (int y = 0; y < pan->size(); y++){
QDomNode panNode = doc.createElement( "pan" );
LocalFileMng::writeXmlString( panNode, "pan-position", QString("%1").arg( pan->at(y).frame ) );
LocalFileMng::writeXmlString( panNode, "pan-value", QString("%1").arg( pan->at(y).value ) );
layerNode.appendChild( panNode );
}
componentNode.appendChild( layerNode );
}
instrumentNode.appendChild( componentNode );
}
instrumentListNode.appendChild( instrumentNode );
}
songNode.appendChild( instrumentListNode );
// pattern list
QDomNode patternListNode = doc.createElement( "patternList" );
unsigned nPatterns = song->get_pattern_list()->size();
for ( unsigned i = 0; i < nPatterns; i++ ) {
Pattern *pat = song->get_pattern_list()->get( i );
// pattern
QDomNode patternNode = doc.createElement( "pattern" );
LocalFileMng::writeXmlString( patternNode, "name", pat->get_name() );
LocalFileMng::writeXmlString( patternNode, "category", pat->get_category() );
LocalFileMng::writeXmlString( patternNode, "size", QString("%1").arg( pat->get_length() ) );
LocalFileMng::writeXmlString( patternNode, "info", pat->get_info() );
QDomNode noteListNode = doc.createElement( "noteList" );
const Pattern::notes_t* notes = pat->get_notes();
FOREACH_NOTE_CST_IT_BEGIN_END(notes,it) {
Note *pNote = it->second;
assert( pNote );
QDomNode noteNode = doc.createElement( "note" );
LocalFileMng::writeXmlString( noteNode, "position", QString("%1").arg( pNote->get_position() ) );
LocalFileMng::writeXmlString( noteNode, "leadlag", QString("%1").arg( pNote->get_lead_lag() ) );
LocalFileMng::writeXmlString( noteNode, "velocity", QString("%1").arg( pNote->get_velocity() ) );
LocalFileMng::writeXmlString( noteNode, "pan_L", QString("%1").arg( pNote->get_pan_l() ) );
LocalFileMng::writeXmlString( noteNode, "pan_R", QString("%1").arg( pNote->get_pan_r() ) );
LocalFileMng::writeXmlString( noteNode, "pitch", QString("%1").arg( pNote->get_pitch() ) );
LocalFileMng::writeXmlString( noteNode, "probability", QString("%1").arg( pNote->get_probability() ) );
LocalFileMng::writeXmlString( noteNode, "key", pNote->key_to_string() );
LocalFileMng::writeXmlString( noteNode, "length", QString("%1").arg( pNote->get_length() ) );
LocalFileMng::writeXmlString( noteNode, "instrument", QString("%1").arg( pNote->get_instrument()->get_id() ) );
QString noteoff = "false";
if ( pNote->get_note_off() ) noteoff = "true";
LocalFileMng::writeXmlString( noteNode, "note_off", noteoff );
noteListNode.appendChild( noteNode );
}
patternNode.appendChild( noteListNode );
patternListNode.appendChild( patternNode );
}
/// Render a note
/// Return false: the note is not ended
/// Return true: the note is ended
bool Sampler::__render_note( Note* pNote, unsigned nBufferSize, Song* pSong )
{
//infoLog( "[renderNote] instr: " + pNote->getInstrument()->m_sName );
assert( pSong );
unsigned int nFramepos;
Hydrogen* pEngine = Hydrogen::get_instance();
AudioOutput* audio_output = pEngine->getAudioOutput();
if ( pEngine->getState() == STATE_PLAYING ) {
nFramepos = audio_output->m_transport.m_nFrames;
} else {
// use this to support realtime events when not playing
nFramepos = pEngine->getRealtimeFrames();
}
Instrument *pInstr = pNote->get_instrument();
if ( !pInstr ) {
ERRORLOG( "NULL instrument" );
return 1;
}
bool nReturnValues [pInstr->get_components()->size()];
for(int i = 0; i < pInstr->get_components()->size(); i++){
nReturnValues[i] = false;
}
int nReturnValueIndex = 0;
int nAlreadySelectedLayer = -1;
for (std::vector<InstrumentComponent*>::iterator it = pInstr->get_components()->begin() ; it !=pInstr->get_components()->end(); ++it) {
nReturnValues[nReturnValueIndex] = false;
InstrumentComponent *pCompo = *it;
DrumkitComponent* pMainCompo = pEngine->getSong()->get_component( pCompo->get_drumkit_componentID() );
if( pNote->get_specific_compo_id() != -1 && pNote->get_specific_compo_id() != pCompo->get_drumkit_componentID() )
continue;
if( pInstr->is_preview_instrument()
|| pInstr->is_metronome_instrument()){
pMainCompo = pEngine->getSong()->get_components()->front();
} else {
pMainCompo = pEngine->getSong()->get_component( pCompo->get_drumkit_componentID() );
}
assert(pMainCompo);
float fLayerGain = 1.0;
float fLayerPitch = 0.0;
// scelgo il sample da usare in base alla velocity
Sample *pSample = nullptr;
SelectedLayerInfo *pSelectedLayer = pNote->get_layer_selected( pCompo->get_drumkit_componentID() );
if ( !pSelectedLayer ) {
QString dummy = QString( "NULL Layer Information for instrument %1. Component: %2" ).arg( pInstr->get_name() ).arg( pCompo->get_drumkit_componentID() );
WARNINGLOG( dummy );
nReturnValues[nReturnValueIndex] = true;
continue;
}
if( pSelectedLayer->SelectedLayer != -1 ) {
InstrumentLayer *pLayer = pCompo->get_layer( pSelectedLayer->SelectedLayer );
if( pLayer )
{
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
}
}
else {
switch ( pInstr->sample_selection_alg() ) {
case Instrument::VELOCITY:
for ( unsigned nLayer = 0; nLayer < __maxLayers; ++nLayer ) {
InstrumentLayer *pLayer = pCompo->get_layer( nLayer );
if ( pLayer == NULL ) continue;
if ( ( pNote->get_velocity() >= pLayer->get_start_velocity() ) && ( pNote->get_velocity() <= pLayer->get_end_velocity() ) ) {
pSelectedLayer->SelectedLayer = nLayer;
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
break;
}
}
break;
case Instrument::RANDOM:
if( nAlreadySelectedLayer != -1 ) {
InstrumentLayer *pLayer = pCompo->get_layer( nAlreadySelectedLayer );
if ( pLayer != NULL ) {
pSelectedLayer->SelectedLayer = nAlreadySelectedLayer;
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
}
}
if( pSample == NULL ) {
int __possibleIndex[ __maxLayers ];
int __poundSamples = 0;
for ( unsigned nLayer = 0; nLayer < __maxLayers; ++nLayer ) {
InstrumentLayer *pLayer = pCompo->get_layer( nLayer );
if ( pLayer == NULL ) continue;
if ( ( pNote->get_velocity() >= pLayer->get_start_velocity() ) && ( pNote->get_velocity() <= pLayer->get_end_velocity() ) ) {
__possibleIndex[__poundSamples] = nLayer;
__poundSamples++;
}
}
if( __poundSamples > 0 ) {
nAlreadySelectedLayer = __possibleIndex[rand() % __poundSamples];
pSelectedLayer->SelectedLayer = nAlreadySelectedLayer;
InstrumentLayer *pLayer = pCompo->get_layer( nAlreadySelectedLayer );
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
}
}
break;
case Instrument::ROUND_ROBIN:
if( nAlreadySelectedLayer != -1 ) {
InstrumentLayer *pLayer = pCompo->get_layer( nAlreadySelectedLayer );
if ( pLayer != NULL ) {
pSelectedLayer->SelectedLayer = nAlreadySelectedLayer;
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
}
}
if( !pSample ) {
int __possibleIndex[ __maxLayers ];
int __foundSamples = 0;
float __roundRobinID;
for ( unsigned nLayer = 0; nLayer < __maxLayers; ++nLayer ) {
InstrumentLayer *pLayer = pCompo->get_layer( nLayer );
if ( pLayer == NULL ) continue;
if ( ( pNote->get_velocity() >= pLayer->get_start_velocity() ) && ( pNote->get_velocity() <= pLayer->get_end_velocity() ) ) {
__possibleIndex[__foundSamples] = nLayer;
__roundRobinID = pLayer->get_start_velocity();
__foundSamples++;
}
}
if( __foundSamples > 0 ) {
__roundRobinID = pInstr->get_id() * 10 + __roundRobinID;
int p_indexToUse = pSong->get_latest_round_robin(__roundRobinID)+1;
if( p_indexToUse > __foundSamples - 1)
p_indexToUse = 0;
pSong->set_latest_round_robin(__roundRobinID, p_indexToUse);
nAlreadySelectedLayer = __possibleIndex[p_indexToUse];
pSelectedLayer->SelectedLayer = nAlreadySelectedLayer;
InstrumentLayer *pLayer = pCompo->get_layer( nAlreadySelectedLayer );
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
}
}
break;
}
}
if ( !pSample ) {
QString dummy = QString( "NULL sample for instrument %1. Note velocity: %2" ).arg( pInstr->get_name() ).arg( pNote->get_velocity() );
WARNINGLOG( dummy );
nReturnValues[nReturnValueIndex] = true;
continue;
}
if ( pSelectedLayer->SamplePosition >= pSample->get_frames() ) {
WARNINGLOG( "sample position out of bounds. The layer has been resized during note play?" );
nReturnValues[nReturnValueIndex] = true;
continue;
}
int noteStartInFrames = ( int ) ( pNote->get_position() * audio_output->m_transport.m_nTickSize ) + pNote->get_humanize_delay();
int nInitialSilence = 0;
if ( noteStartInFrames > ( int ) nFramepos ) { // scrivo silenzio prima dell'inizio della nota
nInitialSilence = noteStartInFrames - nFramepos;
int nFrames = nBufferSize - nInitialSilence;
if ( nFrames < 0 ) {
int noteStartInFramesNoHumanize = ( int )pNote->get_position() * audio_output->m_transport.m_nTickSize;
if ( noteStartInFramesNoHumanize > ( int )( nFramepos + nBufferSize ) ) {
// this note is not valid. it's in the future...let's skip it....
ERRORLOG( QString( "Note pos in the future?? Current frames: %1, note frame pos: %2" ).arg( nFramepos ).arg(noteStartInFramesNoHumanize ) );
//pNote->dumpInfo();
nReturnValues[nReturnValueIndex] = true;
continue;
}
// delay note execution
//INFOLOG( "Delaying note execution. noteStartInFrames: " + to_string( noteStartInFrames ) + ", nFramePos: " + to_string( nFramepos ) );
//return 0;
continue;
}
}
float cost_L = 1.0f;
float cost_R = 1.0f;
float cost_track_L = 1.0f;
float cost_track_R = 1.0f;
assert(pMainCompo);
bool isMutedForExport = (pEngine->getIsExportSessionActive() && !pInstr->is_currently_exported());
/*
* Is instrument muted?
*
* This can be the case either if the song, instrument or component is muted or if we're in an
* export session and we're doing per-instruments exports, but this instrument is not currently
* beeing exported.
*/
if ( isMutedForExport || pInstr->is_muted() || pSong->__is_muted || pMainCompo->is_muted() ) {
cost_L = 0.0;
cost_R = 0.0;
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_L = 0.0;
cost_track_R = 0.0;
}
} else { // Precompute some values...
if ( pInstr->get_apply_velocity() ) {
cost_L = cost_L * pNote->get_velocity(); // note velocity
cost_R = cost_R * pNote->get_velocity(); // note velocity
}
cost_L = cost_L * pNote->get_pan_l(); // note pan
cost_L = cost_L * fLayerGain; // layer gain
cost_L = cost_L * pInstr->get_pan_l(); // instrument pan
cost_L = cost_L * pInstr->get_gain(); // instrument gain
cost_L = cost_L * pCompo->get_gain(); // Component gain
cost_L = cost_L * pMainCompo->get_volume(); // Component volument
cost_L = cost_L * pInstr->get_volume(); // instrument volume
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_L = cost_L * 2;
}
cost_L = cost_L * pSong->get_volume(); // song volume
cost_L = cost_L * 2; // max pan is 0.5
cost_R = cost_R * pNote->get_pan_r(); // note pan
cost_R = cost_R * fLayerGain; // layer gain
cost_R = cost_R * pInstr->get_pan_r(); // instrument pan
cost_R = cost_R * pInstr->get_gain(); // instrument gain
cost_R = cost_R * pCompo->get_gain(); // Component gain
cost_R = cost_R * pMainCompo->get_volume(); // Component volument
cost_R = cost_R * pInstr->get_volume(); // instrument volume
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_R = cost_R * 2;
}
cost_R = cost_R * pSong->get_volume(); // song pan
cost_R = cost_R * 2; // max pan is 0.5
}
// direct track outputs only use velocity
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 1 ) {
cost_track_L = cost_track_L * pNote->get_velocity();
cost_track_L = cost_track_L * fLayerGain;
cost_track_R = cost_track_L;
}
// Se non devo fare resample (drumkit) posso evitare di utilizzare i float e gestire il tutto in
// maniera ottimizzata
// constant^12 = 2, so constant = 2^(1/12) = 1.059463.
// float nStep = 1.0;1.0594630943593
float fTotalPitch = pNote->get_total_pitch() + fLayerPitch;
//_INFOLOG( "total pitch: " + to_string( fTotalPitch ) );
if( ( int )pSelectedLayer->SamplePosition == 0 )
{
if( Hydrogen::get_instance()->getMidiOutput() != NULL ){
Hydrogen::get_instance()->getMidiOutput()->handleQueueNote( pNote );
}
}
if ( fTotalPitch == 0.0 && pSample->get_sample_rate() == audio_output->getSampleRate() ) // NO RESAMPLE
nReturnValues[nReturnValueIndex] = __render_note_no_resample( pSample, pNote, pSelectedLayer, pCompo, pMainCompo, nBufferSize, nInitialSilence, cost_L, cost_R, cost_track_L, cost_track_R, pSong );
else // RESAMPLE
nReturnValues[nReturnValueIndex] = __render_note_resample( pSample, pNote, pSelectedLayer, pCompo, pMainCompo, nBufferSize, nInitialSilence, cost_L, cost_R, cost_track_L, cost_track_R, fLayerPitch, pSong );
nReturnValueIndex++;
}
for ( unsigned i = 0 ; i < pInstr->get_components()->size() ; i++ )
if ( !nReturnValues[i] ) return false;
return true;
}
void Mixer::updateMixer()
{
Preferences *pPref = Preferences::get_instance();
bool bShowPeaks = pPref->showInstrumentPeaks();
Hydrogen *pEngine = Hydrogen::get_instance();
Song *pSong = pEngine->getSong();
InstrumentList *pInstrList = pSong->get_instrument_list();
std::vector<DrumkitComponent*>* compoList = pSong->get_components();
uint nSelectedInstr = pEngine->getSelectedInstrumentNumber();
float fallOff = pPref->getMixerFalloffSpeed();
uint nMuteClicked = 0;
int nInstruments = pInstrList->size();
int nCompo = compoList->size();
for ( unsigned nInstr = 0; nInstr < MAX_INSTRUMENTS; ++nInstr ) {
if ( nInstr >= nInstruments ) { // unused instrument! let's hide and destroy the mixerline!
if ( m_pMixerLine[ nInstr ] ) {
delete m_pMixerLine[ nInstr ];
m_pMixerLine[ nInstr ] = NULL;
int newWidth = MIXER_STRIP_WIDTH * ( nInstruments + nCompo );
if ( m_pFaderPanel->width() != newWidth ) {
m_pFaderPanel->resize( newWidth, height() );
}
}
continue;
}
else {
if ( m_pMixerLine[ nInstr ] == NULL ) {
// the mixerline doesn't exists..I'll create a new one!
m_pMixerLine[ nInstr ] = createMixerLine( nInstr );
m_pFaderHBox->insertWidget( nInstr, m_pMixerLine[ nInstr ] );
int newWidth = MIXER_STRIP_WIDTH * ( nInstruments + nCompo );
if ( m_pFaderPanel->width() != newWidth ) {
m_pFaderPanel->resize( newWidth, height() );
}
}
MixerLine *pLine = m_pMixerLine[ nInstr ];
Instrument *pInstr = pInstrList->get( nInstr );
assert( pInstr );
float fNewPeak_L = pInstr->get_peak_l();
pInstr->set_peak_l( 0.0f ); // reset instrument peak
float fNewPeak_R = pInstr->get_peak_r();
pInstr->set_peak_r( 0.0f ); // reset instrument peak
float fNewVolume = pInstr->get_volume();
bool bMuted = pInstr->is_muted();
QString sName = pInstr->get_name();
float fPan_L = pInstr->get_pan_l();
float fPan_R = pInstr->get_pan_r();
// fader
float fOldPeak_L = pLine->getPeak_L();
float fOldPeak_R = pLine->getPeak_R();
if (!bShowPeaks) {
fNewPeak_L = 0.0f;
fNewPeak_R = 0.0f;
}
if ( fNewPeak_L >= fOldPeak_L) { // LEFT peak
pLine->setPeak_L( fNewPeak_L );
}
else {
pLine->setPeak_L( fOldPeak_L / fallOff );
}
if ( fNewPeak_R >= fOldPeak_R) { // Right peak
pLine->setPeak_R( fNewPeak_R );
}
else {
pLine->setPeak_R( fOldPeak_R / fallOff );
}
// fader position
pLine->setVolume( fNewVolume );
// mute
if ( bMuted ) {
nMuteClicked++;
}
pLine->setMuteClicked( bMuted );
// instr name
pLine->setName( sName );
// pan
float fPanValue = 0.0;
if (fPan_R == 1.0) {
fPanValue = 1.0 - (fPan_L / 2.0);
}
else {
fPanValue = fPan_R / 2.0;
}
pLine->setPan( fPanValue );
// activity
if ( pLine->getActivity() > 0 ) {
pLine->setActivity( m_pMixerLine[ nInstr ]->getActivity() - 30 );
pLine->setPlayClicked( true );
}
else {
pLine->setPlayClicked( false );
}
for (uint nFX = 0; nFX < MAX_FX; nFX++) {
pLine->setFXLevel( nFX, pInstr->get_fx_level( nFX ) );
}
pLine->setSelected( nInstr == nSelectedInstr );
pLine->updateMixerLine();
}
}
for (std::vector<DrumkitComponent*>::iterator it = compoList->begin() ; it != compoList->end(); ++it) {
DrumkitComponent* p_compo = *it;
if( m_pComponentMixerLine.find(p_compo->get_id()) == m_pComponentMixerLine.end() ) {
// the mixerline doesn't exists..I'll create a new one!
m_pComponentMixerLine[ p_compo->get_id() ] = createComponentMixerLine( p_compo->get_id() );
m_pFaderHBox->addWidget( m_pComponentMixerLine[ p_compo->get_id() ] );
int newWidth = MIXER_STRIP_WIDTH * ( nInstruments + nCompo );
if ( m_pFaderPanel->width() != newWidth ) {
m_pFaderPanel->resize( newWidth, height() );
}
}
ComponentMixerLine *pLine = m_pComponentMixerLine[ p_compo->get_id() ];
float fNewPeak_L = p_compo->get_peak_l();
p_compo->set_peak_l( 0.0f ); // reset instrument peak
float fNewPeak_R = p_compo->get_peak_r();
p_compo->set_peak_r( 0.0f ); // reset instrument peak
float fNewVolume = p_compo->get_volume();
bool bMuted = p_compo->is_muted();
QString sName = p_compo->get_name();
float fOldPeak_L = pLine->getPeak_L();
float fOldPeak_R = pLine->getPeak_R();
if (!bShowPeaks) {
fNewPeak_L = 0.0f;
fNewPeak_R = 0.0f;
}
if ( fNewPeak_L >= fOldPeak_L) { // LEFT peak
pLine->setPeak_L( fNewPeak_L );
}
else {
pLine->setPeak_L( fOldPeak_L / fallOff );
}
if ( fNewPeak_R >= fOldPeak_R) { // Right peak
pLine->setPeak_R( fNewPeak_R );
}
else {
pLine->setPeak_R( fOldPeak_R / fallOff );
}
// fader position
pLine->setVolume( fNewVolume );
// mute
if ( bMuted ) {
nMuteClicked++;
}
pLine->setMuteClicked( bMuted );
// instr name
pLine->setName( sName );
pLine->updateMixerLine();
}
if( compoList->size() < m_pComponentMixerLine.size() ) {
std::vector<int>* p_ids_to_delete = new std::vector<int>();
for (std::map<int, ComponentMixerLine*>::iterator it=m_pComponentMixerLine.begin(); it!=m_pComponentMixerLine.end(); ++it) {
bool p_foundExistingRelatedComponent = false;
for ( std::vector<DrumkitComponent*>::iterator it2 = compoList->begin() ; it2 != compoList->end(); ++it2 ) {
DrumkitComponent* p_compo = *it2;
if( p_compo->get_id() == it->first ) {
p_foundExistingRelatedComponent = true;
break;
}
}
if( !p_foundExistingRelatedComponent )
p_ids_to_delete->push_back( it->first ) ;
}
for ( std::vector<int>::iterator it = p_ids_to_delete->begin() ; it != p_ids_to_delete->end(); ++it ) {
int p_compoID = *it;
delete m_pComponentMixerLine[p_compoID];
m_pComponentMixerLine.erase( p_compoID );
int newWidth = MIXER_STRIP_WIDTH * ( nInstruments + nCompo );
if ( m_pFaderPanel->width() != newWidth ) {
m_pFaderPanel->resize( newWidth, height() );
}
}
}
if (nMuteClicked == nInstruments - 1) {
// find the not muted button
for (uint i = 0; i < nInstruments; i++) {
Instrument *instr = pInstrList->get(i);
if (instr->is_muted() == false) {
m_pMixerLine[i]->setSoloClicked(true);
break;
}
}
}
else {
for (uint i = 0; i < nInstruments; i++) {
m_pMixerLine[i]->setSoloClicked(false);
}
}
// update MasterPeak
float oldPeak_L = m_pMasterLine->getPeak_L();
float newPeak_L = pEngine->getMasterPeak_L();
pEngine->setMasterPeak_L(0.0);
float oldPeak_R = m_pMasterLine->getPeak_R();
float newPeak_R = pEngine->getMasterPeak_R();
pEngine->setMasterPeak_R(0.0);
if (!bShowPeaks) {
newPeak_L = 0.0;
newPeak_R = 0.0;
}
if (newPeak_L >= oldPeak_L) {
m_pMasterLine->setPeak_L( newPeak_L );
}
else {
m_pMasterLine->setPeak_L( oldPeak_L / fallOff );
}
if (newPeak_R >= oldPeak_R) {
m_pMasterLine->setPeak_R(newPeak_R);
}
else {
m_pMasterLine->setPeak_R( oldPeak_R / fallOff );
}
// set master fader position
float newVolume = pSong->get_volume();
float oldVolume = m_pMasterLine->getVolume();
if (oldVolume != newVolume) {
m_pMasterLine->setVolume(newVolume);
}
m_pMasterLine->updateMixerLine();
#ifdef H2CORE_HAVE_LADSPA
// LADSPA
for (uint nFX = 0; nFX < MAX_FX; nFX++) {
LadspaFX *pFX = Effects::get_instance()->getLadspaFX( nFX );
if ( pFX ) {
m_pLadspaFXLine[nFX]->setName( pFX->getPluginName() );
float fNewPeak_L = 0.0;
float fNewPeak_R = 0.0;
float fOldPeak_L = 0.0;
float fOldPeak_R = 0.0;
m_pLadspaFXLine[nFX]->getPeaks( &fOldPeak_L, &fOldPeak_R );
if (fNewPeak_L < fOldPeak_L) fNewPeak_L = fOldPeak_L / fallOff;
if (fNewPeak_R < fOldPeak_R) fNewPeak_R = fOldPeak_R / fallOff;
m_pLadspaFXLine[nFX]->setPeaks( fNewPeak_L, fNewPeak_R );
m_pLadspaFXLine[nFX]->setFxActive( pFX->isEnabled() );
m_pLadspaFXLine[nFX]->setVolume( pFX->getVolume() );
}
else {
m_pLadspaFXLine[nFX]->setName( "No plugin" );
m_pLadspaFXLine[nFX]->setFxActive( false );
m_pLadspaFXLine[nFX]->setVolume( 0.0 );
}
}
// ~LADSPA
#endif
}