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