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 ); }