Merge lp:~smspillaz/compiz/compiz.experimental_buffer_age_support into lp:compiz/0.9.9

[Sam Spilsbury]

Add support for the GLX_EXT_buffer_age extension on hardware that supports it, which should result in a nice speed-boost due to the fact that we no longer have to abuse fillrate by retaining old frame contents, and instead asking the driver how defined the current frame is.

Note: Unity gets a bit confused by this change and will cause full-screen redraws constantly unless these branches are applied to both nux and unity respectively:

https://code.launchpad.net/~smspillaz/nux/nux.experimental_fix_1091589
https://code.launchpad.net/~smspillaz/unity/unity.fix_1089811

Add support for the GLX_EXT_buffer_age extension on hardware that supports it, which should result in a nice speed-boost due to the fact that we no longer have to abuse fillrate by retaining old frame contents, and instead asking the driver how defined the current frame is.

[lp:~smspillaz/compiz/compiz.experimental_buffer_age_support]

3553. By Sam Spilsbury on 2013-01-30

Merge lp:compiz

3554. By Sam Spilsbury on 2013-02-10

Merge lp:compiz

3555. By Sam Spilsbury on 2013-02-10

Remove useless printf

Unmerged revisions

3555. By Sam Spilsbury on 2013-02-10

Remove useless printf

3554. By Sam Spilsbury on 2013-02-10

Merge lp:compiz

3553. By Sam Spilsbury on 2013-01-30

Merge lp:compiz

3552. By Sam Spilsbury on 2013-01-04

Fix warnings and compile errors on clang and gles

3551. By Sam Spilsbury on 2013-01-03

Merge lp:compiz

3550. By Sam Spilsbury on 2013-01-03

Add test to indicate the new behaviour of getDamageForAge when adding additional
damage regions

3549. By Sam Spilsbury on 2013-01-02

Added missing func

3548. By Sam Spilsbury on 2013-01-02

Apply other necessary changes, revert a change that didn't belong here

3547. By Sam Spilsbury on 2013-01-02

Allow plugins to have their own FrameRosters in core - have a callback
to determine whether or not a particular piece of damage should be tracked.

This is necessary for plugins that need to increase damage regions upon
incoming damage from older frames, but don't want to feedback on that
damage (such as the blur plugin).

Also fixed some potential overdraw problems with
PAINT_WINDOW_NO_CORE_INSTANCE_MASK

3546. By Sam Spilsbury on 2013-01-01

Switch to stack allocation again, make the tests pass

=== modified file 'compizconfig/CMakeLists.txt'
--- compizconfig/CMakeLists.txt	2012-09-12 08:35:51 +0000
+++ compizconfig/CMakeLists.txt	2013-01-30 08:46:22 +0000
@@ -7,7 +7,7 @@
 option (USE_GCONF "Enable legacy GNOME 2.x option integration with GConf" ON)
 
 add_subdirectory (libcompizconfig)
-add_subdirectory (compizconfig-python)
+#add_subdirectory (compizconfig-python)
 add_subdirectory (integration)
 add_subdirectory (ccsm)
 

=== modified file 'plugins/animation/src/animation.cpp'
--- plugins/animation/src/animation.cpp	2013-01-11 08:28:51 +0000
+++ plugins/animation/src/animation.cpp	2013-01-30 08:46:22 +0000
@@ -1617,7 +1617,7 @@
     // Is this the first glPaint call this round
     // without the mask PAINT_WINDOW_OCCLUSION_DETECTION_MASK?
     if (mPAScreen->mStartingNewPaintRound &&
-	!(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK))
+	!(mask & PAINT_WINDOW_NO_DRAW_MASKS))
     {
 	mPAScreen->mStartingNewPaintRound = false;
 

=== modified file 'plugins/composite/CMakeLists.txt'
--- plugins/composite/CMakeLists.txt	2012-09-25 01:15:36 +0000
+++ plugins/composite/CMakeLists.txt	2013-01-30 08:46:22 +0000
@@ -2,9 +2,14 @@
 
 include (CompizPlugin)
 
+include_directories (${CMAKE_CURRENT_SOURCE_DIR}/include)
 include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/pixmapbinding/include)
+include_directories (${CMAKE_CURRENT_SOURCE_DIR}/src/backbuffertracking/include)
+
 link_directories (${CMAKE_CURRENT_BINARY_DIR}/src/pixmapbinding)
+link_directories (${CMAKE_CURRENT_BINARY_DIR}/src/backbuffertracking)
 
-compiz_plugin (composite LIBRARIES compiz_composite_pixmapbinding)
+compiz_plugin (composite LIBRARIES compiz_composite_pixmapbinding compiz_composite_backbuffertracking)
 
 add_subdirectory (src/pixmapbinding)
+add_subdirectory (src/backbuffertracking)

=== added file 'plugins/composite/include/composite/agedamagequery.h'
--- plugins/composite/include/composite/agedamagequery.h	1970-01-01 00:00:00 +0000
+++ plugins/composite/include/composite/agedamagequery.h	2013-01-30 08:46:22 +0000
@@ -0,0 +1,53 @@
+/*
+ * Compiz, composite plugin, GLX_EXT_buffer_age logic
+ *
+ * Copyright (c) 2012 Sam Spilsbury
+ * Authors: Sam Spilsbury <[e-mail]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef _COMPIZ_COMPOSITE_AGEDAMAGEQUERY_H
+#define _COMPIZ_COMPOSITE_AGEDAMAGEQUERY_H
+
+#include <boost/shared_ptr.hpp>
+#include <core/region.h>
+
+namespace compiz
+{
+namespace composite
+{
+namespace buffertracking
+{
+class AgeDamageQuery
+{
+    public:
+
+	typedef boost::shared_ptr <AgeDamageQuery> Ptr;
+	typedef boost::function <bool (const CompRegion &)> AreaShouldBeMarkedDirty;
+
+	virtual ~AgeDamageQuery () {}
+	virtual CompRegion damageForFrameAge (unsigned int) = 0;
+	virtual const CompRegion & currentFrameDamage () = 0;
+};
+}
+}
+}
+
+#endif
+

=== modified file 'plugins/composite/include/composite/composite.h'
--- plugins/composite/include/composite/composite.h	2012-10-16 05:11:10 +0000
+++ plugins/composite/include/composite/composite.h	2013-01-30 08:46:22 +0000
@@ -30,7 +30,7 @@
 
 #include <X11/extensions/Xcomposite.h>
 
-#define COMPIZ_COMPOSITE_ABI 5
+#define COMPIZ_COMPOSITE_ABI 6
 
 #include "core/pluginclasshandler.h"
 #include "core/timer.h"
@@ -38,6 +38,8 @@
 #include "core/screen.h"
 #include "core/wrapsystem.h"
 
+#include "composite/agedamagequery.h"
+
 #define COMPOSITE_SCREEN_DAMAGE_PENDING_MASK (1 << 0)
 #define COMPOSITE_SCREEN_DAMAGE_REGION_MASK  (1 << 1)
 #define COMPOSITE_SCREEN_DAMAGE_ALL_MASK     (1 << 2)
@@ -98,18 +100,19 @@
 namespace composite
 {
 class PaintHandler {
-public:
-    virtual ~PaintHandler () {};
-
-    virtual void paintOutputs (CompOutput::ptrList &outputs,
-			       unsigned int        mask,
-			       const CompRegion    &region) = 0;
-
-    virtual bool hasVSync () { return false; };
-    virtual bool requiredForcedRefreshRate () { return false; };
-
-    virtual void prepareDrawing () {};
-    virtual bool compositingActive () { return false; };
+    public:
+	virtual ~PaintHandler () {};
+
+	virtual void paintOutputs (CompOutput::ptrList &outputs,
+				   unsigned int        mask,
+				   const CompRegion    &region) = 0;
+
+	virtual bool hasVSync () { return false; };
+	virtual bool requiredForcedRefreshRate () { return false; };
+
+	virtual void prepareDrawing () {};
+	virtual bool compositingActive () { return false; };
+	virtual unsigned int getFrameAge () { return 1; }
 };
 }
 }
@@ -173,12 +176,19 @@
 	 * Hookable function to damage regions directly
 	 */
 	virtual void damageRegion (const CompRegion &r);
+
+	/**
+	 * Hookable function to notify plugins that the last damage
+	 * event for this frame has been received, and all further damage
+	 * events will be for the next frame
+	 */
+	virtual void damageCutoff ();
 };
 
 extern template class PluginClassHandler<CompositeScreen, CompScreen, COMPIZ_COMPOSITE_ABI>;
 
 class CompositeScreen :
-    public WrapableHandler<CompositeScreenInterface, 7>,
+    public WrapableHandler<CompositeScreenInterface, 8>,
     public PluginClassHandler<CompositeScreen, CompScreen, COMPIZ_COMPOSITE_ABI>,
     public CompOption::Class
 {
@@ -203,6 +213,24 @@
 	void damageScreen ();
 
 	void damagePending ();
+
+	/**
+	 * Causes the damage that was recorded on N - 1 number of
+	 * frames ago to be added to the current frame, applied
+	 * culmulatively. An age of "zero" means that the entire frame
+	 * is considered undefined and must be completely repaired,
+	 * wheras an age of 1 means that this frame is the same as the
+	 * last frame, so no damage is required.
+	 */
+	void applyDamageForFrameAge (unsigned int);
+	unsigned int getFrameAge ();
+	void addOverdrawDamageRegion (const CompRegion &);
+
+	typedef compiz::composite::buffertracking::AgeDamageQuery DamageQuery;
+	typedef DamageQuery::AreaShouldBeMarkedDirty AreaShouldBeMarkedDirty;
+
+	DamageQuery::Ptr
+	getDamageQuery (const AreaShouldBeMarkedDirty &callback);
 	
 
 	unsigned int damageMask ();
@@ -248,6 +276,7 @@
 	 * event loop
 	 */
 	WRAPABLE_HND (6, CompositeScreenInterface, void, damageRegion, const CompRegion &);
+	WRAPABLE_HND (7, CompositeScreenInterface, void, damageCutoff);
 
 	friend class PrivateCompositeDisplay;
 
@@ -310,6 +339,12 @@
  */
 #define PAINT_WINDOW_BLEND_MASK			(1 << 19)
 
+/**
+ * flags that would indicate the window is never actually drawn
+ */
+#define PAINT_WINDOW_NO_DRAW_MASKS (PAINT_WINDOW_OCCLUSION_DETECTION_MASK | \
+				    PAINT_WINDOW_NO_CORE_INSTANCE_MASK)
+
 class CompositeWindowInterface;
 extern template class WrapableInterface<CompositeWindow, CompositeWindowInterface>;
 

=== added directory 'plugins/composite/src/backbuffertracking'
=== added file 'plugins/composite/src/backbuffertracking/CMakeLists.txt'
--- plugins/composite/src/backbuffertracking/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/composite/src/backbuffertracking/CMakeLists.txt	2013-01-30 08:46:22 +0000
@@ -0,0 +1,31 @@
+INCLUDE_DIRECTORIES (  
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../include
+  ${CMAKE_CURRENT_SOURCE_DIR}/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/src
+    
+  ${Boost_INCLUDE_DIRS}
+)
+
+LINK_DIRECTORIES (${COMPIZ_LIBRARY_DIRS}) 
+
+SET( 
+  SRCS 
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/backbuffertracking.cpp
+)
+
+ADD_LIBRARY( 
+  compiz_composite_backbuffertracking STATIC
+  
+  ${SRCS}
+)
+
+if (COMPIZ_BUILD_TESTING)
+ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/tests )
+endif (COMPIZ_BUILD_TESTING)
+
+TARGET_LINK_LIBRARIES(
+  compiz_composite_backbuffertracking
+
+  compiz_size
+  compiz_core
+)

=== added directory 'plugins/composite/src/backbuffertracking/include'
=== added file 'plugins/composite/src/backbuffertracking/include/backbuffertracking.h'
--- plugins/composite/src/backbuffertracking/include/backbuffertracking.h	1970-01-01 00:00:00 +0000
+++ plugins/composite/src/backbuffertracking/include/backbuffertracking.h	2013-01-30 08:46:22 +0000
@@ -0,0 +1,125 @@
+/*
+ * Compiz, composite plugin, GLX_EXT_buffer_age logic
+ *
+ * Copyright (c) 2012 Sam Spilsbury
+ * Authors: Sam Spilsbury <[e-mail]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef _COMPIZ_COMPOSITE_BACKBUFFERTRACKING_H
+#define _COMPIZ_COMPOSITE_BACKBUFFERTRACKING_H
+
+#include <memory>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/function.hpp>
+
+#include <composite/agedamagequery.h>
+
+class CompSize;
+class CompRegion;
+
+namespace compiz
+{
+namespace composite
+{
+namespace buffertracking
+{
+class DamageAgeTracking
+{
+    public:
+
+	virtual ~DamageAgeTracking () {};
+	virtual void dirtyAreaOnCurrentFrame (const CompRegion &) = 0;
+	virtual void overdrawRegionOnPaintingFrame (const CompRegion &) = 0;
+	virtual void subtractObscuredArea (const CompRegion &) = 0;
+	virtual void incrementFrameAges () = 0;
+};
+
+class AgeingDamageBufferObserver
+{
+    public:
+
+	virtual ~AgeingDamageBufferObserver () {};
+	virtual void observe (DamageAgeTracking &damageAgeTracker) = 0;
+	virtual void unobserve (DamageAgeTracking &damageAgeTracker) = 0;
+};
+
+class AgeingDamageBuffers :
+    public AgeingDamageBufferObserver,
+    boost::noncopyable
+{
+    public:
+
+	AgeingDamageBuffers ();
+
+	void observe (DamageAgeTracking &damageAgeTracker);
+	void unobserve (DamageAgeTracking &damageAgeTracker);
+	void incrementAges ();
+	void markAreaDirty (const CompRegion &reg);
+	void markAreaDirtyOnLastFrame (const CompRegion &reg);
+	void subtractObscuredArea (const CompRegion &reg);
+
+    private:
+
+	class Private;
+	std::auto_ptr <Private> priv;
+};
+
+class FrameRoster :
+    public DamageAgeTracking,
+    public AgeDamageQuery,
+    boost::noncopyable
+{
+    public:
+
+	typedef AgeDamageQuery::AreaShouldBeMarkedDirty AreaShouldBeMarkedDirty;
+	typedef boost::shared_ptr <FrameRoster> Ptr;
+
+	FrameRoster (const CompSize                   &size,
+		     AgeingDamageBufferObserver       &tracker,
+		     const AreaShouldBeMarkedDirty    &shouldMarkDirty);
+
+	~FrameRoster ();
+
+	void dirtyAreaOnCurrentFrame (const CompRegion &);
+	void overdrawRegionOnPaintingFrame (const CompRegion &);
+	void subtractObscuredArea (const CompRegion &);
+	void incrementFrameAges ();
+	CompRegion damageForFrameAge (unsigned int);
+	const CompRegion & currentFrameDamage ();
+
+	class Private;
+	std::auto_ptr <Private> priv;
+
+	static const unsigned int NUM_TRACKED_FRAMES = 10;
+
+	static
+	FrameRoster::Ptr create (const CompSize                &size,
+
+				 const AreaShouldBeMarkedDirty &shouldMarkDirty);
+
+    private:
+
+};
+} // namespace buffertracking
+} // namespace composite
+} // namespace compiz
+#endif

=== added directory 'plugins/composite/src/backbuffertracking/src'
=== added file 'plugins/composite/src/backbuffertracking/src/backbuffertracking.cpp'
--- plugins/composite/src/backbuffertracking/src/backbuffertracking.cpp	1970-01-01 00:00:00 +0000
+++ plugins/composite/src/backbuffertracking/src/backbuffertracking.cpp	2013-01-30 08:46:22 +0000
@@ -0,0 +1,214 @@
+/*
+ * Compiz, composite plugin, GLX_EXT_buffer_age logic
+ *
+ * Copyright (c) 2012 Sam Spilsbury
+ * Authors: Sam Spilsbury <[e-mail]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <deque>
+#include <core/size.h>
+#include <core/region.h>
+#include "backbuffertracking.h"
+#include <cstdio>
+
+namespace bt = compiz::composite::buffertracking;
+
+class bt::FrameRoster::Private
+{
+    public:
+
+	Private (const CompSize                                 &size,
+		 bt::AgeingDamageBufferObserver                 &observer,
+		 const bt::FrameRoster::AreaShouldBeMarkedDirty &shouldBeMarkedDirty) :
+	    screenSize (size),
+	    observer (observer),
+	    shouldBeMarkedDirty (shouldBeMarkedDirty),
+	    oldFrames (1)
+	{
+	}
+
+	CompSize                                 screenSize;
+	bt::AgeingDamageBufferObserver           &observer;
+	bt::FrameRoster::AreaShouldBeMarkedDirty shouldBeMarkedDirty;
+	std::deque <CompRegion>                  oldFrames;
+};
+
+bt::FrameRoster::FrameRoster (const CompSize                 &size,
+			      bt::AgeingDamageBufferObserver &tracker,
+			      const AreaShouldBeMarkedDirty  &shouldBeMarkedDirty) :
+    priv (new bt::FrameRoster::Private (size,
+					tracker,
+					shouldBeMarkedDirty))
+{
+    priv->observer.observe (*this);
+}
+
+bt::FrameRoster::~FrameRoster ()
+{
+    priv->observer.unobserve (*this);
+}
+
+CompRegion
+bt::FrameRoster::damageForFrameAge (unsigned int age)
+{
+    if (!age)
+	return CompRegion (0, 0,
+			   priv->screenSize.width (),
+			   priv->screenSize.height ());
+
+    if (age >= priv->oldFrames.size ())
+	return CompRegion (0, 0,
+			   priv->screenSize.width (),
+			   priv->screenSize.height ());
+
+    CompRegion accumulatedDamage;
+
+    while (age--)
+    {
+	unsigned int frameNum = (priv->oldFrames.size () - age) - 1;
+	accumulatedDamage += priv->oldFrames[frameNum];
+    }
+
+    return accumulatedDamage;
+}
+
+void
+bt::FrameRoster::dirtyAreaOnCurrentFrame (const CompRegion &r)
+{
+    if (priv->shouldBeMarkedDirty (r))
+	(*priv->oldFrames.rbegin ()) += r;
+}
+
+void
+bt::FrameRoster::subtractObscuredArea (const CompRegion &r)
+{
+    (*priv->oldFrames.rbegin ()) -= r;
+}
+
+void
+bt::FrameRoster::overdrawRegionOnPaintingFrame (const CompRegion &r)
+{
+    assert (priv->oldFrames.size () > 1);
+    std::deque <CompRegion>::reverse_iterator it = priv->oldFrames.rbegin ();
+    ++it;
+    (*it) += r;
+}
+
+void
+bt::FrameRoster::incrementFrameAges ()
+{
+    priv->oldFrames.push_back (CompRegion ());
+
+    /* Get rid of old frames */
+    if (priv->oldFrames.size () > NUM_TRACKED_FRAMES)
+	priv->oldFrames.pop_front ();
+}
+
+const CompRegion &
+bt::FrameRoster::currentFrameDamage ()
+{
+    return *priv->oldFrames.rbegin ();
+}
+
+class bt::AgeingDamageBuffers::Private
+{
+    public:
+
+	std::vector <bt::DamageAgeTracking *> damageAgeTrackers;
+};
+
+bt::AgeingDamageBuffers::AgeingDamageBuffers () :
+    priv (new bt::AgeingDamageBuffers::Private ())
+{
+}
+
+void
+bt::AgeingDamageBuffers::observe (bt::DamageAgeTracking &damageAgeTracker)
+{
+    priv->damageAgeTrackers.push_back (&damageAgeTracker);
+}
+
+void
+bt::AgeingDamageBuffers::unobserve (bt::DamageAgeTracking &damageAgeTracker)
+{
+    std::vector <bt::DamageAgeTracking *>::iterator it =
+	std::find (priv->damageAgeTrackers.begin (),
+		   priv->damageAgeTrackers.end (),
+		   &damageAgeTracker);
+
+    if (it != priv->damageAgeTrackers.end ())
+	priv->damageAgeTrackers.erase (it);
+}
+
+void
+bt::AgeingDamageBuffers::incrementAges ()
+{
+    for (std::vector <bt::DamageAgeTracking *>::iterator it =
+	 priv->damageAgeTrackers.begin ();
+	 it != priv->damageAgeTrackers.end ();
+	 ++it)
+    {
+	bt::DamageAgeTracking *tracker = *it;
+
+	tracker->incrementFrameAges ();
+    }
+}
+
+void
+bt::AgeingDamageBuffers::markAreaDirty (const CompRegion &reg)
+{
+    for (std::vector <bt::DamageAgeTracking *>::iterator it =
+	 priv->damageAgeTrackers.begin ();
+	 it != priv->damageAgeTrackers.end ();
+	 ++it)
+    {
+	bt::DamageAgeTracking *tracker = *it;
+
+	tracker->dirtyAreaOnCurrentFrame (reg);
+    }
+}
+
+void
+bt::AgeingDamageBuffers::subtractObscuredArea (const CompRegion &reg)
+{
+    for (std::vector <bt::DamageAgeTracking *>::iterator it =
+	 priv->damageAgeTrackers.begin ();
+	 it != priv->damageAgeTrackers.end ();
+	 ++it)
+    {
+	bt::DamageAgeTracking *tracker = *it;
+
+	tracker->subtractObscuredArea (reg);
+    }
+}
+
+void
+bt::AgeingDamageBuffers::markAreaDirtyOnLastFrame (const CompRegion &reg)
+{
+    for (std::vector <bt::DamageAgeTracking *>::iterator it =
+	 priv->damageAgeTrackers.begin ();
+	 it != priv->damageAgeTrackers.end ();
+	 ++it)
+    {
+	bt::DamageAgeTracking *tracker = *it;
+
+	tracker->overdrawRegionOnPaintingFrame (reg);
+    }
+}

=== added directory 'plugins/composite/src/backbuffertracking/tests'
=== added file 'plugins/composite/src/backbuffertracking/tests/CMakeLists.txt'
--- plugins/composite/src/backbuffertracking/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/composite/src/backbuffertracking/tests/CMakeLists.txt	2013-01-30 08:46:22 +0000
@@ -0,0 +1,24 @@
+find_library (GMOCK_LIBRARY gmock)
+find_library (GMOCK_MAIN_LIBRARY gmock_main)
+
+if (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
+  message ("Google Mock and Google Test not found - cannot build tests!")
+  set (COMPIZ_BUILD_TESTING OFF)
+endif (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
+
+include_directories (${GTEST_INCLUDE_DIRS})
+
+link_directories (${COMPIZ_LIBRARY_DIRS})
+
+add_executable (compiz_test_composite_backbuffertracking
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-composite-backbuffertracking.cpp)
+
+target_link_libraries (compiz_test_composite_backbuffertracking
+                       compiz_composite_backbuffertracking
+                       ${GTEST_BOTH_LIBRARIES}
+		       ${GMOCK_LIBRARY}
+		       ${GMOCK_MAIN_LIBRARY}
+		       ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
+                       )
+
+compiz_discover_tests (compiz_test_composite_backbuffertracking COVERAGE compiz_composite_backbuffertracking)

=== added file 'plugins/composite/src/backbuffertracking/tests/test-composite-backbuffertracking.cpp'
--- plugins/composite/src/backbuffertracking/tests/test-composite-backbuffertracking.cpp	1970-01-01 00:00:00 +0000
+++ plugins/composite/src/backbuffertracking/tests/test-composite-backbuffertracking.cpp	2013-01-30 08:46:22 +0000
@@ -0,0 +1,450 @@
+/*
+ * Compiz, composite plugin, GLX_EXT_buffer_age logic
+ *
+ * Copyright (c) 2012 Sam Spilsbury
+ * Authors: Sam Spilsbury <[e-mail]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <boost/bind.hpp>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <core/region.h>
+#include <core/size.h>
+
+#include "backbuffertracking.h"
+
+using ::testing::NiceMock;
+using ::testing::_;
+using ::testing::AtLeast;
+
+namespace bt = compiz::composite::buffertracking;
+
+namespace
+{
+class MockAgeingDamageBufferObserver :
+    public bt::AgeingDamageBufferObserver
+{
+    public:
+
+	MOCK_METHOD1 (observe, void (bt::DamageAgeTracking &));
+	MOCK_METHOD1 (unobserve, void (bt::DamageAgeTracking &));
+};
+
+bool alwaysTrackDamage (const CompRegion &)
+{
+    return true;
+}
+
+
+class BackbufferTracking :
+    public ::testing::Test
+{
+    public:
+
+	BackbufferTracking () :
+	    screen (1000, 1000),
+	    roster ()
+	{
+	}
+
+	virtual void SetUp ()
+	{
+	    SetupRoster ();
+	}
+
+	virtual void SetupRoster ()
+	{
+	    roster.reset (new bt::FrameRoster (screen,
+					       niceTracker,
+					       boost::bind (alwaysTrackDamage,
+							   _1)));
+	}
+
+    protected:
+
+	CompSize                           screen;
+	NiceMock <MockAgeingDamageBufferObserver> niceTracker;
+	bt::FrameRoster::Ptr               roster;
+};
+
+class BackbufferTrackingCallbacks :
+    public BackbufferTracking
+{
+    public:
+
+	BackbufferTrackingCallbacks () :
+	    shouldDamage (false)
+	{
+	}
+
+    protected:
+
+	void allowDamage (bool allow)
+	{
+	    shouldDamage = allow;
+	}
+
+    private:
+
+	virtual void SetupRoster ()
+	{
+	    roster.reset (new bt::FrameRoster (screen,
+					       niceTracker,
+					       boost::bind (&BackbufferTrackingCallbacks::shouldDamageCallback,
+							    this, _1)));
+	}
+
+	bool shouldDamageCallback (const CompRegion &)
+	{
+	    return shouldDamage;
+	}
+
+	bool shouldDamage;
+};
+}
+
+std::ostream &
+operator<< (std::ostream &os, const CompRegion &reg)
+{
+    os << "Region with Bounding Rectangle : " <<
+	  reg.boundingRect ().x () << " " <<
+	  reg.boundingRect ().y () << " " <<
+	  reg.boundingRect ().width () << " " <<
+	  reg.boundingRect ().height () << std::endl;
+    CompRect::vector rects (reg.rects ());
+    for (CompRect::vector::iterator it = rects.begin ();
+	 it != rects.end ();
+	 it++)
+	os << " - subrectangle: " <<
+	      (*it).x () << " " <<
+	      (*it).y () << " " <<
+	      (*it).width () << " " <<
+	      (*it).height () << " " << std::endl;
+
+    return os;
+}
+
+TEST (BackbufferTrackingConstruction, CreateAddsToObserverList)
+{
+    MockAgeingDamageBufferObserver mockAgeingDamageBufferObserver;
+
+    /* We can't verify the argument here,
+     * but we can verify the function call */
+    EXPECT_CALL (mockAgeingDamageBufferObserver, observe (_));
+    EXPECT_CALL (mockAgeingDamageBufferObserver, unobserve (_)).Times (AtLeast (0));
+    bt::FrameRoster roster (CompSize (),
+			    mockAgeingDamageBufferObserver,
+			    boost::bind (alwaysTrackDamage, _1));
+}
+
+TEST (BackbufferTrackingConstruction, DestroyRemovesFromObserverList)
+{
+    MockAgeingDamageBufferObserver mockAgeingDamageBufferObserver;
+
+    /* We can't verify the argument here,
+     * but we can verify the function call */
+    EXPECT_CALL (mockAgeingDamageBufferObserver, observe (_)).Times (AtLeast (0));
+    EXPECT_CALL (mockAgeingDamageBufferObserver, unobserve (_));
+    bt::FrameRoster roster (CompSize (),
+			    mockAgeingDamageBufferObserver,
+			    boost::bind (alwaysTrackDamage, _1));
+}
+
+TEST_F (BackbufferTrackingCallbacks, TrackIntoCurrentIfCallbackTrue)
+{
+    allowDamage (true);
+    CompRegion damage (100, 100, 100, 100);
+    roster->dirtyAreaOnCurrentFrame (damage);
+    EXPECT_EQ (damage, roster->currentFrameDamage ());
+}
+
+TEST_F (BackbufferTrackingCallbacks, NoTrackIntoCurrentIfCallbackFalse)
+{
+    allowDamage (false);
+    CompRegion damage (100, 100, 100, 100);
+    roster->dirtyAreaOnCurrentFrame (damage);
+    EXPECT_EQ (emptyRegion, roster->currentFrameDamage ());
+}
+
+TEST_F (BackbufferTracking, DirtyAreaSubtraction)
+{
+    CompRegion dirty (100, 100, 100, 100);
+    CompRegion obscured (150, 150, 50, 50);
+    roster->dirtyAreaOnCurrentFrame (dirty);
+    roster->subtractObscuredArea (obscured);
+    EXPECT_EQ (dirty - obscured, roster->currentFrameDamage ());
+}
+
+TEST_F (BackbufferTracking, DirtyAreaForAgeZeroAll)
+{
+    EXPECT_EQ (CompRegion (0, 0, screen.width (), screen.height ()),
+	       roster->damageForFrameAge (0));
+}
+
+TEST_F (BackbufferTracking, DirtyAreaAllForOlderThanTrackedAge)
+{
+    EXPECT_EQ (CompRegion (0, 0, screen.width (), screen.height ()),
+	       roster->damageForFrameAge (1));
+}
+
+TEST_F (BackbufferTracking, NoDirtyAreaForLastFrame)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    EXPECT_EQ (emptyRegion, roster->damageForFrameAge (1));
+}
+
+TEST_F (BackbufferTracking, DirtyAreaIfMoreSinceLastFrame)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame(all);
+    EXPECT_EQ (all, roster->damageForFrameAge (1));
+}
+
+TEST_F (BackbufferTracking, AddOverdrawRegionForLastFrame)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->incrementFrameAges ();
+    roster->overdrawRegionOnPaintingFrame (all);
+    EXPECT_EQ (all, roster->damageForFrameAge (2));
+}
+
+TEST_F (BackbufferTracking, TwoFramesAgo)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topleft);
+    roster->incrementFrameAges ();
+    EXPECT_EQ (topleft, roster->damageForFrameAge (2));
+}
+
+TEST_F (BackbufferTracking, TwoFramesAgoCulmulative)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
+    CompRegion topright (0, screen.width () / 2,
+			 screen.width () / 2,
+			 screen.height () / 2);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topleft);
+    roster->dirtyAreaOnCurrentFrame (topright);
+    roster->incrementFrameAges ();
+    EXPECT_EQ (topleft + topright, roster->damageForFrameAge (2));
+}
+
+TEST_F (BackbufferTracking, ThreeFramesAgo)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
+    CompRegion bottomright (screen.width () / 2,
+			    screen.height () / 2,
+			    screen.width () / 2,
+			    screen.height () / 2);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topleft);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (bottomright);
+    roster->incrementFrameAges ();
+
+    EXPECT_EQ (topleft + bottomright, roster->damageForFrameAge (3));
+}
+
+/* These are more or less functional tests from this point forward
+ * just checking a number of different situations */
+
+TEST_F (BackbufferTracking, ThreeFramesAgoWithFourFrames)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
+    CompRegion bottomright (screen.width () / 2,
+			    screen.height () / 2,
+			    screen.width () / 2,
+			    screen.height () / 2);
+    CompRegion topright (screen.width () / 2,
+			 0,
+			 screen.width () / 2,
+			 screen.height () / 2);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topleft);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (bottomright);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topright);
+    roster->incrementFrameAges ();
+
+    EXPECT_EQ (topright + bottomright, roster->damageForFrameAge (3));
+}
+
+TEST_F (BackbufferTracking, ThreeFramesAgoWithFourFramesAndOverlap)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion topleft (0, 0, screen.width () / 2, screen.height () / 2);
+    CompRegion bottomright (screen.width () / 2,
+			    screen.height () / 2,
+			    screen.width () / 2,
+			    screen.height () / 2);
+    CompRegion topright (screen.width () / 2,
+			 0,
+			 screen.width () / 2,
+			 screen.height () / 2);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (topleft);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (bottomright);
+    roster->incrementFrameAges ();
+    roster->dirtyAreaOnCurrentFrame (bottomright);
+    roster->incrementFrameAges ();
+
+    EXPECT_EQ (bottomright, roster->damageForFrameAge (3));
+}
+
+TEST_F (BackbufferTracking, AllDamageForExceedingMaxTrackedFrames)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion damage (0, 0, 1, 1);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+
+    for (unsigned int i = 0; i < bt::FrameRoster::NUM_TRACKED_FRAMES - 1; ++i)
+    {
+	roster->incrementFrameAges ();
+	roster->dirtyAreaOnCurrentFrame (damage);
+    }
+
+    EXPECT_EQ (all, roster->damageForFrameAge (bt::FrameRoster::NUM_TRACKED_FRAMES + 1));
+}
+
+TEST_F (BackbufferTracking, DamageForMaxTrackedFrame)
+{
+    CompRegion all (0, 0, screen.width (), screen.height ());
+    CompRegion damage (0, 0, 1, 1);
+
+    roster->dirtyAreaOnCurrentFrame (all);
+
+    for (unsigned int i = 0; i < bt::FrameRoster::NUM_TRACKED_FRAMES + 1; ++i)
+    {
+	roster->incrementFrameAges ();
+	roster->dirtyAreaOnCurrentFrame (damage);
+    }
+
+    EXPECT_EQ (all, roster->damageForFrameAge (bt::FrameRoster::NUM_TRACKED_FRAMES));
+}
+
+class MockDamageAgeTracking :
+    public bt::DamageAgeTracking
+{
+    public:
+
+	typedef boost::shared_ptr <MockDamageAgeTracking> Ptr;
+
+	MOCK_METHOD0 (incrementFrameAges, void ());
+	MOCK_METHOD1 (dirtyAreaOnCurrentFrame, void (const CompRegion &));
+	MOCK_METHOD1 (subtractObscuredArea, void (const CompRegion &));
+	MOCK_METHOD1 (overdrawRegionOnPaintingFrame, void (const CompRegion &));
+};
+
+class AgeingDamageBuffers :
+    public ::testing::Test
+{
+    public:
+
+	AgeingDamageBuffers ()
+	{
+	    ageing.observe (mockDamageAgeTracker);
+	}
+
+	MockDamageAgeTracking   mockDamageAgeTracker;
+	bt::AgeingDamageBuffers ageing;
+};
+
+TEST_F (AgeingDamageBuffers, IncrementAgesOnValidRosters)
+{
+    EXPECT_CALL (mockDamageAgeTracker, incrementFrameAges ());
+    ageing.incrementAges ();
+}
+
+TEST_F (AgeingDamageBuffers, DirtyAreaOnValidRosters)
+{
+    CompRegion dirtyArea (100, 100, 100, 100);
+    EXPECT_CALL (mockDamageAgeTracker, dirtyAreaOnCurrentFrame (dirtyArea));
+    ageing.markAreaDirty (dirtyArea);
+}
+
+TEST_F (AgeingDamageBuffers, SubtractObscuredAreaOnValidRosters)
+{
+    CompRegion obscuredArea (100, 100, 100, 100);
+    EXPECT_CALL (mockDamageAgeTracker, subtractObscuredArea (obscuredArea));
+    ageing.subtractObscuredArea (obscuredArea);
+}
+
+TEST_F (AgeingDamageBuffers, AddOverdrawAreaOnValidRosters)
+{
+    CompRegion overdrawArea (100, 100, 100, 100);
+    EXPECT_CALL (mockDamageAgeTracker, overdrawRegionOnPaintingFrame (overdrawArea));
+    ageing.markAreaDirtyOnLastFrame (overdrawArea);
+}
+
+TEST_F (AgeingDamageBuffers, IncrementAgesOnInvalidRosters)
+{
+    EXPECT_CALL (mockDamageAgeTracker, incrementFrameAges ()).Times (0);
+    ageing.unobserve (mockDamageAgeTracker);
+    ageing.incrementAges ();
+}
+
+TEST_F (AgeingDamageBuffers, DirtyAreaOnInvalidRosters)
+{
+    EXPECT_CALL (mockDamageAgeTracker, dirtyAreaOnCurrentFrame (_)).Times (0);
+    ageing.unobserve (mockDamageAgeTracker);
+    ageing.markAreaDirty (emptyRegion);
+}
+
+TEST_F (AgeingDamageBuffers, SubtractObscuredAreaOnInvalidRosters)
+{
+    EXPECT_CALL (mockDamageAgeTracker, subtractObscuredArea (_)).Times (0);
+    ageing.unobserve (mockDamageAgeTracker);
+    ageing.subtractObscuredArea (emptyRegion);
+}
+
+TEST_F (AgeingDamageBuffers, AddOverdrawAreaOnInvalidRosters)
+{
+    EXPECT_CALL (mockDamageAgeTracker, overdrawRegionOnPaintingFrame (_)).Times (0);
+    ageing.unobserve (mockDamageAgeTracker);
+    ageing.markAreaDirtyOnLastFrame (emptyRegion);
+}
+
+

=== modified file 'plugins/composite/src/privates.h'
--- plugins/composite/src/privates.h	2012-09-20 09:35:40 +0000
+++ plugins/composite/src/privates.h	2013-01-30 08:46:22 +0000
@@ -36,12 +36,20 @@
 #include <map>
 
 #include "pixmapbinding.h"
+#include "backbuffertracking.h"
 #include "composite_options.h"
 
 extern CompPlugin::VTable *compositeVTable;
 
 extern CompWindow *lastDamagedWindow;
 
+enum DamageTracking
+{
+    DamageForCurrentFrame = 0,
+    DamageForLastFrame = 1,
+    DamageFinalPaintRegion
+};
+
 class PrivateCompositeScreen :
     ScreenInterface,
     public CompositeOptions
@@ -66,6 +74,8 @@
 
 	void scheduleRepaint ();
 
+	const CompRegion * damageTrackedBuffer (const CompRegion &);
+
     public:
 
 	CompositeScreen *cScreen;
@@ -80,10 +90,12 @@
 	bool randrExtension;
 	int  randrEvent, randrError;
 
-	CompRegion    damage;
+	CompRegion    lastFrameDamage;
 	unsigned long damageMask;
 
-	CompRegion    tmpRegion;
+	CompRegion     tmpRegion;
+
+	DamageTracking currentlyTrackingDamage;
 
 	Window	      overlay;
 	Window	      output;
@@ -99,6 +111,7 @@
 	int            redrawTime;
 	int            optimalRedrawTime;
 	bool           scheduled, painting, reschedule;
+	bool           damageRequiresRepaintReschedule;
 
 	bool slowAnimations;
 
@@ -115,6 +128,9 @@
 
 	/* Map Damage handle to its bounding box */
 	std::map<Damage, XRectangle> damages;
+
+	compiz::composite::buffertracking::AgeingDamageBuffers ageingBuffers;
+	compiz::composite::buffertracking::FrameRoster         roster;
 };
 
 class PrivateCompositeWindow :

=== modified file 'plugins/composite/src/screen.cpp'
--- plugins/composite/src/screen.cpp	2012-11-18 00:22:02 +0000
+++ plugins/composite/src/screen.cpp	2013-01-30 08:46:22 +0000
@@ -47,6 +47,8 @@
 
 template class WrapableInterface<CompositeScreen, CompositeScreenInterface>;
 
+namespace bt = compiz::composite::buffertracking;
+
 static const int FALLBACK_REFRESH_RATE = 60;   /* if all else fails */
 
 CompWindow *lastDamagedWindow = 0;
@@ -276,6 +278,14 @@
     delete priv;
 }
 
+namespace
+{
+bool alwaysMarkDirty ()
+{
+    return true;
+}
+}
+
 
 PrivateCompositeScreen::PrivateCompositeScreen (CompositeScreen *cs) :
     cScreen (cs),
@@ -294,6 +304,7 @@
     randrEvent (0),
     randrError (0),
     damageMask (COMPOSITE_SCREEN_DAMAGE_ALL_MASK),
+    currentlyTrackingDamage (DamageForCurrentFrame),
     overlay (None),
     output (None),
     exposeRects (),
@@ -305,12 +316,16 @@
     scheduled (false),
     painting (false),
     reschedule (false),
+    damageRequiresRepaintReschedule (true),
     slowAnimations (false),
     pHnd (NULL),
     FPSLimiterMode (CompositeFPSLimiterModeDefault),
     withDestroyedWindows (),
     cmSnAtom (0),
-    newCmSnOwner (None)
+    newCmSnOwner (None),
+    roster (*screen,
+	    ageingBuffers,
+	    boost::bind (alwaysMarkDirty))
 {
     gettimeofday (&lastRedraw, 0);
     // wrap outputChangeNotify
@@ -491,15 +506,47 @@
     return false;
 }
 
+const CompRegion *
+PrivateCompositeScreen::damageTrackedBuffer (const CompRegion &region)
+{
+    const CompRegion *currentDamage = NULL;
+
+    switch (currentlyTrackingDamage)
+    {
+	case DamageForCurrentFrame:
+	    currentDamage = &(roster.currentFrameDamage ());
+	    ageingBuffers.markAreaDirty (region);
+	    break;
+	case DamageForLastFrame:
+	    currentDamage = &(lastFrameDamage);
+	    lastFrameDamage += region;
+	    break;
+	case DamageFinalPaintRegion:
+	    currentDamage = &(tmpRegion);
+	    tmpRegion += region;
+	    break;
+	default:
+	    compLogMessage ("composite", CompLogLevelFatal, "unreachable section");
+	    assert (false);
+	    abort ();
+    }
+
+    assert (currentDamage);
+    return currentDamage;
+}
+
 void
 CompositeScreen::damageScreen ()
 {
+    /* Don't tell plugins about damage events when the damage buffer is already full */
     bool alreadyDamaged = priv->damageMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK;
+    alreadyDamaged |= ((currentDamage () & screen->region ()) == screen->region ());
 
     priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_ALL_MASK;
     priv->damageMask &= ~COMPOSITE_SCREEN_DAMAGE_REGION_MASK;
 
-    priv->scheduleRepaint ();
+    if (priv->damageRequiresRepaintReschedule)
+	priv->scheduleRepaint ();
 
     /*
      * Call through damageRegion since plugins listening for incoming damage
@@ -507,7 +554,15 @@
      */
 
     if (!alreadyDamaged)
+    {
 	damageRegion (CompRegion (0, 0, screen->width (), screen->height ()));
+
+	/* Set the damage region as the fullscreen region, because if
+	 * windows are unredirected we need to correctly subtract from
+	 * it later
+	 */
+	priv->damageTrackedBuffer (screen->region ());
+    }
 }
 
 void
@@ -518,7 +573,12 @@
     if (priv->damageMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
 	return;
 
-    priv->damage += region;
+    /* Don't cause repaints to be scheduled for empty damage
+     * regions */
+    if (region.isEmpty ())
+        return;
+
+    const CompRegion *currentDamage = priv->damageTrackedBuffer (region);
     priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_REGION_MASK;
 
     /* if the number of damage rectangles grows two much between repaints,
@@ -526,16 +586,61 @@
        in order to make sure we're not having too much overhead, damage
        the whole screen if we have a lot of damage rects */
 
-    if (priv->damage.numRects () > 100)
-       damageScreen ();
-    priv->scheduleRepaint ();
+    if (currentDamage->numRects () > 100)
+	damageScreen ();
+
+    if (priv->damageRequiresRepaintReschedule)
+	priv->scheduleRepaint ();
+}
+
+void
+CompositeScreen::damageCutoff ()
+{
+    WRAPABLE_HND_FUNCTN (damageCutoff);
 }
 
 void
 CompositeScreen::damagePending ()
 {
     priv->damageMask |= COMPOSITE_SCREEN_DAMAGE_PENDING_MASK;
-    priv->scheduleRepaint ();
+
+    if (priv->damageRequiresRepaintReschedule)
+	priv->scheduleRepaint ();
+}
+
+void
+CompositeScreen::applyDamageForFrameAge (unsigned int age)
+{
+    /* Track into "last frame damage" */
+    priv->currentlyTrackingDamage = DamageForLastFrame;
+    damageRegion (priv->roster.damageForFrameAge (age));
+    priv->currentlyTrackingDamage = DamageForCurrentFrame;
+}
+
+unsigned int
+CompositeScreen::getFrameAge ()
+{
+    if (priv->pHnd)
+	return priv->pHnd->getFrameAge ();
+
+    return 1;
+}
+
+void
+CompositeScreen::addOverdrawDamageRegion (const CompRegion &r)
+{
+    priv->ageingBuffers.markAreaDirtyOnLastFrame (r);
+}
+
+typedef CompositeScreen::AreaShouldBeMarkedDirty ShouldMarkDirty;
+
+CompositeScreen::DamageQuery::Ptr
+CompositeScreen::getDamageQuery (const ShouldMarkDirty &callback)
+{
+    /* No initial damage */
+    return bt::FrameRoster::Ptr (new bt::FrameRoster (CompSize (),
+						      priv->ageingBuffers,
+						      callback));
 }
 
 unsigned int
@@ -780,6 +885,10 @@
     {
 	int         timeDiff;
 
+	/* Damage that accumulates here does not require a repaint reschedule
+	 * as it will end up on this frame */
+	priv->damageRequiresRepaintReschedule = false;
+
 	if (priv->pHnd)
 	    priv->pHnd->prepareDrawing ();
 
@@ -814,7 +923,7 @@
 		    continue;
 
 		if (!CompositeWindow::get (w)->redirected ())
-		    priv->damage -= w->region ();
+		    priv->ageingBuffers.subtractObscuredArea (w->region ());
 
 		break;
 	    }
@@ -826,7 +935,13 @@
 	    }
 	}
 
-	priv->tmpRegion = priv->damage & screen->region ();
+	/* All further damage is for the next frame now, as
+	 * priv->tmpRegion will be assigned. Notify plugins that do
+	 * damage tracking of this */
+	damageCutoff ();
+
+	priv->tmpRegion = (priv->roster.currentFrameDamage () + priv->lastFrameDamage) & screen->region ();
+	priv->currentlyTrackingDamage = DamageFinalPaintRegion;
 
 	if (priv->damageMask & COMPOSITE_SCREEN_DAMAGE_REGION_MASK)
 	{
@@ -848,7 +963,9 @@
 	XSync (dpy, False);
 	priv->damages.clear ();
 
-	priv->damage = CompRegion ();
+	/* Any more damage requires a repaint reschedule */
+	priv->damageRequiresRepaintReschedule = true;
+	priv->lastFrameDamage = CompRegion ();
 
 	int mask = priv->damageMask;
 	priv->damageMask = 0;
@@ -864,9 +981,13 @@
 	else
 	    outputs.push_back (&screen->fullscreenOutput ());
 
+	priv->currentlyTrackingDamage = DamageForCurrentFrame;
+
+	/* All new damage goes on the next frame */
+	priv->ageingBuffers.incrementAges ();
+
 	paint (outputs, mask);
 
-
 	donePaint ();
 
 	priv->outputShapeChanged = false;
@@ -1023,8 +1144,12 @@
 CompositeScreenInterface::damageRegion (const CompRegion &r)
     WRAPABLE_DEF (damageRegion, r);
 
+void
+CompositeScreenInterface::damageCutoff ()
+    WRAPABLE_DEF (damageCutoff);
+
 const CompRegion &
 CompositeScreen::currentDamage () const
 {
-    return priv->damage;
+    return priv->roster.currentFrameDamage ();
 }

=== modified file 'plugins/kdecompat/src/kdecompat.cpp'
--- plugins/kdecompat/src/kdecompat.cpp	2012-08-14 06:33:22 +0000
+++ plugins/kdecompat/src/kdecompat.cpp	2013-01-30 08:46:22 +0000
@@ -196,7 +196,7 @@
     if ((!(ks->optionGetPlasmaThumbnails () || mPreviews.empty ()) &&
         !(mSlideData || mSlideData->remaining)) ||
 	!window->mapNum ()                ||
-	(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK))
+	(mask & PAINT_WINDOW_NO_DRAW_MASKS))
     {
 	status = gWindow->glPaint (attrib, transform, region, mask);
 	return status;
@@ -210,7 +210,7 @@
 	CompRect           clipBox (window->x (), window->y (),
 				    window->width (), window->height ());
 
-	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+	if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
 	    return false;
 
 	remainder = (float) data->remaining / data->duration;

=== modified file 'plugins/opengl/include/opengl/opengl.h'
--- plugins/opengl/include/opengl/opengl.h	2013-01-10 09:23:24 +0000
+++ plugins/opengl/include/opengl/opengl.h	2013-01-30 08:46:22 +0000
@@ -37,6 +37,13 @@
 #else
 #include <GL/gl.h>
 #include <GL/glx.h>
+
+/* Some implementations have not yet given a definition
+ * to GLX_BACK_BUFFER_AGE_EXT but this is the token as defined
+ * in the spec (https://www.opengl.org/registry/specs/EXT/glx_buffer_age.txt)
+ */
+#define GLX_BACK_BUFFER_AGE_EXT 0x20F4
+
 #endif
 
 #include <core/size.h>
@@ -50,7 +57,7 @@
 #include <opengl/programcache.h>
 #include <opengl/shadercache.h>
 
-#define COMPIZ_OPENGL_ABI 6
+#define COMPIZ_OPENGL_ABI 8
 
 /*
  * Some plugins check for #ifdef USE_MODERN_COMPIZ_GL. Support it for now, but
@@ -525,6 +532,7 @@
     extern bool  shaders;
     extern bool  stencilBuffer;
     extern GLint maxTextureUnits;
+    extern bool  bufferAge;
 
     extern bool canDoSaturated;
     extern bool canDoSlightlySaturated;
@@ -663,6 +671,11 @@
 					      unsigned int         mask);
 
 	/**
+	 * Return true if glPaintCompositedOutput is required for this frame
+	 */
+	virtual bool glPaintCompositedOutputRequired ();
+
+	/**
 	 * Hookable function used by plugins to determine stenciling mask
 	 */
 	virtual void glBufferStencil (const GLMatrix       &matrix,
@@ -674,7 +687,7 @@
 extern template class PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI>;
 
 class GLScreen :
-    public WrapableHandler<GLScreenInterface, 8>,
+    public WrapableHandler<GLScreenInterface, 9>,
     public PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI>,
     public CompOption::Class
 {
@@ -788,7 +801,9 @@
 	WRAPABLE_HND (6, GLScreenInterface, void, glPaintCompositedOutput,
 		      const CompRegion &, GLFramebufferObject *, unsigned int);
 
-	WRAPABLE_HND (7, GLScreenInterface, void, glBufferStencil, const GLMatrix &,
+	WRAPABLE_HND (7, GLScreenInterface, bool, glPaintCompositedOutputRequired);
+
+	WRAPABLE_HND (8, GLScreenInterface, void, glBufferStencil, const GLMatrix &,
 		      GLVertexBuffer &,
 		      CompOutput *);
 

=== modified file 'plugins/opengl/src/doublebuffer/src/double-buffer.cpp'
--- plugins/opengl/src/doublebuffer/src/double-buffer.cpp	2012-11-09 06:13:00 +0000
+++ plugins/opengl/src/doublebuffer/src/double-buffer.cpp	2013-01-30 08:46:22 +0000
@@ -26,6 +26,7 @@
 
 #include <cstdlib>
 #include <cassert>
+#include <cstdio>
 #include "opengl/doublebuffer.h"
 
 using namespace compiz::opengl;
@@ -77,9 +78,7 @@
 
 	if (setting[NEED_PERSISTENT_BACK_BUFFER] &&
 	    !setting[HAVE_PERSISTENT_BACK_BUFFER])
-	{
 	    copyFrontToBack ();
-	}
     }
     else
     {

=== modified file 'plugins/opengl/src/framebufferobject.cpp'
--- plugins/opengl/src/framebufferobject.cpp	2012-08-06 09:44:49 +0000
+++ plugins/opengl/src/framebufferobject.cpp	2013-01-30 08:46:22 +0000
@@ -131,7 +131,7 @@
 
     (*GL::framebufferTexture2D) (GL::FRAMEBUFFER, GL::COLOR_ATTACHMENT0,
                                  priv->glTex->target (),
-                                 priv->glTex->name (), 0);
+				 priv->glTex->name (), 0);
 
     priv->status = (*GL::checkFramebufferStatus) (GL::DRAW_FRAMEBUFFER);
 

=== modified file 'plugins/opengl/src/paint.cpp'
--- plugins/opengl/src/paint.cpp	2013-01-01 10:04:50 +0000
+++ plugins/opengl/src/paint.cpp	2013-01-30 08:46:22 +0000
@@ -626,8 +626,8 @@
 	    if (mask & PAINT_SCREEN_FULL_MASK)
 	    {
 		glPaintTransformedOutput (sAttrib, sTransform,
-					  CompRegion (*output), output, mask);
-
+					  CompRegionRef (output->region ()), output, mask);
+		priv->cScreen->addOverdrawDamageRegion (CompRegionRef (output->region ()));
 		return true;
 	    }
 
@@ -657,8 +657,9 @@
     }
     else if (mask & PAINT_SCREEN_FULL_MASK)
     {
-	glPaintTransformedOutput (sAttrib, sTransform, CompRegion (*output),
+        glPaintTransformedOutput (sAttrib, sTransform, CompRegionRef (output->region ()),
 				  output, mask);
+	priv->cScreen->addOverdrawDamageRegion (CompRegionRef (output->region ()));
 
 	return true;
     }
@@ -668,6 +669,13 @@
     }
 }
 
+bool
+GLScreen::glPaintCompositedOutputRequired ()
+{
+    WRAPABLE_HND_FUNCTN_RETURN (bool, glPaintCompositedOutputRequired);
+    return false;
+}
+
 void
 GLScreen::glPaintCompositedOutput (const CompRegion    &region,
 				   GLFramebufferObject *fbo,

=== modified file 'plugins/opengl/src/privates.h'
--- plugins/opengl/src/privates.h	2013-01-01 09:41:41 +0000
+++ plugins/opengl/src/privates.h	2013-01-30 08:46:22 +0000
@@ -29,6 +29,9 @@
 #define _OPENGL_PRIVATES_H
 
 #include <memory>
+#include <vector>
+#include <tr1/tuple>
+#include <boost/shared_ptr.hpp>
 
 #include <composite/composite.h>
 #include <opengl/opengl.h>
@@ -119,8 +122,26 @@
 	GLTexture::List textures;
 };
 
+class FrameProvider
+{
+    public:
+
+	typedef boost::shared_ptr <FrameProvider> Ptr;
+	typedef std::tr1::tuple <GLFramebufferObject *, int> Frame;
+
+	virtual ~FrameProvider () {}
+
+	virtual GLuint getCurrentFrame () = 0;
+	virtual void endFrame () = 0;
+
+	virtual bool providesPersistence () = 0;
+	virtual bool alwaysPostprocess () = 0;
+	virtual void invalidateAll () = 0;
+};
+
 class PrivateGLScreen :
     public ScreenInterface,
+    public CompositeScreenInterface,
     public compiz::composite::PaintHandler,
     public OpenglOptions
 {
@@ -141,12 +162,16 @@
 	bool hasVSync ();
 	bool requiredForcedRefreshRate ();
 
+	unsigned int getFrameAge ();
+
 	void updateRenderMode ();
 
 	void prepareDrawing ();
 
 	bool compositingActive ();
 
+	void damageCutoff ();
+
 	void paintBackground (const GLMatrix   &transform,
 	                      const CompRegion &region,
 			      bool             transformed);
@@ -162,6 +187,8 @@
 
 	bool driverIsBlacklisted (const char *regex) const;
 
+	bool postprocessRequiredForCurrentFrame ();
+
     public:
 
 	GLScreen        *gScreen;
@@ -196,7 +223,7 @@
 	GLXDoubleBuffer doubleBuffer;
 	#endif
 
-	GLFramebufferObject *scratchFbo;
+	boost::shared_ptr <GLFramebufferObject> scratchFbo;
 	CompRegion outputRegion;
 
 	XRectangle lastViewport;
@@ -221,8 +248,10 @@
 	Pixmap rootPixmapCopy;
 	CompSize rootPixmapSize;
 
+	FrameProvider::Ptr frameProvider;
 	const char *glVendor, *glRenderer, *glVersion;
 
+	bool postprocessingRequired;
 	mutable CompString prevRegex;
 	mutable bool       prevBlacklisted;
 };

=== modified file 'plugins/opengl/src/screen.cpp'
--- plugins/opengl/src/screen.cpp	2013-01-09 10:57:03 +0000
+++ plugins/opengl/src/screen.cpp	2013-01-30 08:46:22 +0000
@@ -186,6 +186,7 @@
     bool  vboEnabled = false;
     bool  shaders = false;
     GLint maxTextureUnits = 1;
+    bool  bufferAge = false;
 
     bool canDoSaturated = false;
     bool canDoSlightlySaturated = false;
@@ -301,6 +302,52 @@
 
 #ifndef USE_GLES
 
+class BufferAgeFrameProvider :
+    public FrameProvider
+{
+    public:
+
+	BufferAgeFrameProvider (Display     *disp,
+				GLXDrawable drawable) :
+	    mDisplay (disp),
+	    mDrawable (drawable)
+	{
+	}
+
+	unsigned int getCurrentFrame ()
+	{
+	    unsigned int age = 0;
+	    (*GL::queryDrawable) (mDisplay,
+				  mDrawable,
+				  GLX_BACK_BUFFER_AGE_EXT,
+				  &age);
+	    return age;
+	}
+
+	void endFrame ()
+	{
+	}
+
+	void invalidateAll ()
+	{
+	}
+
+	bool providesPersistence ()
+	{
+	    return true;
+	}
+
+	bool alwaysPostprocess ()
+	{
+	    return false;
+	}
+
+    private:
+
+	Display *mDisplay;
+	GLXDrawable mDrawable;
+};
+
 namespace compiz
 {
 namespace opengl
@@ -358,6 +405,137 @@
 
 #endif
 
+class UndefinedFrameProvider :
+    public FrameProvider
+{
+    public:
+
+	unsigned int getCurrentFrame ()
+	{
+	    return 0;
+	}
+
+	void endFrame ()
+	{
+	}
+
+	void invalidateAll ()
+	{
+	}
+
+	bool providesPersistence ()
+	{
+	    return false;
+	}
+
+	bool alwaysPostprocess ()
+	{
+	    return false;
+	}
+};
+
+class PostprocessFrameProvider :
+    public FrameProvider
+{
+    public:
+
+	PostprocessFrameProvider (GLFramebufferObject *object) :
+	    mObject (object),
+	    mAge (0)
+	{
+	}
+
+	unsigned int getCurrentFrame ()
+	{
+	    /* We are now using this buffer, reset
+	     * age back to zero */
+	    unsigned int lastAge = mAge;
+	    mAge = 0;
+
+	    return lastAge;
+	}
+
+	void endFrame ()
+	{
+	    ++mAge;
+	}
+
+	void invalidateAll ()
+	{
+	    mAge = 0;
+	}
+
+	bool providesPersistence ()
+	{
+	    return true;
+	}
+
+	bool alwaysPostprocess ()
+	{
+	    return true;
+	}
+
+    private:
+
+	GLFramebufferObject *mObject;
+	unsigned int        mAge;
+};
+
+class OptionalPostprocessFrameProvider :
+    public FrameProvider
+{
+    public:
+
+	typedef boost::function <bool ()> PostprocessRequired;
+
+	OptionalPostprocessFrameProvider (const FrameProvider::Ptr  &backbuffer,
+					  const FrameProvider::Ptr  &scratchbuffer,
+					  const PostprocessRequired &ppRequired) :
+	    mBackbuffer (backbuffer),
+	    mScratchbuffer (scratchbuffer),
+	    mPPRequired (ppRequired)
+	{
+	}
+
+	unsigned int getCurrentFrame ()
+	{
+	    if (mPPRequired ())
+		return mScratchbuffer->getCurrentFrame ();
+	    else
+		return mBackbuffer->getCurrentFrame ();
+	}
+
+	void endFrame ()
+	{
+	    mScratchbuffer->endFrame ();
+	}
+
+	void invalidateAll ()
+	{
+	    mScratchbuffer->invalidateAll ();
+	}
+
+	bool providesPersistence ()
+	{
+	    /* We are only as good as the backbuffer is */
+	    return mBackbuffer->providesPersistence ();
+	}
+
+	bool alwaysPostprocess ()
+	{
+	    if (mPPRequired ())
+		return mScratchbuffer->alwaysPostprocess ();
+	    else
+		return mBackbuffer->alwaysPostprocess ();
+	}
+
+    private:
+
+	FrameProvider::Ptr mBackbuffer;
+	FrameProvider::Ptr mScratchbuffer;
+	PostprocessRequired mPPRequired;
+};
+
 bool
 GLScreen::glInitContext (XVisualInfo *visinfo)
 {
@@ -593,6 +771,8 @@
 
     priv->incorrectRefreshRate = false;
 
+    priv->frameProvider.reset (new PostprocessFrameProvider ());
+
     #else
 
     Display		 *dpy = screen->dpy ();
@@ -899,12 +1079,48 @@
 
     if (GL::fboSupported)
     {
-	priv->scratchFbo = new GLFramebufferObject;
+	priv->scratchFbo.reset (new GLFramebufferObject ());
 	priv->scratchFbo->allocate (*screen, NULL, GL_BGRA);
     }
 
     GLVertexBuffer::streamingBuffer ()->setAutoProgram (priv->autoProgram);
 
+    /* We need scratchFbo to be set before doing this, and it is common
+     * to both the GLES and non-GLES codepaths, so using another #ifdef
+     */
+#ifndef USE_GLES
+    const Window outputWindow = CompositeScreen::get (screen)->output ();
+
+    if (GL::fboEnabled)
+    {
+	if (GL::bufferAge)
+	{
+	    FrameProvider::Ptr back (new BufferAgeFrameProvider (screen->dpy (),
+								 outputWindow));
+	    FrameProvider::Ptr scratch (new PostprocessFrameProvider (priv->scratchFbo.get ()));
+	    OptionalPostprocessFrameProvider::PostprocessRequired ppReq
+		    (boost::bind (&PrivateGLScreen::postprocessRequiredForCurrentFrame,
+				  priv));
+	    priv->frameProvider.reset (new OptionalPostprocessFrameProvider (back,
+									     scratch,
+									     ppReq));
+	}
+	else
+	{
+	    /* Prefer using FBO's instead of switching between a defined/undefined backbuffer */
+	    priv->frameProvider.reset (new PostprocessFrameProvider (priv->scratchFbo.get ()));
+	}
+    }
+    else
+    {
+	if (GL::bufferAge)
+	    priv->frameProvider.reset (new BufferAgeFrameProvider (screen->dpy (),
+								   outputWindow));
+	else
+	    priv->frameProvider.reset (new UndefinedFrameProvider ());
+    }
+#endif
+
     return true;
 }
 
@@ -993,6 +1209,13 @@
 	return;
     }
 
+    if (strstr (glxExtensions, "GLX_EXT_buffer_age"))
+    {
+	compLogMessage ("opengl", CompLogLevelInfo,
+			"GLX_EXT_buffer_age is supported");
+	GL::bufferAge = true;
+    }
+
     priv->getProcAddress = (GL::GLXGetProcAddressProc)
 	getProcAddress ("glXGetProcAddressARB");
     GL::bindTexImage = (GL::GLXBindTexImageProc)
@@ -1209,9 +1432,6 @@
 	glXDestroyContext (screen->dpy (), priv->ctx);
     #endif
 
-    if (priv->scratchFbo)
-	delete priv->scratchFbo;
-
     delete priv;
 }
 
@@ -1233,7 +1453,7 @@
     ctx (EGL_NO_CONTEXT),
     doubleBuffer (screen->dpy (), *screen, surface),
     #endif
-    scratchFbo (NULL),
+    scratchFbo (),
     outputRegion (),
     refreshSubBuffer (false),
     lastMask (0),
@@ -1246,13 +1466,16 @@
     autoProgram (new GLScreenAutoProgram(gs)),
     rootPixmapCopy (None),
     rootPixmapSize (),
+    frameProvider (),
     glVendor (NULL),
     glRenderer (NULL),
     glVersion (NULL),
+    postprocessingRequired (false)
     prevRegex (),
     prevBlacklisted (false)
 {
     ScreenInterface::setHandler (screen);
+    CompositeScreenInterface::setHandler (cScreen);
 }
 
 PrivateGLScreen::~PrivateGLScreen ()
@@ -1443,8 +1666,11 @@
 {
     screen->outputChangeNotify ();
 
+    frameProvider->invalidateAll ();
+
     if (scratchFbo)
 	scratchFbo->allocate (*screen, NULL, GL_BGRA);
+
     updateView ();
 }
 
@@ -1669,6 +1895,10 @@
 GLScreenInterface::projectionMatrix ()
     WRAPABLE_DEF (projectionMatrix)
 
+bool
+GLScreenInterface::glPaintCompositedOutputRequired ()
+    WRAPABLE_DEF (glPaintCompositedOutputRequired)
+
 void
 GLScreenInterface::glPaintCompositedOutput (const CompRegion    &region,
 					    GLFramebufferObject *fbo,
@@ -1977,18 +2207,6 @@
     glDepthMask (GL_FALSE);
     glStencilMask (0);
 
-    GLFramebufferObject *oldFbo = NULL;
-    bool useFbo = false;
-
-    /* Clear the color buffer where appropriate */
-    if (GL::fboEnabled && scratchFbo)
-    {
-	oldFbo = scratchFbo->bind ();
-	useFbo = scratchFbo->checkStatus () && scratchFbo->tex ();
-	if (!useFbo)
-	    GLFramebufferObject::rebind (oldFbo);
-    }
-
 #ifdef UNSAFE_ARM_SGX_FIXME
     refreshSubBuffer = ((lastMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
                         !(mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
@@ -2006,8 +2224,21 @@
     }
 #endif
 
-    CompRegion tmpRegion = (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) ?
-                           screen->region () : region;
+    CompRegion paintRegion ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) ?
+			     screen->region () : region);
+    bool useFbo = false;
+    GLFramebufferObject *oldFbo = NULL;
+
+    postprocessingRequired = gScreen->glPaintCompositedOutputRequired ();
+    postprocessingRequired |= frameProvider->alwaysPostprocess ();
+
+    /* Clear the color buffer where appropriate */
+    if ((GL::fboEnabled && postprocessRequiredForCurrentFrame ()))
+    {
+	oldFbo = scratchFbo->bind ();
+	if (scratchFbo->checkStatus ())
+	    useFbo = true;
+    }
 
     foreach (CompOutput *output, outputs)
     {
@@ -2034,7 +2265,8 @@
 
 	    gScreen->glPaintOutput (defaultScreenPaintAttrib,
 				    identity,
-				    CompRegion (*output), output,
+				    CompRegion (*output),
+				    output,
 				    PAINT_SCREEN_REGION_MASK |
 				    PAINT_SCREEN_FULL_MASK);
 	}
@@ -2057,7 +2289,9 @@
 		tmpRegion = CompRegion (*output);
 #endif
 
-	    outputRegion = tmpRegion & CompRegion (*output);
+	    /* Clip current paint region to output extents */
+	    CompRegionRef wholeOutput (output->region ());
+	    outputRegion = (paintRegion & wholeOutput);
 
 	    if (!gScreen->glPaintOutput (defaultScreenPaintAttrib,
 					 identity,
@@ -2068,10 +2302,11 @@
 
 		gScreen->glPaintOutput (defaultScreenPaintAttrib,
 					identity,
-					CompRegion (*output), output,
+					wholeOutput, output,
 					PAINT_SCREEN_FULL_MASK);
 
-		tmpRegion += *output;
+		paintRegion += wholeOutput;
+		cScreen->addOverdrawDamageRegion (wholeOutput);
 	    }
 	}
     }
@@ -2082,13 +2317,18 @@
 
     if (useFbo)
     {
-	GLFramebufferObject::rebind (oldFbo);
-
 	// FIXME: does not work if screen dimensions exceed max texture size
 	//        We should try to use glBlitFramebuffer instead.
-	gScreen->glPaintCompositedOutput (screen->region (), scratchFbo, mask);
+	GLFramebufferObject::rebind (oldFbo);
+	/* If we must always postprocess, then we don't have any
+	 * "real" backbuffer persistence, redraw the whole thing */
+	gScreen->glPaintCompositedOutput (frameProvider->alwaysPostprocess () ?
+					      screen->region () :
+					      paintRegion, scratchFbo.get (), mask);
     }
 
+    frameProvider->endFrame ();
+
     if (cScreen->outputWindowChanged ())
     {
 	/*
@@ -2100,20 +2340,27 @@
 	return;
     }
 
+    bool persistence = frameProvider->providesPersistence ();
     bool alwaysSwap = optionGetAlwaysSwapBuffers ();
-    bool fullscreen = useFbo ||
+    bool fullscreen = persistence ||
                       alwaysSwap ||
                       ((mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
                        commonFrontbuffer);
 
     doubleBuffer.set (DoubleBuffer::VSYNC, optionGetSyncToVblank ());
-    doubleBuffer.set (DoubleBuffer::HAVE_PERSISTENT_BACK_BUFFER, useFbo);
+    doubleBuffer.set (DoubleBuffer::HAVE_PERSISTENT_BACK_BUFFER, persistence);
     doubleBuffer.set (DoubleBuffer::NEED_PERSISTENT_BACK_BUFFER, alwaysSwap);
-    doubleBuffer.render (tmpRegion, fullscreen);
+    doubleBuffer.render (paintRegion, fullscreen);
 
     lastMask = mask;
 }
 
+unsigned int
+PrivateGLScreen::getFrameAge ()
+{
+    return frameProvider->getCurrentFrame ();
+}
+
 bool
 PrivateGLScreen::hasVSync ()
 {
@@ -2138,6 +2385,13 @@
 }
 
 void
+PrivateGLScreen::damageCutoff ()
+{
+    cScreen->applyDamageForFrameAge (frameProvider->getCurrentFrame ());
+    cScreen->damageCutoff ();
+}
+
+void
 PrivateGLScreen::updateRenderMode ()
 {
 #ifndef USE_GLES
@@ -2170,6 +2424,12 @@
     return prevBlacklisted;
 }
 
+bool
+PrivateGLScreen::postprocessRequiredForCurrentFrame ()
+{
+    return postprocessingRequired;
+}
+
 GLTexture::BindPixmapHandle
 GLScreen::registerBindPixmap (GLTexture::BindPixmapProc proc)
 {
@@ -2198,7 +2458,7 @@
 GLFramebufferObject *
 GLScreen::fbo ()
 {
-    return priv->scratchFbo;
+    return priv->scratchFbo.get ();
 }
 
 GLTexture *

=== modified file 'plugins/resize/src/resize.cpp'
--- plugins/resize/src/resize.cpp	2012-10-19 09:23:11 +0000
+++ plugins/resize/src/resize.cpp	2013-01-30 08:46:22 +0000
@@ -257,7 +257,7 @@
 	float	       xScale, yScale;
 	int            x, y;
 
-	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+	if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
 	    return false;
 
 	status = gWindow->glPaint (attrib, transform, region,

=== modified file 'plugins/ring/src/ring.cpp'
--- plugins/ring/src/ring.cpp	2013-01-19 11:47:22 +0000
+++ plugins/ring/src/ring.cpp	2013-01-30 08:46:22 +0000
@@ -264,7 +264,7 @@
 	    GLWindowPaintAttrib wAttrib (gWindow->lastPaintAttrib ());
 	    GLMatrix           wTransform = transform;
 
-	    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+	    if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
 		return false;
 
 	    if (mSlot)

=== modified file 'plugins/scale/src/scale.cpp'
--- plugins/scale/src/scale.cpp	2013-01-29 23:16:32 +0000
+++ plugins/scale/src/scale.cpp	2013-01-30 08:46:22 +0000
@@ -384,12 +384,14 @@
 
 	status = gWindow->glPaint (sAttrib, transform, region, mask);
 
+	mask &= ~(PAINT_WINDOW_NO_CORE_INSTANCE_MASK);
+
 	if (scaled)
 	{
 	    GLWindowPaintAttrib lastAttrib (gWindow->lastPaintAttrib ());
 	    GLMatrix           wTransform (transform);
 
-	    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+	    if (mask & PAINT_WINDOW_NO_DRAW_MASKS)
 		return false;
 
 	    if (window->alpha () || lastAttrib.opacity != OPAQUE)

=== modified file 'plugins/staticswitcher/src/staticswitcher.cpp'
--- plugins/staticswitcher/src/staticswitcher.cpp	2012-12-10 03:28:47 +0000
+++ plugins/staticswitcher/src/staticswitcher.cpp	2013-01-30 08:46:22 +0000
@@ -1246,7 +1246,7 @@
 
 	const CompWindow::Geometry &g = window->geometry ();
 
-	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK ||
+	if (mask & PAINT_WINDOW_NO_DRAW_MASKS ||
 	    sScreen->ignoreSwitcher)
 	    return false;
 

=== modified file 'plugins/switcher/src/switcher.cpp'
--- plugins/switcher/src/switcher.cpp	2012-12-10 03:28:47 +0000
+++ plugins/switcher/src/switcher.cpp	2013-01-30 08:46:22 +0000
@@ -971,7 +971,7 @@
 
 	const CompWindow::Geometry &g = window->geometry ();
 
-	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK ||
+	if (mask & PAINT_WINDOW_NO_DRAW_MASKS ||
 	    sScreen->ignoreSwitcher)
 	    return false;
 

=== modified file 'plugins/td/src/3d.cpp'
--- plugins/td/src/3d.cpp	2013-01-11 22:35:15 +0000
+++ plugins/td/src/3d.cpp	2013-01-30 08:46:22 +0000
@@ -163,7 +163,7 @@
     glGetIntegerv (GL_CULL_FACE_MODE, &cull);
     cullInv = (cull == GL_BACK)? GL_FRONT : GL_BACK;
 
-    if (ww && wh && !(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK) &&
+    if (ww && wh && !(mask & PAINT_WINDOW_NO_DRAW_MASKS) &&
 	((cs->paintOrder () == FTB && mFtb) ||
 	(cs->paintOrder () == BTF && !mFtb)))
     {

=== modified file 'plugins/water/src/water.cpp'
--- plugins/water/src/water.cpp	2012-12-10 03:28:47 +0000
+++ plugins/water/src/water.cpp	2013-01-30 08:46:22 +0000
@@ -183,6 +183,7 @@
 	cScreen->preparePaintSetEnabled (this, true);
 	gScreen->glPaintOutputSetEnabled (this, true);
 	gScreen->glPaintCompositedOutputSetEnabled (this, true);
+	gScreen->glPaintCompositedOutputRequiredSetEnabled (this, true);
 	cScreen->donePaintSetEnabled (this, true);
     }
 
@@ -317,6 +318,13 @@
     }
 }
 
+bool
+WaterScreen::glPaintCompositedOutputRequired ()
+{
+    printf ("call\n");
+    return true;
+}
+
 void
 WaterScreen::glPaintCompositedOutput (const CompRegion    &region,
                                       GLFramebufferObject *fbo,
@@ -467,6 +475,7 @@
 	cScreen->preparePaintSetEnabled (this, false);
 	gScreen->glPaintOutputSetEnabled (this, false);
 	gScreen->glPaintCompositedOutputSetEnabled (this, false);
+	gScreen->glPaintCompositedOutputRequiredSetEnabled (this, false);
 	cScreen->donePaintSetEnabled (this, false);
     }
 

=== modified file 'plugins/water/src/water.h'
--- plugins/water/src/water.h	2012-09-07 23:56:21 +0000
+++ plugins/water/src/water.h	2013-01-30 08:46:22 +0000
@@ -64,6 +64,7 @@
 
 	void handleEvent (XEvent *);
 
+	bool glPaintCompositedOutputRequired ();
 	void glPaintCompositedOutput (const CompRegion    &region,
 				      GLFramebufferObject *fbo,
 				      unsigned int         mask);