Merge lp:~mixxxdevelopers/mixxx/waveform-dejerk into lp:~mixxxdevelopers/mixxx/trunk

[Daniel Schürmann]

This branch contains the first transition of waveform dejerking.
It introduces a timestamped visual play position, a vsync thread for precise timing and the infrastructure to allow advanced vsync strategies.
In this merge, is only the simple pure timer sync strategy included for not making this merge too big.
The improvement is notable but the waveforms are still jerking.
A vsync test waveform type is included an is available by starting Mixxx with --developer.

--

The Implementation tries to display the right waveform picture in the right moment.
This is archived by the VisualPlayPosition Class. It is something like a time stamped Control object, using he new atomic ControlObjectBase for bypassing the delays from the Qt Mesasage Queue and the Sync Thread from the current Control Object implementation.

This way we get rid of unpredictable delays and mixed up message order during heavy load.

The time stamp ov the Visual Play position is generated by the Portaudio timeInfo VisualPlayPosition::setTimeInfo(timeInfo);
The Play position for the waveform is adjusted for the actual display time in
VisualPlayPosition::getAt

The display frame timing is done by a separate Thread. This is required because the Qt Timer event is not super precise. This thread controls the rendering process by using sleep() and semaphores.

Currently it is not using Time stamp information from the driver. I have relay good results with specific set-ups, but it is also suffering from driver quality in other set-ups. So I have removed this from the current merge request but I am planning to add additional advanced dejerking strategies using openGL from daschuers_trunk later.

[jus (jus)]

FYI branch needs the diff from https://bazaar.launchpad.net/~mixxxdevelopers/mixxx/release-1.11.x/revision/3836 in order to compile on OSX. Going to test branch on MacBookPro8,1 and iMac13,1

[lp:~mixxxdevelopers/mixxx/waveform-dejerk]

3344. By Daniel Schürmann on 2013-05-01

merged from lp:mixxx

[Daniel Schürmann (daschuer)]

Thank you, for testing!

Just merged with lp:mixxx, so it should now build with OSX.

Do you have any results?

Unmerged revisions

3344. By Daniel Schürmann on 2013-05-01

merged from lp:mixxx

3343. By Daniel Schürmann on 2013-04-03

merged from lp:mixxx

3342. By Daniel Schürmann on 2013-04-03

clean up finished

3341. By Daniel Schürmann on 2013-04-02

code clean up

3340. By Daniel Schürmann on 2013-04-01

merged from lp:mixxx

3339. By Daniel Schürmann on 2013-04-01

fixed crash

3338. By Daniel Schürmann on 2013-03-31

compilable but crashing

3337. By Daniel Schürmann on 2013-03-31

merged ../daschuers_trunk/mixxx/src/waveform/

3336. By Daniel Schürmann on 2013-03-30

merged from lp:mixxx

=== modified file 'mixxx/build/depends.py'
--- mixxx/build/depends.py	2013-02-09 00:49:59 +0000
+++ mixxx/build/depends.py	2013-05-01 22:08:27 +0000
@@ -632,6 +632,7 @@
                    "waveform/waveform.cpp",
                    "waveform/waveformfactory.cpp",
                    "waveform/waveformwidgetfactory.cpp",
+                   "waveform/vsyncthread.cpp", 
                    "waveform/renderers/waveformwidgetrenderer.cpp",
                    "waveform/renderers/waveformrendererabstract.cpp",
                    "waveform/renderers/waveformrenderbackground.cpp",
@@ -648,6 +649,7 @@
                    "waveform/renderers/glwaveformrendererfilteredsignal.cpp",
                    "waveform/renderers/glwaveformrenderersimplesignal.cpp",
                    "waveform/renderers/glslwaveformrenderersignal.cpp",
+                   "waveform/renderers/glvsynctestrenderer.cpp",
 
                    "waveform/renderers/waveformsignalcolors.cpp",
 
@@ -664,6 +666,7 @@
                    "waveform/widgets/qtsimplewaveformwidget.cpp",
                    "waveform/widgets/glwaveformwidget.cpp",
                    "waveform/widgets/glsimplewaveformwidget.cpp",
+                   "waveform/widgets/glvsynctestwidget.cpp",
 
                    "waveform/widgets/glslwaveformwidget.cpp",
 
@@ -696,6 +699,7 @@
                    "soundmanagerutil.cpp",
                    "dlgprefrecord.cpp",
                    "playerinfo.cpp",
+                   "visualplayposition.cpp",
 
                    "recording/enginerecord.cpp",
                    "recording/encoder.cpp",

=== added file 'mixxx/src/controlobjectbase.h'
--- mixxx/src/controlobjectbase.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/controlobjectbase.h	2013-05-01 22:08:27 +0000
@@ -0,0 +1,147 @@
+
+#ifndef CONTROLOBJECTBASE_H_
+#define CONTROLOBJECTBASE_H_
+
+#include <QAtomicInt>
+#include <QObject>
+
+static const int cReaderSlotCnt = 7;
+
+template<typename T>
+class ControlObjectRingValue {
+  public:
+    ControlObjectRingValue()
+        : m_value(T()),
+          m_readerSlots(cReaderSlotCnt) {
+    }
+
+    int tryGet(T* value) {
+        // Read while consuming one readerSlot
+        bool originalSlots = m_readerSlots.fetchAndAddAcquire(-1);
+        if (originalSlots) {
+            *value = m_value;
+        }
+        (void)m_readerSlots.fetchAndAddRelease(1);
+        return originalSlots;
+    }
+
+    bool trySet(const T& value) {
+        // try to lock this element entirely for reading
+        if (m_readerSlots.testAndSetAcquire(cReaderSlotCnt, 0)) {
+            m_value = value;
+            m_readerSlots.fetchAndAddRelease(cReaderSlotCnt);
+            return true;
+        }
+        return false;
+   }
+
+  private:
+    T m_value;
+    QAtomicInt m_readerSlots;
+};
+
+// Common implementation for all Types
+template<typename T, bool ATOMIC = false>
+class ControlObjectValue {
+  public:
+    inline T getValue() {
+        T value = T();
+        unsigned int index = (unsigned int)m_readIndex
+                % (cReaderSlotCnt + 1);
+        while (m_ring[index].tryGet(&value) == 0) {
+            // We are here if
+            // 1) there are more then cReaderSlotCnt reader (get) reading the same value or
+            // 2) the formerly current value is locked by a writer
+            // Case 1 is prevented by enough reader slots and schould not happen
+            // Case 2 happens when the a reader is delayed after reading the
+            // m_currentIndex and the writers have written cReaderSlotCnt times so that the
+            // formally current value is locked again for writing.
+            // In both cases reading the less recent value will fix it.
+            index = (index - 1) % (cReaderSlotCnt + 1);
+        }
+        return value;
+    }
+
+    inline void setValue(const T& value) {
+        // Test if we can read atomic
+        // This test is const and will be mad only at compile time
+        unsigned int index;
+        do {
+            index = (unsigned int)m_writeIndex.fetchAndAddAcquire(1)
+                    % (cReaderSlotCnt + 1);
+            // This will be repeated if the value is locked
+            // 1) by an other writer writing at the same time or
+            // 2) a delayed reader is still blocking the formerly current value
+            // In both cases writing to the next value will fix it.
+        } while (!m_ring[index].trySet(value));
+        m_readIndex = (int)index;
+    }
+
+  protected:
+    ControlObjectValue()
+        : m_readIndex(0),
+          m_writeIndex(1) {
+    }
+
+  private:
+    ControlObjectRingValue<T> m_ring[cReaderSlotCnt+1];
+    QAtomicInt m_readIndex;
+    QAtomicInt m_writeIndex;
+};
+
+// Specialized Template for atomic types
+template<typename T>
+class ControlObjectValue<T, true> {
+  public:
+    inline T getValue() {
+        return m_value;
+    }
+
+    inline void setValue(const T& value) {
+        m_value = value;
+    }
+
+  protected:
+    ControlObjectValue()
+        : m_value(T()) {
+    }
+
+  private:
+    T m_value;
+};
+
+// Note: Qt does not support templates for signal and slots
+// So the typified ControlObject has to handle the Event Queue connections
+template<typename T>
+class ControlObjectBase
+    : public ControlObjectValue<T, sizeof(T) <= sizeof(void*)> {
+  public:
+    ControlObjectBase()
+        : ControlObjectValue<T, sizeof(T) <= sizeof(void*)>() {
+    }
+};
+
+
+template<typename T>
+class ControlObjectThreadBase {
+  public:
+    ControlObjectThreadBase(ControlObjectBase<T>* pControlObject)
+        : m_pControlObject(pControlObject) {
+    }
+    virtual ~ControlObjectThreadBase();
+
+    inline T get() const {
+        return m_pControlObject->get();
+    }
+
+    inline void set(const T& value) {
+        return m_pControlObject->get();
+    }
+
+  private:
+    ControlObjectBase<T>* m_pControlObject;
+};
+
+
+#endif // CONTROLOBJECTBASE_H_
+

=== modified file 'mixxx/src/dlgprefcontrols.cpp'
--- mixxx/src/dlgprefcontrols.cpp	2013-01-27 23:04:37 +0000
+++ mixxx/src/dlgprefcontrols.cpp	2013-05-01 22:08:27 +0000
@@ -44,7 +44,6 @@
                                  ConfigObject<ConfigValue> * pConfig)
         :  QWidget(parent) {
     m_pConfig = pConfig;
-    m_timer = -1;
     m_mixxx = mixxx;
     m_pSkinLoader = pSkinLoader;
     m_pPlayerManager = pPlayerManager;
@@ -597,24 +596,14 @@
     WaveformWidgetFactory::instance()->setOverviewNormalized(normalize);
 }
 
-void DlgPrefControls::onShow() {
-    m_timer = startTimer(100); //refresh actual frame rate every 100 ms
-}
-
-void DlgPrefControls::onHide() {
-    if (m_timer != -1) {
-        killTimer(m_timer);
-    }
-}
-
-void DlgPrefControls::timerEvent(QTimerEvent * /*event*/) {
-    //Just to refresh actual framrate any time the controller is modified
-    frameRateAverage->setText(QString::number(
-        WaveformWidgetFactory::instance()->getActualFrameRate()));
-}
-
-void DlgPrefControls::initWaveformControl()
-{
+void DlgPrefControls::slotWaveformMeasured(float frameRate, int rtErrorCnt) {
+    frameRateAverage->setText(
+            QString::number((double)frameRate, 'f', 2) +
+            " e" +
+            QString::number(rtErrorCnt));
+}
+
+void DlgPrefControls::initWaveformControl() {
     waveformTypeComboBox->clear();
     WaveformWidgetFactory* factory = WaveformWidgetFactory::instance();
 
@@ -626,15 +615,17 @@
     WaveformWidgetType::Type currentType = factory->getType();
     int currentIndex = -1;
 
-    std::vector<WaveformWidgetAbstractHandle> handles = factory->getAvailableTypes();
-    for (unsigned int i = 0; i < handles.size(); i++) {
+    QVector<WaveformWidgetAbstractHandle> handles = factory->getAvailableTypes();
+    for (int i = 0; i < handles.size(); i++) {
         waveformTypeComboBox->addItem(handles[i].getDisplayName());
-        if (handles[i].getType() == currentType)
+        if (handles[i].getType() == currentType) {
             currentIndex = i;
+        }
     }
 
-    if (currentIndex != -1)
+    if (currentIndex != -1) {
         waveformTypeComboBox->setCurrentIndex(currentIndex);
+    }
 
     frameRateSpinBox->setValue(factory->getFrameRate());
 
@@ -671,6 +662,8 @@
     connect(normalizeOverviewCheckBox,SIGNAL(toggled(bool)),
             this,SLOT(slotSetNormalizeOverview(bool)));
 
+    connect(WaveformWidgetFactory::instance(), SIGNAL(waveformMeasured(float,int)),
+            this, SLOT(slotWaveformMeasured(float,int)));
 }
 
 //Returns TRUE if skin fits to screen resolution, FALSE otherwise

=== modified file 'mixxx/src/dlgprefcontrols.h'
--- mixxx/src/dlgprefcontrols.h	2013-01-27 23:04:37 +0000
+++ mixxx/src/dlgprefcontrols.h	2013-05-01 22:08:27 +0000
@@ -73,12 +73,7 @@
     void slotSetVisualGainMid(double gain);
     void slotSetVisualGainHigh(double gain);
     void slotSetNormalizeOverview( bool normalize);
-
-    virtual void onShow();
-    virtual void onHide();
-
-protected:
-    void timerEvent(QTimerEvent *);
+    void slotWaveformMeasured(float frameRate, int rtErrorCnt);
 
 private:
     void initWaveformControl();

=== modified file 'mixxx/src/engine/bpmcontrol.cpp'
--- mixxx/src/engine/bpmcontrol.cpp	2013-03-31 16:56:35 +0000
+++ mixxx/src/engine/bpmcontrol.cpp	2013-05-01 22:08:27 +0000
@@ -8,6 +8,7 @@
 
 #include "engine/enginebuffer.h"
 #include "engine/bpmcontrol.h"
+#include "visualplayposition.h"
 #include "engine/enginechannel.h"
 #include "engine/enginemaster.h"
 
@@ -318,8 +319,8 @@
     double dThisPosition = getCurrentSample();
     double dOtherLength = ControlObject::getControl(
         ConfigKey(pOtherEngineBuffer->getGroup(), "track_samples"))->get();
-    double dOtherEnginePlayPos = ControlObject::getControl(
-        ConfigKey(pOtherEngineBuffer->getGroup(), "visual_playposition"))->get();
+    double dOtherEnginePlayPos =
+            VisualPlayPosition::getVisualPlayPosition(pOtherEngineBuffer->getGroup())->getEnginePlayPos();
     double dOtherPosition = dOtherLength * dOtherEnginePlayPos;
 
     double dThisPrevBeat = m_pBeats->findPrevBeat(dThisPosition);

=== modified file 'mixxx/src/engine/enginebuffer.cpp'
--- mixxx/src/engine/enginebuffer.cpp	2013-04-23 18:15:21 +0000
+++ mixxx/src/engine/enginebuffer.cpp	2013-05-01 22:08:27 +0000
@@ -37,6 +37,7 @@
 #include "engine/ratecontrol.h"
 #include "engine/bpmcontrol.h"
 #include "engine/quantizecontrol.h"
+#include "visualplayposition.h"
 #include "util/timer.h"
 
 #ifdef __VINYLCONTROL__
@@ -148,7 +149,6 @@
     connect(m_pSlipButton, SIGNAL(valueChangedFromEngine(double)),
             this, SLOT(slotControlSlip(double)),
             Qt::DirectConnection);
-    m_pSlipPosition = new ControlObject(ConfigKey(m_group, "slip_playposition"));
 
     // Actual rate (used in visuals, not for control)
     m_rateEngine = new ControlObject(ConfigKey(m_group, "rateEngine"));
@@ -165,8 +165,7 @@
             Qt::DirectConnection);
 
     // Control used to communicate ratio playpos to GUI thread
-    m_visualPlaypos = new ControlPotmeter(
-        ConfigKey(m_group, "visual_playposition"), kMinPlayposRange, kMaxPlayposRange);
+    m_visualPlayPos = VisualPlayPosition::getVisualPlayPosition(m_group);
 
     m_pRepeat = new ControlPushButton(ConfigKey(m_group, "repeat"));
     m_pRepeat->setButtonMode(ControlPushButton::TOGGLE);
@@ -251,11 +250,9 @@
     delete m_stopButton;
     delete m_rateEngine;
     delete m_playposSlider;
-    delete m_visualPlaypos;
     delete m_visualBpm;
 
     delete m_pSlipButton;
-    delete m_pSlipPosition;
     delete m_pRepeat;
 
     delete m_pTrackSamples;
@@ -384,7 +381,7 @@
                                    int iTrackSampleRate,
                                    int iTrackNumSamples) {
     m_pause.lock();
-    m_visualPlaypos->set(-1);
+    m_visualPlayPos->setInvalid();
     m_pCurrentTrack = pTrack;
     m_file_srate_old = iTrackSampleRate;
     m_file_length_old = iTrackNumSamples;
@@ -527,13 +524,11 @@
         // TODO(rryan): Should this filepos instead be the RAMAN current
         // position? filepos_play could be out of date.
         m_dSlipPosition = m_filepos_play;
-        m_pSlipPosition->set(fractionalPlayposFromAbsolute(m_dSlipPosition));
         m_dSlipRate = m_rate_old;
     } else {
         // TODO(owen) assuming that looping will get canceled properly
         slotControlSeekAbs(m_dSlipPosition);
         m_dSlipPosition = 0;
-        m_pSlipPosition->set(0);
     }
 }
 
@@ -577,7 +572,6 @@
         // Update the slipped position
         if (m_bSlipEnabled) {
             m_dSlipPosition += static_cast<double>(iBufferSize) * m_dSlipRate;
-            m_pSlipPosition->set(fractionalPlayposFromAbsolute(m_dSlipPosition));
         }
 
         // Scratching always disables keylock because keylock sounds terrible
@@ -852,6 +846,9 @@
     m_iSamplesCalculated += iBufferSize;
 
     double fFractionalPlaypos = fractionalPlayposFromAbsolute(m_filepos_play);
+    if(rate > 0 && fFractionalPlaypos == 1.0) {
+        rate = 0;
+    }
 
     // Update indicators that are only updated after every
     // sampleRate/kiUpdateRate samples processed.  (e.g. playposSlider,
@@ -874,7 +871,9 @@
 
     // Update visual control object, this needs to be done more often than the
     // rateEngine and playpos slider
-    m_visualPlaypos->set(fFractionalPlaypos);
+    m_visualPlayPos->set(fFractionalPlaypos, rate,
+            (double)iBufferSize/m_file_length_old,
+            fractionalPlayposFromAbsolute(m_dSlipPosition));
 }
 
 void EngineBuffer::hintReader(const double dRate) {

=== modified file 'mixxx/src/engine/enginebuffer.h'
--- mixxx/src/engine/enginebuffer.h	2013-02-03 18:50:24 +0000
+++ mixxx/src/engine/enginebuffer.h	2013-05-01 22:08:27 +0000
@@ -49,6 +49,7 @@
 class EngineBufferScaleLinear;
 class EngineBufferScaleST;
 class EngineWorkerScheduler;
+class VisualPlayPosition;
 class EngineMaster;
 
 struct Hint;
@@ -225,13 +226,11 @@
     ControlObject* m_fwdButton;
     ControlObject* m_backButton;
     ControlPushButton* m_pSlipButton;
-    ControlObject* m_pSlipPosition;
 
     ControlObject* m_rateEngine;
     ControlObject* m_visualBpm;
     ControlObject* m_pMasterRate;
     ControlPotmeter* m_playposSlider;
-    ControlPotmeter* m_visualPlaypos;
     ControlObject* m_pSampleRate;
     ControlPushButton* m_pKeylock;
 
@@ -277,6 +276,8 @@
     CSAMPLE* m_pCrossFadeBuffer;
     int m_iCrossFadeSamples;
     int m_iLastBufferSize;
+
+    VisualPlayPosition* m_visualPlayPos;
 };
 
 #endif

=== modified file 'mixxx/src/main.cpp'
--- mixxx/src/main.cpp	2013-04-28 18:46:48 +0000
+++ mixxx/src/main.cpp	2013-05-01 22:08:27 +0000
@@ -40,6 +40,10 @@
 #include <ladspa/ladspaloader.h>
 #endif
 
+#ifdef Q_WS_X11
+#include <X11/Xlib.h>
+#endif
+
 #ifdef __WINDOWS__
 #ifdef DEBUGCONSOLE
 #include <io.h> // Debug Console
@@ -139,6 +143,11 @@
 
 int main(int argc, char * argv[])
 {
+
+#ifdef Q_WS_X11
+    XInitThreads();
+#endif
+
     // Check if an instance of Mixxx is already running
     // See http://qt.nokia.com/products/appdev/add-on-products/catalog/4/Utilities/qtsingleapplication
 

=== modified file 'mixxx/src/mixxx.cpp'
--- mixxx/src/mixxx.cpp	2013-05-01 20:29:44 +0000
+++ mixxx/src/mixxx.cpp	2013-05-01 22:08:27 +0000
@@ -387,6 +387,7 @@
             this, SLOT(slotSyncControlSystem()));
 
     WaveformWidgetFactory::create();
+    WaveformWidgetFactory::instance()->startVSync(this);
     WaveformWidgetFactory::instance()->setConfig(m_pConfig);
 
     m_pSkinLoader = new SkinLoader(m_pConfig);
@@ -1609,7 +1610,6 @@
 
     m_pView->hide();
 
-    WaveformWidgetFactory::instance()->stop();
     WaveformWidgetFactory::instance()->destroyWidgets();
 
     // Workaround for changing skins while fullscreen, just go out of fullscreen
@@ -1658,8 +1658,6 @@
              initPosition.y() + (initSize.height() - m_pView->height()) / 2);
     }
 
-    WaveformWidgetFactory::instance()->start();
-
 #ifdef __APPLE__
     // Original the following line fixes issue on OSX where menu bar went away
     // after a skin change. It was original surrounded by #if __OSX__

=== modified file 'mixxx/src/sounddeviceportaudio.cpp'
--- mixxx/src/sounddeviceportaudio.cpp	2013-03-21 22:29:13 +0000
+++ mixxx/src/sounddeviceportaudio.cpp	2013-05-01 22:08:27 +0000
@@ -25,6 +25,7 @@
 #include "sounddeviceportaudio.h"
 #include "soundmanagerutil.h"
 #include "controlobject.h"
+#include "visualplayposition.h"
 #include "util/timer.h"
 
 SoundDevicePortAudio::SoundDevicePortAudio(ConfigObject<ConfigValue> *config, SoundManager *sm,
@@ -326,6 +327,7 @@
         m_bSetThreadPriority = true;
     }
 
+    VisualPlayPosition::setTimeInfo(timeInfo);
     if (!m_undeflowUpdateCount) {
         if (statusFlags & (paOutputUnderflow | paInputOverflow)) {
             if (m_pMasterUnderflowCount) {

=== added file 'mixxx/src/visualplayposition.cpp'
--- mixxx/src/visualplayposition.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/visualplayposition.cpp	2013-05-01 22:08:27 +0000
@@ -0,0 +1,109 @@
+
+#include <qdebug.h>
+
+#include "visualplayposition.h"
+#include "controlobjectthreadmain.h"
+#include "controlobject.h"
+#include "waveform/waveformwidgetfactory.h"
+#include "mathstuff.h"
+#include "waveform/vsyncthread.h"
+
+
+//static
+QMap<QString, VisualPlayPosition*> VisualPlayPosition::m_listVisualPlayPosition;
+const PaStreamCallbackTimeInfo* VisualPlayPosition::m_timeInfo;
+PerformanceTimer VisualPlayPosition::m_timeInfoTime;
+
+VisualPlayPosition::VisualPlayPosition() :
+        m_valid(false) {
+
+    m_audioBufferSize = new ControlObjectThreadMain(
+        ControlObject::getControl(ConfigKey("[Master]","audio_buffer_size")));
+}
+
+VisualPlayPosition::~VisualPlayPosition() {
+
+}
+
+// This function must be called only form the engine thread (PA callback)
+void VisualPlayPosition::set(double playPos, double rate,
+                double positionStep, double pSlipPosition) {
+    VisualPlayPositionData data;
+
+    data.m_referenceTime = m_timeInfoTime;
+    // Time from reference time to Buffer at DAC in µs
+    data.m_timeDac = (m_timeInfo->outputBufferDacTime - m_timeInfo->currentTime) * 1000000;
+    data.m_playPos = playPos;
+    data.m_rate = rate;
+    data.m_positionStep = positionStep;
+    data.m_pSlipPosition = pSlipPosition;
+
+    // Atomic write
+    m_data.setValue(data);
+    m_valid = true;
+}
+
+double VisualPlayPosition::getAt(VSyncThread* vsyncThread) {
+    //static double testPos = 0;
+    //testPos += 0.000017759; //0.000016608; //  1.46257e-05;
+    //return testPos;
+
+    if (m_valid) {
+        VisualPlayPositionData data = m_data.getValue();
+        int usRefToVSync = vsyncThread->usFromTimerToNextSync(&data.m_referenceTime);
+        int offset = usRefToVSync - data.m_timeDac;
+        double playPos = data.m_playPos;  // load playPos for the first sample in Buffer
+        playPos += data.m_positionStep * offset * data.m_rate / m_audioBufferSize->get() / 1000;
+        //qDebug() << "delta Pos" << playPos - m_playPosOld << offset;
+        m_playPosOld = playPos;
+        return playPos;
+    }
+    return -1;
+}
+
+void VisualPlayPosition::getPlaySlipAt(int usFromNow, double* playPosition, double* slipPosition) {
+    //static double testPos = 0;
+    //testPos += 0.000017759; //0.000016608; //  1.46257e-05;
+    //return testPos;
+
+    if (m_valid) {
+        VisualPlayPositionData data = m_data.getValue();
+        int usElapsed = data.m_referenceTime.elapsed() / 1000;
+        int dacFromNow = usElapsed - data.m_timeDac;
+        int offset = dacFromNow - usFromNow;
+        double playPos = data.m_playPos;  // load playPos for the first sample in Buffer
+        playPos += data.m_positionStep * offset * data.m_rate / m_audioBufferSize->get() / 1000;
+        *playPosition = playPos;
+        *slipPosition = data.m_pSlipPosition;
+    }
+}
+
+double VisualPlayPosition::getEnginePlayPos() {
+    if (m_valid) {
+        VisualPlayPositionData data = m_data.getValue();
+        return data.m_playPos;
+    } else {
+        return -1;
+    }
+}
+
+//static
+VisualPlayPosition* VisualPlayPosition::getVisualPlayPosition(QString group) {
+    VisualPlayPosition* vpp = m_listVisualPlayPosition[group];
+    if (!vpp) {
+        vpp = new VisualPlayPosition();
+        m_listVisualPlayPosition[group] = vpp;
+    }
+    return vpp;
+}
+
+//static
+void VisualPlayPosition::setTimeInfo(const PaStreamCallbackTimeInfo *timeInfo) {
+    m_timeInfo = timeInfo;
+    m_timeInfoTime.start();
+    //qDebug() << "TimeInfo" << (timeInfo->currentTime - floor(timeInfo->currentTime)) << (timeInfo->outputBufferDacTime - floor(timeInfo->outputBufferDacTime));
+    //m_timeInfo.currentTime = timeInfo->currentTime;
+    //m_timeInfo.inputBufferAdcTime = timeInfo->inputBufferAdcTime;
+    //m_timeInfo.outputBufferDacTime = timeInfo->outputBufferDacTime;
+}
+

=== added file 'mixxx/src/visualplayposition.h'
--- mixxx/src/visualplayposition.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/visualplayposition.h	2013-05-01 22:08:27 +0000
@@ -0,0 +1,57 @@
+#ifndef VISUALPLAYPOSITION_H
+#define VISUALPLAYPOSITION_H
+
+#include <portaudio.h>
+#include "util/performancetimer.h"
+#include "controlobjectbase.h"
+
+#include <QMutex>
+#include <QTime>
+#include <QMap>
+#include <QAtomicPointer>
+
+class ControlObjectThreadMain;
+class VSyncThread;
+
+class VisualPlayPositionData {
+  public:
+    PerformanceTimer m_referenceTime;
+    int m_timeDac;
+    double m_playPos;
+    double m_rate;
+    double m_positionStep;
+    double m_pSlipPosition;
+};
+
+
+class VisualPlayPosition
+{
+  public:
+    VisualPlayPosition();
+    ~VisualPlayPosition();
+
+    void set(double playPos, double rate, double positionStep, double pSlipPosition);
+    double getAt(VSyncThread* vsyncThread);
+    void getPlaySlipAt(int usFromNow, double* playPosition, double* slipPosition);
+    double getEnginePlayPos();
+    static VisualPlayPosition* getVisualPlayPosition(QString group);
+    static void setTimeInfo(const PaStreamCallbackTimeInfo *timeInfo);
+    void setInvalid() { m_valid = false; };
+
+
+  private:
+    ControlObjectBase<VisualPlayPositionData> m_data;
+    double m_playPosOld;
+    int m_deltatime;
+    ControlObjectThreadMain* m_audioBufferSize;
+    PaTime m_outputBufferDacTime;
+    bool m_valid;
+
+    static QMap<QString, VisualPlayPosition*> m_listVisualPlayPosition;
+    static const PaStreamCallbackTimeInfo* m_timeInfo;
+    static PerformanceTimer m_timeInfoTime;
+
+};
+
+#endif // VISUALPLAYPOSITION_H
+

=== added file 'mixxx/src/waveform/renderers/glvsynctestrenderer.cpp'
--- mixxx/src/waveform/renderers/glvsynctestrenderer.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/waveform/renderers/glvsynctestrenderer.cpp	2013-05-01 22:08:27 +0000
@@ -0,0 +1,133 @@
+#include "glvsynctestrenderer.h"
+
+#include "waveformwidgetrenderer.h"
+#include "waveform/waveform.h"
+
+#include "waveform/waveformwidgetfactory.h"
+
+#include "util/performancetimer.h"
+
+#include <qgl.h>
+
+GLVSyncTestRenderer::GLVSyncTestRenderer(
+        WaveformWidgetRenderer* waveformWidgetRenderer)
+    : WaveformRendererSignalBase(waveformWidgetRenderer),
+      m_drawcount(0) {
+}
+
+GLVSyncTestRenderer::~GLVSyncTestRenderer() {
+}
+
+void GLVSyncTestRenderer::onSetup(const QDomNode &node) {
+    Q_UNUSED(node);
+}
+
+inline void setPoint(QPointF& point, qreal x, qreal y) {
+    point.setX(x);
+    point.setY(y);
+}
+
+void GLVSyncTestRenderer::draw(QPainter* painter, QPaintEvent* /*event*/) {
+
+    PerformanceTimer timer;
+    //int t5, t6, t7, t8, t9, t10, t11, t12, t13;
+
+
+    timer.start();
+
+    TrackPointer pTrack = m_waveformRenderer->getTrackInfo();
+    if (!pTrack) {
+        return;
+    }
+
+    const Waveform* waveform = pTrack->getWaveform();
+    if (waveform == NULL) {
+        return;
+    }
+
+    const int dataSize = waveform->getDataSize();
+    if (dataSize <= 1) {
+        return;
+    }
+
+    const WaveformData* data = waveform->data();
+    if (data == NULL) {
+        return;
+    }
+
+    double firstVisualIndex = m_waveformRenderer->getFirstDisplayedPosition() * dataSize;
+    double lastVisualIndex = m_waveformRenderer->getLastDisplayedPosition() * dataSize;
+
+    const int firstIndex = int(firstVisualIndex + 0.5);
+    firstVisualIndex = firstIndex - firstIndex % 2;
+
+    const int lastIndex = int(lastVisualIndex + 0.5);
+    lastVisualIndex = lastIndex + lastIndex % 2;
+
+    //t5 = timer.restart(); // 910
+
+    // Reset device for native painting
+    painter->beginNativePainting();
+
+    //t6 = timer.restart(); // 29,150
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    const QColor& color = m_pColors->getSignalColor();
+
+    //t7 = timer.restart(); // 5,770
+
+    WaveformWidgetFactory* factory = WaveformWidgetFactory::instance();
+    const double visualGain = factory->getVisualGain(::WaveformWidgetFactory::All);
+
+    float maxAll[2];
+
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glLoadIdentity();
+
+    //t8 = timer.restart(); // 2,611
+
+    if (m_alignment == Qt::AlignCenter) {
+        glOrtho(firstVisualIndex, lastVisualIndex, -255.0, 255.0, -10.0, 10.0);
+    } else if (m_alignment == Qt::AlignBottom) {
+        glOrtho(firstVisualIndex, lastVisualIndex, 0.0, 255.0, -10.0, 10.0);
+    } else {
+        glOrtho(firstVisualIndex, lastVisualIndex, 255.0, 0.0, -10.0, 10.0);
+    }
+
+    //t9 = timer.restart(); // 1,320
+
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glLoadIdentity();
+
+    //t10 = timer.restart(); // 915
+
+    if (++m_drawcount & 1) {
+        glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+        glColor3f(1.0f, 1.0f, 1.0f);
+    } else {
+        glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
+        glColor3f(1.0f, 0.0f, 0.0f);
+    }
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glRectf(0, 0, 1, 1);
+
+    //t11 = timer.restart(); // 217,985
+
+    glEnd();
+    glPopMatrix();
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+
+    //t12 = timer.restart(); // 22,426
+    painter->endNativePainting();
+
+    //t13 = timer.restart(); // 1,430
+
+    //qDebug() << t5 << t6 << t7 << t8 << t9 << t10 << t11 << t12 << t13;
+
+    //qDebug() << timer.restart(); // 129,498
+}

=== added file 'mixxx/src/waveform/renderers/glvsynctestrenderer.h'
--- mixxx/src/waveform/renderers/glvsynctestrenderer.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/waveform/renderers/glvsynctestrenderer.h	2013-05-01 22:08:27 +0000
@@ -0,0 +1,19 @@
+#ifndef GLVSYNCTESTRENDERER_H
+#define GLVSYNCTESTRENDERER_H
+
+#include "waveformrenderersignalbase.h"
+
+class ControlObject;
+
+class GLVSyncTestRenderer : public WaveformRendererSignalBase {
+  public:
+    explicit GLVSyncTestRenderer( WaveformWidgetRenderer* waveformWidgetRenderer);
+    virtual ~GLVSyncTestRenderer();
+
+    virtual void onSetup(const QDomNode &node);
+    virtual void draw(QPainter* painter, QPaintEvent* event);
+  private:
+    int m_drawcount;
+};
+
+#endif // GLVSYNCTESTRENDERER_H

=== modified file 'mixxx/src/waveform/renderers/waveformrenderbeat.cpp'
--- mixxx/src/waveform/renderers/waveformrenderbeat.cpp	2013-04-12 15:06:58 +0000
+++ mixxx/src/waveform/renderers/waveformrenderbeat.cpp	2013-05-01 22:08:27 +0000
@@ -74,7 +74,7 @@
 
     while (it->hasNext()) {
         int beatPosition = it->next();
-        m_waveformRenderer->regulateVisualSample(beatPosition);
+        // m_waveformRenderer->regulateVisualSample(beatPosition);
         double xBeatPoint = m_waveformRenderer->transformSampleIndexInRendererWorld(beatPosition);
 
         painter->setPen(beatPen);

=== modified file 'mixxx/src/waveform/renderers/waveformrendererendoftrack.cpp'
--- mixxx/src/waveform/renderers/waveformrendererendoftrack.cpp	2013-01-28 13:06:12 +0000
+++ mixxx/src/waveform/renderers/waveformrendererendoftrack.cpp	2013-05-01 22:08:27 +0000
@@ -13,6 +13,8 @@
 #include "widget/wskincolor.h"
 #include "widget/wwidget.h"
 
+#include "util/timer.h"
+
 WaveformRendererEndOfTrack::WaveformRendererEndOfTrack(
         WaveformWidgetRenderer* waveformWidgetRenderer)
     : WaveformRendererAbstract(waveformWidgetRenderer),
@@ -61,14 +63,20 @@
 }
 
 void WaveformRendererEndOfTrack::onResize() {
-    m_rect = QRect( 0, 0, m_waveformRenderer->getWidth(), m_waveformRenderer->getHeight());
     m_backRects.resize(4);
     for (int i = 0; i < 4; i++) {
         m_backRects[i].setTop(0);
         m_backRects[i].setBottom(m_waveformRenderer->getHeight());
-        m_backRects[i].setLeft(m_waveformRenderer->getWidth()/2+i*m_waveformRenderer->getWidth()/8);
+        m_backRects[i].setLeft(m_waveformRenderer->getWidth()/2 +
+                i*m_waveformRenderer->getWidth()/8);
         m_backRects[i].setRight(m_waveformRenderer->getWidth());
     }
+    /*
+    m_gradient.setStart(m_waveformRenderer->getWidth()/2, 0);
+    m_gradient.setFinalStop(m_waveformRenderer->getWidth(), 0);
+    m_gradient.setColorAt(0, Qt::transparent);
+    m_gradient.setColorAt(1, m_color);
+    */
 }
 
 void WaveformRendererEndOfTrack::draw(QPainter* painter,
@@ -121,6 +129,8 @@
         //qDebug() << "EndOfTrack ON";
     }
 
+    ScopedTimer t("WaveformRendererEndOfTrack::draw");
+
     const int elapsed = m_timer.elapsed() % m_blinkingPeriodMillis;
 
     const double blickIntensity = (double)(2 * abs(elapsed - m_blinkingPeriodMillis/2)) /
@@ -139,5 +149,9 @@
     painter->setPen(QPen(Qt::transparent));
     painter->setBrush(m_color);
     painter->drawRects(m_backRects);
+    //painter->setOpacity(0.5 * criticalIntensity * blickIntensity);
+    //painter->fillRect(m_waveformRenderer->getWidth()/2, 1,
+    //        m_waveformRenderer->getWidth() - 2, m_waveformRenderer->getHeight() - 2,
+    //        m_gradient);
     painter->restore();
 }

=== modified file 'mixxx/src/waveform/renderers/waveformrendererendoftrack.h'
--- mixxx/src/waveform/renderers/waveformrendererendoftrack.h	2012-12-14 01:26:04 +0000
+++ mixxx/src/waveform/renderers/waveformrendererendoftrack.h	2013-05-01 22:08:27 +0000
@@ -3,6 +3,7 @@
 
 #include <QColor>
 #include <QTime>
+#include <QLinearGradient>
 
 #include "util.h"
 #include "waveformrendererabstract.h"
@@ -35,9 +36,9 @@
     int m_blinkingPeriodMillis;
     double m_remainingTimeTriggerSeconds;
 
-    QRect m_rect;
     QVector<QRect> m_backRects;
     QPen m_pen;
+    QLinearGradient m_gradient;
 
     DISALLOW_COPY_AND_ASSIGN(WaveformRendererEndOfTrack);
 };

=== added file 'mixxx/src/waveform/renderers/waveformrendererhsv.cpp'
--- mixxx/src/waveform/renderers/waveformrendererhsv.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/waveform/renderers/waveformrendererhsv.cpp	2013-05-01 22:08:27 +0000
@@ -0,0 +1,177 @@
+#include "waveformrendererhsv.h"
+
+#include "waveformwidgetrenderer.h"
+#include "waveform/waveform.h"
+#include "waveform/waveformwidgetfactory.h"
+
+#include "widget/wskincolor.h"
+#include "trackinfoobject.h"
+#include "widget/wwidget.h"
+
+#include "defs.h"
+
+#include "controlobjectthreadmain.h"
+
+WaveformRendererHSV::WaveformRendererHSV(
+        WaveformWidgetRenderer* waveformWidgetRenderer)
+    : WaveformRendererSignalBase( waveformWidgetRenderer) {
+}
+
+WaveformRendererHSV::~WaveformRendererHSV() {
+}
+
+void WaveformRendererHSV::onSetup(const QDomNode& node) {
+    Q_UNUSED(node);
+}
+
+void WaveformRendererHSV::draw(QPainter* painter,
+                                          QPaintEvent* /*event*/) {
+    const TrackPointer trackInfo = m_waveformRenderer->getTrackInfo();
+    if (!trackInfo) {
+        return;
+    }
+
+    const Waveform* waveform = trackInfo->getWaveform();
+    if (waveform == NULL) {
+        return;
+    }
+
+    const int dataSize = waveform->getDataSize();
+    if (dataSize <= 1) {
+        return;
+    }
+
+    const WaveformData* data = waveform->data();
+    if (data == NULL) {
+        return;
+    }
+
+    painter->save();
+    painter->setRenderHints(QPainter::Antialiasing, false);
+    painter->setRenderHints(QPainter::HighQualityAntialiasing, false);
+    painter->setRenderHints(QPainter::SmoothPixmapTransform, false);
+    painter->setWorldMatrixEnabled(false);
+    painter->resetTransform();
+
+    const double firstVisualIndex = m_waveformRenderer->getFirstDisplayedPosition() * dataSize;
+    const double lastVisualIndex = m_waveformRenderer->getLastDisplayedPosition() * dataSize;
+
+    const double offset = firstVisualIndex;
+
+    // Represents the # of waveform data points per horizontal pixel.
+    const double gain = (lastVisualIndex - firstVisualIndex) /
+            (double)m_waveformRenderer->getWidth();
+
+    float allGain(1.0);
+    allGain = m_waveformRenderer->getGain();
+
+    WaveformWidgetFactory* factory = WaveformWidgetFactory::instance();
+    allGain *= factory->getVisualGain(::WaveformWidgetFactory::All);
+
+    // Save HSV of waveform color
+    double h,s,v;
+
+    // Get base color of waveform in the HSV format (s and v isn't use)
+    m_pColors->getLowColor().getHsvF(&h,&s,&v);
+
+    QColor color;
+    float lo, hi, total;
+
+    const float halfHeight = (float)m_waveformRenderer->getHeight()/2.0;
+
+    const float heightFactor = allGain*halfHeight/255.0;
+
+    //draw reference line
+    painter->setPen(m_axesColor);
+    painter->drawLine(0,halfHeight,m_waveformRenderer->getWidth(),halfHeight);
+
+    for (int x = 0; x < m_waveformRenderer->getWidth(); ++x) {
+        // Width of the x position in visual indices.
+        const double xSampleWidth = gain * x;
+
+        // Effective visual index of x
+        const double xVisualSampleIndex = xSampleWidth + offset;
+
+        // Our current pixel (x) corresponds to a number of visual samples
+        // (visualSamplerPerPixel) in our waveform object. We take the max of
+        // all the data points on either side of xVisualSampleIndex within a
+        // window of 'maxSamplingRange' visual samples to measure the maximum
+        // data point contained by this pixel.
+        double maxSamplingRange = gain / 2.0;
+
+        // Since xVisualSampleIndex is in visual-samples (e.g. R,L,R,L) we want
+        // to check +/- maxSamplingRange frames, not samples. To do this, divide
+        // xVisualSampleIndex by 2. Since frames indices are integers, we round
+        // to the nearest integer by adding 0.5 before casting to int.
+        int visualFrameStart = int(xVisualSampleIndex / 2.0 - maxSamplingRange + 0.5);
+        int visualFrameStop = int(xVisualSampleIndex / 2.0 + maxSamplingRange + 0.5);
+        const int lastVisualFrame = dataSize / 2 - 1;
+
+        // We now know that some subset of [visualFrameStart, visualFrameStop]
+        // lies within the valid range of visual frames. Clamp
+        // visualFrameStart/Stop to within [0, lastVisualFrame].
+        visualFrameStart = math_max(math_min(lastVisualFrame, visualFrameStart), 0);
+        visualFrameStop = math_max(math_min(lastVisualFrame, visualFrameStop), 0);
+
+        int visualIndexStart = visualFrameStart * 2;
+        int visualIndexStop = visualFrameStop * 2;
+
+        int maxLow[2] = {0, 0};
+        int maxHigh[2] = {0, 0};
+        int maxMid[2] = {0, 0};
+        int maxAll[2] = {0, 0};
+
+        for (int i = visualIndexStart;
+             i >= 0 && i + 1 < dataSize && i + 1 <= visualIndexStop; i += 2) {
+            const WaveformData& waveformData = *(data + i);
+            const WaveformData& waveformDataNext = *(data + i + 1);
+            maxLow[0] = math_max(maxLow[0], (int)waveformData.filtered.low);
+            maxLow[1] = math_max(maxLow[1], (int)waveformDataNext.filtered.low);
+            maxMid[0] = math_max(maxMid[0], (int)waveformData.filtered.mid);
+            maxMid[1] = math_max(maxMid[1], (int)waveformDataNext.filtered.mid);
+            maxHigh[0] = math_max(maxHigh[0], (int)waveformData.filtered.high);
+            maxHigh[1] = math_max(maxHigh[1], (int)waveformDataNext.filtered.high);
+            maxAll[0] = math_max( maxAll[0], (int)waveformData.filtered.all);
+            maxAll[1] = math_max( maxAll[1], (int)waveformDataNext.filtered.all);
+        }
+
+        if( maxAll[0] && maxAll[1] ) {
+            // Calculate sum, to normalize
+            // Also multiply on 1.2 to prevent very dark or light color
+            total = (maxLow[0] + maxLow[1] + maxMid[0] + maxMid[1] + maxHigh[0] + maxHigh[1]) * 1.2;
+
+            // prevent division by zero
+            if( total > 0 )
+            {
+                // Normalize low and high (mid not need, because it not change the color)
+                lo = (maxLow[0] + maxLow[1]) / total;
+                hi = (maxHigh[0] + maxHigh[1]) / total;
+            }
+            else
+                lo = hi = 0.0;
+
+            // Set color
+            color.setHsvF(h, 1.0-hi, 1.0-lo);
+
+            painter->setPen(color);
+            switch (m_alignment) {
+                case Qt::AlignBottom :
+                    painter->drawLine(
+                        x, m_waveformRenderer->getHeight(),
+                        x, m_waveformRenderer->getHeight() - (int)(heightFactor*(float)math_max(maxAll[0],maxAll[1])));
+                    break;
+                case Qt::AlignTop :
+                    painter->drawLine(
+                        x, 0,
+                        x, (int)(heightFactor*(float)math_max(maxAll[0],maxAll[1])));
+                    break;
+                default :
+                    painter->drawLine(
+                        x, (int)(halfHeight-heightFactor*(float)maxAll[0]),
+                        x, (int)(halfHeight+heightFactor*(float)maxAll[1]));
+            }
+        }
+    }
+
+    painter->restore();
+}

=== removed file 'mixxx/src/waveform/renderers/waveformrendererhsv.cpp'
--- mixxx/src/waveform/renderers/waveformrendererhsv.cpp	2013-01-16 21:03:36 +0000
+++ mixxx/src/waveform/renderers/waveformrendererhsv.cpp	1970-01-01 00:00:00 +0000
@@ -1,177 +0,0 @@
-#include "waveformrendererhsv.h"
-
-#include "waveformwidgetrenderer.h"
-#include "waveform/waveform.h"
-#include "waveform/waveformwidgetfactory.h"
-
-#include "widget/wskincolor.h"
-#include "trackinfoobject.h"
-#include "widget/wwidget.h"
-
-#include "defs.h"
-
-#include "controlobjectthreadmain.h"
-
-WaveformRendererHSV::WaveformRendererHSV(
-        WaveformWidgetRenderer* waveformWidgetRenderer)
-    : WaveformRendererSignalBase( waveformWidgetRenderer) {
-}
-
-WaveformRendererHSV::~WaveformRendererHSV() {
-}
-
-void WaveformRendererHSV::onSetup(const QDomNode& node) {
-    Q_UNUSED(node);
-}
-
-void WaveformRendererHSV::draw(QPainter* painter,
-                                          QPaintEvent* /*event*/) {
-    const TrackPointer trackInfo = m_waveformRenderer->getTrackInfo();
-    if (!trackInfo) {
-        return;
-    }
-
-    const Waveform* waveform = trackInfo->getWaveform();
-    if (waveform == NULL) {
-        return;
-    }
-
-    const int dataSize = waveform->getDataSize();
-    if (dataSize <= 1) {
-        return;
-    }
-
-    const WaveformData* data = waveform->data();
-    if (data == NULL) {
-        return;
-    }
-
-    painter->save();
-    painter->setRenderHints(QPainter::Antialiasing, false);
-    painter->setRenderHints(QPainter::HighQualityAntialiasing, false);
-    painter->setRenderHints(QPainter::SmoothPixmapTransform, false);
-    painter->setWorldMatrixEnabled(false);
-    painter->resetTransform();
-
-    const double firstVisualIndex = m_waveformRenderer->getFirstDisplayedPosition() * dataSize;
-    const double lastVisualIndex = m_waveformRenderer->getLastDisplayedPosition() * dataSize;
-
-    const double offset = firstVisualIndex;
-
-    // Represents the # of waveform data points per horizontal pixel.
-    const double gain = (lastVisualIndex - firstVisualIndex) /
-            (double)m_waveformRenderer->getWidth();
-
-    float allGain(1.0);
-    allGain = m_waveformRenderer->getGain();
-
-    WaveformWidgetFactory* factory = WaveformWidgetFactory::instance();
-    allGain *= factory->getVisualGain(::WaveformWidgetFactory::All);
-
-    // Save HSV of waveform color
-    double h,s,v;
-
-    // Get base color of waveform in the HSV format (s and v isn't use)
-    m_pColors->getLowColor().getHsvF(&h,&s,&v);
-
-    QColor color;
-    float lo, hi, total;
-
-    const float halfHeight = (float)m_waveformRenderer->getHeight()/2.0;
-
-    const float heightFactor = allGain*halfHeight/255.0;
-
-    //draw reference line
-    painter->setPen(m_axesColor);
-    painter->drawLine(0,halfHeight,m_waveformRenderer->getWidth(),halfHeight);
-
-    for (int x = 0; x < m_waveformRenderer->getWidth(); ++x) {
-        // Width of the x position in visual indices.
-        const double xSampleWidth = gain * x;
-
-        // Effective visual index of x
-        const double xVisualSampleIndex = xSampleWidth + offset;
-
-        // Our current pixel (x) corresponds to a number of visual samples
-        // (visualSamplerPerPixel) in our waveform object. We take the max of
-        // all the data points on either side of xVisualSampleIndex within a
-        // window of 'maxSamplingRange' visual samples to measure the maximum
-        // data point contained by this pixel.
-        double maxSamplingRange = gain / 2.0;
-
-        // Since xVisualSampleIndex is in visual-samples (e.g. R,L,R,L) we want
-        // to check +/- maxSamplingRange frames, not samples. To do this, divide
-        // xVisualSampleIndex by 2. Since frames indices are integers, we round
-        // to the nearest integer by adding 0.5 before casting to int.
-        int visualFrameStart = int(xVisualSampleIndex / 2.0 - maxSamplingRange + 0.5);
-        int visualFrameStop = int(xVisualSampleIndex / 2.0 + maxSamplingRange + 0.5);
-        const int lastVisualFrame = dataSize / 2 - 1;
-
-        // We now know that some subset of [visualFrameStart, visualFrameStop]
-        // lies within the valid range of visual frames. Clamp
-        // visualFrameStart/Stop to within [0, lastVisualFrame].
-        visualFrameStart = math_max(math_min(lastVisualFrame, visualFrameStart), 0);
-        visualFrameStop = math_max(math_min(lastVisualFrame, visualFrameStop), 0);
-
-        int visualIndexStart = visualFrameStart * 2;
-        int visualIndexStop = visualFrameStop * 2;
-
-        int maxLow[2] = {0, 0};
-        int maxHigh[2] = {0, 0};
-        int maxMid[2] = {0, 0};
-        int maxAll[2] = {0, 0};
-
-        for (int i = visualIndexStart;
-             i >= 0 && i + 1 < dataSize && i + 1 <= visualIndexStop; i += 2) {
-            const WaveformData& waveformData = *(data + i);
-            const WaveformData& waveformDataNext = *(data + i + 1);
-            maxLow[0] = math_max(maxLow[0], (int)waveformData.filtered.low);
-            maxLow[1] = math_max(maxLow[1], (int)waveformDataNext.filtered.low);
-            maxMid[0] = math_max(maxMid[0], (int)waveformData.filtered.mid);
-            maxMid[1] = math_max(maxMid[1], (int)waveformDataNext.filtered.mid);
-            maxHigh[0] = math_max(maxHigh[0], (int)waveformData.filtered.high);
-            maxHigh[1] = math_max(maxHigh[1], (int)waveformDataNext.filtered.high);
-            maxAll[0] = math_max( maxAll[0], (int)waveformData.filtered.all);
-            maxAll[1] = math_max( maxAll[1], (int)waveformDataNext.filtered.all);
-        }
-
-        if( maxAll[0] && maxAll[1] ) {
-            // Calculate sum, to normalize
-            // Also multiply on 1.2 to prevent very dark or light color
-            total = (maxLow[0] + maxLow[1] + maxMid[0] + maxMid[1] + maxHigh[0] + maxHigh[1]) * 1.2;
-
-            // prevent division by zero
-            if( total > 0 )
-            {
-                // Normalize low and high (mid not need, because it not change the color)
-                lo = (maxLow[0] + maxLow[1]) / total;
-                hi = (maxHigh[0] + maxHigh[1]) / total;
-            }
-            else
-                lo = hi = 0.0;
-
-            // Set color
-            color.setHsvF(h, 1.0-hi, 1.0-lo);
-
-            painter->setPen(color);
-            switch (m_alignment) {
-                case Qt::AlignBottom :
-                    painter->drawLine(
-                        x, m_waveformRenderer->getHeight(),
-                        x, m_waveformRenderer->getHeight() - (int)(heightFactor*(float)math_max(maxAll[0],maxAll[1])));
-                    break;
-                case Qt::AlignTop :
-                    painter->drawLine(
-                        x, 0,
-                        x, (int)(heightFactor*(float)math_max(maxAll[0],maxAll[1])));
-                    break;
-                default :
-                    painter->drawLine(
-                        x, (int)(halfHeight-heightFactor*(float)maxAll[0]),
-                        x, (int)(halfHeight+heightFactor*(float)maxAll[1]));
-            }
-        }
-    }
-
-    painter->restore();
-}

=== added file 'mixxx/src/waveform/renderers/waveformrendererhsv.h'
--- mixxx/src/waveform/renderers/waveformrendererhsv.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/waveform/renderers/waveformrendererhsv.h	2013-05-01 22:08:27 +0000
@@ -0,0 +1,21 @@
+#ifndef WAVEFORMRENDERERHSV_H
+#define WAVEFORMRENDERERHSV_H
+
+#include "waveformrenderersignalbase.h"
+#include "util.h"
+
+class WaveformRendererHSV : public WaveformRendererSignalBase {
+  public:
+    explicit WaveformRendererHSV(
+        WaveformWidgetRenderer* waveformWidget);
+    virtual ~WaveformRendererHSV();
+
+    virtual void onSetup(const QDomNode& node);
+
+    virtual void draw(QPainter* painter, QPaintEvent* event);
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(WaveformRendererHSV);
+};
+
+#endif // WAVEFORMRENDERERFILTEREDSIGNAL_H

=== removed file 'mixxx/src/waveform/renderers/waveformrendererhsv.h'
--- mixxx/src/waveform/renderers/waveformrendererhsv.h	2012-12-14 01:26:04 +0000
+++ mixxx/src/waveform/renderers/waveformrendererhsv.h	1970-01-01 00:00:00 +0000
@@ -1,21 +0,0 @@
-#ifndef WAVEFORMRENDERERHSV_H
-#define WAVEFORMRENDERERHSV_H
-
-#include "waveformrenderersignalbase.h"
-#include "util.h"
-
-class WaveformRendererHSV : public WaveformRendererSignalBase {
-  public:
-    explicit WaveformRendererHSV(
-        WaveformWidgetRenderer* waveformWidget);
-    virtual ~WaveformRendererHSV();
-
-    virtual void onSetup(const QDomNode& node);
-
-    virtual void draw(QPainter* painter, QPaintEvent* event);
-
-  private:
-    DISALLOW_COPY_AND_ASSIGN(WaveformRendererHSV);
-};
-
-#endif // WAVEFORMRENDERERFILTEREDSIGNAL_H

=== modified file 'mixxx/src/waveform/renderers/waveformrendererpreroll.cpp'
--- mixxx/src/waveform/renderers/waveformrendererpreroll.cpp	2012-11-20 21:24:37 +0000
+++ mixxx/src/waveform/renderers/waveformrendererpreroll.cpp	2013-05-01 22:08:27 +0000
@@ -29,14 +29,13 @@
     if (!track) {
         return;
     }
-    const Waveform* waveform = track->getWaveform();
     double samplesPerPixel = m_waveformRenderer->getVisualSamplePerPixel();
     double numberOfSamples = m_waveformRenderer->getWidth() * samplesPerPixel;
 
     // TODO (vRince) not really accurate since waveform size une visual reasampling and
     // have two mores samples to hold the complete visual data
-    int currentPosition = m_waveformRenderer->getPlayPos() * waveform->getDataSize();
-    m_waveformRenderer->regulateVisualSample(currentPosition);
+    int currentPosition = m_waveformRenderer->getPlayPosVSample();
+    // m_waveformRenderer->regulateVisualSample(currentPosition);
 
     // Some of the pre-roll is on screen. Draw little triangles to indicate
     // where the pre-roll is located.
@@ -47,6 +46,9 @@
         const float halfPolyHeight = m_waveformRenderer->getHeight()/5.0;
 
         painter->save();
+        painter->setRenderHint(QPainter::Antialiasing);
+        //painter->setRenderHint(QPainter::HighQualityAntialiasing);
+        //painter->setBackgroundMode(Qt::TransparentMode);
         painter->setWorldMatrixEnabled(false);
         painter->setPen(QPen(QBrush(m_color), 1));
         QPolygonF polygon;

=== modified file 'mixxx/src/waveform/renderers/waveformrendermark.cpp'
--- mixxx/src/waveform/renderers/waveformrendermark.cpp	2013-03-27 21:32:51 +0000
+++ mixxx/src/waveform/renderers/waveformrendermark.cpp	2013-05-01 22:08:27 +0000
@@ -48,8 +48,8 @@
         }
 
         int samplePosition = mark.m_pointControl->get();
-        if (samplePosition >= 0.0) {
-            m_waveformRenderer->regulateVisualSample(samplePosition);
+        if (samplePosition > 0.0) {
+            //m_waveformRenderer->regulateVisualSample(samplePosition);
             double currentMarkPoint = m_waveformRenderer->transformSampleIndexInRendererWorld(samplePosition);
 
             // NOTE: vRince I guess image width is odd to display the center on the exact line !

=== modified file 'mixxx/src/waveform/renderers/waveformrendermarkrange.cpp'
--- mixxx/src/waveform/renderers/waveformrendermarkrange.cpp	2013-01-31 19:48:57 +0000
+++ mixxx/src/waveform/renderers/waveformrendermarkrange.cpp	2013-05-01 22:08:27 +0000
@@ -58,10 +58,10 @@
         int startSample = markRange.start();
         int endSample = markRange.end();
 
-        m_waveformRenderer->regulateVisualSample(startSample);
+        //m_waveformRenderer->regulateVisualSample(startSample);
         double startPosition = m_waveformRenderer->transformSampleIndexInRendererWorld(startSample);
 
-        m_waveformRenderer->regulateVisualSample(endSample);
+        //m_waveformRenderer->regulateVisualSample(endSample);
         double endPosition = m_waveformRenderer->transformSampleIndexInRendererWorld(endSample);
 
         //range not in the current display

=== modified file 'mixxx/src/waveform/renderers/waveformwidgetrenderer.cpp'
--- mixxx/src/waveform/renderers/waveformwidgetrenderer.cpp	2013-01-31 21:53:32 +0000
+++ mixxx/src/waveform/renderers/waveformwidgetrenderer.cpp	2013-05-01 22:08:27 +0000
@@ -6,56 +6,49 @@
 #include "controlobjectthreadmain.h"
 #include "controlobject.h"
 #include "defs.h"
+#include "visualplayposition.h"
 #include "mathstuff.h"
 
+#include "util/performancetimer.h"
+
+#include <QPainter>
+
 const int WaveformWidgetRenderer::s_waveformMinZoom = 1;
 const int WaveformWidgetRenderer::s_waveformMaxZoom = 6;
 
-WaveformWidgetRenderer::WaveformWidgetRenderer() {
-    m_playPosControlObject = NULL;
-    m_rateControlObject = NULL;
-    m_rateRangeControlObject = NULL;
-    m_rateDirControlObject = NULL;
-    m_gainControlObject = NULL;
-    m_trackSamplesControlObject = NULL;
-
-#ifdef WAVEFORMWIDGETRENDERER_DEBUG
-    m_timer = NULL;
-#endif
-}
-
-WaveformWidgetRenderer::WaveformWidgetRenderer( const char* group) :
-    m_group(group),
-    m_trackInfoObject(0),
-    m_height(-1),
-    m_width(-1) {
+WaveformWidgetRenderer::WaveformWidgetRenderer( const char* group) 
+    : m_group(group),
+      m_trackInfoObject(0),
+      m_height(-1),
+      m_width(-1),
+
+      m_firstDisplayedPosition(0.0),
+      m_lastDisplayedPosition(0.0),
+      m_rendererTransformationOffset(0.0),
+      m_rendererTransformationGain(0.0),
+
+      m_zoomFactor(1.0),
+      m_rateAdjust(0.0),
+      m_visualSamplePerPixel(1.0),
+      m_audioSamplePerPixel(1.0),
+
+      // Really create some to manage those;
+      m_visualPlayPosition(NULL),
+      m_playPos(-1),
+      m_playPosVSample(0),
+      m_rateControlObject(NULL),
+      m_rate(0.0),
+      m_rateRangeControlObject(NULL),
+      m_rateRange(0.0),
+      m_rateDirControlObject(NULL),
+      m_rateDir(0.0),
+      m_gainControlObject(NULL),
+      m_gain(1.0),
+      m_trackSamplesControlObject(NULL),
+      m_trackSamples(0.0) {
+
     //qDebug() << "WaveformWidgetRenderer";
 
-    m_firstDisplayedPosition = 0.0;
-    m_lastDisplayedPosition = 0.0;
-    m_rendererTransformationOffset = 0.0;
-    m_rendererTransformationGain = 0.0;
-
-    m_zoomFactor = 1.0;
-    m_rateAdjust = 0.0;
-    m_visualSamplePerPixel = 1.0;
-    m_audioSamplePerPixel = 1.0;
-
-    // Really create some to manage those
-    m_playPosControlObject = NULL;
-    m_playPos = 0.0;
-    m_rateControlObject = NULL;
-    m_rate = 0.0;
-    m_rateRangeControlObject = NULL;
-    m_rateRange = 0.0;
-    m_rateDirControlObject = NULL;
-    m_rateDir = 0.0;
-    m_gainControlObject = NULL;
-    m_gain = 1.0;
-    m_trackSamplesControlObject = NULL;
-    m_trackSamples = -1.0;
-
-
 #ifdef WAVEFORMWIDGETRENDERER_DEBUG
     m_timer = new QTime();
     currentFrame = 0;
@@ -74,7 +67,6 @@
     for( int i = 0; i < m_rendererStack.size(); ++i)
         delete m_rendererStack[i];
 
-    delete m_playPosControlObject;
     delete m_rateControlObject;
     delete m_rateRangeControlObject;
     delete m_rateDirControlObject;
@@ -89,9 +81,8 @@
 bool WaveformWidgetRenderer::init() {
 
     //qDebug() << "WaveformWidgetRenderer::init";
+    m_visualPlayPosition = VisualPlayPosition::getVisualPlayPosition(m_group);
 
-    m_playPosControlObject = new ControlObjectThreadMain(
-                ControlObject::getControl( ConfigKey(m_group, "visual_playposition")));
     m_rateControlObject = new ControlObjectThreadMain(
                 ControlObject::getControl( ConfigKey(m_group, "rate")));
     m_rateRangeControlObject = new ControlObjectThreadMain(
@@ -111,7 +102,7 @@
     return true;
 }
 
-void WaveformWidgetRenderer::onPreRender() {
+void WaveformWidgetRenderer::onPreRender(VSyncThread* vsyncThread) {
     // For a valid track to render we need
     m_trackSamples = m_trackSamplesControlObject->get();
     if (m_trackSamples <= 0.0) {
@@ -141,7 +132,7 @@
         m_audioSamplePerPixel = 0.0;
     }
 
-    m_playPos = m_playPosControlObject->get();
+    m_playPos = m_visualPlayPosition->getAt(vsyncThread);
     // m_playPos = -1 happens, when a new track is in buffer but m_visualPlayPosition was not updated
 
     if (m_audioSamplePerPixel && m_playPos != -1) {
@@ -153,7 +144,9 @@
         double displayedLengthHalf = static_cast<double>(m_width) / trackPixel / 2.0;
         // Avoid pixel jitter in play position by rounding to the nearest track
         // pixel.
-        m_playPos = round(m_playPosControlObject->get() * trackPixel) / trackPixel;
+        m_playPos = round(m_playPos * trackPixel)/(double)trackPixel; // Avoid pixel jitter in play position
+        m_playPosVSample = m_playPos * m_trackInfoObject->getWaveform()->getDataSize();
+
         m_firstDisplayedPosition = m_playPos - displayedLengthHalf;
         m_lastDisplayedPosition = m_playPos + displayedLengthHalf;
         m_rendererTransformationOffset = - m_firstDisplayedPosition;
@@ -181,6 +174,9 @@
     m_lastSystemFrameTime = m_timer->restart();
 #endif
 
+//    PerformanceTimer timer;
+//    timer.start();
+
     //not ready to display need to wait until track initialization is done
     //draw only first is stack (background)
     int stackSize = m_rendererStack.size();
@@ -191,7 +187,9 @@
         return;
     } else {
         for (int i = 0; i < stackSize; i++) {
+ //           qDebug() << i << " a  " << timer.restart();
             m_rendererStack.at(i)->draw(painter, event);
+ //           qDebug() << i << " e " << timer.restart();
         }
 
         painter->setPen(m_colors.getPlayPosColor());
@@ -215,7 +213,8 @@
                       QString::number(m_lastFrameTime).rightJustified(2,'0') + "(" +
                       QString::number(frameMax).rightJustified(2,'0') + ")" +
                       QString::number(m_lastSystemFrameTime) + "(" +
-                      QString::number(systemMax) + ")");
+                      QString::number(systemMax) + ")" +
+                      QString::number(realtimeError));
 
     painter->drawText(1,m_height-1,
                       QString::number(m_playPos) + " [" +
@@ -234,6 +233,7 @@
     m_lastFramesTime[currentFrame] = m_lastFrameTime;
 #endif
 
+ //   qDebug() << "draw() ende" << timer.restart();
 }
 
 void WaveformWidgetRenderer::resize( int width, int height) {

=== modified file 'mixxx/src/waveform/renderers/waveformwidgetrenderer.h'
--- mixxx/src/waveform/renderers/waveformwidgetrenderer.h	2013-01-31 21:53:32 +0000
+++ mixxx/src/waveform/renderers/waveformwidgetrenderer.h	2013-05-01 22:08:27 +0000
@@ -15,6 +15,8 @@
 
 class TrackInfoObject;
 class ControlObjectThreadMain;
+class VisualPlayPosition;
+class VSyncThread;
 
 class WaveformWidgetRenderer {
 public:
@@ -29,7 +31,7 @@
     virtual bool onInit() {return true;}
 
     void setup(const QDomNode& node);
-    void onPreRender();
+    void onPreRender(VSyncThread* vsyncThread);
     void draw(QPainter* painter, QPaintEvent* event);
 
     const char* getGroup() const { return m_group;}
@@ -56,6 +58,7 @@
     double transformPositionInRendererWorld(double position) const;
 
     double getPlayPos() const { return m_playPos;}
+    double getPlayPosVSample() const { return m_playPosVSample;}
     double getZoomFactor() const { return m_zoomFactor;}
     double getRateAdjust() const { return m_rateAdjust;}
     double getGain() const { return m_gain;}
@@ -78,7 +81,7 @@
 protected:
     const char* m_group;
     TrackPointer m_trackInfoObject;
-    QVector<WaveformRendererAbstract*> m_rendererStack;
+    QList<WaveformRendererAbstract*> m_rendererStack;
     int m_height;
     int m_width;
     WaveformSignalColors m_colors;
@@ -95,8 +98,9 @@
 
     //TODO: vRince create some class to manage control/value
     //ControlConnection
-    ControlObjectThreadMain* m_playPosControlObject;
+    VisualPlayPosition* m_visualPlayPosition;
     double m_playPos;
+    int m_playPosVSample;
     ControlObjectThreadMain* m_rateControlObject;
     double m_rate;
     ControlObjectThreadMain* m_rateRangeControlObject;
@@ -117,7 +121,6 @@
     int currentFrame;
 #endif
 
-    WaveformWidgetRenderer();
 private:
     DISALLOW_COPY_AND_ASSIGN(WaveformWidgetRenderer);
     friend class WaveformWidgetFactory;

=== added file 'mixxx/src/waveform/vsyncthread.cpp'
--- mixxx/src/waveform/vsyncthread.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/waveform/vsyncthread.cpp	2013-05-01 22:08:27 +0000
@@ -0,0 +1,179 @@
+
+#include <QThread>
+#include <QGLWidget>
+#include <QGLFormat>
+#include <QTime>
+#include <qdebug.h>
+#include <QTime>
+
+#include "mathstuff.h"
+#include "vsyncthread.h"
+#include "util/performancetimer.h"
+
+#if defined(__APPLE__)
+
+#elif defined(__WINDOWS__)
+
+#else
+   extern const QX11Info *qt_x11Info(const QPaintDevice *pd);
+#endif
+
+VSyncThread::VSyncThread(QWidget* parent)
+        : QThread(),
+          m_firstRun(false),
+          m_usSyncTime(33333),
+          m_vSyncMode(ST_TIMER),
+          m_syncOk(false),
+          m_rtErrorCnt(0),
+          m_swapWait(0),
+          m_displayFrameRate(60.0),
+          m_interval(1) {
+    doRendering = true;
+}
+
+VSyncThread::~VSyncThread() {
+    doRendering = false;
+    m_sema.release(2); // Two slots
+    wait();
+    //delete m_glw;
+}
+
+void VSyncThread::stop()
+{
+    doRendering = false;
+}
+
+
+void VSyncThread::run() {
+    QThread::currentThread()->setObjectName("VSyncThread");
+
+    int usRest;
+    int usLast;
+
+    m_usWait = m_usSyncTime;
+    m_timer.start();
+
+    while (doRendering) {
+        if (m_vSyncMode == ST_FREE) {
+            // for benchmark only!
+            emit(vsync1()); // renders the waveform, Possible delayed due to anti tearing
+            m_sema.acquire();
+            emit(vsync2()); // swaps the new waveform to front
+            m_sema.acquire();
+            m_timer.restart();
+            m_usWait = 1000;
+            usleep(1000);
+        } else { // if (m_vSyncMode == ST_TIMER) {
+            usRest = m_usWait - m_timer.elapsed() / 1000;
+            // waiting for interval by sleep
+            if (usRest > 100) {
+                usleep(usRest);
+            }
+
+            emit(vsync2()); // swaps the new waveform to front in case of gl-wf
+            m_sema.acquire(); // wait until swap was scheduled. It might be delayed due to driver vSync settings  
+            // <- Assume we are VSynced here ->
+            usLast = m_timer.restart() / 1000;
+            if (usRest < 0) {
+                // Our swapping call was already delayed
+                // The real swap might happens on the following VSync, depending on driver settings 
+                m_rtErrorCnt++; // Count as Real Time Error
+            }
+            // try to stay in right intervals
+            usRest = m_usWait - usLast;
+            m_usWait = m_usSyncTime + (usRest % m_usSyncTime);
+            emit(vsync1()); // renders the new waveform.
+            m_sema.acquire(); // wait until rendreing was scheduled. It might be delayed due a pending swap (depends one driver vSync settings) 
+ 			// qDebug() << "ST_TIMER                      " << usLast << usRest;
+        }
+    }
+}
+
+
+void VSyncThread::postRender(QGLWidget* glw, int index) {
+    // No need for glw->makeCurrent() here.
+//    qDebug() << "postRender" << m_timer.elapsed();
+#if defined(__APPLE__)
+    glw->swapBuffers();
+#elif defined(__WINDOWS__)
+    glw->swapBuffers();
+#else
+    const QX11Info *xinfo = qt_x11Info(glw);
+    glXSwapBuffers(xinfo->display(), glw->winId());
+#endif
+}
+
+int VSyncThread::elapsed() {
+    return m_timer.elapsed() / 1000;
+}
+
+void VSyncThread::setUsSyncTime(int syncTime) {
+    m_usSyncTime = syncTime;
+    double frameRate = 60.0;
+    m_interval = round(m_displayFrameRate * m_usSyncTime / 1000);
+}
+
+void VSyncThread::setVSyncType(int type) {
+    if (type >= (int)VSyncThread::ST_COUNT) {
+        type = VSyncThread::ST_TIMER;
+    }
+    m_vSyncMode = (enum VSyncMode)type;
+    m_rtErrorCnt = 0;
+    m_firstRun = true;
+}
+
+int VSyncThread::usToNextSync() {
+    int usRest = m_usWait - m_timer.elapsed() / 1000;
+    if (usRest < 0) {
+        usRest %= m_usSyncTime;
+        usRest += m_usSyncTime;
+    }
+    return usRest;
+}
+
+int VSyncThread::usFromTimerToNextSync(PerformanceTimer* timer) {
+    int difference = m_timer.difference(timer) / 1000;
+    return difference + m_usWait;
+}
+
+int VSyncThread::rtErrorCnt() {
+    return m_rtErrorCnt;
+}
+
+void VSyncThread::vsyncSlotFinished() {
+    m_sema.release();
+}
+
+void VSyncThread::getAvailableVSyncTypes(QList<QPair<int, QString > >* pList) {
+    QPair<int, QString > pair;
+
+    for (int i = (int)VSyncThread::ST_TIMER; i < (int)VSyncThread::ST_COUNT; i++) {
+        //if (isAvailable(type))  // TODO
+        {
+            enum VSyncMode mode = (enum VSyncMode)i;
+
+            QString name;
+            switch (mode) {
+            case VSyncThread::ST_TIMER:
+                name = tr("Timer (Fallback)");
+                break;
+            case VSyncThread::ST_MESA_VBLANK_MODE_1:
+                name = tr("MESA vblank_mode = 1");
+                break;
+            case VSyncThread::ST_SGI_VIDEO_SYNC:
+                name = tr("Wait for Video sync");
+                break;
+            case VSyncThread::ST_OML_SYNC_CONTROL:
+                name = tr("Sync Control");
+                break;
+            case VSyncThread::ST_FREE:
+                name = tr("Free + 1 ms (for benchmark only)");
+                break;
+            default:
+                break;
+            }
+            QPair<int, QString > pair = QPair<int, QString >(i, name);
+            pList->append(pair);
+        }
+    }
+}

=== added file 'mixxx/src/waveform/vsyncthread.h'
--- mixxx/src/waveform/vsyncthread.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/waveform/vsyncthread.h	2013-05-01 22:08:27 +0000
@@ -0,0 +1,109 @@
+#ifndef VSYNCTHREAD_H
+#define VSYNCTHREAD_H
+
+#include <QTime>
+#include <QThread>
+#include <QSemaphore>
+#include <QPair>
+
+#include <qx11info_x11.h>
+#include "util/performancetimer.h"
+
+
+#if defined(__APPLE__)
+
+#elif defined(__WINDOWS__)
+
+#else
+    #include <GL/glx.h>
+    #include "GL/glxext.h"
+#endif
+
+
+class QGLWidget;
+
+class VSyncThread : public QThread {
+    Q_OBJECT
+  public:
+    enum VSyncMode {
+        ST_TIMER = 0,
+        ST_MESA_VBLANK_MODE_1,
+        ST_SGI_VIDEO_SYNC,
+        ST_OML_SYNC_CONTROL,
+        ST_FREE,
+        ST_COUNT // Dummy Type at last, counting possible types
+    };
+
+    VSyncThread(QWidget* parent);
+    ~VSyncThread();
+    void run();
+    void stop();
+
+    bool waitForVideoSync(QGLWidget* glw);
+    int elapsed();
+    int usToNextSync();
+    void setUsSyncTime(int usSyncTimer);
+    void setVSyncType(int mode);
+    int rtErrorCnt();
+    void setSwapWait(int sw);
+    int usFromTimerToNextSync(PerformanceTimer* timer);
+    void vsyncSlotFinished();
+    void getAvailableVSyncTypes(QList<QPair<int, QString > >* list);
+    void setupSync(QGLWidget* glw, int index);
+    void postRender(QGLWidget* glw, int index);
+    void waitUntilSwap(QGLWidget* glw);
+
+  signals:
+    void vsync1();
+    void vsync2();
+        
+  private:
+    bool doRendering;
+    QGLWidget *m_glw;
+
+#if defined(__APPLE__)
+
+#elif defined(__WINDOWS__)
+
+#else
+    void initGlxext(QGLWidget* glw);
+    bool glXExtensionSupported(Display *dpy, int screen, const char *extension);
+
+    PFNGLXGETVIDEOSYNCSGIPROC glXGetVideoSyncSGI;
+    PFNGLXWAITVIDEOSYNCSGIPROC glXWaitVideoSyncSGI;
+
+    PFNGLXSWAPINTERVALSGIPROC glXSwapIntervalSGI;
+
+    PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT;
+
+    PFNGLXGETSYNCVALUESOMLPROC glXGetSyncValuesOML;
+    PFNGLXGETMSCRATEOMLPROC glXGetMscRateOML;
+    PFNGLXSWAPBUFFERSMSCOMLPROC glXSwapBuffersMscOML;
+    PFNGLXWAITFORMSCOMLPROC glXWaitForMscOML;
+    PFNGLXWAITFORSBCOMLPROC  glXWaitForSbcOML;
+
+    PFNGLXSWAPINTERVALSGIPROC glXSwapIntervalMESA;
+
+    uint m_counter;
+
+    int64_t m_target_msc;
+    Display* m_dpy;
+    GLXDrawable m_drawable;
+
+#endif
+
+    bool m_firstRun;
+    int m_usSyncTime;
+    int m_usWait;
+    enum VSyncMode m_vSyncMode;
+    bool m_syncOk;
+    int m_rtErrorCnt;
+    int m_swapWait;
+    PerformanceTimer m_timer;
+    QSemaphore m_sema;
+    double m_displayFrameRate;
+    int m_interval;
+};
+
+
+#endif // VSYNCTHREAD_H

=== modified file 'mixxx/src/waveform/waveformwidgetfactory.cpp'
--- mixxx/src/waveform/waveformwidgetfactory.cpp	2012-12-13 22:46:16 +0000
+++ mixxx/src/waveform/waveformwidgetfactory.cpp	2013-05-01 22:08:27 +0000
@@ -18,8 +18,13 @@
 #include "waveform/widgets/qtwaveformwidget.h"
 #include "waveform/widgets/qtsimplewaveformwidget.h"
 #include "waveform/widgets/glslwaveformwidget.h"
+#include "waveform/widgets/glvsynctestwidget.h"
 #include "waveform/widgets/waveformwidgetabstract.h"
 #include "widget/wwaveformviewer.h"
+#include "waveform/vsyncthread.h"
+#include "util/cmdlineargs.h"
+
+#include "util/performancetimer.h"
 #include "util/timer.h"
 
 ///////////////////////////////////////////
@@ -31,6 +36,12 @@
 
 ///////////////////////////////////////////
 
+WaveformWidgetHolder::WaveformWidgetHolder()
+    : m_waveformWidget(NULL),
+      m_waveformViewer(NULL),
+      m_visualNodeCache(QDomNode()) {
+}
+
 WaveformWidgetHolder::WaveformWidgetHolder(WaveformWidgetAbstract* waveformWidget,
                                            WWaveformViewer* waveformViewer,
                                            const QDomNode& visualNodeCache)
@@ -51,8 +62,8 @@
         m_overviewNormalized(false),
         m_openGLAvailable(false),
         m_openGLShaderAvailable(false),
-        m_time(new QTime()),
-        m_lastFrameTime(0),
+        m_vsyncThread(NULL),
+        m_frameCnt(0),
         m_actualFrameRate(0) {
 
     m_visualGain[All] = 1.5;
@@ -129,17 +140,20 @@
     }
 
     evaluateWidgets();
-    start();
+    m_time.start();
 }
 
 WaveformWidgetFactory::~WaveformWidgetFactory() {
-    delete m_time;
+    if (m_vsyncThread) {
+        delete m_vsyncThread;
+    }
 }
 
-bool WaveformWidgetFactory::setConfig(ConfigObject<ConfigValue> *config){
+bool WaveformWidgetFactory::setConfig(ConfigObject<ConfigValue> *config) {
     m_config = config;
-    if (!m_config)
+    if (!m_config) {
         return false;
+    }
 
     bool ok = false;
 
@@ -150,6 +164,9 @@
         m_config->set(ConfigKey("[Waveform]","FrameRate"), ConfigValue(m_frameRate));
     }
 
+    int vsync = m_config->getValueString(ConfigKey("[Waveform]","VSync"),"0").toInt();
+    setVSyncType(vsync);
+
     int defaultZoom = m_config->getValueString(ConfigKey("[Waveform]","DefaultZoom")).toInt(&ok);
     if (ok) {
         setDefaultZoom(defaultZoom);
@@ -192,25 +209,8 @@
     return true;
 }
 
-void WaveformWidgetFactory::start() {
-    //qDebug() << "WaveformWidgetFactory::start";
-    killTimer(m_mainTimerId);
-    m_mainTimerId = startTimer(1000.0/double(m_frameRate));
-}
-
-void WaveformWidgetFactory::stop() {
-    killTimer(m_mainTimerId);
-    m_mainTimerId = -1;
-}
-
-void WaveformWidgetFactory::timerEvent(QTimerEvent *timerEvent) {
-    if (timerEvent->timerId() == m_mainTimerId) {
-        refresh();
-    }
-}
-
 void WaveformWidgetFactory::destroyWidgets() {
-    for (unsigned int i = 0; i < m_waveformWidgetHolders.size(); i++) {
+    for (int i = 0; i < m_waveformWidgetHolders.size(); i++) {
         WaveformWidgetAbstract* pWidget = m_waveformWidgetHolders[i].m_waveformWidget;;
         m_waveformWidgetHolders[i].m_waveformWidget = NULL;
         delete pWidget;
@@ -247,6 +247,7 @@
     }
 
     viewer->setZoom(m_defaultZoom);
+    viewer->update();
 
     qDebug() << "WaveformWidgetFactory::setWaveformWidget - waveform widget added in factory, index" << index;
 
@@ -254,11 +255,25 @@
 }
 
 void WaveformWidgetFactory::setFrameRate(int frameRate) {
-    m_frameRate = math_min(60, math_max(10, frameRate));
+    m_frameRate = math_min(120, math_max(1, frameRate));
     if (m_config) {
         m_config->set(ConfigKey("[Waveform]","FrameRate"), ConfigValue(m_frameRate));
     }
-    start();
+    m_vsyncThread->setUsSyncTime(1000000/m_frameRate);
+}
+
+
+void WaveformWidgetFactory::setVSyncType(int type) {
+    if (m_config) {
+        m_config->set(ConfigKey("[Waveform]","VSync"), ConfigValue((int)type));
+    }
+
+    m_vSyncType = type;
+    m_vsyncThread->setVSyncType(type);
+}
+
+int WaveformWidgetFactory::getVSyncType() {
+    return m_vSyncType;
 }
 
 bool WaveformWidgetFactory::setWidgetType(WaveformWidgetType::Type type) {
@@ -266,7 +281,7 @@
         return true;
 
     // check if type is acceptable
-    for (unsigned int i = 0; i < m_waveformWidgetHandles.size(); i++) {
+    for (int i = 0; i < m_waveformWidgetHandles.size(); i++) {
         WaveformWidgetAbstractHandle& handle = m_waveformWidgetHandles[i];
         if (handle.m_type == type) {
             // type is acceptable
@@ -307,7 +322,7 @@
     //qDebug() << "recreate start";
 
     //re-create/setup all waveform widgets
-    for (unsigned int i = 0; i < m_waveformWidgetHolders.size(); i++) {
+    for (int i = 0; i < m_waveformWidgetHolders.size(); i++) {
         WaveformWidgetHolder& holder = m_waveformWidgetHolders[i];
         WaveformWidgetAbstract* previousWidget = holder.m_waveformWidget;
         TrackPointer pTrack = previousWidget->getTrackInfo();
@@ -325,6 +340,8 @@
         //viewer->resize(viewer->size());
         widget->resize(viewer->width(), viewer->height());
         widget->setTrack(pTrack);
+        widget->getWidget()->show();
+        viewer->update();
     }
 
     m_skipRender = false;
@@ -339,7 +356,7 @@
         m_config->set(ConfigKey("[Waveform]","DefaultZoom"), ConfigValue(m_defaultZoom));
     }
 
-    for (unsigned int i = 0; i < m_waveformWidgetHolders.size(); i++) {
+    for (int i = 0; i < m_waveformWidgetHolders.size(); i++) {
         m_waveformWidgetHolders[i].m_waveformViewer->setZoom(m_defaultZoom);
     }
 }
@@ -355,7 +372,7 @@
     }
 
     int refZoom = m_waveformWidgetHolders[0].m_waveformWidget->getZoomFactor();
-    for (unsigned int i = 1; i < m_waveformWidgetHolders.size(); i++) {
+    for (int i = 1; i < m_waveformWidgetHolders.size(); i++) {
         m_waveformWidgetHolders[i].m_waveformViewer->setZoom(refZoom);
     }
 }
@@ -390,29 +407,67 @@
 }
 
 void WaveformWidgetFactory::refresh() {
-    if (m_skipRender)
-        return;
-
     ScopedTimer t(QString("WaveformWidgetFactory::refresh() %1waveforms")
-                  .arg(m_waveformWidgetHolders.size()));
-
-    for (unsigned int i = 0; i < m_waveformWidgetHolders.size(); i++)
-        m_waveformWidgetHolders[i].m_waveformWidget->preRender();
-
-    for (unsigned int i = 0; i < m_waveformWidgetHolders.size(); i++)
-        m_waveformWidgetHolders[i].m_waveformWidget->render();
-
-    for (unsigned int i = 0; i < m_waveformWidgetHolders.size(); i++)
-        m_waveformWidgetHolders[i].m_waveformWidget->postRender();
-
-    // Notify all other waveform-like widgets (e.g. WSpinny's) that they should
-    // update.
-    emit(waveformUpdateTick());
-
-    m_lastFrameTime = m_time->restart();
-    if (m_lastFrameTime && m_lastFrameTime <= 1000) {
-        m_actualFrameRate = 1000.0/(double)(m_lastFrameTime);
-    }
+            .arg(m_waveformWidgetHolders.size()));    
+
+    int paintersSetupTime0 = 0;
+    int paintersSetupTime1 = 0;
+
+    if (!m_skipRender) {
+        if (m_type) {   // no regular updates for an empty waveform
+            // next rendered frame is displayed after next buffer swap and than after VSync
+            for (int i = 0; i < m_waveformWidgetHolders.size(); i++) {
+                // Calculate play position for the new Frame in following run
+                m_waveformWidgetHolders[i].m_waveformWidget->preRender(m_vsyncThread);
+            }
+            //qDebug() << "prerender" << m_vsyncThread->elapsed();
+
+            // It may happen that there is an artificially delayed due to
+            // anti tearing driver settings
+            // all render commands are delayed until the swap from the previous run is executed
+            for (int i = 0; i < m_waveformWidgetHolders.size(); i++) {
+                (void)m_waveformWidgetHolders[i].m_waveformWidget->render();
+                // qDebug() << "render" << i << m_vsyncThread->elapsed();
+            }
+        }
+
+        // Notify all other waveform-like widgets (e.g. WSpinny's) that they should
+        // update.
+        //int t1 = m_vsyncThread->elapsed();
+        emit(waveformUpdateTick());
+        //qDebug() << "emit" << m_vsyncThread->elapsed() - t1;
+
+        m_frameCnt += 1.0;
+        int timeCnt = m_time.elapsed();
+        if (timeCnt > 1000) {
+            m_time.start();
+            m_frameCnt = m_frameCnt * 1000 / timeCnt; // latency correction
+            emit(waveformMeasured(m_frameCnt, m_vsyncThread->rtErrorCnt()));
+            m_frameCnt = 0.0;
+        }
+    }
+    //qDebug() << "refresh end" << m_vsyncThread->elapsed();
+    m_vsyncThread->vsyncSlotFinished();
+}
+
+void WaveformWidgetFactory::postRefresh() {
+    // Do this in an extra slot to be sure to hit the desired interval
+    if (!m_skipRender) {
+        if (m_type) {   // no regular updates for an empty waveform
+            // Show rendered buffer from last refresh() run
+            //qDebug() << "postRefresh start" << m_vsyncThread->elapsed();
+            for (int i = 0; i < m_waveformWidgetHolders.size(); i++) {
+                QGLWidget* glw = dynamic_cast<QGLWidget*>(
+                        m_waveformWidgetHolders[i].m_waveformWidget->getWidget());
+                if (glw) {
+                    m_vsyncThread->postRender(glw, i);
+                }
+                //qDebug() << "postRefresh x" << m_vsyncThread->elapsed();
+            }
+        }
+    }
+    //qDebug() << "postRefresh end" << m_vsyncThread->elapsed();
+    m_vsyncThread->vsyncSlotFinished();
 }
 
 WaveformWidgetType::Type WaveformWidgetFactory::autoChooseWidgetType() const {
@@ -435,12 +490,14 @@
         QString widgetName;
         bool useOpenGl;
         bool useOpenGLShaders;
+        bool developerOnly;
 
         switch(type) {
         case WaveformWidgetType::EmptyWaveform:
             widgetName = EmptyWaveformWidget::getWaveformWidgetName();
             useOpenGl = EmptyWaveformWidget::useOpenGl();
             useOpenGLShaders = EmptyWaveformWidget::useOpenGLShaders();
+            developerOnly = EmptyWaveformWidget::developerOnly();
             break;
         case WaveformWidgetType::SoftwareSimpleWaveform:
             continue; // //TODO(vrince):
@@ -448,37 +505,52 @@
             widgetName = SoftwareWaveformWidget::getWaveformWidgetName();
             useOpenGl = SoftwareWaveformWidget::useOpenGl();
             useOpenGLShaders = SoftwareWaveformWidget::useOpenGLShaders();
+            developerOnly = SoftwareWaveformWidget::developerOnly();
             break;
         case WaveformWidgetType::HSVWaveform:
             widgetName = HSVWaveformWidget::getWaveformWidgetName();
             useOpenGl = HSVWaveformWidget::useOpenGl();
             useOpenGLShaders = HSVWaveformWidget::useOpenGLShaders();
+            developerOnly = HSVWaveformWidget::developerOnly();
             break;
         case WaveformWidgetType::QtSimpleWaveform:
             widgetName = QtSimpleWaveformWidget::getWaveformWidgetName();
             useOpenGl = QtSimpleWaveformWidget::useOpenGl();
             useOpenGLShaders = QtSimpleWaveformWidget::useOpenGLShaders();
+            developerOnly = QtSimpleWaveformWidget::developerOnly();
             break;
         case WaveformWidgetType::QtWaveform:
             widgetName = QtWaveformWidget::getWaveformWidgetName();
             useOpenGl = QtWaveformWidget::useOpenGl();
             useOpenGLShaders = QtWaveformWidget::useOpenGLShaders();
+            developerOnly = QtWaveformWidget::developerOnly();
             break;
         case WaveformWidgetType::GLSimpleWaveform:
             widgetName = GLSimpleWaveformWidget::getWaveformWidgetName();
             useOpenGl = GLSimpleWaveformWidget::useOpenGl();
             useOpenGLShaders = GLSimpleWaveformWidget::useOpenGLShaders();
+            developerOnly = GLSimpleWaveformWidget::developerOnly();
             break;
         case WaveformWidgetType::GLWaveform:
             widgetName = GLWaveformWidget::getWaveformWidgetName();
             useOpenGl = GLWaveformWidget::useOpenGl();
             useOpenGLShaders = GLWaveformWidget::useOpenGLShaders();
+            developerOnly = GLWaveformWidget::developerOnly();
             break;
         case WaveformWidgetType::GLSLWaveform:
             widgetName = GLSLWaveformWidget::getWaveformWidgetName();
             useOpenGl = GLSLWaveformWidget::useOpenGl();
             useOpenGLShaders = GLSLWaveformWidget::useOpenGLShaders();
-            break;
+            developerOnly = GLSLWaveformWidget::developerOnly();
+            break;
+        case WaveformWidgetType::GLVSyncTest:
+            widgetName = GLVSyncTestWidget::getWaveformWidgetName();
+            useOpenGl = GLVSyncTestWidget::useOpenGl();
+            useOpenGLShaders = GLVSyncTestWidget::useOpenGLShaders();
+            developerOnly = GLVSyncTestWidget::developerOnly();
+            break;
+        default:
+            continue;
         }
 
         if (useOpenGLShaders) {
@@ -499,6 +571,12 @@
             handle.m_active = false;
             continue;
         }
+
+        if (developerOnly && !CmdlineArgs::Instance().getDeveloper()) {
+            handle.m_active = false;
+            continue;
+        }
+
         m_waveformWidgetHandles.push_back(handle);
     }
 }
@@ -529,6 +607,9 @@
         case WaveformWidgetType::GLSLWaveform:
             widget = new GLSLWaveformWidget(viewer->getGroup(), viewer);
             break;
+        case WaveformWidgetType::GLVSyncTest:
+            widget = new GLVSyncTestWidget(viewer->getGroup(), viewer);
+            break;
         default:
         //case WaveformWidgetType::SoftwareSimpleWaveform: TODO: (vrince)
         //case WaveformWidgetType::EmptyWaveform:
@@ -552,8 +633,32 @@
 }
 
 int WaveformWidgetFactory::findIndexOf(WWaveformViewer* viewer) const {
-    for (int i = 0; i < (int)m_waveformWidgetHolders.size(); i++)
-        if (m_waveformWidgetHolders[i].m_waveformViewer == viewer)
+    for (int i = 0; i < (int)m_waveformWidgetHolders.size(); i++) {
+        if (m_waveformWidgetHolders[i].m_waveformViewer == viewer) {
             return i;
+        }
+    }
     return -1;
 }
+
+void WaveformWidgetFactory::startVSync(QWidget *parent) {
+    if (m_vsyncThread) {
+        disconnect(m_vsyncThread, SIGNAL(vsync1()), this, SLOT(refresh()));
+        disconnect(m_vsyncThread, SIGNAL(vsync2()), this, SLOT(postRefresh()));
+        delete m_vsyncThread;
+    }
+    m_vsyncThread = new VSyncThread(parent);
+    m_vsyncThread->start();
+
+    connect(m_vsyncThread, SIGNAL(vsync1()),
+            this, SLOT(refresh()));
+    connect(m_vsyncThread, SIGNAL(vsync2()),
+            this, SLOT(postRefresh()));
+
+}
+
+void WaveformWidgetFactory::getAvailableVSyncTypes(QList<QPair<int, QString > >* pList) {
+    m_vsyncThread->getAvailableVSyncTypes(pList);
+}
+
+

=== modified file 'mixxx/src/waveform/waveformwidgetfactory.h'
--- mixxx/src/waveform/waveformwidgetfactory.h	2012-05-30 18:26:44 +0000
+++ mixxx/src/waveform/waveformwidgetfactory.h	2013-05-01 22:08:27 +0000
@@ -8,14 +8,15 @@
 #include "waveform/waveform.h"
 
 #include <QObject>
-
-#include <vector>
+#include <QTime>
+#include <QVector>
 
 class WWaveformViewer;
 class WaveformWidgetAbstract;
 class ControlObjectThreadMain;
 class QTimer;
-class QTime;
+class VSyncThread;
+
 
 class WaveformWidgetAbstractHandle {
   public:
@@ -34,7 +35,9 @@
 };
 
 class WaveformWidgetHolder {
-private:
+  public:
+    WaveformWidgetHolder();
+  private:
     WaveformWidgetHolder(WaveformWidgetAbstract* waveformWidget,
                          WWaveformViewer* waveformViewer,
                          const QDomNode& visualNodeCache);
@@ -62,7 +65,7 @@
 
     void setFrameRate( int frameRate);
     int getFrameRate() const { return m_frameRate;}
-    double getActualFrameRate() const { return m_actualFrameRate;}
+//    bool getVSync() const { return m_vSyncType;}
 
     bool isOpenGLAvailable() const { return m_openGLAvailable;}
     QString getOpenGLVersion() const { return m_openGLVersion;}
@@ -85,22 +88,21 @@
     void setOverviewNormalized(bool normalize);
     int isOverviewNormalized() const { return m_overviewNormalized;}
 
-    const std::vector<WaveformWidgetAbstractHandle> getAvailableTypes() const { return m_waveformWidgetHandles;}
+    const QVector<WaveformWidgetAbstractHandle> getAvailableTypes() const { return m_waveformWidgetHandles;}
+    void getAvailableVSyncTypes(QList<QPair<int, QString > >* list);
     void destroyWidgets();
 
     void addTimerListener(QWidget* pWidget);
 
-  public slots:
-    void start();
-    void stop();
+    void startVSync(QWidget *parent);
+    void setVSyncType(int vsType);
+    int getVSyncType();
 
     void notifyZoomChange(WWaveformViewer *viewer);
 
   signals:
     void waveformUpdateTick();
-
-  protected:
-    void timerEvent(QTimerEvent *timerEvent);
+    void waveformMeasured(float frameRate, int rtErrorCnt);
 
   protected:
     WaveformWidgetFactory();
@@ -110,6 +112,7 @@
 
   private slots:
     void refresh();
+    void postRefresh();
 
   private:
     WaveformWidgetType::Type autoChooseWidgetType() const;
@@ -118,10 +121,11 @@
     int findIndexOf( WWaveformViewer* viewer) const;
 
     //All type of available widgets
-    std::vector<WaveformWidgetAbstractHandle> m_waveformWidgetHandles;
+
+    QVector<WaveformWidgetAbstractHandle> m_waveformWidgetHandles;
 
     //Currently in use widgets/visual/node
-    std::vector<WaveformWidgetHolder> m_waveformWidgetHolders;
+    QVector<WaveformWidgetHolder> m_waveformWidgetHolders;
 
     WaveformWidgetType::Type m_type;
 
@@ -139,10 +143,17 @@
     QString m_openGLVersion;
     bool m_openGLShaderAvailable;
 
+    VSyncThread* m_vsyncThread;
+
     //Debug
-    QTime* m_time;
-    int m_lastFrameTime;
+    QTime m_time;
+    QTime m_delayTime;
+    float m_frameCnt;
+    int m_lastRenderDuration;
     double m_actualFrameRate;
+    double m_minimumFrameRate;
+    double m_maximumlFrameRate;
+    int m_vSyncType;
 };
 
 #endif // WAVEFORMWIDGETFACTORY_H

=== modified file 'mixxx/src/waveform/widgets/emptywaveformwidget.cpp'
--- mixxx/src/waveform/widgets/emptywaveformwidget.cpp	2012-09-19 21:04:53 +0000
+++ mixxx/src/waveform/widgets/emptywaveformwidget.cpp	2013-05-01 22:08:27 +0000
@@ -25,6 +25,12 @@
 }
 
 void EmptyWaveformWidget::paintEvent(QPaintEvent* event) {
+    // Only render if Qt thinks it is required
     QPainter painter(this);
     draw(&painter,event);
 }
+
+int EmptyWaveformWidget::render() {
+    // skip update every frame
+    return 0;
+}

=== modified file 'mixxx/src/waveform/widgets/emptywaveformwidget.h'
--- mixxx/src/waveform/widgets/emptywaveformwidget.h	2012-09-19 21:04:53 +0000
+++ mixxx/src/waveform/widgets/emptywaveformwidget.h	2013-05-01 22:08:27 +0000
@@ -18,13 +18,14 @@
     static inline QString getWaveformWidgetName() { return tr("Empty"); }
     static inline bool useOpenGl() { return false; }
     static inline bool useOpenGLShaders() { return false; }
+    static inline bool developerOnly() { return false; }
 
   protected:
     virtual void castToQWidget();
     virtual void paintEvent(QPaintEvent* event);
+    virtual int render();
 
   private:
-    EmptyWaveformWidget() {}
     EmptyWaveformWidget(const char* group, QWidget* parent);
     friend class WaveformWidgetFactory;
 };

=== modified file 'mixxx/src/waveform/widgets/glsimplewaveformwidget.cpp'
--- mixxx/src/waveform/widgets/glsimplewaveformwidget.cpp	2013-01-04 20:29:33 +0000
+++ mixxx/src/waveform/widgets/glsimplewaveformwidget.cpp	2013-05-01 22:08:27 +0000
@@ -13,6 +13,8 @@
 #include "waveform/renderers/waveformrendererendoftrack.h"
 #include "waveform/renderers/waveformrenderbeat.h"
 
+#include "util/performancetimer.h"
+
 GLSimpleWaveformWidget::GLSimpleWaveformWidget( const char* group, QWidget* parent)
         : QGLWidget(parent, SharedGLContext::getWidget()),
           WaveformWidgetAbstract(group) {
@@ -49,11 +51,24 @@
 }
 
 void GLSimpleWaveformWidget::paintEvent( QPaintEvent* event) {
-    if (QGLContext::currentContext() != context()) {
-        makeCurrent();
-    }
+    Q_UNUSED(event);
+}
+
+int GLSimpleWaveformWidget::render() {
+    PerformanceTimer timer;
+    int t1;
+    //int t2, t3;
+    timer.start();
+    // QPainter makes QGLContext::currentContext() == context()
+    // this may delayed until previous buffer swap finished
     QPainter painter(this);
-    draw(&painter,event);
+    t1 = timer.restart();
+    draw(&painter, NULL);
+    //t2 = timer.restart();
+    //glFinish();
+    //t3 = timer.restart();
+    //qDebug() << "GLVSyncTestWidget "<< t1 << t2 << t3;
+    return t1 / 1000; // return timer for painter setup
 }
 
 void GLSimpleWaveformWidget::postRender() {

=== modified file 'mixxx/src/waveform/widgets/glsimplewaveformwidget.h'
--- mixxx/src/waveform/widgets/glsimplewaveformwidget.h	2012-09-19 21:04:53 +0000
+++ mixxx/src/waveform/widgets/glsimplewaveformwidget.h	2013-05-01 22:08:27 +0000
@@ -11,19 +11,20 @@
     GLSimpleWaveformWidget(const char* group, QWidget* parent);
     virtual ~GLSimpleWaveformWidget();
 
-    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::GLSimpleWaveform;}
+    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::GLSimpleWaveform; }
 
-    static inline QString getWaveformWidgetName() { return tr("Simple");}
-    static inline bool useOpenGl() { return true;}
-    static inline bool useOpenGLShaders() { return false;}
+    static inline QString getWaveformWidgetName() { return tr("Simple"); }
+    static inline bool useOpenGl() { return true; }
+    static inline bool useOpenGLShaders() { return false; }
+    static inline bool developerOnly() { return false; }
 
   protected:
     virtual void castToQWidget();
     virtual void paintEvent(QPaintEvent* event);
     virtual void postRender();
+    virtual int render();
 
   private:
-    GLSimpleWaveformWidget() {}
     friend class WaveformWidgetFactory;
 };
 #endif // GLSIMPLEWAVEFORMWIDGET_H

=== modified file 'mixxx/src/waveform/widgets/glslwaveformwidget.cpp'
--- mixxx/src/waveform/widgets/glslwaveformwidget.cpp	2013-01-04 20:29:33 +0000
+++ mixxx/src/waveform/widgets/glslwaveformwidget.cpp	2013-05-01 22:08:27 +0000
@@ -13,6 +13,8 @@
 #include "waveform/renderers/waveformrenderbeat.h"
 #include "sharedglcontext.h"
 
+#include "util/performancetimer.h"
+
 GLSLWaveformWidget::GLSLWaveformWidget( const char* group, QWidget* parent)
         : QGLWidget(parent, SharedGLContext::getWidget()),
           WaveformWidgetAbstract(group) {
@@ -48,10 +50,24 @@
 }
 
 void GLSLWaveformWidget::paintEvent( QPaintEvent* event) {
-    makeCurrent();
+    Q_UNUSED(event);
+}
+
+int GLSLWaveformWidget::render() {
+    PerformanceTimer timer;
+    int t1;
+    //int t2, t3;
+    timer.start();
+    // QPainter makes QGLContext::currentContext() == context()
+    // this may delayed until previous buffer swap finished
     QPainter painter(this);
-    draw(&painter,event);
-    QGLWidget::swapBuffers();
+    t1 = timer.restart();
+    draw(&painter, NULL);
+    //t2 = timer.restart();
+    //glFinish();
+    //t3 = timer.restart();
+    //qDebug() << "GLVSyncTestWidget "<< t1 << t2 << t3;
+    return t1 / 1000; // return timer for painter setup
 }
 
 void GLSLWaveformWidget::resize( int width, int height) {
@@ -67,3 +83,7 @@
         signalRenderer_->loadShaders();
     }
 }
+
+void GLSLWaveformWidget::postRender() {
+    swapBuffers();
+}

=== modified file 'mixxx/src/waveform/widgets/glslwaveformwidget.h'
--- mixxx/src/waveform/widgets/glslwaveformwidget.h	2012-12-06 06:35:21 +0000
+++ mixxx/src/waveform/widgets/glslwaveformwidget.h	2013-05-01 22:08:27 +0000
@@ -13,11 +13,12 @@
     GLSLWaveformWidget(const char* group, QWidget* parent);
     virtual ~GLSLWaveformWidget();
 
-    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::GLSLWaveform;}
+    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::GLSLWaveform; }
 
-    static inline QString getWaveformWidgetName() { return tr("Filtered") + " - " + tr("experimental");}
-    static inline bool useOpenGl() { return true;}
-    static inline bool useOpenGLShaders() { return true;}
+    static inline QString getWaveformWidgetName() { return tr("Filtered") + " - " + tr("experimental"); }
+    static inline bool useOpenGl() { return true; }
+    static inline bool useOpenGLShaders() { return true; }
+    static inline bool developerOnly() { return false; }
 
     virtual void resize(int width, int height);
 
@@ -25,11 +26,12 @@
     virtual void castToQWidget();
     virtual void paintEvent(QPaintEvent* event);
     virtual void mouseDoubleClickEvent(QMouseEvent *);
+    virtual void postRender();
+    virtual int render();
 
   private:
     GLSLWaveformRendererSignal* signalRenderer_;
 
-    GLSLWaveformWidget() {}
     friend class WaveformWidgetFactory;
 };
 

=== added file 'mixxx/src/waveform/widgets/glvsynctestwidget.cpp'
--- mixxx/src/waveform/widgets/glvsynctestwidget.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/waveform/widgets/glvsynctestwidget.cpp	2013-05-01 22:08:27 +0000
@@ -0,0 +1,75 @@
+#include "glvsynctestwidget.h"
+
+#include <QPainter>
+
+#include "sharedglcontext.h"
+#include "waveform/renderers/waveformwidgetrenderer.h"
+#include "waveform/renderers/waveformrenderbackground.h"
+#include "waveform/renderers/glwaveformrenderersimplesignal.h"
+#include "waveform/renderers/glvsynctestrenderer.h"
+#include "waveform/renderers/waveformrendererpreroll.h"
+#include "waveform/renderers/waveformrendermark.h"
+#include "waveform/renderers/waveformrendermarkrange.h"
+#include "waveform/renderers/waveformrendererendoftrack.h"
+#include "waveform/renderers/waveformrenderbeat.h"
+
+#include "util/performancetimer.h"
+
+GLVSyncTestWidget::GLVSyncTestWidget( const char* group, QWidget* parent)
+    : QGLWidget(parent, SharedGLContext::getWidget()),
+      WaveformWidgetAbstract(group) {
+
+//    addRenderer<WaveformRenderBackground>(); // 172 µs
+//    addRenderer<WaveformRendererEndOfTrack>(); // 677 µs 1145 µs (active)
+//    addRenderer<WaveformRendererPreroll>(); // 652 µs 2034 µs (active)
+//    addRenderer<WaveformRenderMarkRange>(); // 793 µs
+    addRenderer<GLVSyncTestRenderer>(); // 841 µs // 2271 µs
+//    addRenderer<WaveformRenderMark>(); // 711 µs
+//    addRenderer<WaveformRenderBeat>(); // 1183 µs
+
+    setAttribute(Qt::WA_NoSystemBackground);
+    setAttribute(Qt::WA_OpaquePaintEvent);
+
+    setAutoBufferSwap(false);
+
+    if (QGLContext::currentContext() != context()) {
+        makeCurrent();
+    }
+    m_initSuccess = init();
+    qDebug() << "GLVSyncTestWidget.isSharing() =" << isSharing();
+}
+
+GLVSyncTestWidget::~GLVSyncTestWidget(){
+    if (QGLContext::currentContext() != context()) {
+        makeCurrent();
+    }
+}
+
+void GLVSyncTestWidget::castToQWidget() {
+    m_widget = static_cast<QWidget*>(static_cast<QGLWidget*>(this));
+}
+
+void GLVSyncTestWidget::paintEvent( QPaintEvent* event) {
+    Q_UNUSED(event);
+}
+
+int GLVSyncTestWidget::render() {
+    PerformanceTimer timer;
+    int t1;
+    //int t2, t3;
+    timer.start();
+    // QPainter makes QGLContext::currentContext() == context()
+    // this may delayed until previous buffer swap finished
+    QPainter painter(this);
+    t1 = timer.restart();
+    draw(&painter, NULL);
+    //t2 = timer.restart();
+    glFinish();
+    //t3 = timer.restart();
+    //qDebug() << "GLVSyncTestWidget "<< t1 << t2 << t3;
+    return t1 / 1000; // return timer for painter setup
+}
+
+void GLVSyncTestWidget::postRender() {
+    QGLWidget::swapBuffers();
+}

=== added file 'mixxx/src/waveform/widgets/glvsynctestwidget.h'
--- mixxx/src/waveform/widgets/glvsynctestwidget.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/waveform/widgets/glvsynctestwidget.h	2013-05-01 22:08:27 +0000
@@ -0,0 +1,30 @@
+#ifndef GLVSYNCTESTWIDGET_H
+#define GLVSYNCTESTWIDGET_H
+
+#include <QGLWidget>
+
+#include "waveformwidgetabstract.h"
+
+class GLVSyncTestWidget : public QGLWidget, public WaveformWidgetAbstract {
+    Q_OBJECT
+  public:
+    GLVSyncTestWidget(const char* group, QWidget* parent);
+    virtual ~GLVSyncTestWidget();
+
+    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::GLVSyncTest; }
+
+    static inline QString getWaveformWidgetName() { return tr("VSyncTest"); }
+    static inline bool useOpenGl() { return true; }
+    static inline bool useOpenGLShaders() { return false; }
+    static inline bool developerOnly() { return true; }
+
+  protected:
+    virtual void castToQWidget();
+    virtual void paintEvent(QPaintEvent* event);
+    virtual void postRender();
+    virtual int render();
+
+  private:
+    friend class WaveformWidgetFactory;
+};
+#endif // GLVSYNCTESTWIDGET_H

=== modified file 'mixxx/src/waveform/widgets/glwaveformwidget.cpp'
--- mixxx/src/waveform/widgets/glwaveformwidget.cpp	2013-01-04 20:29:33 +0000
+++ mixxx/src/waveform/widgets/glwaveformwidget.cpp	2013-05-01 22:08:27 +0000
@@ -13,6 +13,7 @@
 #include "waveform/renderers/waveformrendererendoftrack.h"
 #include "waveform/renderers/waveformrenderbeat.h"
 #include "sharedglcontext.h"
+#include "util/performancetimer.h"
 
 GLWaveformWidget::GLWaveformWidget( const char* group, QWidget* parent)
         : QGLWidget(parent, SharedGLContext::getWidget()),
@@ -48,11 +49,24 @@
 }
 
 void GLWaveformWidget::paintEvent( QPaintEvent* event) {
-    if (QGLContext::currentContext() != context()) {
-        makeCurrent();
-    }
+    Q_UNUSED(event);
+}
+
+int GLWaveformWidget::render() {
+    PerformanceTimer timer;
+    int t1;
+    //int t2, t3;
+    timer.start();
+    // QPainter makes QGLContext::currentContext() == context()
+    // this may delayed until previous buffer swap finished
     QPainter painter(this);
-    draw(&painter, event);
+    t1 = timer.restart();
+    draw(&painter, NULL);
+    //t2 = timer.restart();
+    // glFinish();
+    //t3 = timer.restart();
+    //qDebug() << "GLVSyncTestWidget "<< t1 << t2 << t3;
+    return t1 / 1000; // return timer for painter setup
 }
 
 void GLWaveformWidget::postRender() {

=== modified file 'mixxx/src/waveform/widgets/glwaveformwidget.h'
--- mixxx/src/waveform/widgets/glwaveformwidget.h	2012-12-06 06:35:21 +0000
+++ mixxx/src/waveform/widgets/glwaveformwidget.h	2013-05-01 22:08:27 +0000
@@ -13,17 +13,18 @@
 
     virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::GLWaveform; }
 
-    static inline QString getWaveformWidgetName() { return tr("Filtered");}
-    static inline bool useOpenGl() { return true;}
-    static inline bool useOpenGLShaders() { return false;}
+    static inline QString getWaveformWidgetName() { return tr("Filtered"); }
+    static inline bool useOpenGl() { return true; }
+    static inline bool useOpenGLShaders() { return false; }
+    static inline bool developerOnly() { return false; }
 
   protected:
     virtual void castToQWidget();
     virtual void paintEvent(QPaintEvent* event);
     virtual void postRender();
+    virtual int render();
 
   private:
-    GLWaveformWidget() {}
     friend class WaveformWidgetFactory;
 };
 

=== added file 'mixxx/src/waveform/widgets/hsvwaveformwidget.cpp'
--- mixxx/src/waveform/widgets/hsvwaveformwidget.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/waveform/widgets/hsvwaveformwidget.cpp	2013-05-01 22:08:27 +0000
@@ -0,0 +1,41 @@
+#include "hsvwaveformwidget.h"
+
+#include <QPainter>
+
+#include "waveform/renderers/waveformwidgetrenderer.h"
+#include "waveform/renderers/waveformrenderbackground.h"
+#include "waveform/renderers/waveformrendermark.h"
+#include "waveform/renderers/waveformrendermarkrange.h"
+#include "waveform/renderers/waveformrendererhsv.h"
+#include "waveform/renderers/waveformrendererpreroll.h"
+#include "waveform/renderers/waveformrendererendoftrack.h"
+#include "waveform/renderers/waveformrenderbeat.h"
+
+HSVWaveformWidget::HSVWaveformWidget( const char* group, QWidget* parent)
+    : QWidget(parent),
+      WaveformWidgetAbstract(group) {
+    addRenderer<WaveformRenderBackground>();
+    addRenderer<WaveformRendererEndOfTrack>();
+    addRenderer<WaveformRendererPreroll>();
+    addRenderer<WaveformRenderMarkRange>();
+    addRenderer<WaveformRendererHSV>();
+    addRenderer<WaveformRenderMark>();
+    addRenderer<WaveformRenderBeat>();
+
+    setAttribute(Qt::WA_NoSystemBackground);
+    setAttribute(Qt::WA_OpaquePaintEvent);
+
+    m_initSuccess = init();
+}
+
+HSVWaveformWidget::~HSVWaveformWidget() {
+}
+
+void HSVWaveformWidget::castToQWidget() {
+    m_widget = static_cast<QWidget*>(this);
+}
+
+void HSVWaveformWidget::paintEvent( QPaintEvent* event) {
+    QPainter painter(this);
+    draw(&painter,event);
+}

=== removed file 'mixxx/src/waveform/widgets/hsvwaveformwidget.cpp'
--- mixxx/src/waveform/widgets/hsvwaveformwidget.cpp	2013-01-04 20:29:33 +0000
+++ mixxx/src/waveform/widgets/hsvwaveformwidget.cpp	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-#include "hsvwaveformwidget.h"
-
-#include <QPainter>
-
-#include "waveform/renderers/waveformwidgetrenderer.h"
-#include "waveform/renderers/waveformrenderbackground.h"
-#include "waveform/renderers/waveformrendermark.h"
-#include "waveform/renderers/waveformrendermarkrange.h"
-#include "waveform/renderers/waveformrendererhsv.h"
-#include "waveform/renderers/waveformrendererpreroll.h"
-#include "waveform/renderers/waveformrendererendoftrack.h"
-#include "waveform/renderers/waveformrenderbeat.h"
-
-HSVWaveformWidget::HSVWaveformWidget( const char* group, QWidget* parent)
-    : QWidget(parent),
-      WaveformWidgetAbstract(group) {
-    addRenderer<WaveformRenderBackground>();
-    addRenderer<WaveformRendererEndOfTrack>();
-    addRenderer<WaveformRendererPreroll>();
-    addRenderer<WaveformRenderMarkRange>();
-    addRenderer<WaveformRendererHSV>();
-    addRenderer<WaveformRenderBeat>();
-    addRenderer<WaveformRenderMark>();
-
-    setAttribute(Qt::WA_NoSystemBackground);
-    setAttribute(Qt::WA_OpaquePaintEvent);
-
-    m_initSuccess = init();
-}
-
-HSVWaveformWidget::~HSVWaveformWidget() {
-}
-
-void HSVWaveformWidget::castToQWidget() {
-    m_widget = static_cast<QWidget*>(this);
-}
-
-void HSVWaveformWidget::paintEvent( QPaintEvent* event) {
-    QPainter painter(this);
-    draw(&painter,event);
-}

=== added file 'mixxx/src/waveform/widgets/hsvwaveformwidget.h'
--- mixxx/src/waveform/widgets/hsvwaveformwidget.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/waveform/widgets/hsvwaveformwidget.h	2013-05-01 22:08:27 +0000
@@ -0,0 +1,29 @@
+#ifndef HSVWAVEFORMWIDGET_H
+#define HSVWAVEFORMWIDGET_H
+
+#include <QWidget>
+
+#include "waveformwidgetabstract.h"
+
+class HSVWaveformWidget : public QWidget, public WaveformWidgetAbstract {
+    Q_OBJECT
+  public:
+    virtual ~HSVWaveformWidget();
+
+    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::HSVWaveform; }
+
+    static inline QString getWaveformWidgetName() { return tr("HSV"); }
+    static inline bool useOpenGl() { return false; }
+    static inline bool useOpenGLShaders() { return false; }
+    static inline bool developerOnly() { return false; }
+
+  protected:
+    virtual void castToQWidget();
+    virtual void paintEvent(QPaintEvent* event);
+
+  private:
+    HSVWaveformWidget(const char* group, QWidget* parent);
+    friend class WaveformWidgetFactory;
+};
+
+#endif // HSVWAVEFORMWIDGET_H

=== removed file 'mixxx/src/waveform/widgets/hsvwaveformwidget.h'
--- mixxx/src/waveform/widgets/hsvwaveformwidget.h	2012-12-14 01:26:04 +0000
+++ mixxx/src/waveform/widgets/hsvwaveformwidget.h	1970-01-01 00:00:00 +0000
@@ -1,29 +0,0 @@
-#ifndef HSVWAVEFORMWIDGET_H
-#define HSVWAVEFORMWIDGET_H
-
-#include <QWidget>
-
-#include "waveformwidgetabstract.h"
-
-class HSVWaveformWidget : public QWidget, public WaveformWidgetAbstract {
-    Q_OBJECT
-  public:
-    virtual ~HSVWaveformWidget();
-
-    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::HSVWaveform;}
-
-    static inline QString getWaveformWidgetName() { return tr("HSV");}
-    static inline bool useOpenGl() { return false;}
-    static inline bool useOpenGLShaders() { return false;}
-
-  protected:
-    virtual void castToQWidget();
-    virtual void paintEvent(QPaintEvent* event);
-
-  private:
-    HSVWaveformWidget() {}
-    HSVWaveformWidget(const char* group, QWidget* parent);
-    friend class WaveformWidgetFactory;
-};
-
-#endif // HSVWAVEFORMWIDGET_H

=== modified file 'mixxx/src/waveform/widgets/qtsimplewaveformwidget.cpp'
--- mixxx/src/waveform/widgets/qtsimplewaveformwidget.cpp	2013-01-31 19:48:57 +0000
+++ mixxx/src/waveform/widgets/qtsimplewaveformwidget.cpp	2013-05-01 22:08:27 +0000
@@ -13,6 +13,8 @@
 #include "waveform/renderers/waveformrendererendoftrack.h"
 #include "waveform/renderers/waveformrenderbeat.h"
 
+#include "util/performancetimer.h"
+
 QtSimpleWaveformWidget::QtSimpleWaveformWidget( const char* group, QWidget* parent)
         : QGLWidget(parent, SharedGLContext::getWidget()),
           WaveformWidgetAbstract(group) {
@@ -49,11 +51,24 @@
 }
 
 void QtSimpleWaveformWidget::paintEvent(QPaintEvent* event) {
-    if (QGLContext::currentContext() != context()) {
-        makeCurrent();
-    }
+    Q_UNUSED(event);
+}
+
+int QtSimpleWaveformWidget::render() {
+    PerformanceTimer timer;
+    int t1;
+    //int t2, t3;
+    timer.start();
+    // QPainter makes QGLContext::currentContext() == context()
+    // this may delayed until previous buffer swap finished
     QPainter painter(this);
-    draw(&painter, event);
+    t1 = timer.restart();
+    draw(&painter, NULL);
+    //t2 = timer.restart();
+    //glFinish();
+    //t3 = timer.restart();
+    //qDebug() << "GLVSyncTestWidget "<< t1 << t2 << t3;
+    return t1/1000; // return timer for painter setup
 }
 
 void QtSimpleWaveformWidget::postRender() {

=== modified file 'mixxx/src/waveform/widgets/qtsimplewaveformwidget.h'
--- mixxx/src/waveform/widgets/qtsimplewaveformwidget.h	2012-09-19 21:04:53 +0000
+++ mixxx/src/waveform/widgets/qtsimplewaveformwidget.h	2013-05-01 22:08:27 +0000
@@ -12,19 +12,20 @@
     virtual ~QtSimpleWaveformWidget();
 
 
-    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::GLSimpleWaveform;}
+    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::GLSimpleWaveform; }
 
-    static inline QString getWaveformWidgetName() { return tr("Simple") + " - Qt";}
-    static inline bool useOpenGl() { return true;}
-    static inline bool useOpenGLShaders() { return false;}
+    static inline QString getWaveformWidgetName() { return tr("Simple") + " - Qt"; }
+    static inline bool useOpenGl() { return true; }
+    static inline bool useOpenGLShaders() { return false; }
+    static inline bool developerOnly() { return false; }
 
   protected:
     virtual void castToQWidget();
     virtual void paintEvent(QPaintEvent* event);
     virtual void postRender();
+    virtual int render();
 
   private:
-    QtSimpleWaveformWidget() {}
     friend class WaveformWidgetFactory;
 };
 

=== modified file 'mixxx/src/waveform/widgets/qtwaveformwidget.cpp'
--- mixxx/src/waveform/widgets/qtwaveformwidget.cpp	2013-01-04 20:29:33 +0000
+++ mixxx/src/waveform/widgets/qtwaveformwidget.cpp	2013-05-01 22:08:27 +0000
@@ -14,6 +14,8 @@
 #include "waveform/renderers/waveformrenderbeat.h"
 #include "sharedglcontext.h"
 
+#include "util/performancetimer.h"
+
 QtWaveformWidget::QtWaveformWidget( const char* group, QWidget* parent)
         : QGLWidget(parent, SharedGLContext::getWidget()),
           WaveformWidgetAbstract(group) {
@@ -47,11 +49,24 @@
 }
 
 void QtWaveformWidget::paintEvent( QPaintEvent* event) {
-    if (QGLContext::currentContext() != context()) {
-        makeCurrent();
-    }
+    Q_UNUSED(event);
+}
+
+int QtWaveformWidget::render() {
+    PerformanceTimer timer;
+    int t1;
+    //int t2, t3;
+    timer.start();
+    // QPainter makes QGLContext::currentContext() == context()
+    // this may delayed until previous buffer swap finished
     QPainter painter(this);
-    draw(&painter, event);
+    t1 = timer.restart();
+    draw(&painter, NULL);
+    //t2 = timer.restart();
+    //glFinish();
+    //t3 = timer.restart();
+    //qDebug() << "GLVSyncTestWidget "<< t1 << t2 << t3;
+    return t1/1000; // return timer for painter setup
 }
 
 void QtWaveformWidget::postRender() {

=== modified file 'mixxx/src/waveform/widgets/qtwaveformwidget.h'
--- mixxx/src/waveform/widgets/qtwaveformwidget.h	2012-09-19 21:39:13 +0000
+++ mixxx/src/waveform/widgets/qtwaveformwidget.h	2013-05-01 22:08:27 +0000
@@ -11,19 +11,20 @@
     QtWaveformWidget(const char* group, QWidget* parent);
     virtual ~QtWaveformWidget();
 
-    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::QtWaveform;}
+    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::QtWaveform; }
 
-    static inline QString getWaveformWidgetName() { return tr("Filtered") + " - Qt";}
-    static inline bool useOpenGl() { return true;}
-    static inline bool useOpenGLShaders() { return false;}
+    static inline QString getWaveformWidgetName() { return tr("Filtered") + " - Qt"; }
+    static inline bool useOpenGl() { return true; }
+    static inline bool useOpenGLShaders() { return false; }
+    static inline bool developerOnly() { return false; }
 
   protected:
     virtual void castToQWidget();
     virtual void paintEvent(QPaintEvent* event);
     virtual void postRender();
+    virtual int render();
 
   private:
-    QtWaveformWidget() {}
     friend class WaveformWidgetFactory;
 };
 

=== modified file 'mixxx/src/waveform/widgets/softwarewaveformwidget.h'
--- mixxx/src/waveform/widgets/softwarewaveformwidget.h	2012-11-04 20:33:22 +0000
+++ mixxx/src/waveform/widgets/softwarewaveformwidget.h	2013-05-01 22:08:27 +0000
@@ -10,18 +10,18 @@
   public:
     virtual ~SoftwareWaveformWidget();
 
-    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::SoftwareWaveform;}
+    virtual WaveformWidgetType::Type getType() const { return WaveformWidgetType::SoftwareWaveform; }
 
-    static inline QString getWaveformWidgetName() { return tr("Filtered") + " - " + tr("Software");}
-    static inline bool useOpenGl() { return false;}
-    static inline bool useOpenGLShaders() { return false;}
+    static inline QString getWaveformWidgetName() { return tr("Filtered") + " - " + tr("Software"); }
+    static inline bool useOpenGl() { return false; }
+    static inline bool useOpenGLShaders() { return false; }
+    static inline bool developerOnly() { return false; }
 
   protected:
     virtual void castToQWidget();
     virtual void paintEvent(QPaintEvent* event);
 
   private:
-    SoftwareWaveformWidget() {}
     SoftwareWaveformWidget(const char* group, QWidget* parent);
     friend class WaveformWidgetFactory;
 };

=== modified file 'mixxx/src/waveform/widgets/waveformwidgetabstract.cpp'
--- mixxx/src/waveform/widgets/waveformwidgetabstract.cpp	2012-12-10 17:23:43 +0000
+++ mixxx/src/waveform/widgets/waveformwidgetabstract.cpp	2013-05-01 22:08:27 +0000
@@ -4,15 +4,10 @@
 #include <QtDebug>
 #include <QWidget>
 
-// Default constructor is only use by the factory to evaluate dynamically
-// WaveformWidget
-WaveformWidgetAbstract::WaveformWidgetAbstract() :
-    WaveformWidgetRenderer() {
-    m_widget = NULL;
-}
 
-WaveformWidgetAbstract::WaveformWidgetAbstract( const char* group) :
-    WaveformWidgetRenderer(group) {
+WaveformWidgetAbstract::WaveformWidgetAbstract( const char* group) 
+    : WaveformWidgetRenderer(group),
+      m_initSuccess(false) {
     m_widget = NULL;
 }
 
@@ -31,17 +26,15 @@
     }
 }
 
-void WaveformWidgetAbstract::preRender() {
-    WaveformWidgetRenderer::onPreRender();
+void WaveformWidgetAbstract::preRender(VSyncThread* vsyncThread) {
+    WaveformWidgetRenderer::onPreRender(vsyncThread);
 }
 
-void WaveformWidgetAbstract::render() {
+int WaveformWidgetAbstract::render() {
     if (m_widget) {
-        if (!m_widget->isVisible()) {
-            m_widget->show();
-        }
-        m_widget->repaint();
+        m_widget->repaint(); // Repaints the widget directly by calling paintEvent()
     }
+    return 0; // Time for Painter setup, unknown in this case
 }
 
 void WaveformWidgetAbstract::resize( int width, int height) {

=== modified file 'mixxx/src/waveform/widgets/waveformwidgetabstract.h'
--- mixxx/src/waveform/widgets/waveformwidgetabstract.h	2012-09-19 21:04:53 +0000
+++ mixxx/src/waveform/widgets/waveformwidgetabstract.h	2013-05-01 22:08:27 +0000
@@ -8,6 +8,8 @@
 #include "waveformwidgettype.h"
 #include "trackinfoobject.h"
 
+class VSyncThread;
+
 // NOTE(vRince) This class represent objects the waveformwidgetfactory can
 // holds, IMPORTANT all WaveformWidgetAbstract MUST inherist QWidget too !!  we
 // can't do it here because QWidget and QGLWidget are both QWidgets so they
@@ -27,9 +29,9 @@
     void hold();
     void release();
 
-    virtual void preRender();
-    virtual void render();
-    virtual void postRender() {}
+    virtual void preRender(VSyncThread* vsyncThread);
+    virtual int render();
+    virtual void postRender() {};
 
     virtual void resize( int width, int height);
 
@@ -37,7 +39,6 @@
     QWidget* m_widget;
     bool m_initSuccess;
 
-    WaveformWidgetAbstract();
     //this is the factory resposability to trigger QWidget casting after constructor
     virtual void castToQWidget() = 0;
 

=== modified file 'mixxx/src/waveform/widgets/waveformwidgettype.h'
--- mixxx/src/waveform/widgets/waveformwidgettype.h	2012-12-13 22:46:16 +0000
+++ mixxx/src/waveform/widgets/waveformwidgettype.h	2013-05-01 22:08:27 +0000
@@ -6,13 +6,14 @@
     enum Type {
         EmptyWaveform = 0,
         SoftwareSimpleWaveform, //TODO
-        SoftwareWaveform, //TODO
-        QtSimpleWaveform, //TODO
+        SoftwareWaveform,
+        QtSimpleWaveform,
         QtWaveform,
         GLSimpleWaveform,
         GLWaveform,
         GLSLWaveform,
         HSVWaveform,
+        GLVSyncTest,
         Count_WaveformwidgetType // Also used as invalid value
     };
 };

=== modified file 'mixxx/src/widget/wspinny.cpp'
--- mixxx/src/widget/wspinny.cpp	2013-04-05 23:13:45 +0000
+++ mixxx/src/widget/wspinny.cpp	2013-05-01 22:08:27 +0000
@@ -7,6 +7,7 @@
 #include "controlobject.h"
 #include "controlobjectthreadmain.h"
 #include "sharedglcontext.h"
+#include "visualplayposition.h"
 #include "wspinny.h"
 
 WSpinny::WSpinny(QWidget* parent, VinylControlManager* pVCMan)
@@ -16,7 +17,6 @@
           m_pGhostImage(NULL),
           m_pPlay(NULL),
           m_pPlayPos(NULL),
-          m_pVisualPlayPos(NULL),
           m_pDuration(NULL),
           m_pTrackSamples(NULL),
           m_pScratch(NULL),
@@ -50,7 +50,7 @@
 
 WSpinny::~WSpinny() {
     // No need to delete anything if m_group is empty because setup() was not called.
-    if (!m_group.isEmpty()) {
+    if (!m_group.isEmpty()) {    
         WImageStore::deleteImage(m_pBgImage);
         WImageStore::deleteImage(m_pFgImage);
         WImageStore::deleteImage(m_pGhostImage);
@@ -96,8 +96,8 @@
                         ConfigKey(group, "play")));
     m_pPlayPos = new ControlObjectThreadMain(ControlObject::getControl(
                         ConfigKey(group, "playposition")));
-    m_pVisualPlayPos = new ControlObjectThreadMain(ControlObject::getControl(
-                        ConfigKey(group, "visual_playposition")));
+    m_pVisualPlayPos = VisualPlayPosition::getVisualPlayPosition(group);
+
     m_pDuration = new ControlObjectThreadMain(ControlObject::getControl(
                         ConfigKey(group, "duration")));
     m_pTrackSamples = new ControlObjectThreadMain(ControlObject::getControl(
@@ -115,8 +115,6 @@
 
     m_pSlipEnabled = new ControlObjectThreadMain(ControlObject::getControl(
         ConfigKey(group, "slip_enabled")));
-    m_pSlipPosition = new ControlObjectThreadMain(ControlObject::getControl(
-        ConfigKey(group, "slip_playposition")));
 
 #ifdef __VINYLCONTROL__
     m_pVinylControlSpeedType = new ControlObjectThreadMain(ControlObject::getControl(
@@ -211,8 +209,9 @@
         p.save();
     }
 
-    double playPosition = m_pVisualPlayPos->get();
-    double slipPosition = m_pSlipPosition->get();
+    double playPosition = -1;
+    double slipPosition = -1;
+    m_pVisualPlayPos->getPlaySlipAt(0, &playPosition, &slipPosition);
 
     if (playPosition != m_dAngleLastPlaypos) {
         m_fAngle = calculateAngle(playPosition);

=== modified file 'mixxx/src/widget/wspinny.h'
--- mixxx/src/widget/wspinny.h	2013-03-23 12:47:24 +0000
+++ mixxx/src/widget/wspinny.h	2013-05-01 22:08:27 +0000
@@ -11,6 +11,7 @@
 #endif
 
 class ControlObjectThreadMain;
+class VisualPlayPosition;
 
 class WSpinny : public QGLWidget {
     Q_OBJECT
@@ -48,7 +49,7 @@
     QImage* m_pGhostImage;
     ControlObjectThreadMain* m_pPlay;
     ControlObjectThreadMain* m_pPlayPos;
-    ControlObjectThreadMain* m_pVisualPlayPos;
+    VisualPlayPosition* m_pVisualPlayPos;
     ControlObjectThreadMain* m_pDuration;
     ControlObjectThreadMain* m_pTrackSamples;
     ControlObjectThreadMain* m_pTrackSampleRate;
@@ -60,7 +61,6 @@
     ControlObjectThreadMain* m_pVinylControlEnabled;
     ControlObjectThreadMain* m_pSignalEnabled;
     ControlObjectThreadMain* m_pSlipEnabled;
-    ControlObjectThreadMain* m_pSlipPosition;
 
 #ifdef __VINYLCONTROL__
     VinylControlManager* m_pVCManager;