1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
#include "waveform/visualplayposition.h"
#include <QtDebug>
#include "control/controlobject.h"
#include "control/controlproxy.h"
#include "moc_visualplayposition.cpp"
#include "util/math.h"
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
#include "waveform/vsyncthread.h"
#endif
//static
QMap<QString, QWeakPointer<VisualPlayPosition>> VisualPlayPosition::m_listVisualPlayPosition;
PerformanceTimer VisualPlayPosition::m_timeInfoTime;
double VisualPlayPosition::m_dCallbackEntryToDacSecs = 0;
VisualPlayPosition::VisualPlayPosition(const QString& key)
: m_valid(false),
m_key(key) {
}
VisualPlayPosition::~VisualPlayPosition() {
m_listVisualPlayPosition.remove(m_key);
}
void VisualPlayPosition::set(
double playPos,
double rate,
double positionStep,
double slipPosition,
double slipRate,
double tempoTrackSeconds,
double audioBufferMicroS) {
VisualPlayPositionData data;
data.m_referenceTime = m_timeInfoTime;
data.m_callbackEntrytoDac = static_cast<int>(m_dCallbackEntryToDacSecs * 1000000); // s to µs
data.m_enginePlayPos = playPos;
data.m_rate = rate;
data.m_slipRate = slipRate;
data.m_positionStep = positionStep;
data.m_slipPosition = slipPosition;
data.m_tempoTrackSeconds = tempoTrackSeconds;
data.m_audioBufferMicroS = audioBufferMicroS;
// Atomic write
m_data.setValue(data);
m_valid = true;
}
double VisualPlayPosition::calcOffsetAtNextVSync(
VSyncThread* pVSyncThread, const VisualPlayPositionData& data) {
if (data.m_audioBufferMicroS != 0.0) {
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
Q_UNUSED(pVSyncThread);
const int refToVSync = 0;
const int syncIntervalTimeMicros = 0;
#else
const int refToVSync = pVSyncThread->fromTimerToNextSyncMicros(data.m_referenceTime);
const int syncIntervalTimeMicros = pVSyncThread->getSyncIntervalTimeMicros();
#endif
// The offset is limited to the audio buffer + waveform sync interval
// This should be sufficient to compensate jitter, but does not continue
// in case of underflows.
const int maxOffset = static_cast<int>(data.m_audioBufferMicroS + syncIntervalTimeMicros);
// Calculate the offset in micros for the position of the sample that will be transferred
// to the DAC when the next display frame is displayed
const int offset = math_clamp(
refToVSync - data.m_callbackEntrytoDac, -maxOffset, maxOffset);
// Apply the offset proportional to m_positionStep
return data.m_positionStep * static_cast<double>(offset) / data.m_audioBufferMicroS;
}
return 0.0;
}
double VisualPlayPosition::getAtNextVSync(VSyncThread* pVSyncThread) {
if (m_valid) {
const VisualPlayPositionData data = m_data.getValue();
const double offset = calcOffsetAtNextVSync(pVSyncThread, data);
return data.m_enginePlayPos + offset * data.m_rate;
}
return -1;
}
void VisualPlayPosition::getPlaySlipAtNextVSync(VSyncThread* pVSyncThread,
double* pPlayPosition,
double* pSlipPosition) {
if (m_valid) {
const VisualPlayPositionData data = m_data.getValue();
const double offset = calcOffsetAtNextVSync(pVSyncThread, data);
*pPlayPosition = data.m_enginePlayPos + offset * data.m_rate;
*pSlipPosition = data.m_slipPosition + offset * data.m_slipRate;
}
}
double VisualPlayPosition::getEnginePlayPos() {
if (m_valid) {
VisualPlayPositionData data = m_data.getValue();
return data.m_enginePlayPos;
} else {
return -1;
}
}
void VisualPlayPosition::getTrackTime(double* pPlayPosition, double* pTempoTrackSeconds) {
if (m_valid) {
VisualPlayPositionData data = m_data.getValue();
*pPlayPosition = data.m_enginePlayPos;
*pTempoTrackSeconds = data.m_tempoTrackSeconds;
} else {
*pPlayPosition = 0;
*pTempoTrackSeconds = 0;
}
}
//static
QSharedPointer<VisualPlayPosition> VisualPlayPosition::getVisualPlayPosition(const QString& group) {
QSharedPointer<VisualPlayPosition> vpp = m_listVisualPlayPosition.value(group);
if (vpp.isNull()) {
vpp = QSharedPointer<VisualPlayPosition>(new VisualPlayPosition(group));
m_listVisualPlayPosition.insert(group, vpp);
}
return vpp;
}
//static
void VisualPlayPosition::setCallbackEntryToDacSecs(double secs, const PerformanceTimer& time) {
// the time is valid only just NOW, so measure the time from NOW for
// later correction
m_timeInfoTime = time;
m_dCallbackEntryToDacSecs = secs;
}
|
