jens/JaySynth
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixing MidiClock (Zwischenstand)

Browse Source
This commit is contained in:
jens
2025-08-16 14:16:13 +02:00
parent e3fb2074f6
commit 159fa60b08
2 changed files with 180 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/plug/JK_MidiClock.cpp
+158 -130
View File
@@ -12,24 +12,30 @@
*/ */
#include "JK_MidiClock.h" #include "JK_MidiClock.h"
#include "juce_core/maths/juce_MathsFunctions.h"
#include <synth/synth_defs.h>
JK_MidiClock::JK_MidiClock() JK_MidiClock::JK_MidiClock()
:wasPlaying(false), :m_wasPlaying(false),
syncPpqPosition(-999.0), m_syncPpqPosition(-999.0),
posChangeThreshold(0.001), m_posChangeThreshold(0.001),
ppqToStartSyncAt(0.0), m_ppqToStartSyncAt(0.0),
followSongPosition(true), m_followSongPosition(true),
syncFlag(0), m_syncFlag(0),
ppqOffset(0) m_ppqOffset(0)
{ {
//Prepare Midi messages to avoid blocking the caller of generateMidiclock()! //Prepare Midi messages to avoid blocking the caller of generateMidiclock()!
continueMessage = new MidiMessage(MidiMessage::midiContinue()); m_continueMessage = new MidiMessage(MidiMessage::midiContinue());
stopMessage = new MidiMessage(MidiMessage::midiStop()); m_stopMessage = new MidiMessage(MidiMessage::midiStop());
clockMessage = new MidiMessage(MidiMessage::midiClock()); m_clockMessage = new MidiMessage(MidiMessage::midiClock());
songPositionMessage = new MidiMessage(MidiMessage::songPositionPointer(0)); m_songPositionMessage = new MidiMessage(MidiMessage::songPositionPointer(0));
m_last_sample_pos_sync = 0;
m_last_sample_pos_sync = 0;
m_syncSamplePos = 0;
} }
//================================================================================================= //=================================================================================================
void JK_MidiClock::generateMidiclock(AudioPlayHead::CurrentPositionInfo &lastPosInfo, void JK_MidiClock::generateMidiclock(const AudioPlayHead::CurrentPositionInfo &posInfo,
MidiBuffer* midiBuffer, const int bufferSize, const double sampleRate) MidiBuffer* midiBuffer, const int bufferSize, const double sampleRate)
{ {
//###################################Some explanation about musical tempo ################# //###################################Some explanation about musical tempo #################
@@ -38,137 +44,159 @@ void JK_MidiClock::generateMidiclock(AudioPlayHead::CurrentPositionInfo &lastPos
//So 4/4 would be four quarter-notes per Bar, while 4/2 would be four half-notes per Bar, # //So 4/4 would be four quarter-notes per Bar, while 4/2 would be four half-notes per Bar, #
//4/8 would be four eighth-notes per Bar, and 2/4 would be two quarter-notes per Bar. # //4/8 would be four eighth-notes per Bar, and 2/4 would be two quarter-notes per Bar. #
//######################################################################################### //#########################################################################################
if (midiBuffer == nullptr)
if (midiBuffer != nullptr)
{ {
//PPQ value of one sample return;
const double ppqPerSample = (lastPosInfo.bpm / 60.0) / sampleRate; }
//PPQ offset to compensate Midi interface latency //PPQ value of one sample
double hostPpqPosition = lastPosInfo.ppqPosition + ppqOffset * ppqPerSample;; const double ppqPerSample = (posInfo.bpm / 60.0) / sampleRate;
if (lastPosInfo.isPlaying || lastPosInfo.isRecording) //PPQ offset to compensate Midi interface latency
{ double hostPpqPosition = posInfo.ppqPosition + m_ppqOffset * ppqPerSample;;
if (! wasPlaying)
{ if (posInfo.isPlaying || posInfo.isRecording)
//set the point where to start the slave {
ppqToStartSyncAt = getNearestSixteenthInPPQ(hostPpqPosition); if (! m_wasPlaying)
{
//Special case: Master is set to always start playback from the previous start position... //set the point where to start the slave
if (positionJumped(syncPpqPosition, hostPpqPosition, sampleRate, ppqPerSample)) m_ppqToStartSyncAt = getNearestSixteenthInPPQ(hostPpqPosition);
{
//Cue Midiclock slave to the nearest sixteenth note to new start position
//because the one calculated in stop mode isn't valid anymore.
sendSongPositionPointerMessage(ppqToStartSyncAt, 0, midiBuffer);
}
}
else
{
//Position jump (loop or manually position change while playing)
if (positionJumped(syncPpqPosition, hostPpqPosition, sampleRate, ppqPerSample))
{
//set the point where to start the slave
ppqToStartSyncAt = getNearestSixteenthInPPQ(hostPpqPosition);
//User has changed position manually while playing
if (syncFlag == 0)
{
midiBuffer->addEvent(*stopMessage, 0);
sendSongPositionPointerMessage(hostPpqPosition, 0, midiBuffer);
syncFlag = startSlave_;
}
else
{
if (followSongPosition)
{
sendSongPositionPointerMessage(hostPpqPosition, 0, midiBuffer);
syncFlag = startSlave_;
}
else
syncFlag = 0;
}
}
}
for (int posInBuffer = 0; posInBuffer < bufferSize; ++posInBuffer) //Special case: Master is set to always start playback from the previous start position...
{ if (positionJumped(m_syncPpqPosition, hostPpqPosition, sampleRate, ppqPerSample))
syncPpqPosition = hostPpqPosition + (posInBuffer * ppqPerSample); {
//Cue Midiclock slave to the nearest sixteenth note to new start position
const int clockDistanceInSamples = roundToInt((60.0 * sampleRate) / (lastPosInfo.bpm * 24.0)); //because the one calculated in stop mode isn't valid anymore.
const int64 hostSamplePos = roundToInt64((hostPpqPosition * (60.0 / lastPosInfo.bpm)) * sampleRate); sendSongPositionPointerMessage(m_ppqToStartSyncAt, 0, midiBuffer);
const int64 syncSamplePos = hostSamplePos + posInBuffer;
//Some hosts like Cubase come up with a wacky ppqPosition
//that could break the timing! Best is to "wait"
//here for the right ppqPosition to jump on.
if (syncPpqPosition >= ppqToStartSyncAt)
{
if ((syncFlag & startSlave_) == startSlave_)
{
midiBuffer->addEvent(*continueMessage, posInBuffer);
syncFlag &= cycleEnd_;
}
//Cycle mode on
if (lastPosInfo.isLooping && lastPosInfo.ppqLoopStart != lastPosInfo.ppqLoopEnd)
{
const double ppqToCycleEnd = fabs(lastPosInfo.ppqLoopEnd - syncPpqPosition);
const int64 samplesToCycleEnd = roundToInt64(ppqToCycleEnd * (60.0 / lastPosInfo.bpm) * sampleRate);
if ((syncFlag & cycleEnd_) == 0)
{
if (samplesToCycleEnd <= clockDistanceInSamples) //For fine tuning tweak here
{
//We have reached the cycle- end position
//and must stop the Midiclock slave here
if (followSongPosition)
midiBuffer->addEvent(*stopMessage, posInBuffer);
syncFlag |= cycleEnd_;
}
}
}
}
//For best timing we should never interupt Midiclock messages!
//Seems that some slaves constantly adjusting their internal clock
//to Midiclock even if they are in stop mode.
if (syncSamplePos % clockDistanceInSamples == 0)
midiBuffer->addEvent(*clockMessage, posInBuffer);
} }
wasPlaying = true;
} }
else else
{ {
//Send positioning message if the user has stopped or if he changed the playhead position //Position jump (loop or manually position change while playing)
//manually in stop mode! This will also initially cue slave after loading plugin instance. if (positionJumped(m_syncPpqPosition, hostPpqPosition, sampleRate, ppqPerSample))
if (wasPlaying || positionJumped(syncPpqPosition, hostPpqPosition, sampleRate, ppqPerSample)) {
{ SynthDebug("positionJumped");
midiBuffer->addEvent(*stopMessage, 0); //set the point where to start the slave
sendSongPositionPointerMessage(hostPpqPosition, 0, midiBuffer); m_ppqToStartSyncAt = getNearestSixteenthInPPQ(hostPpqPosition);
//User has changed position manually while playing
if (m_syncFlag == 0)
{
SynthDebug("Sync=0");
midiBuffer->addEvent(*m_stopMessage, 0);
sendSongPositionPointerMessage(hostPpqPosition, 0, midiBuffer);
m_syncFlag = startSlave_;
}
else
{
SynthDebug("Sync=1");
if (m_followSongPosition)
{
sendSongPositionPointerMessage(hostPpqPosition, 0, midiBuffer);
m_syncFlag = startSlave_;
}
else
{
m_syncFlag = 0;
}
}
}
}
const int clockDistanceInSamples = roundToInt((60.0 * sampleRate) / (posInfo.bpm * 24.0));
const double quant = (60.0 / posInfo.bpm) * sampleRate;
const double hostSamplePos_f = hostPpqPosition * quant;
double syncSamplePos_f = hostSamplePos_f;
int64 syncSamplePos = roundToInt64(syncSamplePos_f);
double sample_offset = syncSamplePos_f - m_syncSamplePos;
for (int posInBuffer = 0; posInBuffer < bufferSize; ++posInBuffer)
{
m_syncPpqPosition = hostPpqPosition + (posInBuffer * ppqPerSample);
//Some hosts like Cubase come up with a wacky ppqPosition
//that could break the timing! Best is to "wait"
//here for the right ppqPosition to jump on.
if (m_syncPpqPosition >= m_ppqToStartSyncAt)
{
if ((m_syncFlag & startSlave_) == startSlave_)
{
midiBuffer->addEvent(*m_continueMessage, posInBuffer);
m_syncFlag &= cycleEnd_;
}
//Cycle mode on
if (posInfo.isLooping && posInfo.ppqLoopStart != posInfo.ppqLoopEnd)
{
const double ppqToCycleEnd = fabs(posInfo.ppqLoopEnd - m_syncPpqPosition);
const int64 samplesToCycleEnd = roundToInt64(ppqToCycleEnd * (60.0 / posInfo.bpm) * sampleRate);
if ((m_syncFlag & cycleEnd_) == 0)
{
if (samplesToCycleEnd <= clockDistanceInSamples) //For fine tuning tweak here
{
//We have reached the cycle- end position
//and must stop the Midiclock slave here
if (m_followSongPosition)
midiBuffer->addEvent(*m_stopMessage, posInBuffer);
m_syncFlag |= cycleEnd_;
}
}
}
} }
syncPpqPosition = hostPpqPosition; //For best timing we should never interupt Midiclock messages!
//Seems that some slaves constantly adjusting their internal clock
syncFlag = startSlave_; //to Midiclock even if they are in stop mode.
double sample_pos = (double)posInBuffer + sample_offset;
wasPlaying = false; double distance = fabs(syncSamplePos_f-m_last_sample_pos_sync);
// SynthDebug("Distance: %f", distance);
// SynthDebug("Quant: %f", quant);
// if (fabs(distance - clockDistanceInSamples) < quant and sample_pos >= 0)
if ((syncSamplePos % clockDistanceInSamples) == 0 and sample_pos >= 0)
{
// SynthDebug("MidiClock at Sample Sync: %d | PPQ Host: %f | PPQ Sync: %f", syncSamplePos-m_last_sample_pos_sync, hostPpqPosition-m_last_ppq_pos_host, m_syncPpqPosition-m_last_syncPpqPosition);
SynthDebug("MidiClock at Sample Sync: %f, diff %f", sample_pos, syncSamplePos_f-m_last_sample_pos_sync);
m_last_sample_pos_sync = syncSamplePos_f;
m_last_ppq_pos_host = hostPpqPosition;
m_last_syncPpqPosition = m_syncPpqPosition;
midiBuffer->addEvent(*m_clockMessage, roundToInt(sample_pos));
}
m_syncSamplePos = ++syncSamplePos;
} }
m_wasPlaying = true;
} }
} else
{
//Send positioning message if the user has stopped or if he changed the playhead position
//manually in stop mode! This will also initially cue slave after loading plugin instance.
if (m_wasPlaying || positionJumped(m_syncPpqPosition, hostPpqPosition, sampleRate, ppqPerSample))
{
midiBuffer->addEvent(*m_stopMessage, 0);
sendSongPositionPointerMessage(hostPpqPosition, 0, midiBuffer);
}
m_syncPpqPosition = hostPpqPosition;
m_syncFlag = startSlave_;
m_wasPlaying = false;
}
}
//================================================================================================= //=================================================================================================
bool JK_MidiClock::positionJumped(const double lastPosInPPQ, const double currentPosInPPQ, bool JK_MidiClock::positionJumped(const double lastPosInPPQ, const double currentPosInPPQ,
const double sampleRate, const double ppqPerSample) const double sampleRate, const double ppqPerSample)
{ {
//This returns true if the user has changed the playhead position manually or if //This returns true if the user has changed the playhead position manually or if
//a jump has occured! The comperator's default threshold is lastPosInPPQ +- 10ms. //a jump has occured! The comperator's default threshold is lastPosInPPQ +- 10ms.
if (currentPosInPPQ < lastPosInPPQ - ((posChangeThreshold * sampleRate) * ppqPerSample) || if (currentPosInPPQ < lastPosInPPQ - ((m_posChangeThreshold * sampleRate) * ppqPerSample) ||
currentPosInPPQ > lastPosInPPQ + ((posChangeThreshold * sampleRate) * ppqPerSample)) currentPosInPPQ > lastPosInPPQ + ((m_posChangeThreshold * sampleRate) * ppqPerSample))
return true; return true;
return false; return false;
@@ -180,10 +208,10 @@ void JK_MidiClock::sendSongPositionPointerMessage(const double ppqPosition, cons
//16th note to the given ppqPosition. //16th note to the given ppqPosition.
int intBeat = int(ceil(ppqPosition * 4)); int intBeat = int(ceil(ppqPosition * 4));
uint8* pSongPositionTime((uint8*)(songPositionMessage->getRawData())); uint8* pSongPositionTime((uint8*)(m_songPositionMessage->getRawData()));
*(pSongPositionTime + 1) = (uint8)(intBeat & 0x7f); *(pSongPositionTime + 1) = (uint8)(intBeat & 0x7f);
*(pSongPositionTime + 2) = (uint8)((intBeat & 0x3f80)>>7); *(pSongPositionTime + 2) = (uint8)((intBeat & 0x3f80)>>7);
buffer->addEvent(*songPositionMessage, posInBuffer); buffer->addEvent(*m_songPositionMessage, posInBuffer);
} }
src/plug/JK_MidiClock.h
+22 -19
View File
@@ -23,14 +23,14 @@ class JK_MidiClock
public: public:
JK_MidiClock(); JK_MidiClock();
void setPositionJumpThreshold(const double ms) {posChangeThreshold = ms / 1000.0;} void setPositionJumpThreshold(const double ms) {m_posChangeThreshold = ms / 1000.0;}
double getPositionJumpThreshold() {return posChangeThreshold;} double getPositionJumpThreshold() {return m_posChangeThreshold;}
void setFollowSongPosition(const bool shouldFollow) {followSongPosition = shouldFollow;} void setFollowSongPosition(const bool shouldFollow) {m_followSongPosition = shouldFollow;}
bool getFollowSongPosition() {return followSongPosition;} bool getFollowSongPosition() {return m_followSongPosition;}
void setOffset(const int offset) {ppqOffset = offset;} void setOffset(const int offset) {m_ppqOffset = offset;}
int getOffset() {return ppqOffset;} int getOffset() {return m_ppqOffset;}
void generateMidiclock(AudioPlayHead::CurrentPositionInfo &lastPosInfo, void generateMidiclock(const AudioPlayHead::CurrentPositionInfo &lastPosInfo,
MidiBuffer* midiBuffer, MidiBuffer* midiBuffer,
const int bufferSize, const int bufferSize,
const double sampleRate); const double sampleRate);
@@ -45,21 +45,24 @@ private:
} }
bool wasPlaying; bool m_wasPlaying;
double syncPpqPosition; double m_syncPpqPosition;
double posChangeThreshold; double m_posChangeThreshold;
double ppqToStartSyncAt; double m_ppqToStartSyncAt;
bool followSongPosition; bool m_followSongPosition;
uint8 syncFlag; uint8 m_syncFlag;
int ppqOffset; int m_ppqOffset;
double m_last_sample_pos_sync;
double m_last_ppq_pos_host;
double m_last_syncPpqPosition;
double m_syncSamplePos;
static const int cycleEnd_ = 1; static const int cycleEnd_ = 1;
static const int startSlave_ = 2; static const int startSlave_ = 2;
ScopedPointer <MidiMessage> clockMessage; ScopedPointer <MidiMessage> m_clockMessage;
ScopedPointer <MidiMessage> continueMessage; ScopedPointer <MidiMessage> m_continueMessage;
ScopedPointer <MidiMessage> stopMessage; ScopedPointer <MidiMessage> m_stopMessage;
ScopedPointer <MidiMessage> songPositionMessage; ScopedPointer <MidiMessage> m_songPositionMessage;
void sendSongPositionPointerMessage(const double ppqPosition, const int posInBuffer, MidiBuffer* buffer); void sendSongPositionPointerMessage(const double ppqPosition, const int posInBuffer, MidiBuffer* buffer);