static void writeSeqConfiguration(int level, Xml& xml, bool writePortInfo)/*{{{*/
{
xml.tag(level++, "sequencer");
if (writePortInfo)
{
//
// write information about all midi ports, their assigned
// instruments and all managed midi controllers
//
for (int i = 0; i < MIDI_PORTS; ++i)
{
bool used = false;
MidiPort* mport = &midiPorts[i];
// Route check by Tim. Port can now be used for routing even if no device.
// Also, check for other non-defaults and save port, to preserve settings even if no device.
// Dont write the config for the global inputs list they will be auto created with each startup
if (mport->defaultInChannels() || mport->defaultOutChannels() ||
(mport->instrument() && !mport->instrument()->iname().isEmpty() && mport->instrument()->iname() != "GM") /*|| !mport->syncInfo().isDefault()*/ )
{
used = true;
}
else
{//Put the ID of this track into a list
MidiTrackList* tl = song->midis();
for (iMidiTrack it = tl->begin(); it != tl->end(); ++it)
{
MidiTrack* t = *it;
if (t->outPort() == i)
{
used = true;
break;
}
}
}
MidiDevice* dev = mport->device();
if (!used && !dev)
continue;
bool isGlobal = gInputListPorts.contains(mport->portno());
xml.tag(level++, "midiport portId=\"%lld\" isGlobalInput=\"%d\"", mport->id(), isGlobal);
if (mport->defaultInChannels())
xml.intTag(level, "defaultInChans", mport->defaultInChannels());
if (mport->defaultOutChannels())
xml.intTag(level, "defaultOutChans", mport->defaultOutChannels());
if (mport->instrument() && !mport->instrument()->iname().isEmpty() &&
(mport->instrument()->iname() != "GM")) // FIXME: TODO: Make this user configurable.
{
xml.strTag(level, "instrument", mport->instrument()->iname());
}
if (dev)
{
xml.strTag(level, "name", dev->name());
xml.intTag(level, "cacheNRPN", (int)dev->cacheNRPN());
if (dev->deviceType() != MidiDevice::ALSA_MIDI)
xml.intTag(level, "type", dev->deviceType());
xml.intTag(level, "openFlags", dev->openFlags());
}
// write out registered controller for all channels
MidiCtrlValListList* vll = mport->controller();
for (int k = 0; k < MIDI_CHANNELS; ++k)
{
int min = k << 24;
int max = min + 0x100000;
xml.tag(level++, "channel idx=\"%d\"", k);
iMidiCtrlValList s = vll->lower_bound(min);
iMidiCtrlValList e = vll->lower_bound(max);
if (s != e)
{
for (iMidiCtrlValList i = s; i != e; ++i)
{
if(i->second->num() != 262145)
{
xml.tag(level++, "controller id=\"%d\"", i->second->num());
if (i->second->hwVal() != CTRL_VAL_UNKNOWN)
xml.intTag(level, "val", i->second->hwVal());
xml.etag(--level, "controller");
}
}
}
xml.etag(--level, "channel");
}
QList<PatchSequence*> *patchSequences = mport->patchSequences();
if (patchSequences && !patchSequences->isEmpty())
{
for (int p = 0; p < patchSequences->size(); ++p)
{
PatchSequence* ps = patchSequences->at(p);
QString pm = ps->name.replace('\n', " ");
xml.put(level, "<patchSequence id=\"%d\" name=\"%s\" checked=\"%d\" />", ps->id, pm.toLatin1().constData(), ps->selected);
}
}
if(!mport->presets()->isEmpty())
{
QHashIterator<int, QString> iter(*mport->presets());
while(iter.hasNext())
{
iter.next();
xml.put(level, "<midiPreset id=\"%d\" sysex=\"%s\"/>", iter.key(), iter.value().toLatin1().constData());
}
}
xml.etag(--level, "midiport");
}
}
xml.tag(--level, "/sequencer");
}/*}}}*/
void MidiDevice::handleSeek()
{
// If the device is not in use by a port, don't bother it.
if(_port == -1)
return;
MidiPort* mp = &MusEGlobal::midiPorts[_port];
MidiInstrument* instr = mp->instrument();
MidiCtrlValListList* cll = mp->controller();
unsigned pos = MusEGlobal::audio->tickPos();
//---------------------------------------------------
// Send STOP
//---------------------------------------------------
// Don't send if external sync is on. The master, and our sync routing system will take care of that.
if(!MusEGlobal::extSyncFlag.value())
{
if(mp->syncInfo().MRTOut())
{
// Shall we check for device write open flag to see if it's ok to send?...
//if(!(rwFlags() & 0x1) || !(openFlags() & 1))
//if(!(openFlags() & 1))
// continue;
mp->sendStop();
}
}
//---------------------------------------------------
// If playing, clear all notes and flush out any
// stuck notes which were put directly to the device
//---------------------------------------------------
if(MusEGlobal::audio->isPlaying())
{
_playEvents.clear();
for(iMPEvent i = _stuckNotes.begin(); i != _stuckNotes.end(); ++i)
{
MidiPlayEvent ev(*i);
ev.setTime(0);
putEvent(ev); // For immediate playback try putEvent, putMidiEvent, or sendEvent (for the optimizations).
}
_stuckNotes.clear();
}
//---------------------------------------------------
// Send new controller values
//---------------------------------------------------
// Find channels on this port used in the song...
bool usedChans[MIDI_CHANNELS];
int usedChanCount = 0;
for(int i = 0; i < MIDI_CHANNELS; ++i)
usedChans[i] = false;
if(MusEGlobal::song->click() && MusEGlobal::clickPort == _port)
{
usedChans[MusEGlobal::clickChan] = true;
++usedChanCount;
}
bool drum_found = false;
for(ciMidiTrack imt = MusEGlobal::song->midis()->begin(); imt != MusEGlobal::song->midis()->end(); ++imt)
{
//------------------------------------------------------------
// While we are at it, flush out any track-related playback stuck notes
// (NOT 'live' notes) which were not put directly to the device
//------------------------------------------------------------
MPEventList& mel = (*imt)->stuckNotes;
for(iMPEvent i = mel.begin(), i_next = i; i != mel.end(); i = i_next)
{
++i_next;
if((*i).port() != _port)
continue;
MidiPlayEvent ev(*i);
ev.setTime(0);
putEvent(ev); // For immediate playback try putEvent, putMidiEvent, or sendEvent (for the optimizations).
mel.erase(i);
}
if((*imt)->type() == MusECore::Track::DRUM)
{
if(!drum_found)
{
drum_found = true;
for(int i = 0; i < DRUM_MAPSIZE; ++i)
{
// Default to track port if -1 and track channel if -1.
int mport = MusEGlobal::drumMap[i].port;
if(mport == -1)
mport = (*imt)->outPort();
int mchan = MusEGlobal::drumMap[i].channel;
if(mchan == -1)
mchan = (*imt)->outChannel();
if(mport != _port || usedChans[mchan])
continue;
usedChans[mchan] = true;
++usedChanCount;
if(usedChanCount >= MIDI_CHANNELS)
break; // All are used, done searching.
}
}
}
else
{
if((*imt)->outPort() != _port || usedChans[(*imt)->outChannel()])
continue;
usedChans[(*imt)->outChannel()] = true;
++usedChanCount;
}
if(usedChanCount >= MIDI_CHANNELS)
break; // All are used. Done searching.
}
for(iMidiCtrlValList ivl = cll->begin(); ivl != cll->end(); ++ivl)
{
MidiCtrlValList* vl = ivl->second;
int chan = ivl->first >> 24;
if(!usedChans[chan]) // Channel not used in song?
continue;
int ctlnum = vl->num();
// Find the first non-muted value at the given tick...
bool values_found = false;
bool found_value = false;
iMidiCtrlVal imcv = vl->lower_bound(pos);
if(imcv != vl->end() && imcv->first == (int)pos)
{
for( ; imcv != vl->end() && imcv->first == (int)pos; ++imcv)
{
const Part* p = imcv->second.part;
if(!p)
continue;
// Ignore values that are outside of the part.
if(pos < p->tick() || pos >= (p->tick() + p->lenTick()))
continue;
values_found = true;
// Ignore if part or track is muted or off.
if(p->mute())
continue;
const Track* track = p->track();
if(track && (track->isMute() || track->off()))
continue;
found_value = true;
break;
}
}
else
{
while(imcv != vl->begin())
{
--imcv;
const Part* p = imcv->second.part;
if(!p)
continue;
// Ignore values that are outside of the part.
unsigned t = imcv->first;
if(t < p->tick() || t >= (p->tick() + p->lenTick()))
continue;
values_found = true;
// Ignore if part or track is muted or off.
if(p->mute())
continue;
const Track* track = p->track();
if(track && (track->isMute() || track->off()))
continue;
found_value = true;
break;
}
}
if(found_value)
{
// Don't bother sending any sustain values if not playing. Just set the hw state.
if(ctlnum == CTRL_SUSTAIN && !MusEGlobal::audio->isPlaying())
mp->setHwCtrlState(chan, CTRL_SUSTAIN, imcv->second.val);
else
// Use sendEvent to get the optimizations and limiting. But force if there's a value at this exact position.
// NOTE: Why again was this forced? There was a reason. Think it was RJ in response to bug rep, then I modded.
// A reason not to force: If a straight line is drawn on graph, multiple identical events are stored
// (which must be allowed). So seeking through them here sends them all redundantly, not good. // REMOVE Tim.
mp->sendEvent(MidiPlayEvent(0, _port, chan, ME_CONTROLLER, ctlnum, imcv->second.val), false); //, imcv->first == pos);
//mp->sendEvent(MidiPlayEvent(0, _port, chan, ME_CONTROLLER, ctlnum, imcv->second.val), pos == 0 || imcv->first == pos);
}
// Either no value was found, or they were outside parts, or pos is in the unknown area before the first value.
// Send instrument default initial values. NOT for syntis. Use midiState and/or initParams for that.
//if((imcv == vl->end() || !done) && !MusEGlobal::song->record() && instr && !isSynti())
// Hmm, without refinement we can only do this at position 0, due to possible 'skipped' values outside parts, above.
if(!values_found && MusEGlobal::config.midiSendCtlDefaults && !MusEGlobal::song->record() && pos == 0 && instr && !isSynti())
{
MidiControllerList* mcl = instr->controller();
ciMidiController imc = mcl->find(vl->num());
if(imc != mcl->end())
{
MidiController* mc = imc->second;
if(mc->initVal() != CTRL_VAL_UNKNOWN)
// Use sendEvent to get the optimizations and limiting. No force sending. Note the addition of bias.
mp->sendEvent(MidiPlayEvent(0, _port, chan, ME_CONTROLLER, ctlnum, mc->initVal() + mc->bias()), false);
}
}
}
//---------------------------------------------------
// reset sustain
//---------------------------------------------------
for(int ch = 0; ch < MIDI_CHANNELS; ++ch)
{
if(mp->hwCtrlState(ch, CTRL_SUSTAIN) == 127)
{
const MidiPlayEvent ev(0, _port, ch, ME_CONTROLLER, CTRL_SUSTAIN, 0);
putEvent(ev);
}
}
//---------------------------------------------------
// Send STOP and "set song position pointer"
//---------------------------------------------------
// Don't send if external sync is on. The master, and our sync routing system will take care of that.
if(!MusEGlobal::extSyncFlag.value())
{
if(mp->syncInfo().MRTOut())
{
//mp->sendStop(); // Moved above
int beat = (pos * 4) / MusEGlobal::config.division;
mp->sendSongpos(beat);
}
}
}
void MPConfig::songChanged(int flags)
{
// Is it simply a midi controller value adjustment? Forget it.
if (flags == SC_MIDI_CONTROLLER)
return;
// Get currently selected index...
int no = -1;
QTableWidgetItem* sitem = mdevView->currentItem();
if (sitem)
{
QString id = sitem->tableWidget()->item(sitem->row(), DEVCOL_NO)->text();
no = atoi(id.toLatin1().constData()) - 1;
if (no < 0 || no >= kMaxMidiPorts)
no = -1;
}
sitem = 0;
for (int i = kMaxMidiPorts - 1; i >= 0; --i)
{
mdevView->blockSignals(true); // otherwise itemChanged() is triggered and bad things happen.
MidiPort* port = &midiPorts[i];
MidiDevice* dev = port->device();
QString s;
s.setNum(i + 1);
QTableWidgetItem* itemno = mdevView->item(i, DEVCOL_NO);
QTableWidgetItem* itemstate = mdevView->item(i, DEVCOL_STATE);
itemstate->setText(port->state());
QTableWidgetItem* iteminstr = mdevView->item(i, DEVCOL_INSTR);
QString instrumentName = port->instrument() ? port->instrument()->iname() : tr("<unknown>");
iteminstr->setText(instrumentName);
iteminstr->setToolTip(instrumentName);
QTableWidgetItem* itemname = mdevView->item(i, DEVCOL_NAME);
QTableWidgetItem* itemgui = mdevView->item(i, DEVCOL_GUI);
QTableWidgetItem* itemfb = mdevView->item(i, DEVCOL_CACHE_NRPN);
QTableWidgetItem* itemrec = mdevView->item(i, DEVCOL_REC);
QTableWidgetItem* itemplay = mdevView->item(i, DEVCOL_PLAY);
QTableWidgetItem* itemout = mdevView->item(i, DEVCOL_OUTROUTES);
QTableWidgetItem* itemin = mdevView->item(i, DEVCOL_INROUTES);
QTableWidgetItem* itemdefin = mdevView->item(i, DEVCOL_DEF_IN_CHANS);
itemdefin->setText(bitmap2String(port->defaultInChannels()));
QTableWidgetItem* itemdefout = mdevView->item(i, DEVCOL_DEF_OUT_CHANS);
itemdefout->setText(bitmap2String(port->defaultOutChannels()));
mdevView->blockSignals(false);
if (dev)
{
itemname->setText(dev->name());
itemname->setToolTip(dev->name());
// Is it a Jack midi device? Allow renaming.
//if(dynamic_cast<MidiJackDevice*>(dev))
if (dev->deviceType() == MidiDevice::JACK_MIDI)
itemname->setFlags(Qt::ItemIsEditable | Qt::ItemIsEnabled);
if (dev->rwFlags() & 0x2)
{
itemrec->setIcon(dev->openFlags() & 2 ? QIcon(*dotIcon) : QIcon(*dothIcon));
}
else
{
itemrec->setIcon(QIcon(QPixmap()));
}
if (dev->rwFlags() & 0x1)
{
itemplay->setIcon(dev->openFlags() & 1 ? QIcon(*dotIcon) : QIcon(*dothIcon));
}
else
itemplay->setIcon(QIcon(QPixmap()));
itemfb->setIcon(dev->cacheNRPN() ? QIcon(*dotIcon) : QIcon(*dothIcon));
}
else
{
itemname->setText(tr("<none>"));
itemname->setToolTip("");
itemgui->setIcon(QIcon(*dothIcon));
itemrec->setIcon(QIcon(QPixmap()));
itemplay->setIcon(QIcon(QPixmap()));
itemfb->setIcon(QIcon(QPixmap()));
}
// falkTX, we don't want this in the connections manager
//if (port->hasGui())
//{
// itemgui->setIcon(port->guiVisible() ? QIcon(*dotIcon) : QIcon(*dothIcon));
//}
//else
//{
itemgui->setIcon(QIcon(QPixmap()));
//}
iteminstr->setIcon(QIcon(*buttondownIcon));
itemname->setIcon(QIcon(*buttondownIcon));
//if(dev && dynamic_cast<MidiJackDevice*>(dev))
if (dev && dev->deviceType() == MidiDevice::JACK_MIDI)
{
//item->setPixmap(DEVCOL_ROUTES, *buttondownIcon);
//item->setText(DEVCOL_ROUTES, tr("routes"));
// p3.3.55
if (dev->rwFlags() & 1)
//if(dev->openFlags() & 1)
{
itemout->setIcon(QIcon(*buttondownIcon));
if (port->device() && !port->device()->outRoutes()->empty())
{
RouteList* list = port->device()->outRoutes();
if (!list->empty())
{
iRoute r = list->begin();
itemout->setText(r->name());
}
}
else
{
itemout->setText(tr("out"));
}
//if (dev->openFlags() & 1)
// itemout->setText(tr("out"));
}
if (dev->rwFlags() & 2)
//if(dev->openFlags() & 2)
{
itemin->setIcon(QIcon(*buttondownIcon));
if (dev->openFlags() & 2)
itemin->setText(tr("in"));
}
}
if (i == no) sitem = itemno;
}
if (sitem)
{
mdevView->setCurrentItem(sitem);
}
}
void Audio::initDevices()
{
//
// mark all used ports
//
bool activePorts[MIDI_PORTS];
for (int i = 0; i < MIDI_PORTS; ++i)
activePorts[i] = false;
MidiTrackList* tracks = song->midis();
for (iMidiTrack it = tracks->begin(); it != tracks->end(); ++it)
{
MidiTrack* track = *it;
activePorts[track->outPort()] = true;
}
if (song->click())
activePorts[clickPort] = true;
//
// test for explicit instrument initialization
//
for (int i = 0; i < MIDI_PORTS; ++i)
{
if (!activePorts[i])
continue;
MidiPort* port = &midiPorts[i];
MidiInstrument* instr = port->instrument();
MidiDevice* md = port->device();
if (instr && md)
{
EventList* events = instr->midiInit();
if (events->empty())
continue;
for (iEvent ie = events->begin(); ie != events->end(); ++ie)
{
MidiPlayEvent ev(0, i, 0, ie->second);
md->putEvent(ev);
}
activePorts[i] = false; // no standard initialization
}
}
//
// damit Midi-Devices, die mehrere Ports besitzen, wie z.B.
// das Korg NS5R, nicht mehrmals zwischen GM und XG/GS hin und
// hergeschaltet werden, wird zunïÿýhst auf allen Ports GM
// initialisiert, und dann erst XG/GS
//
// Standard initialization...
for (int i = 0; i < MIDI_PORTS; ++i)
{
if (!activePorts[i])
continue;
MidiPort* port = &midiPorts[i];
switch (song->mtype())
{
case MT_GS:
case MT_UNKNOWN:
break;
case MT_GM:
case MT_XG:
port->sendGmOn();
break;
}
}
for (int i = 0; i < MIDI_PORTS; ++i)
{
if (!activePorts[i])
continue;
MidiPort* port = &midiPorts[i];
switch (song->mtype())
{
case MT_UNKNOWN:
break;
case MT_GM:
port->sendGmInitValues();
break;
case MT_GS:
port->sendGsOn();
port->sendGsInitValues();
break;
case MT_XG:
port->sendXgOn();
port->sendXgInitValues();
break;
}
}
}
