DeviceId Studio::getSpareDeviceId(InstrumentId &baseInstrumentId) { InstrumentId highestMidiInstrumentId = MidiInstrumentBase; bool foundInstrument = false; std::set<DeviceId> ids; DeviceListIterator it; for (it = m_devices.begin(); it != m_devices.end(); it++) { ids.insert((*it)->getId()); if ((*it)->getType() == Device::Midi) { InstrumentList il = (*it)->getAllInstruments(); for (size_t i = 0; i < il.size(); ++i) { if (il[i]->getId() > highestMidiInstrumentId) { highestMidiInstrumentId = il[i]->getId(); foundInstrument = true; } } } } if (!foundInstrument) { baseInstrumentId = MidiInstrumentBase; } else { baseInstrumentId = ((highestMidiInstrumentId / 128) + 1) * 128; } DeviceId id = 0; while (ids.find(id) != ids.end()) ++id; return id; }
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 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 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 ModifyDeviceCommand::unexecute() { Device *device = m_studio->getDevice(m_device); if (!device) { std::cerr << "ERROR: ModifyDeviceCommand::unexecute(): no such device as " << m_device << std::endl; return; } MidiDevice *midiDevice = dynamic_cast<MidiDevice *>(device); if (!midiDevice) { std::cerr << "ERROR: ModifyDeviceCommand::unexecute(): device " << m_device << " is not a MIDI device" << std::endl; return; } if (m_rename) midiDevice->setName(m_oldName); midiDevice->replaceBankList(m_oldBankList); midiDevice->replaceProgramList(m_oldProgramList); midiDevice->replaceControlParameters(m_oldControlList); midiDevice->replaceKeyMappingList(m_oldKeyMappingList); midiDevice->setLibrarian(m_oldLibrarianName, m_oldLibrarianEmail); if (m_changeVariation) midiDevice->setVariationType(m_oldVariationType); InstrumentList instruments = midiDevice->getAllInstruments(); for (size_t i = 0; i < instruments.size(); ++i) { instruments[i]->setProgram(m_oldInstrumentPrograms[i]); } // ??? Instead of this kludge, we should be calling a Studio::hasChanged() // which would then notify all observers (e.g. MIPP) who, in turn, // would update themselves. RosegardenMainWindow::self()->uiUpdateKludge(); }
MidiDevice::MidiDevice(const MidiDevice &dev) : Device(dev.getId(), dev.getName(), dev.getType()), Controllable(), m_programList(dev.m_programList), m_bankList(dev.m_bankList), m_controlList(dev.m_controlList), m_keyMappingList(dev.m_keyMappingList), m_metronome(0), m_direction(dev.getDirection()), m_variationType(dev.getVariationType()), m_librarian(dev.getLibrarian()), m_allocator(new AllocateChannels(ChannelSetup::MIDI)) { // Create and assign a metronome if required // if (dev.getMetronome()) { m_metronome = new MidiMetronome(*dev.getMetronome()); } // Copy the instruments // InstrumentList insList = dev.getAllInstruments(); InstrumentList::iterator iIt = insList.begin(); for (; iIt != insList.end(); ++iIt) { Instrument *newInst = new Instrument(**iIt); newInst->setDevice(this); m_instruments.push_back(newInst); } // generate presentation instruments generatePresentationList(); }
void Part::insertTime(int tick, int len) { if (len == 0) return; // move all instruments if (len < 0) { // remove instruments between tickpos >= tick and tickpos < (tick+len) // ownership goes back to class InstrumentChange() auto si = _instruments.lower_bound(tick); auto ei = _instruments.lower_bound(tick-len); _instruments.erase(si, ei); } InstrumentList il; for (auto i = _instruments.lower_bound(tick); i != _instruments.end();) { Instrument* instrument = i->second; int tick = i->first; _instruments.erase(i++); _instruments[tick + len] = instrument; } _instruments.insert(il.begin(), il.end()); }
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); } }
// From a user selection (from a "Presentation" list) return // the matching Instrument // Instrument* Studio::getInstrumentFromList(int index) { std::vector<Device*>::iterator it; InstrumentList list; InstrumentList::iterator iit; int count = 0; for (it = m_devices.begin(); it != m_devices.end(); ++it) { MidiDevice *midiDevice = dynamic_cast<MidiDevice*>(*it); if (midiDevice) { // skip read-only devices if (midiDevice->getDirection() == MidiDevice::Record) continue; } list = (*it)->getPresentationInstruments(); for (iit = list.begin(); iit != list.end(); ++iit) { if (count == index) return (*iit); count++; } } return 0; }
void testSerializeProbability() { QDomDocument doc; QDomElement root = doc.createElement("note"); XMLNode node(root); InstrumentList *instruments = new InstrumentList(); Instrument *snare = new Instrument( 1, "Snare", nullptr ); instruments->add( snare ); Note *in = new Note(snare, 0, 1.0f, 0.5f, 0.5f, 1, 1.0f); in->set_probability(0.67f); in->save_to(&node); Note *out = Note::load_from(&node, instruments); CPPUNIT_ASSERT(in->get_instrument() == out->get_instrument()); CPPUNIT_ASSERT_EQUAL(in->get_position(), out->get_position()); CPPUNIT_ASSERT_EQUAL(in->get_velocity(), out->get_velocity()); CPPUNIT_ASSERT_EQUAL(in->get_pan_l(), out->get_pan_l()); CPPUNIT_ASSERT_EQUAL(in->get_pan_r(), out->get_pan_r()); CPPUNIT_ASSERT_EQUAL(in->get_length(), out->get_length()); CPPUNIT_ASSERT_EQUAL(in->get_pitch(), out->get_pitch()); CPPUNIT_ASSERT_EQUAL(in->get_probability(), out->get_probability()); /* FIXME: this causes double free delete in; delete out; delete instruments; delete snare; */ }
void MainForm::action_instruments_clearAll() { switch( QMessageBox::information( this, "Hydrogen", trUtf8("Clear all instruments?"), trUtf8("Ok"), trUtf8("Cancel"), 0, // Enter == button 0 1 )) { // Escape == button 2 case 0: // ok btn pressed break; case 1: // cancel btn pressed return; } // Remove all layers Song *pSong = Hydrogen::get_instance()->getSong(); InstrumentList* pList = pSong->get_instrument_list(); for (uint i = pList->size(); i > 0; i--) { functionDeleteInstrument(i - 1); } EventQueue::get_instance()->push_event( EVENT_SELECTED_INSTRUMENT_CHANGED, -1 ); }
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 MidiDevice::removeControlFromInstrument(const ControlParameter &con) { InstrumentList insList = getAllInstruments(); InstrumentList::iterator iIt = insList.begin(); for(; iIt != insList.end(); ++iIt) { (*iIt)->removeStaticController(con.getControllerValue()); } }
AudioDevice::AudioDevice(const AudioDevice &dev): Device(dev.getId(), dev.getName(), dev.getType()) { // Copy the instruments // InstrumentList insList = dev.getAllInstruments(); InstrumentList::iterator iIt = insList.begin(); for (; iIt != insList.end(); ++iIt) m_instruments.push_back(new Instrument(**iIt)); }
MidiDevice & MidiDevice::operator=(const MidiDevice &dev) { if (&dev == this) return *this; m_id = dev.getId(); m_name = dev.getName(); m_type = dev.getType(); m_librarian = dev.getLibrarian(); m_keyMappingList = dev.getKeyMappings(), m_programList = dev.getPrograms(); m_bankList = dev.getBanks(); m_controlList = dev.getControlParameters(); m_direction = dev.getDirection(); m_variationType = dev.getVariationType(); // clear down instruments list m_instruments.clear(); m_presentationInstrumentList.clear(); // Create and assign a metronome if required // if (dev.getMetronome()) { if (m_metronome) delete m_metronome; m_metronome = new MidiMetronome(*dev.getMetronome()); } else { delete m_metronome; m_metronome = 0; } if (m_allocator) { delete m_allocator; } m_allocator = new AllocateChannels(ChannelSetup::MIDI); // Copy the instruments // InstrumentList insList = dev.getAllInstruments(); InstrumentList::iterator iIt = insList.begin(); for (; iIt != insList.end(); ++iIt) { Instrument *newInst = new Instrument(**iIt); newInst->setDevice(this); m_instruments.push_back(newInst); } // generate presentation instruments generatePresentationList(); return (*this); }
bool Configuration::save(const char *filename, Drumkit *dk) { kit.name = dk->getName(); InstrumentList instruments = dk->allInstruments(); for(InstrumentList::iterator e = instruments.begin(); e != instruments.end(); ++e) kit.instruments.push_back(InstrumentInfo::from(*e)); for(SceneList::iterator e = dk->getScenes().begin(); e != dk->getScenes().end(); ++e) kit.scenes.push_back(SceneInfo::from(*e)); return save(filename); }
void MidiDevice::clearControlList() { // Clear down instrument controllers first. InstrumentList insList = getAllInstruments(); InstrumentList::iterator iIt = insList.begin(); for(; iIt != insList.end(); ++iIt) { (*iIt)->clearStaticControllers(); } m_controlList.clear(); }
Scene * Scene::updateFrom(Drumkit * kit) { InstrumentList inst = kit->allInstruments(); for(InstrumentList::iterator e = inst.begin(); e != inst.end(); ++e) { SceneSetting * setting = new SceneSetting(); setting->setInstrument(*e); setting->update(); this->add(setting); } return this; }
void TrackParameterBox::slotPlaybackDeviceChanged(int index) { //RG_DEBUG << "slotPlaybackDeviceChanged(" << index << ")"; // If nothing is selected, bail. if (index < 0) return; // Out of range? Bail. if (index >= static_cast<int>(m_playbackDeviceIds2.size())) return; Track *track = getTrack(); if (!track) return; // Switch the Track to the same instrument # on this new Device. DeviceId deviceId = m_playbackDeviceIds2[index]; Device *device = m_doc->getStudio().getDevice(deviceId); if (!device) return; // Query the Studio to get an Instrument for this Device. InstrumentList instrumentList = device->getPresentationInstruments(); // Try to preserve the Instrument number (channel) if possible. int instrumentIndex = m_instrument->currentIndex(); if (instrumentIndex >= static_cast<int>(instrumentList.size())) instrumentIndex = 0; // Set the Track's Instrument to the new Instrument. track->setInstrument(instrumentList[instrumentIndex]->getId()); m_doc->slotDocumentModified(); // Notify observers // This will trigger a call to updateWidgets2(). // ??? Redundant notification. Track::setInstrument() already does // this. It shouldn't. Composition &comp = m_doc->getComposition(); comp.notifyTrackChanged(track); // ??? The following needs to go away. RosegardenMainWindow::self()->getView()->getTrackEditor()-> getTrackButtons()->selectInstrument( track, instrumentList[instrumentIndex]); }
bool Drumkit::save_samples( const QString& dk_dir, bool overwrite ) { INFOLOG( QString( "Saving drumkit %1 samples into %2" ).arg( __name ).arg( dk_dir ) ); if( !Filesystem::mkdir( dk_dir ) ) { return false; } InstrumentList* instruments = get_instruments(); for( int i = 0; i < instruments->size(); i++ ) { Instrument* instrument = ( *instruments )[i]; for (std::vector<InstrumentComponent*>::iterator it = instrument->get_components()->begin() ; it != instrument->get_components()->end(); ++it) { InstrumentComponent* component = *it; for( int n = 0; n < MAX_LAYERS; n++ ) { InstrumentLayer* layer = component->get_layer( n ); if( layer ) { QString src = layer->get_sample()->get_filepath(); QString dst = dk_dir + "/" + layer->get_sample()->get_filename(); if( src != dst ) { QString original_dst = dst; // If the destination path does not have an extension and there is a dot in the path, hell will break loose. QFileInfo maybe? int insertPosition = original_dst.length(); if( original_dst.lastIndexOf(".") > 0 ) insertPosition = original_dst.lastIndexOf("."); if(overwrite == false) { // If the destination path already exists, try to use basename_1, basename_2, etc. instead of basename. int tries = 0; while( Filesystem::file_exists( dst, true )) { tries++; dst = original_dst; dst.insert( insertPosition, QString("_%1").arg(tries) ); } } layer->get_sample()->set_filename( dst ); if( !Filesystem::file_copy( src, dst ) ) { return false; } } } } } } return true; }
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 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 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::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); }
/// 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 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); }
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; }
void CInstrumentGridCtrl::InsertInstrumentList(const InstrumentList& instrumentList){ int rowIndex=0; for(int i=0; i<instrumentList.GetLength(); i++){ rowIndex = i+1; Instrument& instrument = const_cast<InstrumentList&>(instrumentList).GetAt(i); this->InsertInstrument(rowIndex, instrument); } }
/** * 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 MidiDevice::addControlToInstrument(const ControlParameter &con) { if (!isVisibleControlParameter(con)) { return; } // Run through all of this devices instruments and add default controls and // values to them. InstrumentList insList = getAllInstruments(); InstrumentList::iterator iIt = insList.begin(); for(; iIt != insList.end(); ++iIt) { MidiByte conNumber = con.getControllerValue(); MidiByte conValue = con.getDefault(); (*iIt)->setControllerValue(conNumber, conValue); } }