void PlayPanel::setScore(Score* s)
{
if (cs != 0 && cs == s)
return;
cs = s;
bool enable = cs != 0;
volumeSlider->setEnabled(enable);
posSlider->setEnabled(enable);
tempoSlider->setEnabled(enable);
if (cs && seq && seq->canStart()) {
setTempo(cs->tempomap()->tempo(0));
setRelTempo(cs->tempomap()->relTempo());
setEndpos(cs->repeatList()->ticks());
int tick = cs->playPos();
heartBeat(tick, tick, 0);
}
else {
setTempo(120.0);
setRelTempo(1.0);
setEndpos(0);
heartBeat(0, 0, 0);
updatePosLabel(0);
}
update();
}
Song::Song() :
TrackContainer(),
m_globalAutomationTrack( dynamic_cast<AutomationTrack *>(
Track::create( Track::HiddenAutomationTrack,
this ) ) ),
m_tempoModel( DefaultTempo, MinTempo, MaxTempo, this, tr( "Tempo" ) ),
m_timeSigModel( this ),
m_oldTicksPerTact( DefaultTicksPerTact ),
m_masterVolumeModel( 100, 0, 200, this, tr( "Master volume" ) ),
m_masterPitchModel( 0, -12, 12, this, tr( "Master pitch" ) ),
m_fileName(),
m_oldFileName(),
m_modified( false ),
m_loadOnLaunch( true ),
m_recording( false ),
m_exporting( false ),
m_exportLoop( false ),
m_renderBetweenMarkers( false ),
m_playing( false ),
m_paused( false ),
m_loadingProject( false ),
m_isCancelled( false ),
m_playMode( Mode_None ),
m_length( 0 ),
m_patternToPlay( NULL ),
m_loopPattern( false ),
m_elapsedTicks( 0 ),
m_elapsedTacts( 0 ),
m_loopRenderCount(1),
m_loopRenderRemaining(1)
{
for(int i = 0; i < Mode_Count; ++i) m_elapsedMilliSeconds[i] = 0;
connect( &m_tempoModel, SIGNAL( dataChanged() ),
this, SLOT( setTempo() ), Qt::DirectConnection );
connect( &m_tempoModel, SIGNAL( dataUnchanged() ),
this, SLOT( setTempo() ), Qt::DirectConnection );
connect( &m_timeSigModel, SIGNAL( dataChanged() ),
this, SLOT( setTimeSignature() ), Qt::DirectConnection );
connect( Engine::mixer(), SIGNAL( sampleRateChanged() ), this,
SLOT( updateFramesPerTick() ) );
connect( &m_masterVolumeModel, SIGNAL( dataChanged() ),
this, SLOT( masterVolumeChanged() ), Qt::DirectConnection );
/* connect( &m_masterPitchModel, SIGNAL( dataChanged() ),
this, SLOT( masterPitchChanged() ) );*/
qRegisterMetaType<Note>( "Note" );
setType( SongContainer );
}
VstPlugin::VstPlugin( const QString & _plugin ) :
m_plugin( _plugin ),
m_pluginWindowID( 0 ),
m_embedMethod( gui
? ConfigManager::inst()->vstEmbedMethod()
: "headless" ),
m_version( 0 ),
m_currentProgram()
{
if( QDir::isRelativePath( m_plugin ) )
{
m_plugin = ConfigManager::inst()->vstDir() + m_plugin;
}
setSplittedChannels( true );
PE::MachineType machineType;
try {
PE::FileInfo peInfo(m_plugin);
machineType = peInfo.machineType();
} catch (std::runtime_error& e) {
qCritical() << "Error while determining PE file's machine type: " << e.what();
machineType = PE::MachineType::unknown;
}
switch(machineType)
{
case PE::MachineType::amd64:
tryLoad( REMOTE_VST_PLUGIN_FILEPATH_64 ); // Default: RemoteVstPlugin64
break;
case PE::MachineType::i386:
tryLoad( REMOTE_VST_PLUGIN_FILEPATH_32 ); // Default: 32/RemoteVstPlugin32
break;
default:
m_failed = true;
return;
}
setTempo( Engine::getSong()->getTempo() );
connect( Engine::getSong(), SIGNAL( tempoChanged( bpm_t ) ),
this, SLOT( setTempo( bpm_t ) ) );
connect( Engine::mixer(), SIGNAL( sampleRateChanged() ),
this, SLOT( updateSampleRate() ) );
// update once per second
m_idleTimer.start( 1000 );
connect( &m_idleTimer, SIGNAL( timeout() ),
this, SLOT( idleUpdate() ) );
}
void MsScWriter::trailer()
{
qDebug() << "MsScWriter::trailer()"
;
if (tempo) setTempo(score, tempo);
}
void TempoText::read(XmlReader& e)
{
while (e.readNextStartElement()) {
const QStringRef& tag(e.name());
if (tag == "tempo")
setTempo(e.readDouble());
else if (tag == "followText")
_followText = e.readInt();
else if (!Text::readProperties(e))
e.unknown();
}
if (score()->mscVersion() <= 114) {
//
// Reset text in old version to
// style.
//
//TODO if (textStyle() != TextStyleType::INVALID) {
// setStyled(true);
// styleChanged();
// }
}
// check sanity
if (xmlText().isEmpty()) {
setXmlText(QString("<sym>metNoteQuarterUp</sym> = %1").arg(lrint(60 * _tempo)));
setVisible(false);
}
}
void GuitarPro5::readMeasures(int /*startingTempo*/)
{
Measure* measure = score->firstMeasure();
bool mixChange = false;
for (int bar = 0; bar < measures; ++bar, measure = measure->nextMeasure()) {
const GpBar& gpbar = bars[bar];
if (!gpbar.marker.isEmpty()) {
Text* s = new RehearsalMark(score);
s->setText(gpbar.marker.trimmed());
s->setTrack(0);
Segment* segment = measure->getSegment(Segment::Type::ChordRest, measure->tick());
segment->add(s);
}
Tuplet* tuplets[staves * 2]; // two voices
for (int track = 0; track < staves*2; ++track)
tuplets[track] = 0;
for (int staffIdx = 0; staffIdx < staves; ++staffIdx) {
readMeasure(measure, staffIdx, tuplets, mixChange);
if (!(((bar == (measures-1)) && (staffIdx == (staves-1))))) {
/*int a = */ readChar();
// qDebug(" ======skip %02x", a);
}
}
if (bar == 1 && !mixChange)
setTempo(tempo, score->firstMeasure());
}
}
bool MidiParser_SH::loadMusic(byte *musData, uint32 musDataSize) {
Common::StackLock lock(_mutex);
debugC(kDebugLevelMusic, "Music: loadMusic()");
unloadMusic();
_musData = musData;
_musDataSize = musDataSize;
byte *headerPtr = _musData + 12; // skip over the already checked SPACE header
byte *pos = headerPtr;
uint16 headerSize = READ_LE_UINT16(headerPtr);
assert(headerSize == 0x7F); // Security check
// Skip over header
pos += headerSize;
_lastEvent = 0;
_trackEnd = _musData + _musDataSize;
_numTracks = 1;
_tracks[0] = pos;
_ppqn = 1;
setTempo(16667);
setTrack(0);
return true;
}
void PlayPanel::relTempoChanged(double d, int)
{
double relTempo = d * .01;
emit relTempoChanged(relTempo);
setTempo(seq->curTempo() * relTempo);
setRelTempo(relTempo);
}
//--------------------------------------------------------------
/*public */void ofxSimpleMetronome::setup(int bpm, float x, float y){
setTempo(bpm);
millis = ofGetElapsedTimeMillis();
posRect.set(x, y, 0, 0);
ofAddListener(ofEvents().draw, this, &ofxSimpleMetronome::render);
}
song::song() :
TrackContainer(),
m_globalAutomationTrack( dynamic_cast<AutomationTrack *>(
track::create( track::HiddenAutomationTrack,
this ) ) ),
m_tempoModel( DefaultTempo, MinTempo, MaxTempo, this, tr( "Tempo" ) ),
m_timeSigModel( this ),
m_oldTicksPerTact( DefaultTicksPerTact ),
m_masterVolumeModel( 100, 0, 200, this, tr( "Master volume" ) ),
m_masterPitchModel( 0, -12, 12, this, tr( "Master pitch" ) ),
m_fileName(),
m_oldFileName(),
m_modified( false ),
m_recording( false ),
m_exporting( false ),
m_exportLoop( false ),
m_playing( false ),
m_paused( false ),
m_loadingProject( false ),
m_playMode( Mode_None ),
m_length( 0 ),
m_trackToPlay( NULL ),
m_patternToPlay( NULL ),
m_loopPattern( false ),
m_elapsedMilliSeconds( 0 ),
m_elapsedTicks( 0 ),
m_elapsedTacts( 0 )
{
connect( &m_tempoModel, SIGNAL( dataChanged() ),
this, SLOT( setTempo() ) );
connect( &m_tempoModel, SIGNAL( dataUnchanged() ),
this, SLOT( setTempo() ) );
connect( &m_timeSigModel, SIGNAL( dataChanged() ),
this, SLOT( setTimeSignature() ) );
connect( engine::mixer(), SIGNAL( sampleRateChanged() ), this,
SLOT( updateFramesPerTick() ) );
connect( &m_masterVolumeModel, SIGNAL( dataChanged() ),
this, SLOT( masterVolumeChanged() ) );
/* connect( &m_masterPitchModel, SIGNAL( dataChanged() ),
this, SLOT( masterPitchChanged() ) );*/
qRegisterMetaType<note>( "note" );
}
void Song::clear( void )
{
for( int i = 0; i < SongMaxChan; ++i ) channels[ i ]->clear();
startpat = 0;
loopactive = true;
looppos = 1;
loopdest = 0;
setTempo( 140 );
}
MidiClockClass::MidiClockClass() {
init();
mode = OFF;
setTempo(120);
on96Callback = NULL;
on32Callback = NULL;
on16Callback = NULL;
transmit = false;
}
void MainWindow::on_action_Set_Tempo_triggered()
{
bool ok;
int tempo = QInputDialog::getInteger(this, tr("Set Tempo"),
tr("Beats Per Minute:"), 60,
30, 120, 1, &ok);
if (ok)
setTempo(tempo);
}
void SequencerController::prepare( float aQueuedTempo, int aTimeSigBeatAmount, int aTimeSigBeatUnit )
{
// calculate buffers and ranges
if ( aQueuedTempo > 0 )
{
setTempo( aQueuedTempo, aTimeSigBeatAmount, aTimeSigBeatUnit );
AudioEngine::handleTempoUpdate( aQueuedTempo, false ); // just to initialize all buffer sizes
setLoopRange( 0, ( AudioEngine::amount_of_bars * AudioEngine::samples_per_bar ) - 1, stepsPerBar );
}
};
void setTempoFromMidiBytes(const byte* bytes) {
double tempo = 0.0;
unsigned long beatLengthInMicroseconds = 0;
if(bytes != NULL) {
beatLengthInMicroseconds = 0x00000000 | (bytes[0] << 16) | (bytes[1] << 8) | (bytes[2]);
// Convert beats / microseconds -> beats / minutes
tempo = (1000000.0 / (double)beatLengthInMicroseconds) * 60.0;
setTempo(tempo);
}
}
void PlayPanel::relTempoChanged(double d, int)
{
double relTempo = d * .01;
emit relTempoChanged(relTempo);
// Snap tempo slider to 100% when it gets close
if (relTempo < 1.01 && relTempo > 0.99) {
relTempo = 1.00;
}
setTempo(seq->curTempo() * relTempo);
setRelTempo(relTempo);
}
bool MainWindow::setupExercise()
{
connect(exercise_, SIGNAL(updateMain(MainWindowStates)),
this, SLOT(updateMain(MainWindowStates)));
attemptRunningBool = false;
exercise_->setup(centralwidget);
exercise_->setUserInfo(user_);
setupBackend();
setTempo(game_->getTempo());
return true;
}
MidiParser_SH::MidiParser_SH() {
_ppqn = 1;
setTempo(16667);
_data = nullptr;
_beats = 0;
_lastEvent = 0;
_trackEnd = nullptr;
_musData = nullptr;
_musDataSize = 0;
}
bool MidiParser_S1D::loadMusic(byte *data, uint32 size) {
unloadMusic();
if (!size)
return false;
// The original actually just ignores the first two bytes.
byte *pos = data;
if (*pos == 0xFC) {
// SysEx found right at the start
// this seems to happen since Elvira 2, we ignore it
// 3rd byte after the SysEx seems to be saved into a global
// We expect at least 4 bytes in total
if (size < 4)
return false;
byte skipOffset = pos[2]; // get second byte after the SysEx
// pos[1] seems to have been ignored
// pos[3] is saved into a global inside the original interpreters
// Waxworks + Simon 1 demo typical header is:
// 0xFC 0x29 0x07 0x01 [0x00/0x01]
// Elvira 2 typical header is:
// 0xFC 0x04 0x06 0x06
if (skipOffset >= 6) {
// should be at least 6, so that we skip over the 2 size bytes and the
// smallest SysEx possible
skipOffset -= 2; // 2 size bytes were already read by previous code outside of this method
if (size <= skipOffset) // Skip to the end of file? -> something is not correct
return false;
// Do skip over the bytes
pos += skipOffset;
} else {
warning("MidiParser_S1D: unexpected skip offset in music file");
}
}
// And now we're at the actual data. Only one track.
_numTracks = 1;
_data = pos;
_tracks[0] = pos;
// Note that we assume the original data passed in
// will persist beyond this call, i.e. we do NOT
// copy the data to our own buffer. Take warning....
resetTracking();
setTempo(666667);
setTrack(0);
return true;
}
VstPlugin::VstPlugin( const QString & _plugin ) :
RemotePlugin(),
JournallingObject(),
m_plugin( _plugin ),
m_pluginWidget( NULL ),
m_pluginWindowID( 0 ),
m_badDllFormat( false ),
m_name(),
m_version( 0 ),
m_vendorString(),
m_productString(),
m_currentProgramName(),
m_allProgramNames(),
p_name(),
m_currentProgram(),
m_idleTimer()
{
setSplittedChannels( true );
tryLoad( REMOTE_VST_PLUGIN_FILEPATH );
#ifdef LMMS_BUILD_WIN64
if( m_badDllFormat )
{
m_badDllFormat = false;
tryLoad( "32/RemoteVstPlugin32" );
}
#endif
setTempo( Engine::getSong()->getTempo() );
connect( Engine::getSong(), SIGNAL( tempoChanged( bpm_t ) ),
this, SLOT( setTempo( bpm_t ) ) );
connect( Engine::mixer(), SIGNAL( sampleRateChanged() ),
this, SLOT( updateSampleRate() ) );
// update once per second
m_idleTimer.start( 1000 );
connect( &m_idleTimer, SIGNAL( timeout() ),
this, SLOT( idleUpdate() ) );
}
void qtractorTempoSpinBox::stepBy ( int iSteps )
{
#ifdef CONFIG_DEBUG_0
qDebug("qtractorTempoSpinBox[%p]::stepBy(%d)", this, iSteps);
#endif
QLineEdit *pLineEdit = QAbstractSpinBox::lineEdit();
const int iCursorPos = pLineEdit->cursorPosition();
const QString& sText = pLineEdit->text();
if (iCursorPos < sText.section(' ', 0, 0).length() + 1) {
const QChar& decp = QLocale().decimalPoint();
if (iCursorPos > sText.section(decp, 0, 0).length())
setTempo(tempo() + 0.1f * float(iSteps));
else
setTempo(tempo() + float(iSteps));
}
else
if (iCursorPos > sText.section('/', 0, 0).length())
setBeatDivisor(int(beatDivisor()) + iSteps);
else
setBeatsPerBar(int(beatsPerBar()) + iSteps);
}
void TempoText::textChanged()
{
if (!_followText)
return;
// cache regexp, they are costly to create
static QHash<QString, QRegExp> regexps;
static QHash<QString, QRegExp> regexps2;
QString s = plainText();
s.replace(",", ".");
s.replace("<sym>space</sym>"," ");
for (const TempoPattern& pa : tp) {
QRegExp re;
if (!regexps.contains(pa.pattern)) {
re = QRegExp(QString("%1\\s*=\\s*(\\d+[.]{0,1}\\d*)\\s*").arg(pa.pattern));
regexps[pa.pattern] = re;
}
re = regexps.value(pa.pattern);
if (re.indexIn(s) != -1) {
QStringList sl = re.capturedTexts();
if (sl.size() == 2) {
qreal nt = qreal(sl[1].toDouble()) * pa.f;
if (nt != _tempo) {
setTempo(qreal(sl[1].toDouble()) * pa.f);
_relative = 1.0;
_isRelative = false;
updateScore();
}
break;
}
}
else {
for (const TempoPattern& pa2 : tp) {
QString key = QString("%1_%2").arg(pa.pattern).arg(pa2.pattern);
QRegExp re2;
if (!regexps2.contains(key)) {
re2 = QRegExp(QString("%1\\s*=\\s*%2\\s*").arg(pa.pattern).arg(pa2.pattern));
regexps2[key] = re2;
}
re2 = regexps2.value(key);
if (re2.indexIn(s) != -1) {
_relative = pa2.f / pa.f;
_isRelative = true;
updateRelative();
updateScore();
return;
}
}
}
}
}
void PlayPanel::setScore(Score* s)
{
if (cs != 0 && cs == s)
return;
cs = s;
if (cs) {
MeasureBase* lm = cs->last();
if (lm)
setEndpos(lm->tick() + lm->ticks());
}
bool enable = cs != 0;
volumeSlider->setEnabled(enable);
posSlider->setEnabled(enable);
tempoSlider->setEnabled(enable);
swingStyle->setEnabled(enable);
if (cs) {
setTempo(cs->tempomap()->tempo(0));
setRelTempo(cs->tempomap()->relTempo());
Measure* m = cs->lastMeasure();
if (m)
setEndpos(m ? m->tick() + m->ticks() : 0);
int tick = cs->playPos();
heartBeat(tick, tick);
}
else {
setTempo(120.0);
setRelTempo(1.0);
setEndpos(0);
heartBeat(0, 0);
}
// heartBeat2(seq->getCurTime());
// int tick, utick;
// seq->getCurTick(&tick, &utick);
// heartBeat(tick, utick);
update();
}
bool GuitarPro5::readMixChange(Measure* measure)
{
/*char patch =*/ readChar();
skip(16);
char volume = readChar();
char pan = readChar();
char chorus = readChar();
char reverb = readChar();
char phase = readChar();
char tremolo = readChar();
readDelphiString(); // tempo name
int tempo = readInt();
bool editedTempo = false;
if (volume >= 0)
readChar();
if (pan >= 0)
readChar();
if (chorus >= 0)
readChar();
if (reverb >= 0)
readChar();
//qDebug("read reverb: %d", reverb);
if (phase >= 0)
readChar();
if (tremolo >= 0)
readChar();
if (tempo >= 0) {
if (tempo != previousTempo) {
previousTempo = tempo;
setTempo(tempo, measure);
editedTempo = true;
}
readChar();
if (version > 500)
readChar();
}
readChar();
skip(1);
if (version > 500) {
readDelphiString();
readDelphiString();
}
return editedTempo;
}
void PlayPanel::updatePosLabel(int utick)
{
cachedTickPosition = utick;
int bar = 0;
int beat = 0;
int t = 0;
int tick = 0;
if (cs) {
tick = cs->repeatList()->utick2tick(utick);
cs->sigmap()->tickValues(tick, &bar, &beat, &t);
double tpo = cs->tempomap()->tempo(tick) * cs->tempomap()->relTempo();
setTempo(tpo);
}
char buffer[32];
sprintf(buffer, "%03d.%02d", bar+1, beat+1);
posLabel->setText(QString(buffer));
}
void TempoText::read(XmlReader& e)
{
while (e.readNextStartElement()) {
const QStringRef& tag(e.name());
if (tag == "tempo")
setTempo(e.readDouble());
else if (tag == "followText")
_followText = e.readInt();
else if (!TextBase::readProperties(e))
e.unknown();
}
// check sanity
if (xmlText().isEmpty()) {
setXmlText(QString("<sym>metNoteQuarterUp</sym> = %1").arg(lrint(60 * _tempo)));
setVisible(false);
}
}
void startRec()
{
if(RecFlag == 0)
{
setWindow(window,"mohnish/gb-drum-kit record1.jpg");
printf("%d-Tempo \n",Tempo);
setTempo(Tempo);
setTime(4,4);
openOutput(SongName,0,0);
RecFlag = 1;
PlayFlag = 1;
}
else
{
closeOutput();
setWindow(window,"mohnish/gb-drum-kit changed1.jpg");
RecFlag = 0;
}
}
bool TempoText::setProperty(P_ID propertyId, const QVariant& v)
{
switch(propertyId) {
case P_ID::TEMPO:
setTempo(v.toDouble());
score()->setTempo(segment(), _tempo);
score()->fixTicks();
break;
case P_ID::TEMPO_FOLLOW_TEXT:
_followText = v.toBool();
break;
default:
if (!Text::setProperty(propertyId, v))
return false;
break;
}
score()->setLayoutAll();
return true;
}
bool MidiParser_RO::loadMusic (byte *data, uint32 size) {
unloadMusic();
byte *pos = data;
if (memcmp (pos, "RO", 2)) {
error("'RO' header expected but found '%c%c' instead", pos[0], pos[1]);
return false;
}
_num_tracks = 1;
_ppqn = 120;
_tracks[0] = pos + 2;
_markerCount = _lastMarkerCount = 0;
// Note that we assume the original data passed in
// will persist beyond this call, i.e. we do NOT
// copy the data to our own buffer. Take warning....
resetTracking();
setTempo (500000);
setTrack (0);
return true;
}
void MD_MIDIFile::initialise(void)
{
_trackCount = 0; // number of tracks in file
_format = 0;
_tickTime = 0;
_lastTickError = 0;
_syncAtStart = false;
_paused =_looping = false;
setMidiHandler(NULL);
setSysexHandler(NULL);
// File handling
setFilename("");
_sd = NULL;
// Set MIDI defaults
setTicksPerQuarterNote(48); // 48 ticks per quarter note
setTempo(120); // 120 beats per minute
setTempoAdjust(0); // 0 beats per minute
setMicrosecondPerQuarterNote(500000); // 500,000 microseconds per quarter note
setTimeSignature(4, 4); // 4/4 time
}