void Drumkit::dump()
{
DEBUGLOG( "Drumkit dump" );
DEBUGLOG( " |- Path = " + __path );
DEBUGLOG( " |- Name = " + __name );
DEBUGLOG( " |- Author = " + __author );
DEBUGLOG( " |- Info = " + __info );
DEBUGLOG( " |- Instrument list" );
for ( int i=0; i<__instruments->size(); i++ ) {
Instrument* instrument = ( *__instruments )[i];
DEBUGLOG( QString( " |- (%1 of %2) Name = %3" )
.arg( i )
.arg( __instruments->size()-1 )
.arg( instrument->get_name() )
);
for (std::vector<InstrumentComponent*>::iterator it = instrument->get_components()->begin() ; it != instrument->get_components()->end(); ++it) {
InstrumentComponent* component = *it;
for ( int j=0; j<MAX_LAYERS; j++ ) {
InstrumentLayer* layer = component->get_layer( j );
if ( layer ) {
Sample* sample = layer->get_sample();
if ( sample ) {
DEBUGLOG( QString( " |- %1 [%2]" ).arg( sample->get_filepath() ).arg( sample->is_empty() ) );
} else {
DEBUGLOG( " |- NULL sample" );
}
}
}
}
}
}
void MainForm::functionDeleteInstrument(int instrument)
{
Hydrogen * H = Hydrogen::get_instance();
Instrument *pSelectedInstrument = H->getSong()->get_instrument_list()->get( instrument );
std::list< Note* > noteList;
Song* song = H->getSong();
PatternList *patList = song->get_pattern_list();
QString instrumentName = pSelectedInstrument->get_name();
QString drumkitName = H->getCurrentDrumkitname();
for ( int i = 0; i < patList->size(); i++ ) {
H2Core::Pattern *pPattern = song->get_pattern_list()->get(i);
const Pattern::notes_t* notes = pPattern->get_notes();
FOREACH_NOTE_CST_IT_BEGIN_END(notes,it) {
Note *pNote = it->second;
assert( pNote );
if ( pNote->get_instrument() == pSelectedInstrument ) {
pNote->set_pattern_idx( i );
noteList.push_back( pNote );
}
}
}
/// 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 );
}
}
/// 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;
}
// 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 );
}
void SoundLibraryPanel::updateDrumkitList()
{
QString currentSL = Hydrogen::get_instance()->getCurrentDrumkitname();
LocalFileMng mng;
__sound_library_tree->clear();
__system_drumkits_item = new QTreeWidgetItem( __sound_library_tree );
__system_drumkits_item->setText( 0, trUtf8( "System drumkits" ) );
__sound_library_tree->setItemExpanded( __system_drumkits_item, true );
__user_drumkits_item = new QTreeWidgetItem( __sound_library_tree );
__user_drumkits_item->setText( 0, trUtf8( "User drumkits" ) );
__sound_library_tree->setItemExpanded( __user_drumkits_item, true );
for (uint i = 0; i < __system_drumkit_info_list.size(); ++i ) {
delete __system_drumkit_info_list[i];
}
__system_drumkit_info_list.clear();
for (uint i = 0; i < __user_drumkit_info_list.size(); ++i ) {
delete __user_drumkit_info_list[i];
}
__user_drumkit_info_list.clear();
//User drumkit list
QStringList usr_dks = Filesystem::usr_drumkits_list();
for (int i = 0; i < usr_dks.size(); ++i) {
QString absPath = Filesystem::usr_drumkits_dir() + "/" + usr_dks[i];
Drumkit *pInfo = Drumkit::load( absPath );
if (pInfo) {
__user_drumkit_info_list.push_back( pInfo );
QTreeWidgetItem* pDrumkitItem = new QTreeWidgetItem( __user_drumkits_item );
pDrumkitItem->setText( 0, pInfo->get_name() );
if ( QString(pInfo->get_name() ) == currentSL ){
pDrumkitItem->setBackgroundColor( 0, QColor( 50, 50, 50) );
}
InstrumentList *pInstrList = pInfo->get_instruments();
for ( uint nInstr = 0; nInstr < pInstrList->size(); ++nInstr ) {
Instrument *pInstr = pInstrList->get( nInstr );
QTreeWidgetItem* pInstrumentItem = new QTreeWidgetItem( pDrumkitItem );
pInstrumentItem->setText( 0, QString( "[%1] " ).arg( nInstr + 1 ) + pInstr->get_name() );
pInstrumentItem->setToolTip( 0, pInstr->get_name() );
}
}
}
//System drumkit list
QStringList sys_dks = Filesystem::sys_drumkits_list();
for (int i = 0; i < sys_dks.size(); ++i) {
QString absPath = Filesystem::sys_drumkits_dir() + "/" + sys_dks[i];
Drumkit *pInfo = Drumkit::load( absPath );
if (pInfo) {
__system_drumkit_info_list.push_back( pInfo );
QTreeWidgetItem* pDrumkitItem = new QTreeWidgetItem( __system_drumkits_item );
pDrumkitItem->setText( 0, pInfo->get_name() );
if ( QString( pInfo->get_name() ) == currentSL ){
pDrumkitItem->setBackgroundColor( 0, QColor( 50, 50, 50) );
}
InstrumentList *pInstrList = pInfo->get_instruments();
for ( uint nInstr = 0; nInstr < pInstrList->size(); ++nInstr ) {
Instrument *pInstr = pInstrList->get( nInstr );
QTreeWidgetItem* pInstrumentItem = new QTreeWidgetItem( pDrumkitItem );
pInstrumentItem->setText( 0, QString( "[%1] " ).arg( nInstr + 1 ) + pInstr->get_name() );
pInstrumentItem->setToolTip( 0, pInstr->get_name() );
}
}
}
//Songlist
QStringList songs = Filesystem::songs_list();
if ( songs.size() > 0 ) {
__song_item = new QTreeWidgetItem( __sound_library_tree );
__song_item->setText( 0, trUtf8( "Songs" ) );
__song_item->setToolTip( 0, "double click to expand the list" );
__sound_library_tree->setItemExpanded( __song_item, __expand_songs_list );
for (uint i = 0; i < songs.size(); i++) {
QTreeWidgetItem* pSongItem = new QTreeWidgetItem( __song_item );
QString song = songs[i];
pSongItem->setText( 0 , song.left( song.indexOf(".")) );
pSongItem->setToolTip( 0, song );
}
}
//Pattern list
std::vector<QString> patternDirList = mng.getPatternDirList();
if ( patternDirList.size() > 0 ) {
__pattern_item = new QTreeWidgetItem( __sound_library_tree );
__pattern_item->setText( 0, trUtf8( "Patterns" ) );
__pattern_item->setToolTip( 0, "double click to expand the list" );
__sound_library_tree->setItemExpanded( __pattern_item, __expand_pattern_list );
//this is to push the mng.getPatternList in all patterns/drumkit dirs
for (uint i = 0; i < patternDirList.size(); ++i) {
QString absPath = patternDirList[i];
mng.getPatternList( absPath );
}
//this is the second step to push the mng.funktion
//SoundLibraryDatabase::create_instance();
SoundLibraryDatabase* db = SoundLibraryDatabase::get_instance();
soundLibraryInfoVector* allPatternDirList = db->getAllPatterns();
QStringList allCategoryNameList = db->getAllPatternCategories();
//now sorting via category
for (uint i = 0; i < allCategoryNameList.size(); ++i) {
QString categoryName = allCategoryNameList[i];
QTreeWidgetItem* pCategoryItem = new QTreeWidgetItem( __pattern_item );
pCategoryItem->setText( 0, categoryName );
soundLibraryInfoVector::iterator mapIterator;
for( mapIterator=allPatternDirList->begin(); mapIterator != allPatternDirList->end(); mapIterator++ )
{
QString patternCategory = (*mapIterator)->getCategory();
if ( patternCategory == categoryName || patternCategory.isEmpty() && categoryName == "No category" ){
QTreeWidgetItem* pPatternItem = new QTreeWidgetItem( pCategoryItem );
pPatternItem->setText( 0, (*mapIterator)->getName());
pPatternItem->setText( 1, (*mapIterator)->getPath() );
pPatternItem->setToolTip( 0, mng.getDrumkitNameForPattern( (*mapIterator)->getPath() ));
INFOLOG( "Path" + (*mapIterator)->getPath() );
}
}
}
}
}
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
}
void SampleEditor::on_PlayOrigPushButton_clicked()
{
if (PlayOrigPushButton->text() == "Stop" ){
testpTimer();
return;
}
const int selectedlayer = InstrumentEditorPanel::get_instance()->getSelectedLayer();
Song *pSong = Hydrogen::get_instance()->getSong();
Instrument *pInstr = pSong->get_instrument_list()->get( Hydrogen::get_instance()->getSelectedInstrumentNumber() );
/*
*preview_instrument deletes the last used preview instrument, therefore we have to construct a temporary
*instrument. Otherwise pInstr would be deleted if consumed by preview_instrument.
*/
Instrument *tmpInstrument = Instrument::load_instrument( pInstr->get_drumkit_name(), pInstr->get_name() );
Sample *pNewSample = Sample::load( pInstr->get_layer( selectedlayer )->get_sample()->get_filepath() );
if ( pNewSample ){
int length = ( ( pNewSample->get_frames() / pNewSample->get_sample_rate() + 1) * 100 );
AudioEngine::get_instance()->get_sampler()->preview_instrument( tmpInstrument );
AudioEngine::get_instance()->get_sampler()->preview_sample( pNewSample, length );
m_pslframes = pNewSample->get_frames();
}
m_pMainSampleWaveDisplay->paintLocatorEvent( StartFrameSpinBox->value() / m_divider + 24 , true);
m_pSampleAdjustView->setDetailSamplePosition( __loops.start_frame, m_pZoomfactor , 0);
m_pTimer->start(40); // update ruler at 25 fps
m_pRealtimeFrameEnd = Hydrogen::get_instance()->getRealtimeFrames() + m_pslframes;
PlayOrigPushButton->setText( QString( "Stop") );
}