void Mixer::soloClicked(MixerLine* ref)
{
Hydrogen *pEngine = Hydrogen::get_instance();
Song *pSong = pEngine->getSong();
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstruments = pInstrList->size();
int nLine = findMixerLineByRef(ref);
pEngine->setSelectedInstrumentNumber( nLine );
bool isSoloClicked = ref->isSoloClicked();
if (isSoloClicked) {
for ( int i = 0; i < nInstruments; ++i ) {
m_pMixerLine[i]->setSoloClicked( false );
m_pMixerLine[i]->setMuteClicked( true );
pInstrList->get( i )->set_muted( true );
}
m_pMixerLine[nLine]->setSoloClicked( true );
m_pMixerLine[nLine]->setMuteClicked( false );
pInstrList->get( nLine )->set_muted( false );
}
else {
for ( int i = 0; i < nInstruments; ++i ) {
m_pMixerLine[i]->setMuteClicked( false );
m_pMixerLine[i]->setSoloClicked( false );
pInstrList->get( i )->set_muted( false );
}
}
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
void Mixer::panChanged(MixerLine* ref) {
float panValue = ref->getPan();
float pan_L;
float pan_R;
if (panValue >= 0.5) {
pan_L = (1.0 - panValue) * 2;
pan_R = 1.0;
}
else {
pan_L = 1.0;
pan_R = panValue * 2;
}
int nLine = findMixerLineByRef(ref);
Hydrogen::get_instance()->setSelectedInstrumentNumber( nLine );
Hydrogen *pEngine = Hydrogen::get_instance();
Song *pSong = pEngine->getSong();
InstrumentList *pInstrList = pSong->get_instrument_list();
Instrument *pInstr = pInstrList->get(nLine);
pInstr->set_pan_l( pan_L );
pInstr->set_pan_r( pan_R );
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
void SampleEditor::openDisplays()
{
H2Core::Instrument *pInstrument = NULL;
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= static_cast<int>(pInstrList->size()) ) {
nInstr = -1;
}
if (nInstr == -1) {
pInstrument = NULL;
}
else {
pInstrument = pInstrList->get( nInstr );
//INFOLOG( "new instr: " + pInstrument->m_sName );
}
}
// wavedisplays
m_divider = m_pSampleFromFile->get_frames() / 574.0F;
m_pMainSampleWaveDisplay->updateDisplay( m_samplename );
m_pMainSampleWaveDisplay->move( 1, 1 );
m_pSampleAdjustView->updateDisplay( m_samplename );
m_pSampleAdjustView->move( 1, 1 );
m_pTargetSampleView->move( 1, 1 );
}
void CoreMidiDriver::handleQueueAllNoteOff()
{
if (cmH2Dst == NULL ) {
ERRORLOG( "cmH2Dst = NULL " );
return;
}
InstrumentList *instList = Hydrogen::get_instance()->getSong()->get_instrument_list();
unsigned int numInstruments = instList->size();
for (int index = 0; index < numInstruments; ++index) {
Instrument *curInst = instList->get(index);
int channel = curInst->get_midi_out_channel();
if (channel < 0) {
continue;
}
int key = curInst->get_midi_out_note();
MIDIPacketList packetList;
packetList.numPackets = 1;
packetList.packet->timeStamp = 0;
packetList.packet->length = 3;
packetList.packet->data[0] = 0x80 | channel;
packetList.packet->data[1] = key;
packetList.packet->data[2] = 0;
MIDISend(h2OutputRef, cmH2Dst, &packetList);
}
}
void InstrumentLine::muteClicked()
{
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *pInstr = instrList->get(m_nInstrumentNumber);
pInstr->set_muted( !pInstr->is_muted());
}
void Mixer::soloClicked(MixerLine* ref)
{
Hydrogen *pEngine = Hydrogen::get_instance();
CoreActionController* pController = pEngine->getCoreActionController();
Song *pSong = pEngine->getSong();
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstruments = pInstrList->size();
int nLine = findMixerLineByRef(ref);
pController->setStripIsSoloed( nLine, ref->isSoloClicked() );
for ( int i = 0; i < nInstruments; ++i ) {
m_pMixerLine[i]->setSoloClicked( pInstrList->get(i)->is_soloed() );
m_pMixerLine[i]->setMuteClicked( pInstrList->get(i)->is_muted() );
}
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
void Mixer::unmuteAll( int selectedInstrument )
{
Hydrogen *pEngine = Hydrogen::get_instance();
Song *pSong = pEngine->getSong();
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstruments = pInstrList->size();
for ( int i = 0; i < nInstruments; ++i ) {
m_pMixerLine[i]->setMuteClicked( false );
m_pMixerLine[i]->setSoloClicked( false );
pInstrList->get( i )->set_muted( false );
}
// select first instrument after unmute all
Hydrogen::get_instance()->setSelectedInstrumentNumber(selectedInstrument);
}
void Mixer::knobChanged(MixerLine* ref, int nKnob) {
int nLine = findMixerLineByRef(ref);
Hydrogen::get_instance()->setSelectedInstrumentNumber( nLine );
Hydrogen *pEngine = Hydrogen::get_instance();
Song *pSong = pEngine->getSong();
InstrumentList *pInstrList = pSong->get_instrument_list();
Instrument *pInstr = pInstrList->get(nLine);
pInstr->set_fx_level( ref->getFXLevel(nKnob), nKnob );
QString sInfo = trUtf8( "Set FX %1 level ").arg( nKnob + 1 );
( HydrogenApp::get_instance() )->setStatusBarMessage( sInfo+ QString( "[%1]" ).arg( ref->getFXLevel(nKnob), 0, 'f', 2 ), 2000 );
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
void InstrumentEditor::rubberbandbpmchangeEvent()
{
if( !Preferences::get_instance()->getRubberBandBatchMode() /*&& Preferences::get_instance()->__usetimeline */){
//we return also if time-line is activated. this wont work.
// INFOLOG( "Tempo change: Recomputing rubberband samples is disabled" );
return;
}
// INFOLOG( "Tempo change: Recomputing rubberband samples." );
Hydrogen *pEngine = Hydrogen::get_instance();
Song *song = pEngine->getSong();
assert(song);
if(song){
InstrumentList *songInstrList = song->get_instrument_list();
assert(songInstrList);
for ( unsigned nInstr = 0; nInstr < songInstrList->size(); ++nInstr ) {
Instrument *pInstr = songInstrList->get( nInstr );
assert( pInstr );
if ( pInstr ){
for ( int nLayer = 0; nLayer < MAX_LAYERS; nLayer++ ) {
InstrumentLayer *pLayer = pInstr->get_layer( nLayer );
if ( pLayer ) {
Sample *pSample = pLayer->get_sample();
if ( pSample ) {
if( pSample->get_rubberband().use ) {
//INFOLOG( QString("Instrument %1 Layer %2" ).arg(nInstr).arg(nLayer));
Sample *newSample = Sample::load(
pSample->get_filepath(),
pSample->get_loops(),
pSample->get_rubberband(),
*pSample->get_velocity_envelope(),
*pSample->get_pan_envelope()
);
if( !newSample ){
continue;
}
delete pSample;
// insert new sample from newInstrument
AudioEngine::get_instance()->lock( RIGHT_HERE );
pLayer->set_sample( newSample );
AudioEngine::get_instance()->unlock();
}
}
}
}
}
}
}
}
void Mixer::muteClicked(MixerLine* ref)
{
int nLine = findMixerLineByRef(ref);
Hydrogen::get_instance()->setSelectedInstrumentNumber( nLine );
bool isMuteClicked = ref->isMuteClicked();
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *pInstr = instrList->get(nLine);
pInstr->set_muted( isMuteClicked);
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
void Mixer::volumeChanged(MixerLine* ref)
{
int nLine = findMixerLineByRef(ref);
Hydrogen::get_instance()->setSelectedInstrumentNumber( nLine );
Hydrogen *pEngine = Hydrogen::get_instance();
Song *pSong = pEngine->getSong();
InstrumentList *instrList = pSong->get_instrument_list();
Instrument *pInstr = instrList->get(nLine);
pInstr->set_volume( ref->getVolume() );
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
/// Play sample button, right-clicked (note off)
void Mixer::noteOffClicked( MixerLine* ref )
{
int nLine = findMixerLineByRef( ref );
Hydrogen::get_instance()->setSelectedInstrumentNumber( nLine );
Hydrogen *pEngine = Hydrogen::get_instance();
Song *pSong = pEngine->getSong();
InstrumentList *instrList = pSong->get_instrument_list();
const float fPitch = 0.0f;
Note *pNote = new Note( instrList->get( nLine ), 0, 1.0, 0.5, 0.5, -1, fPitch );
AudioEngine::get_instance()->get_sampler()->note_off(pNote);
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
void JackAudioDriver::makeTrackOutputs( Song* pSong )
{
// Only execute the body of this function if a per-track
// creation of the output ports is desired.
if( Preferences::get_instance()->m_bJackTrackOuts == false )
return;
InstrumentList * pInstruments = pSong->get_instrument_list();
Instrument * pInstr;
int nInstruments = ( int ) pInstruments->size();
// create dedicated channel output ports
WARNINGLOG( QString( "Creating / renaming %1 ports" ).arg( nInstruments ) );
int nTrackCount = 0;
// Resets the `track_map' matrix.
for( int i = 0 ; i < MAX_INSTRUMENTS ; i++ ){
for ( int j = 0 ; j < MAX_COMPONENTS ; j++ ){
track_map[i][j] = 0;
}
}
// Creates a new output track or reassigns an existing one for
// each component of each instrument and stores the result in
// the `track_map'.
for ( int n = 0; n <= nInstruments - 1; n++ ) {
pInstr = pInstruments->get( n );
for (std::vector<InstrumentComponent*>::iterator it = pInstr->get_components()->begin() ; it != pInstr->get_components()->end(); ++it) {
InstrumentComponent* pCompo = *it;
setTrackOutput( nTrackCount, pInstr, pCompo, pSong);
track_map[pInstr->get_id()][pCompo->get_drumkit_componentID()] = nTrackCount;
nTrackCount++;
}
}
// clean up unused ports
jack_port_t *p_L, *p_R;
for ( int n = nTrackCount; n < track_port_count; n++ ) {
p_L = track_output_ports_L[n];
p_R = track_output_ports_R[n];
track_output_ports_L[n] = 0;
jack_port_unregister( m_pClient, p_L );
track_output_ports_R[n] = 0;
jack_port_unregister( m_pClient, p_R );
}
track_port_count = nTrackCount;
}
/**
* Make sure the number of track outputs match the instruments in @a song , and name the ports.
*/
void JackOutput::makeTrackOutputs( Song * song )
{
/// Disable Track Outputs
if( Preferences::get_instance()->m_bJackTrackOuts == false )
return;
///
InstrumentList * instruments = song->get_instrument_list();
Instrument * instr;
int nInstruments = ( int )instruments->size();
// create dedicated channel output ports
WARNINGLOG( QString( "Creating / renaming %1 ports" ).arg( nInstruments ) );
int p_trackCount = 0;
for( int i = 0 ; i < MAX_INSTRUMENTS ; i++ ){
for ( int j = 0 ; j < MAX_COMPONENTS ; j++ ){
track_map[i][j] = 0;
}
}
for ( int n = nInstruments - 1; n >= 0; n-- ) {
instr = instruments->get( n );
for (std::vector<InstrumentComponent*>::iterator it = instr->get_components()->begin() ; it != instr->get_components()->end(); ++it) {
InstrumentComponent* pCompo = *it;
setTrackOutput( p_trackCount, instr , pCompo, song);
track_map[instr->get_id()][pCompo->get_drumkit_componentID()] = p_trackCount;
p_trackCount++;
}
}
// clean up unused ports
jack_port_t *p_L, *p_R;
for ( int n = p_trackCount; n < track_port_count; n++ ) {
p_L = track_output_ports_L[n];
p_R = track_output_ports_R[n];
track_output_ports_L[n] = 0;
jack_port_unregister( client, p_L );
track_output_ports_R[n] = 0;
jack_port_unregister( client, p_R );
}
track_port_count = p_trackCount;
}
void SampleEditor::createNewLayer()
{
if ( !m_pSampleEditorStatus ){
Sample *editSample = Sample::load( m_samplename, __loops, __rubberband, *m_pTargetSampleView->get_velocity(), *m_pTargetSampleView->get_pan() );
if( editSample == NULL ){
return;
}
AudioEngine::get_instance()->lock( RIGHT_HERE );
H2Core::Instrument *pInstrument = NULL;
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= static_cast<int>(pInstrList->size()) ) {
nInstr = -1;
}
if (nInstr == -1) {
pInstrument = NULL;
}
else {
pInstrument = pInstrList->get( nInstr );
}
}
H2Core::InstrumentLayer *pLayer = pInstrument->get_layer( m_pSelectedLayer );
Sample *oldSample = pLayer->get_sample();
delete oldSample;
// insert new sample from newInstrument
pLayer->set_sample( editSample );
AudioEngine::get_instance()->unlock();
m_pTargetSampleView->updateDisplay( pLayer );
}
}
bool setCutoff( int instrumentNumber, int value )
{
//helper function to set cutOff levels
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *instr = instrList->get( instrumentNumber );
if ( instr == NULL) return false;
if( value != 0 ){
instr->set_filter_cutoff( (float) (value / 127.0 ) );
} else {
instr->set_filter_cutoff( 0 );
}
Hydrogen::get_instance()->setSelectedInstrumentNumber( instrList->index(instr) );
return true;
}
bool setInstrumentPitch( int instrumentNumber, int value )
{
//helper function to set cutOff levels
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *instr = instrList->get( instrumentNumber );
if ( instr == NULL) return false;
if( value < 63 ){
instr->set_instrument_pitch( (float) ((value-62) / 62.0 * MAX_INSTRUMENT_PITCH ) );
} else if ( value > 64 ) {
instr->set_instrument_pitch( (float) ((value-65) / 62.0 * MAX_INSTRUMENT_PITCH ) );
} else {
instr->set_instrument_pitch( 0 );
}
Hydrogen::get_instance()->setSelectedInstrumentNumber( instrList->index(instr) );
return true;
}
void JackMidiDriver::handleQueueAllNoteOff()
{
InstrumentList *instList = Hydrogen::get_instance()->getSong()->get_instrument_list();
Instrument *curInst;
unsigned int numInstruments = instList->size();
unsigned int i;
int channel;
int key;
for (i = 0; i < numInstruments; i++) {
curInst = instList->get(i);
channel = curInst->get_midi_out_channel();
if (channel < 0 || channel > 15)
continue;
key = curInst->get_midi_out_note();
if (key < 0 || key > 127)
continue;
handleQueueNoteOff(channel, key, 0);
}
}
bool setAbsoluteFXLevel( int nLine, int fx_channel , int fx_param)
{
//helper function to set fx levels
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 false;
if( fx_param != 0 ){
instr->set_fx_level( ( (float) (fx_param / 127.0 ) ), fx_channel );
} else {
instr->set_fx_level( 0 , fx_channel );
}
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
return true;
}
void LayerPreview::selectedInstrumentChangedEvent()
{
AudioEngine::get_instance()->lock( RIGHT_HERE );
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= (int)pInstrList->size() ) {
nInstr = -1;
}
if (nInstr == -1) {
m_pInstrument = NULL;
}
else {
m_pInstrument = pInstrList->get( nInstr );
}
}
else {
m_pInstrument = NULL;
}
AudioEngine::get_instance()->unlock();
// select the last valid layer
if ( m_pInstrument ) {
for (int i = MAX_LAYERS - 1; i >= 0; i-- ) {
if ( m_pInstrument->get_layer( i ) ) {
m_nSelectedLayer = i;
break;
}
}
}
else {
m_nSelectedLayer = 0;
}
update();
}
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 InstrumentEditor::compoChangeAddDelete(QAction* pAction)
{
QString sSelectedAction = pAction->text();
Hydrogen * pEngine = Hydrogen::get_instance();
if( sSelectedAction.compare("add") == 0 ) {
if ( m_pInstrument ) {
bool bIsOkPressed;
QString sNewName = QInputDialog::getText( this, "Hydrogen", trUtf8( "Component name" ), QLineEdit::Normal, "New Component", &bIsOkPressed );
if ( bIsOkPressed ) {
DrumkitComponent* pDrumkitComponent = new DrumkitComponent( findFreeDrumkitComponentId(), sNewName );
pEngine->getSong()->get_components()->push_back( pDrumkitComponent );
//InstrumentComponent* instrument_component = new InstrumentComponent( dm_component->get_id() );
//instrument_component->set_gain( 1.0f );
//m_pInstrument->get_components()->push_back( instrument_component );
m_nSelectedComponent = pDrumkitComponent->get_id();
m_pLayerPreview->set_selected_component( pDrumkitComponent->get_id() );
selectedInstrumentChangedEvent();
// this will force an update...
EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
#ifdef H2CORE_HAVE_JACK
pEngine->renameJackPorts(pEngine->getSong());
#endif
}
else {
// user entered nothing or pressed Cancel
}
}
}
else if( sSelectedAction.compare("delete") == 0 ) {
std::vector<DrumkitComponent*>* pDrumkitComponents = pEngine->getSong()->get_components();
if(pDrumkitComponents->size() == 1){
return;
}
DrumkitComponent* pDrumkitComponent = pEngine->getSong()->get_component( m_nSelectedComponent );
InstrumentList* pInstruments = pEngine->getSong()->get_instrument_list();
for ( int n = ( int )pInstruments->size() - 1; n >= 0; n-- ) {
Instrument* pInstrument = pInstruments->get( n );
for( int o = 0 ; o < pInstrument->get_components()->size() ; o++ ) {
InstrumentComponent* pInstrumentComponent = pInstrument->get_components()->at( o );
if( pInstrumentComponent->get_drumkit_componentID() == pDrumkitComponent->get_id() ) {
for( int nLayer = 0; nLayer < MAX_LAYERS; nLayer++ ) {
InstrumentLayer* pLayer = pInstrumentComponent->get_layer( nLayer );
if( pLayer )
delete pLayer;
}
pInstrument->get_components()->erase( pInstrument->get_components()->begin() + o );;
break;
}
}
}
for ( int n = 0 ; n < pDrumkitComponents->size() ; n++ ) {
DrumkitComponent* pTmpDrumkitComponent = pDrumkitComponents->at( n );
if( pTmpDrumkitComponent->get_id() == pDrumkitComponent->get_id() ) {
pDrumkitComponents->erase( pDrumkitComponents->begin() + n );
break;
}
}
m_nSelectedComponent = pDrumkitComponents->front()->get_id();
selectedInstrumentChangedEvent();
// this will force an update...
EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
}
else if( sSelectedAction.compare("rename") == 0 ) {
labelCompoClicked( NULL );
}
else {
m_nSelectedComponent = -1;
std::vector<DrumkitComponent*>* pDrumkitComponents = pEngine->getSong()->get_components();
for (std::vector<DrumkitComponent*>::iterator it = pDrumkitComponents->begin() ; it != pDrumkitComponents->end(); ++it) {
DrumkitComponent* pDrumkitComponent = *it;
if( pDrumkitComponent->get_name().compare( sSelectedAction ) == 0) {
m_nSelectedComponent = pDrumkitComponent->get_id();
m_pCompoNameLbl->setText( pDrumkitComponent->get_name() );
break;
}
}
if( m_pInstrument && !m_pInstrument->get_component(m_nSelectedComponent)) {
INFOLOG("Component needs to be added");
InstrumentComponent* pInstrComponent = new InstrumentComponent( m_nSelectedComponent );
pInstrComponent->set_gain( 1.0f );
m_pInstrument->get_components()->push_back( pInstrComponent );
#ifdef H2CORE_HAVE_JACK
pEngine->renameJackPorts(pEngine->getSong());
#endif
}
m_pLayerPreview->set_selected_component(m_nSelectedComponent);
selectedInstrumentChangedEvent();
// this will force an update...
EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 );
}
}
void InstrumentEditor::selectedInstrumentChangedEvent()
{
AudioEngine::get_instance()->lock( RIGHT_HERE );
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= (int)pInstrList->size() ) {
nInstr = -1;
}
if (nInstr == -1) {
m_pInstrument = NULL;
}
else {
m_pInstrument = pInstrList->get( nInstr );
//INFOLOG( "new instr: " + m_pInstrument->m_sName );
}
}
else {
m_pInstrument = NULL;
}
AudioEngine::get_instance()->unlock();
// update layer list
if (m_pInstrument) {
m_pNameLbl->setText( m_pInstrument->get_name() );
// ADSR
m_pAttackRotary->setValue( sqrtf(m_pInstrument->get_adsr()->get_attack() / 100000.0) );
m_pDecayRotary->setValue( sqrtf(m_pInstrument->get_adsr()->get_decay() / 100000.0) );
m_pSustainRotary->setValue( m_pInstrument->get_adsr()->get_sustain() );
float fTmp = m_pInstrument->get_adsr()->get_release() - 256.0;
if( fTmp < 0.0 ) {
fTmp = 0.0;
}
m_pReleaseRotary->setValue( sqrtf(fTmp / 100000.0) );
//~ ADSR
// filter
m_pFilterBypassBtn->setPressed( !m_pInstrument->is_filter_active());
m_pCutoffRotary->setValue( m_pInstrument->get_filter_cutoff());
m_pResonanceRotary->setValue( m_pInstrument->get_filter_resonance());
//~ filter
// random pitch
m_pRandomPitchRotary->setValue( m_pInstrument->get_random_pitch_factor());
//Stop Note
m_pIsStopNoteCheckBox->setChecked( m_pInstrument->is_stop_notes() );
// instr gain
char tmp[20];
sprintf( tmp, "%#.2f", m_pInstrument->get_gain());
m_pInstrumentGainLCD->setText( tmp );
m_pInstrumentGain->setValue( m_pInstrument->get_gain()/ 5.0 );
// instr mute group
QString sMuteGroup = QString("%1").arg( m_pInstrument->get_mute_group() );
if (m_pInstrument->get_mute_group() == -1 ) {
sMuteGroup = "Off";
}
m_pMuteGroupLCD->setText( sMuteGroup );
// midi out
QString sMidiOutChannel = QString("%1").arg( m_pInstrument->get_midi_out_channel()+1);
if (m_pInstrument->get_midi_out_channel() == -1 ) {
sMidiOutChannel = "Off";
}
m_pMidiOutChannelLCD->setText( sMidiOutChannel );
//Convert note id into notation
{
int note = m_pInstrument->get_midi_out_note();
int octave = (note / 12) - 2;
const char *noteStrs[12] = { "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" };
QString sMidiOutNote = QString(noteStrs[note % 12]) + QString::number(octave);
m_pMidiOutNoteLCD->setText( sMidiOutNote );
}
// select the last valid layer
for (int i = MAX_LAYERS - 1; i >= 0; i-- ) {
if ( m_pInstrument->get_layer( i ) ) {
m_nSelectedLayer = i;
break;
}
}
m_pWaveDisplay->updateDisplay( m_pInstrument->get_layer( m_nSelectedLayer ) );
}
else {
m_pNameLbl->setText( QString( "NULL Instrument..." ) );
m_pWaveDisplay->updateDisplay( NULL );
m_nSelectedLayer = 0;
}
selectLayer( m_nSelectedLayer );
}
void SampleEditor::getAllFrameInfos()
{
H2Core::Instrument *pInstrument = NULL;
Sample* pSample = NULL;
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= static_cast<int>(pInstrList->size()) ) {
nInstr = -1;
}
if (nInstr == -1) {
pInstrument = NULL;
}
else {
pInstrument = pInstrList->get( nInstr );
//INFOLOG( "new instr: " + pInstrument->m_sName );
}
}
H2Core::InstrumentLayer *pLayer = pInstrument->get_layer( m_pSelectedLayer );
if ( pLayer ) {
pSample = pLayer->get_sample();
}
//this values are needed if we restore a sample from from disk if a new song with sample changes will load
m_sample_is_modified = pSample->get_is_modified();
m_pSamplerate = pSample->get_sample_rate();
__loops = pSample->get_loops();
__rubberband = pSample->get_rubberband();
if ( pSample->get_velocity_envelope()->size()==0 ) {
m_pTargetSampleView->get_velocity()->clear();
m_pTargetSampleView->get_velocity()->push_back( Sample::EnvelopePoint( 0, 0 ) );
m_pTargetSampleView->get_velocity()->push_back( Sample::EnvelopePoint( m_pTargetSampleView->width(), 0 ) );
} else {
*m_pTargetSampleView->get_velocity() = *pSample->get_velocity_envelope();
}
if ( pSample->get_pan_envelope()->size()==0 ) {
m_pTargetSampleView->get_pan()->clear();
m_pTargetSampleView->get_pan()->push_back( Sample::EnvelopePoint( 0, m_pTargetSampleView->height()/2 ) );
m_pTargetSampleView->get_pan()->push_back( Sample::EnvelopePoint( m_pTargetSampleView->width(), m_pTargetSampleView->height()/2 ) );
} else {
*m_pTargetSampleView->get_pan() = *pSample->get_pan_envelope();
}
if (m_sample_is_modified) {
__loops.end_frame = pSample->get_loops().end_frame;
if ( __loops.mode == Sample::Loops::FORWARD )
ProcessingTypeComboBox->setCurrentIndex ( 0 );
if ( __loops.mode == Sample::Loops::REVERSE )
ProcessingTypeComboBox->setCurrentIndex ( 1 );
if ( __loops.mode == Sample::Loops::PINGPONG )
ProcessingTypeComboBox->setCurrentIndex ( 2 );
StartFrameSpinBox->setValue( __loops.start_frame );
LoopFrameSpinBox->setValue( __loops.loop_frame );
EndFrameSpinBox->setValue( __loops.end_frame );
LoopCountSpinBox->setValue( __loops.count );
m_pMainSampleWaveDisplay->m_pStartFramePosition = __loops.start_frame / m_divider + 25 ;
m_pMainSampleWaveDisplay->updateDisplayPointer();
m_pMainSampleWaveDisplay->m_pLoopFramePosition = __loops.loop_frame / m_divider + 25 ;
m_pMainSampleWaveDisplay->updateDisplayPointer();
m_pMainSampleWaveDisplay->m_pEndFramePosition = __loops.end_frame / m_divider + 25 ;
m_pMainSampleWaveDisplay->updateDisplayPointer();
if( !__rubberband.use )rubberComboBox->setCurrentIndex( 0 );
rubberbandCsettingscomboBox->setCurrentIndex( __rubberband.c_settings );
if( !__rubberband.use )rubberbandCsettingscomboBox->setCurrentIndex( 4 );
pitchdoubleSpinBox->setValue( __rubberband.pitch );
if( !__rubberband.use ) pitchdoubleSpinBox->setValue( 0.0 );
if( __rubberband.divider == 1.0/64.0) rubberComboBox->setCurrentIndex( 1 );
else if( __rubberband.divider == 1.0/32.0) rubberComboBox->setCurrentIndex( 2 );
else if( __rubberband.divider == 1.0/16.0) rubberComboBox->setCurrentIndex( 3 );
else if( __rubberband.divider == 1.0/8.0) rubberComboBox->setCurrentIndex( 4 );
else if( __rubberband.divider == 1.0/4.0) rubberComboBox->setCurrentIndex( 5 );
else if( __rubberband.divider == 1.0/2.0) rubberComboBox->setCurrentIndex( 6 );
else if( __rubberband.use && ( __rubberband.divider >= 1.0 ) ) rubberComboBox->setCurrentIndex( (int)(__rubberband.divider + 6) );
setSamplelengthFrames();
checkRatioSettings();
}
m_pTargetSampleView->updateDisplay( pLayer );
connect( StartFrameSpinBox, SIGNAL( valueChanged( int ) ), this, SLOT( valueChangedStartFrameSpinBox(int) ) );
connect( LoopFrameSpinBox, SIGNAL( valueChanged( int ) ), this, SLOT( valueChangedLoopFrameSpinBox(int) ) );
connect( EndFrameSpinBox, SIGNAL( valueChanged( int ) ), this, SLOT( valueChangedEndFrameSpinBox(int) ) );
connect( LoopCountSpinBox, SIGNAL( valueChanged( int ) ), this, SLOT( valueChangedLoopCountSpinBox( int ) ) );
connect( ProcessingTypeComboBox, SIGNAL( currentIndexChanged ( const QString ) ), this, SLOT( valueChangedProcessingTypeComboBox( const QString ) ) );
connect( rubberComboBox, SIGNAL( currentIndexChanged ( const QString ) ), this, SLOT( valueChangedrubberComboBox( const QString ) ) );
connect( rubberbandCsettingscomboBox, SIGNAL( currentIndexChanged ( const QString ) ), this, SLOT( valueChangedrubberbandCsettingscomboBox( const QString ) ) );
connect( pitchdoubleSpinBox, SIGNAL ( valueChanged( double ) ), this, SLOT( valueChangedpitchdoubleSpinBox( double ) ) );
}
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
}
/**
* 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;
}
void InstrumentEditor::loadLayer()
{
static QString lastUsedDir = QDir::homePath();
Hydrogen *engine = Hydrogen::get_instance();
AudioFileBrowser *fb = new AudioFileBrowser( NULL );
QStringList filename;
filename << "false" << "false" << "";
if (fb->exec() == QDialog::Accepted) {
filename = fb->selectedFile();
}
delete fb;
if ( filename[2].isEmpty() ) return;
bool fnc = false;
if ( filename[0] == "true" ){
fnc = true;
}
//use auto velocity if we want to work with multiple filenames
if ( filename.size() > 3) filename[1] = "true";
int selectedLayer = m_nSelectedLayer;
int firstSelection = selectedLayer;
if (filename.size() > 2) {
for(int i=2;i < filename.size();++i)
{
selectedLayer = m_nSelectedLayer + i - 2;
if( ( i-2 >= MAX_LAYERS ) || ( selectedLayer + 1 > MAX_LAYERS ) ) break;
Sample *newSample = Sample::load( filename[i] );
H2Core::Instrument *pInstr = NULL;
AudioEngine::get_instance()->lock( RIGHT_HERE );
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
pInstr = instrList->get( engine->getSelectedInstrumentNumber() );
/*
if we're using multiple layers, we start inserting the first layer
at m_nSelectedLayer and the next layer at m_nSelectedLayer+1
*/
H2Core::InstrumentLayer *pLayer = pInstr->get_layer( selectedLayer );
if (pLayer != NULL) {
// delete old sample
Sample *oldSample = pLayer->get_sample();
delete oldSample;
// insert new sample from newInstrument
pLayer->set_sample( newSample );
}
else {
pLayer = new H2Core::InstrumentLayer(newSample);
pInstr->set_layer( pLayer, selectedLayer );
}
if ( fnc ){
QString newFilename = filename[i].section( '/', -1 );
newFilename.replace( "." + newFilename.section( '.', -1 ), "");
m_pInstrument->set_name( newFilename );
}
//set automatic velocity
if ( filename[1] == "true" ){
setAutoVelocity();
}
//pInstr->set_drumkit_name( "" ); // external sample, no drumkit info
AudioEngine::get_instance()->unlock();
}
}
selectedInstrumentChangedEvent(); // update all
selectLayer( firstSelection );
m_pLayerPreview->updateAll();
}
void InstrumentEditor::selectedInstrumentChangedEvent()
{
AudioEngine::get_instance()->lock( RIGHT_HERE );
Song *pSong = Hydrogen::get_instance()->getSong();
if (pSong != NULL) {
InstrumentList *pInstrList = pSong->get_instrument_list();
int nInstr = Hydrogen::get_instance()->getSelectedInstrumentNumber();
if ( nInstr >= (int)pInstrList->size() ) {
nInstr = -1;
}
if (nInstr == -1) {
m_pInstrument = NULL;
}
else {
m_pInstrument = pInstrList->get( nInstr );
//INFOLOG( "new instr: " + m_pInstrument->m_sName );
}
}
else {
m_pInstrument = NULL;
}
AudioEngine::get_instance()->unlock();
// update layer list
if (m_pInstrument) {
m_pNameLbl->setText( m_pInstrument->get_name() );
// ADSR
m_pAttackRotary->setValue( sqrtf(m_pInstrument->get_adsr()->get_attack() / 100000.0) );
m_pDecayRotary->setValue( sqrtf(m_pInstrument->get_adsr()->get_decay() / 100000.0) );
m_pSustainRotary->setValue( m_pInstrument->get_adsr()->get_sustain() );
float fTmp = m_pInstrument->get_adsr()->get_release() - 256.0;
if( fTmp < 0.0 ) {
fTmp = 0.0;
}
m_pReleaseRotary->setValue( sqrtf(fTmp / 100000.0) );
//~ ADSR
// filter
m_pFilterBypassBtn->setPressed( !m_pInstrument->is_filter_active());
m_pCutoffRotary->setValue( m_pInstrument->get_filter_cutoff());
m_pResonanceRotary->setValue( m_pInstrument->get_filter_resonance());
//~ filter
// random pitch
m_pRandomPitchRotary->setValue( m_pInstrument->get_random_pitch_factor());
//Stop Note
m_pIsStopNoteCheckBox->setChecked( m_pInstrument->is_stop_notes() );
// instr gain
char tmp[20];
sprintf( tmp, "%#.2f", m_pInstrument->get_gain());
m_pInstrumentGainLCD->setText( tmp );
m_pInstrumentGain->setValue( m_pInstrument->get_gain()/ 5.0 );
// instr mute group
QString sMuteGroup = QString("%1").arg( m_pInstrument->get_mute_group() );
if (m_pInstrument->get_mute_group() == -1 ) {
sMuteGroup = "Off";
}
m_pMuteGroupLCD->setText( sMuteGroup );
// midi out
QString sMidiOutChannel = QString("%1").arg( m_pInstrument->get_midi_out_channel()+1);
if (m_pInstrument->get_midi_out_channel() == -1 ) {
sMidiOutChannel = "Off";
}
m_pMidiOutChannelLCD->setText( sMidiOutChannel );
// hihat
m_pIsHihat->setChecked( m_pInstrument->is_hihat() );
QString sHiHatMinRange = QString("%1").arg( m_pInstrument->get_lower_cc() );
m_pHihatMinRangeLCD->setText( sHiHatMinRange );
QString sHiHatMaxRange = QString("%1").arg( m_pInstrument->get_higher_cc() );
m_pHihatMaxRangeLCD->setText( sHiHatMaxRange );
//Convert note id into notation
{
int note = m_pInstrument->get_midi_out_note();
int octave = (note / 12) - 2;
const char *noteStrs[12] = { "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" };
QString sMidiOutNote = QString(noteStrs[note % 12]) + QString::number(octave);
m_pMidiOutNoteLCD->setText( sMidiOutNote );
}
itemsCompo.clear();
std::vector<DrumkitComponent*>* compoList = Hydrogen::get_instance()->getSong()->get_components();
for (std::vector<DrumkitComponent*>::iterator it = compoList->begin() ; it != compoList->end(); ++it) {
DrumkitComponent* p_compo = *it;
if( !itemsCompo.contains( p_compo->get_name() ) )
itemsCompo.append( p_compo->get_name() );
}
itemsCompo.append("--sep--");
itemsCompo.append("add");
itemsCompo.append("delete");
itemsCompo.append("rename");
update();
DrumkitComponent* p_tmpCompo = Hydrogen::get_instance()->getSong()->get_component( m_nSelectedComponent );
assert(p_tmpCompo);
m_pCompoNameLbl->setText( p_tmpCompo->get_name() );
if(m_nSelectedLayer >= 0){
InstrumentComponent* component = m_pInstrument->get_component( m_nSelectedComponent );
if(component) {
char tmp[20];
sprintf( tmp, "%#.2f", component->get_gain());
m_pCompoGainLCD->setText( tmp );
m_pCompoGainRotary->setValue( component->get_gain() / 5.0 );
InstrumentLayer* p_layer = component->get_layer( m_nSelectedLayer );
if(p_layer) {
m_pWaveDisplay->updateDisplay( p_layer );
}
else {
m_pWaveDisplay->updateDisplay( NULL );
}
}
else {
m_pWaveDisplay->updateDisplay( NULL );
}
}
else{
m_pWaveDisplay->updateDisplay( NULL );
}
}
else {
m_pNameLbl->setText( QString( "NULL Instrument..." ) );
m_pWaveDisplay->updateDisplay( NULL );
m_nSelectedLayer = 0;
}
selectLayer( m_nSelectedLayer );
}
