commiting http://svn.reviewboard.kde.org/r/6120/#review9304

this should improve v'syncing, maybe v'synced "smoothness"
remaining and exposed issue are "dirty textures" w/o damage events (see the requst description)
can be diminished by increasing MaxFPS above the fastest update (or shadowed below the slowest one)
CCBUG: 258971

svn path=/trunk/KDE/kdebase/workspace/; revision=1207577

composite.cpp

@@ -57,6 +57,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <stdio.h>
 
 #include <QMenu>
+#include <QTimerEvent>
 #include <kaction.h>
 #include <kactioncollection.h>
 #include <klocale.h>
@@ -197,12 +198,9 @@ void Workspace::setupCompositing()
         delete cm_selection;
         return;
         }
-    int rate = xrrRefreshRate = KWin::currentRefreshRate();
+    xrrRefreshRate = KWin::currentRefreshRate();
-    compositeRate = 1000 / rate;
+    // invalidate timer -> bounds delay to 0 and the update happens instantly
-    lastCompositePaint.start();
+    nextPaintReference = QTime::currentTime().addMSecs( -1000 );
-    // fake a previous paint, so that the next starts right now
-    nextPaintReference = QTime::currentTime().addMSecs( -compositeRate );
-    compositeTimer.setSingleShot( true );
     checkCompositeTimer();
     composite_paint_times.clear();
     XCompositeRedirectSubwindows( display(), rootWindow(), CompositeRedirectManual );
@@ -253,7 +251,9 @@ void Workspace::finishCompositing()
     effects = NULL;
     delete scene;
     scene = NULL;
-    compositeTimer.stop();
+    if (compositeTimer)
+        killTimer(compositeTimer);
+    compositeTimer = 0;
     mousePollingTimer.stop();
     repaints_region = QRegion();
     for( ClientList::ConstIterator it = clients.constBegin();
@@ -370,24 +370,27 @@ void Workspace::addRepaintFull()
     checkCompositeTimer();
     }
 
+void Workspace::timerEvent( QTimerEvent *te )
+{
+    if ( te->timerId() == compositeTimer )
+    {
+        killTimer( compositeTimer );
+        compositeTimer = 0;
+        performCompositing();
+    }
+    else
+        QObject::timerEvent( te );
+}
+
 void Workspace::performCompositing()
     {
 #ifdef KWIN_HAVE_COMPOSITING
-    // The event loop apparently tries to fire a QTimer as often as possible, even
-    // at the expense of not processing many X events. This means that the composite
-    // repaints can seriously impact performance of everything else, therefore throttle
-    // them - leave at least 1msec time after one repaint is finished and next one
-    // is started.
-    if( lastCompositePaint.elapsed() < 1 )
-        {
-        compositeTimer.start( 1 );
-        return;
-        }
-    if( !scene->waitSyncAvailable())
-        nextPaintReference = QTime::currentTime();
     if((( repaints_region.isEmpty() && !windowRepaintsPending()) // no damage
         || !overlay_visible )) // nothing is visible anyway
         {
+        // invalidate timer, we're idle, thus have already waited maxFps don't want to
+        // wait more when we woke up
+        nextPaintReference = QTime::currentTime().addMSecs( -1000 );
         scene->idle();
         // Note: It would seem here we should undo suspended unredirect, but when scenes need
         // it for some reason, e.g. transformations or translucency, the next pass that does not
@@ -395,6 +398,8 @@ void Workspace::performCompositing()
         // Otherwise the window would not be painted normally anyway.
         return;
         }
+    // we paint now, how much time ever it takes, we wanna show up in maxfps from now
+    nextPaintReference = QTime::currentTime();
     // create a list of all windows in the stacking order
     ToplevelList windows = xStackingOrder();
     foreach( EffectWindow* c, static_cast< EffectsHandlerImpl* >( effects )->elevatedWindows())
@@ -403,19 +408,16 @@ void Workspace::performCompositing()
         windows.removeAll( t );
         windows.append( t );
         }
+#if 0
     // skip windows that are not yet ready for being painted
     ToplevelList tmp = windows;
     windows.clear();
-#if 0
     // There is a bug somewhere that prevents this from working properly (#160393), but additionally
     // this cannot be used so carelessly - needs protections against broken clients, the window
     // should not get focus before it's displayed, handle unredirected windows properly and so on.
     foreach( Toplevel* c, tmp )
         if( c->readyForPainting())
             windows.append( c );
-#else
-    foreach( Toplevel* c, tmp )
-        windows.append( c );
 #endif
     foreach( Toplevel* c, windows )
         { // This could be possibly optimized WRT obscuring, but that'd need being already
@@ -423,7 +425,7 @@ void Workspace::performCompositing()
           // TODO I think effects->transformWindowDamage() doesn't need to be called here,
           // pre-paint will extend painted window areas as necessary.
         repaints_region |= c->repaints().translated( c->pos());
-        repaints_region |= c->decorationPendingRegion();        
+        repaints_region |= c->decorationPendingRegion();
         c->resetRepaints( c->decorationRect());
         }
     QRegion repaints = repaints_region;
@@ -431,23 +433,12 @@ void Workspace::performCompositing()
     repaints_region = QRegion();
     QTime t = QTime::currentTime();
     scene->paint( repaints, windows );
-    if( scene->waitSyncAvailable())
-        {
-        // If vsync is used, schedule the next repaint slightly in advance of the next sync,
-        // so that there is still time for the drawing to take place. We have just synced, and
-        // nextPaintReference is time from which multiples of compositeRate should be added,
-        // so set it 10ms back (meaning next paint will be in 'compositeRate - 10').
-        // However, make sure the reserve is smaller than the composite rate.
-        int reserve = compositeRate <= 10 ? compositeRate - 1 : 10;
-        nextPaintReference = QTime::currentTime().addMSecs( -reserve );
-        }
     // Trigger at least one more pass even if there would be nothing to paint, so that scene->idle()
     // is called the next time. If there would be nothing pending, it will not restart the timer and
     // checkCompositeTime() would restart it again somewhen later, called from functions that
     // would again add something pending.
     checkCompositeTimer();
     checkCompositePaintTime( t.elapsed());
-    lastCompositePaint.start();
 #endif
     }
 
@@ -477,9 +468,11 @@ void Workspace::setCompositeTimer()
     {
     if( !compositing()) // should not really happen, but there may be e.g. some damage events still pending
         return;
-    // The last paint set nextPaintReference as a reference time to which multiples of compositeRate
     // should be added for the next paint. qBound() for protection; system time can change without notice.
-    compositeTimer.start( qBound( 0, nextPaintReference.msecsTo( QTime::currentTime() ), 250 ) % compositeRate );
+    if ( compositeTimer )
+        killTimer( compositeTimer );
+    int delay = options->maxFpsInterval - (qBound( 0, nextPaintReference.msecsTo( QTime::currentTime() ), 250 ) % options->maxFpsInterval);
+    compositeTimer = startTimer( delay );
     }
 
 void Workspace::startMousePolling()
@@ -567,7 +560,9 @@ void Workspace::checkCompositePaintTime( int msec )
                 "If this was only a temporary problem, you can resume using the '%1' shortcut.\n"
                 "You can disable functionality checks in System Settings (on the Advanced tab in Desktop Effects).", shortcut );
         Notify::raise( Notify::CompositingSlow, message );
-        compositeTimer.start( 1000 ); // so that it doesn't trigger sooner than suspendCompositing()
+        if ( compositeTimer )
+            killTimer( compositeTimer );
+        compositeTimer = startTimer( 1000 ); // so that it doesn't trigger sooner than suspendCompositing()
         }
     }
 

options.cpp

@@ -66,9 +66,11 @@ int currentRefreshRate()
             {
             QString reply = QString::fromLocal8Bit( nvidia_settings.readAllStandardOutput() );
             bool ok;
-            rate = reply.split(' ').first().split(KGlobal::locale()->decimalSymbol()).first().toUInt( &ok );
+            const float frate = reply.split(' ').first().toFloat( &ok );
             if ( !ok )
                 rate = -1;
+            else
+                rate = qRound(frate);
             }
         }
 #ifdef HAVE_XRANDR
@@ -247,6 +249,7 @@ unsigned long Options::updateSettings()
     CmdAllWheel = mouseWheelCommand(config.readEntry("CommandAllWheel","Nothing"));
 
     config=KConfigGroup(_config,"Compositing");
+    maxFpsInterval = qRound(1000.0/config.readEntry( "MaxFPS", 35 ));
     refreshRate = config.readEntry( "RefreshRate", 0 );
 
     // Read button tooltip animation effect from kdeglobals

options.h

@@ -365,6 +365,7 @@ class Options : public KDecorationOptions
         // XRender
         bool xrenderSmoothScale;
 
+        uint maxFpsInterval;
         // Settings that should be auto-detected
         uint refreshRate;
         bool glDirect;

scene_opengl.cpp

@@ -91,6 +91,8 @@ Sources and other compositing managers:
 namespace KWin
 {
 
+extern int currentRefreshRate();
+
 //****************************************
 // SceneOpenGL
 //****************************************
@@ -109,6 +111,9 @@ GLXDrawable SceneOpenGL::last_pixmap = None;
 bool SceneOpenGL::tfp_mode; // using glXBindTexImageEXT (texture_from_pixmap)
 bool SceneOpenGL::db; // destination drawable is double-buffered
 bool SceneOpenGL::shm_mode;
+uint SceneOpenGL::vBlankInterval;
+uint SceneOpenGL::estimatedRenderTime = 0xfffffff; // Looooong - to ensure we wait on the first frame
+QTime SceneOpenGL::lastVBlank;
 #ifdef HAVE_XSHM
 XShmSegmentInfo SceneOpenGL::shm;
 #endif
@@ -124,6 +129,8 @@ SceneOpenGL::SceneOpenGL( Workspace* ws )
         kDebug( 1212 ) << "No glx extensions available";
         return; // error
         }
+    vBlankInterval = (1000<<10) / KWin::currentRefreshRate();
+    lastVBlank = QTime::currentTime();
     initGLX();
     // check for FBConfig support
     if( !hasGLExtension( "GLX_SGIX_fbconfig" ) || !glXGetFBConfigAttrib || !glXGetFBConfigs ||
@@ -796,22 +803,30 @@ void SceneOpenGL::waitSync()
     { // NOTE that vsync has no effect with indirect rendering
     if( waitSyncAvailable())
         {
-        unsigned int sync;
+        // hackalert - we abuse "sync" as "remaining time before next estimated vblank"
-
+        // reason: we do not "just wait" for the next vsync if we estimate that we can paint the
-        glFlush();
+        // entire frame before this event, what could effectively mean "usleep(10000)", as it used to
-        glXGetVideoSync( &sync );
+        uint sync = ((lastVBlank.msecsTo( QTime::currentTime() )<<10) % vBlankInterval);
-        glXWaitVideoSync( 2, ( sync + 1 ) % 2, &sync );
+        if ( sync < (estimatedRenderTime+1)<<10 )
+            {
+            glFlush();
+            glXGetVideoSync( &sync );
+            glXWaitVideoSync( 2, ( sync + 1 ) % 2, &sync );
+            lastVBlank = QTime::currentTime();
+            }
         }
     }
 
 // actually paint to the screen (double-buffer swap or copy from pixmap buffer)
 void SceneOpenGL::flushBuffer( int mask, QRegion damage )
     {
+    QTime t;
     if( db )
         {
         if( mask & PAINT_SCREEN_REGION )
             {
             waitSync();
+            t = QTime::currentTime();
             if( glXCopySubBuffer )
                 {
                 foreach( const QRect &r, damage.rects())
@@ -849,22 +864,28 @@ void SceneOpenGL::flushBuffer( int mask, QRegion damage )
         else
             {
             waitSync();
+            t = QTime::currentTime();
             glXSwapBuffers( display(), glxbuffer );
             }
         glXWaitGL();
         XFlush( display());
+        estimatedRenderTime = t.elapsed();
         }
     else
         {
+        t = QTime::currentTime();
         glFlush();
         glXWaitGL();
+        estimatedRenderTime = t.elapsed();
         waitSync();
+        t = QTime::currentTime();
         if( mask & PAINT_SCREEN_REGION )
             foreach( const QRect &r, damage.rects())
                 XCopyArea( display(), buffer, rootWindow(), gcroot, r.x(), r.y(), r.width(), r.height(), r.x(), r.y());
         else
             XCopyArea( display(), buffer, rootWindow(), gcroot, 0, 0, displayWidth(), displayHeight(), 0, 0 );
         XFlush( display());
+        estimatedRenderTime += t.elapsed();
         }
     }
 

scene_opengl.h

@@ -90,6 +90,8 @@ class SceneOpenGL
         static GLXDrawable last_pixmap; // for a workaround in bindTexture()
         static bool tfp_mode;
         static bool shm_mode;
+        static uint vBlankInterval, estimatedRenderTime;
+        static QTime lastVBlank;
         QHash< Toplevel*, Window* > windows;
 #ifdef HAVE_XSHM
         static XShmSegmentInfo shm;

workspace.cpp

@@ -151,7 +151,8 @@ Workspace::Workspace( bool restore )
     , forced_global_mouse_grab( false )
     , cm_selection( NULL )
     , compositingSuspended( false )
-    , compositeRate( 0 )
+    , compositeTimer( 0 )
+    , vBlankInterval( 0 )
     , xrrRefreshRate( 0 )
     , overlay( None )
     , overlay_visible( true )
@@ -384,7 +385,6 @@ void Workspace::init()
 
     connect( &reconfigureTimer, SIGNAL( timeout() ), this, SLOT( slotReconfigure() ));
     connect( &updateToolWindowsTimer, SIGNAL( timeout() ), this, SLOT( slotUpdateToolWindows() ));
-    connect( &compositeTimer, SIGNAL( timeout() ), SLOT( performCompositing() ));
     connect( &mousePollingTimer, SIGNAL( timeout() ), SLOT( performMousePoll() ));
 
     connect( KGlobalSettings::self(), SIGNAL( appearanceChanged() ), this, SLOT( reconfigure() ));

workspace.h

@@ -774,6 +774,7 @@ class Workspace : public QObject, public KDecorationDefines
 
     protected:
         bool keyPressMouseEmulation( XKeyEvent& ev );
+        void timerEvent( QTimerEvent *te );
 
     Q_SIGNALS:
         Q_SCRIPTABLE void compositingToggled( bool active );
@@ -1058,11 +1059,10 @@ class Workspace : public QObject, public KDecorationDefines
 
         KSelectionOwner* cm_selection;
         bool compositingSuspended;
-        QTimer compositeTimer;
+        int compositeTimer;
-        QTime lastCompositePaint;
         QTime nextPaintReference;
         QTimer mousePollingTimer;
-        int compositeRate;
+        uint vBlankInterval;
         int xrrRefreshRate; // used only for compositing
         QRegion repaints_region;
         Window overlay; // XComposite overlay window
@@ -1348,7 +1348,7 @@ inline bool Workspace::hasClient( const Client* c )
 
 inline void Workspace::checkCompositeTimer()
     {
-    if( !compositeTimer.isActive() )
+    if( !compositeTimer )
         setCompositeTimer();
     }