Merge lp:~compiz-team/compiz/compiz.performance_1040478 into lp:compiz/0.9.9

[Sam Spilsbury]

Implement support for glBlitFramebuffer. On some platforms this may speed up the final composite operation as we skip the fragment processor entirely.

The logic around this code is basically that if glBlitFramebuffer fails, then we don't use it again (the failure case is it not being available), and use the fallback textured draw code.

Tests added for the new module FramebufferDirectDraw.

(LP: #1040478) (LP: #1051287)

Proposing this now so I can get some early feedback.

Implement support for glBlitFramebuffer. On some platforms this may speed up the final composite operation as we skip the fragment processor entirely.

The logic around this code is basically that if glBlitFramebuffer fails, then we don't use it again (the failure case is it not being available), and use the fallback textured draw code.

Tests added for the new module FramebufferDirectDraw.

The API and ABI of GLFramebufferObject were broken too so that we could specify which buffer we actually wanted to bind.

Also added new concepts of framebuffer binding points. These are now responsible for binding framebuffers to the GL_DRAW_FRAMEBUFFER or GL_READ_FRAMEBUFFER rather than the object itself. This effectively means that we can optimize out multiple binds of the same object, or leave objects bound until they /actually/ need to change.

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:3387
http://jenkins.qa.ubuntu.com/job/compiz-ci/77/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/77/console

review: Needs Fixing (continuous-integration)

[jenkins (martin-mrazik+qa)]

PASSED: Continuous integration, rev:3388
http://jenkins.qa.ubuntu.com/job/compiz-ci/78/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/78/console

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

I have not seen any improvement yet myself. It would have to be quite significant to risk large changes to the 0.9.8 tree right now.

As far as I can tell, this is not required for quantal. So please repropose it after we've branched for 0.9.9.

review: Needs Resubmitting

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:3388
http://jenkins.qa.ubuntu.com/job/compiz-ci/141/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/141/console

review: Needs Fixing (continuous-integration)

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:3389
http://jenkins.qa.ubuntu.com/job/compiz-ci/152/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/152/console

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

Don't we want to fix bug 1051287 before merging this?

review: Needs Information

[Sam Spilsbury (smspillaz)]

Probably a good idea. Lets do that.

[Sam Spilsbury (smspillaz)]

Though, I'm not entirely certain. In order to fix it properly I'll need to add a concept of framebuffer bindings points to opengl, that could inflate this change a little more (or at least introduce a dependency)

[Daniel van Vugt (vanvugt)]

OK, then. Bug 1051287 needs fixing here.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3389
http://jenkins.qa.ubuntu.com/job/compiz-ci/310/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/310/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/310//rebuild/?

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3394
http://jenkins.qa.ubuntu.com/job/compiz-ci/313/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/313/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/compiz-ci/313//rebuild/?

review: Approve (continuous-integration)

[Sam Spilsbury (smspillaz)]

Lets look into this again post 0.9.9.0

review: Needs Resubmitting

[lp:~compiz-team/compiz/compiz.performance_1040478]

3406. By Sam Spilsbury on 2013-02-12

Merge lp:compiz

3407. By Sam Spilsbury on 2013-02-12

Remove referenes to configure buffers

3408. By Sam Spilsbury on 2013-02-12

Revert trunk merge as it was broken

3409. By Sam Spilsbury on 2013-02-12

Merge lp:compiz

3410. By Sam Spilsbury on 2013-02-12

Unrevert changes which shouldn't have been reverted

3411. By Sam Spilsbury on 2013-02-12

Another botched merge

3412. By Sam Spilsbury on 2013-02-13

Merge lp:compiz

3413. By Sam Spilsbury on 2013-02-13

Fix merge errors

3414. By Sam Spilsbury on 2013-02-15

Merge lp:compiz

3415. By Sam Spilsbury on 2013-02-18

Revert more changes which should not have happened

3416. By Sam Spilsbury on 2013-02-18

Make the currently bound drawbuffer available to plugins (as they might want
to do a read/draw swap)

3417. By Sam Spilsbury on 2013-02-25

Merge lp:compiz

3418. By Sam Spilsbury on 2013-02-27

Merge lp:compiz

3419. By Sam Spilsbury on 2013-02-28

Unrevert changes reverted by a merge

Unmerged revisions

3419. By Sam Spilsbury on 2013-02-28

Unrevert changes reverted by a merge

3418. By Sam Spilsbury on 2013-02-27

Merge lp:compiz

3417. By Sam Spilsbury on 2013-02-25

Merge lp:compiz

3416. By Sam Spilsbury on 2013-02-18

Make the currently bound drawbuffer available to plugins (as they might want
to do a read/draw swap)

3415. By Sam Spilsbury on 2013-02-18

Revert more changes which should not have happened

3414. By Sam Spilsbury on 2013-02-15

Merge lp:compiz

3413. By Sam Spilsbury on 2013-02-13

Fix merge errors

3412. By Sam Spilsbury on 2013-02-13

Merge lp:compiz

3411. By Sam Spilsbury on 2013-02-12

Another botched merge

3410. By Sam Spilsbury on 2013-02-12

Unrevert changes which shouldn't have been reverted

=== modified file 'plugins/opengl/CMakeLists.txt'
--- plugins/opengl/CMakeLists.txt	2012-12-12 07:33:12 +0000
+++ plugins/opengl/CMakeLists.txt	2013-02-10 05:18:18 +0000
@@ -5,15 +5,21 @@
 set (INTERNAL_LIBRARIES
     compiz_opengl_double_buffer
     compiz_opengl_fsregion
+    compiz_opengl_framebuffer_direct_draw
     compiz_opengl_blacklist
     compiz_opengl_glx_tfp_bind
 )
 
+set (COMPIZ_OPENGL_PLUGIN_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
+set (COMPIZ_OPENGL_PLUGIN_SOURCE_DIR  ${CMAKE_CURRENT_SOURCE_DIR}/src)
+
 add_subdirectory (src/doublebuffer)
 add_subdirectory (src/fsregion)
+add_subdirectory (src/fbdirectdraw)
 add_subdirectory (src/blacklist)
 add_subdirectory (src/glxtfpbind)
 
+include_directories (src/fbdirectdraw/include)
 include_directories (src/glxtfpbind/include)
 
 if (USE_GLES)

=== modified file 'plugins/opengl/include/opengl/framebufferobject.h'
--- plugins/opengl/include/opengl/framebufferobject.h	2012-08-09 02:19:26 +0000
+++ plugins/opengl/include/opengl/framebufferobject.h	2013-02-10 05:18:18 +0000
@@ -26,29 +26,175 @@
 #ifndef _COMPIZ_GLFRAMEBUFFEROBJECT_H
 #define _COMPIZ_GLFRAMEBUFFEROBJECT_H
 
-#include <opengl/opengl.h>
+#include <list>
+#include <boost/function.hpp>
+#include <opengl/opengl-api.h>
+#include <core/size.h>
+#include <core/rect.h>
+
+class GLVertexBuffer;
+class GLTexture;
+
+namespace compiz
+{
+namespace opengl
+{
+typedef enum _BlitMask
+{
+    ColorData = (1 << 0),
+    StencilData = (1 << 1)
+} BlitMask;
+
+typedef enum _Filter
+{
+    Fast = 0,
+    Good = 1,
+} Filter;
+
+typedef enum _BindPoint
+{
+    Read = 0,
+    Draw = 1
+} BindPoint;
+
+class BindableFramebuffer
+{
+    public:
+
+	virtual ~BindableFramebuffer () {}
+
+	virtual GLuint getResourceId () const = 0;
+	virtual bool   setBindStatus (GLenum) = 0;
+	virtual void   updateAllocation (GLenum) = 0;
+};
+
+class BindLocation
+{
+    public:
+
+	virtual ~BindLocation () {}
+
+	/**
+	 * Bind the specified BindableFramebuffer to this bind location
+	 * usually either as the read target or the draw target
+	 *
+	 * The previous FBO is no longer bound. If it was bound to the
+	 * draw target, it will be safe to use its texture.
+	 *
+	 * This returns the last-bound BindableFramebuffer object on
+	 * success and NULL on failure (no change). Call this again
+	 * in order to restore that framebuffer
+	 */
+	virtual BindableFramebuffer * bind (BindableFramebuffer *) = 0;
+};
+
+typedef boost::function <bool (const CompRect &src,
+			       const CompRect &dst,
+			       GLbitfield     mask,
+			       GLenum         filter)> RectangularDraw;
+typedef std::list <RectangularDraw> RectangularDrawList;
+
+class DirectDrawStrategies
+{
+    public:
+
+	typedef boost::shared_ptr <DirectDrawStrategies> Ptr;
+
+	virtual ~DirectDrawStrategies () {}
+	virtual void draw (const CompRect &src,
+			   const CompRect &dst,
+			   BlitMask       mask,
+			   Filter         filter) = 0;
+};
+
+class FramebufferObject
+{
+    public:
+
+	virtual ~FramebufferObject () {}
+
+	/**
+	 * Ensure the texture is of the given size, recreating it if needed,
+	 * and replace the FBO color attachment with it. The texture contents
+	 * become undefined, unless specified in the 'image' argument.
+	 * When specifying 'image', it's also possible to pass-in the
+	 * desired image's 'format' and 'type'.
+	 *
+	 * Returns true on success, and false on texture allocation failure.
+	 */
+	virtual bool allocate (const CompSize &size,
+			       const char *image = NULL,
+			       GLenum format = GL_RGBA,
+			       GLenum type = GL_UNSIGNED_BYTE) = 0;
+
+	/**
+	 * Check the FBO completeness. Returns true on complete.
+	 * Otherwise returns false and reports the error to log.
+	 */
+	virtual bool checkStatus () = 0;
+
+	/**
+	 * Return a pointer to the texture that is the color attachment.
+	 * This will return NULL, if allocate () has not been called, or
+	 * the last allocate () call failed.
+	 */
+	virtual GLTexture * tex () = 0;
+};
+
+class DirectDrawObject :
+    virtual public compiz::opengl::FramebufferObject,
+    virtual public compiz::opengl::BindableFramebuffer
+{
+    public:
+
+	virtual ~DirectDrawObject () {};
+
+	/**
+	 * Draws a region of the framebuffer object as specified in
+	 * framebuffer-specified co-ordinates as @src co-ordinates in
+	 * the buffer currently bound co-ordinates @dst . @mask indicates
+	 * what kind of data should be propogated downwards. @filter indicates
+	 * what kind of filter should be used when drawing this buffer
+	 *
+	 * This since this code only draws a rectangular region from one
+	 * framebuffer to another, it will try and use the fastest codepath
+	 * possible, falling back to a simple textured draw if
+	 * glBlitFramebuffer is not available
+	 *
+	 */
+	virtual void directDraw (const CompRect           &src,
+				 const CompRect           &dst,
+				 compiz::opengl::BlitMask mask,
+				 compiz::opengl::Filter  filter) = 0;
+};
+
+namespace impl
+{
+namespace cgl = compiz::opengl;
 
 struct PrivateGLFramebufferObject;
 
-/**
- * Class representing a framebuffer object in GL, supporting only one
- * color attachment as per GLES 2 spec. The color attachment is referred
- * to as the texture (of the FBO).
- *
- * Usage:
- * 1. create a GLFramebufferObject (requires a GL context)
- * 2. call allocate (size), and check status ()
- * 3. old = bind ()
- * 4. do your rendering
- * 5. rebind (old)
- * 6. use the rendered texture via tex ()
- * 7. go to 2 or 3, or delete to quit (requires a GL context)
- */
-class GLFramebufferObject
-{
-    public:
-	GLFramebufferObject ();
-	~GLFramebufferObject ();
+class FBOBindLocation :
+    public cgl::BindLocation
+{
+    public:
+
+	FBOBindLocation (GLenum binding, BindableFramebuffer *back);
+	BindableFramebuffer * bind (BindableFramebuffer *);
+
+    private:
+
+	class Private;
+	std::auto_ptr <Private> priv;
+};
+
+class FramebufferObject :
+    public cgl::FramebufferObject,
+    public cgl::BindableFramebuffer
+{
+    public:
+	FramebufferObject ();
+	~FramebufferObject ();
 
 	/**
 	 * Ensure the texture is of the given size, recreating it if needed,
@@ -65,26 +211,6 @@
 		       GLenum type = GL_UNSIGNED_BYTE);
 
 	/**
-	 * Bind this as the current FBO, previous binding in GL context is
-	 * undone. GL rendering is now targeted to this FBO.
-	 * Returns a pointer to the previously bound FBO, or NULL if
-	 * the previous binding was zero (the window system provided
-	 * framebuffer).
-	 *
-	 * The previous FBO is no longer bound, so you can use its
-	 * texture. To restore the previous FBO, call rebind (FBO) with
-	 * the returned pointer as the argument.
-	 */
-	GLFramebufferObject *bind ();
-
-	/**
-	 * Bind the given FBO as the current FBO, without looking up the
-	 * previous binding. The argument can be NULL, in which case the
-	 * window system provided framebuffer gets bound (FBO is unbound).
-	 */
-	static void rebind (GLFramebufferObject *fbo);
-
-	/**
 	 * Check the FBO completeness. Returns true on complete.
 	 * Otherwise returns false and reports the error to log.
 	 */
@@ -95,10 +221,23 @@
 	 * This will return NULL, if allocate () has not been called, or
 	 * the last allocate () call failed.
 	 */
-	GLTexture *tex ();
+	GLTexture * tex ();
 
     private:
+
+	/**
+	 * Returns the framebuffer identifier
+	 */
+	GLuint getResourceId () const;
+	bool   setBindStatus (GLenum);
+	void   updateAllocation (GLenum bindingLocation);
+
 	PrivateGLFramebufferObject *priv;
 };
+}
+}
+}
+
+typedef compiz::opengl::impl::FramebufferObject GLFramebufferObject;
 
 #endif // _COMPIZ_GLFRAMEBUFFEROBJECT_H

=== added file 'plugins/opengl/include/opengl/opengl-api.h'
--- plugins/opengl/include/opengl/opengl-api.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/include/opengl/opengl-api.h	2013-02-10 05:18:18 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2008 Dennis Kasprzyk
+ * Copyright © 2007 Novell, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Dennis Kasprzyk not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Dennis Kasprzyk makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Dennis Kasprzyk <[e-mail]>
+ *          David Reveman <[e-mail]>
+ */
+
+#ifndef _COMPIZ_OPENGL_API_H
+#define _COMPIZ_OPENGL_API_H
+
+#ifdef USE_GLES
+#define SUPPORT_X11
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#else
+#include <GL/gl.h>
+#include <GL/glx.h>
+#endif
+
+#endif

=== 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-02-10 05:18:18 +0000
@@ -28,29 +28,19 @@
 #ifndef _COMPIZ_OPENGL_H
 #define _COMPIZ_OPENGL_H
 
-#ifdef USE_GLES
-#define SUPPORT_X11
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#else
-#include <GL/gl.h>
-#include <GL/glx.h>
-#endif
+#include <opengl/opengl-api.h>
 
 #include <core/size.h>
 #include <core/pluginclasshandler.h>
 
 #include <opengl/matrix.h>
 #include <opengl/texture.h>
-#include <opengl/framebufferobject.h>
 #include <opengl/vertexbuffer.h>
 #include <opengl/program.h>
 #include <opengl/programcache.h>
 #include <opengl/shadercache.h>
 
-#define COMPIZ_OPENGL_ABI 6
+#define COMPIZ_OPENGL_ABI 7
 
 /*
  * Some plugins check for #ifdef USE_MODERN_COMPIZ_GL. Support it for now, but
@@ -84,9 +74,38 @@
 extern const float GREEN_SATURATION_WEIGHT;
 extern const float BLUE_SATURATION_WEIGHT;
 
+class GLScreen;
 class PrivateGLScreen;
 class PrivateGLWindow;
 
+namespace compiz
+{
+namespace opengl
+{
+typedef boost::function <bool (const CompRect &src,
+			       const CompRect &dst,
+			       GLbitfield     mask,
+			       GLenum         filter)> BlitFramebufferFunc;
+
+class DirectDrawObject;
+class FramebufferObject;
+class BindableFramebuffer;
+
+/**
+ * Convenience method to construct a framebuffer object that
+ * supports GLX_EXT_blit_framebuffer and a fallback path
+ */
+DirectDrawObject *createBlittableFramebufferObjectWithFallback(const CompSize &sz, GLScreen *gScreen);
+
+namespace impl
+{
+class FramebufferObject;
+}
+}
+}
+
+typedef compiz::opengl::impl::FramebufferObject GLFramebufferObject;
+
 extern GLushort   defaultColor[4];
 
 #ifndef GLX_EXT_texture_from_pixmap
@@ -313,6 +332,18 @@
 					   GLsizei width,
 					   GLsizei height);
 
+    /* GLX_EXT_blit_framebuffer */
+    typedef void (*GLBlitFramebufferProc) (GLint      srcX0,
+					   GLint      srcY0,
+					   GLint      srcX1,
+					   GLint      srcY1,
+					   GLint      dstX0,
+					   GLint      dstY0,
+					   GLint      dstX1,
+					   GLint      dstY1,
+					   GLbitfield mask,
+					   GLenum     filter);
+
 
     /* GL_ARB_shader_objects */
     #ifndef USE_GLES
@@ -413,11 +444,12 @@
     extern GLDisableVertexAttribArrayProc disableVertexAttribArray;
     extern GLVertexAttribPointerProc      vertexAttribPointer;
 
-    extern GLGenRenderbuffersProc genRenderbuffers;
-    extern GLDeleteRenderbuffersProc deleteRenderbuffers;
-    extern GLBindRenderbufferProc    bindRenderbuffer;
+    extern GLGenRenderbuffersProc        genRenderbuffers;
+    extern GLDeleteRenderbuffersProc     deleteRenderbuffers;
+    extern GLBindRenderbufferProc        bindRenderbuffer;
     extern GLFramebufferRenderbufferProc framebufferRenderbuffer;
-    extern GLRenderbufferStorageProc renderbufferStorage;
+    extern GLRenderbufferStorageProc     renderbufferStorage;
+    extern GLBlitFramebufferProc         blitFramebuffer;
 
     #ifndef USE_GLES
     extern GLCreateShaderObjectARBProc createShaderObjectARB;
@@ -579,7 +611,6 @@
 extern GLScreenPaintAttrib defaultScreenPaintAttrib;
 
 class GLScreen;
-class GLFramebufferObject;
 class GLScreenInterface;
 extern template class WrapableInterface<GLScreen, GLScreenInterface>;
 
@@ -658,9 +689,9 @@
 	 * @param scratchFbo Describes the final composited FBO that is
 	 * to be rendered.
 	 */
-	virtual void glPaintCompositedOutput (const CompRegion    &region,
-					      GLFramebufferObject *fbo,
-					      unsigned int         mask);
+	virtual void glPaintCompositedOutput (const CompRegion				  &region,
+					      compiz::opengl::DirectDrawObject *fbo,
+					      unsigned int				  mask);
 
 	/**
 	 * Hookable function used by plugins to determine stenciling mask
@@ -759,13 +790,36 @@
 	/**
 	 * Returns the FBO compiz is using for the screen
 	 */
-	GLFramebufferObject *fbo ();
+	compiz::opengl::FramebufferObject * fbo ();
+
+	/**
+	 * Binds a framebuffer for drawing, returns the old bindable
+	 */
+	compiz::opengl::BindableFramebuffer *
+	bindFramebufferForDrawing (compiz::opengl::BindableFramebuffer *);
+
+	/**
+	 * Binds a framebuffer for reading, returns the old reading
+	 */
+	compiz::opengl::BindableFramebuffer *
+	bindFramebufferForReading (compiz::opengl::BindableFramebuffer *);
+
+	/**
+	 * Gets the backbuffer as a BindableFramebuffer
+	 */
+	compiz::opengl::BindableFramebuffer *
+	backbuffer ();
 
 	/**
 	 * Returns a default icon texture
 	 */
 	GLTexture *defaultIcon ();
 
+	/**
+	 * Returns the current framebuffer function for blitting the framebuffer
+	 */
+	const compiz::opengl::BlitFramebufferFunc & blitFramebufferFunc ();
+
 	void resetRasterPos ();
 
 	bool glInitContext (XVisualInfo *);
@@ -786,7 +840,7 @@
 
 	WRAPABLE_HND (5, GLScreenInterface, GLMatrix *, projectionMatrix);
 	WRAPABLE_HND (6, GLScreenInterface, void, glPaintCompositedOutput,
-		      const CompRegion &, GLFramebufferObject *, unsigned int);
+		      const CompRegion &, compiz::opengl::DirectDrawObject *, unsigned int);
 
 	WRAPABLE_HND (7, GLScreenInterface, void, glBufferStencil, const GLMatrix &,
 		      GLVertexBuffer &,

=== added directory 'plugins/opengl/src/fbdirectdraw'
=== added file 'plugins/opengl/src/fbdirectdraw/CMakeLists.txt'
--- plugins/opengl/src/fbdirectdraw/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/fbdirectdraw/CMakeLists.txt	2013-02-10 05:18:18 +0000
@@ -0,0 +1,32 @@
+INCLUDE_DIRECTORIES (  
+  ${COMPIZ_OPENGL_PLUGIN_SOURCE_DIR}
+  ${COMPIZ_OPENGL_PLUGIN_INCLUDE_DIR}
+  ${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/framebuffer-direct-draw.cpp
+)
+
+ADD_LIBRARY( 
+  compiz_opengl_framebuffer_direct_draw STATIC
+  
+  ${SRCS}
+)
+
+if (COMPIZ_BUILD_TESTING)
+ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/tests )
+endif (COMPIZ_BUILD_TESTING)
+
+TARGET_LINK_LIBRARIES(
+  compiz_opengl_framebuffer_direct_draw
+
+  compiz_region
+  compiz_logmessage
+)

=== added directory 'plugins/opengl/src/fbdirectdraw/include'
=== added file 'plugins/opengl/src/fbdirectdraw/include/framebuffer-direct-draw.h'
--- plugins/opengl/src/fbdirectdraw/include/framebuffer-direct-draw.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/fbdirectdraw/include/framebuffer-direct-draw.h	2013-02-10 05:18:18 +0000
@@ -0,0 +1,111 @@
+/*
+ * Compiz, opengl plugin, FramebufferDirectDraw class
+ *
+ * Copyright (c) 2012 Canonical Ltd.
+ * 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_OPENGL_FRAMEBUFFER_DIRECT_DRAW_H
+#define _COMPIZ_OPENGL_FRAMEBUFFER_DIRECT_DRAW_H
+
+#include <memory>
+#include <boost/shared_ptr.hpp>
+#include <core/rect.h>
+#include <opengl/framebufferobject.h>
+
+class GLVertexBuffer;
+
+namespace compiz
+{
+namespace opengl
+{
+namespace impl
+{
+namespace cglfb = compiz::opengl;
+
+class PrivateDirectDrawStrategies;
+
+class DirectDrawStrategies :
+    public cglfb::DirectDrawStrategies
+{
+    public:
+
+	typedef boost::shared_ptr <DirectDrawStrategies> Ptr;
+
+	DirectDrawStrategies (const RectangularDrawList &strategies);
+
+	void draw (const CompRect   &src,
+		   const CompRect   &dst,
+		   BlitMask  mask,
+		   Filter           filter);
+
+    private:
+
+	std::auto_ptr <PrivateDirectDrawStrategies> priv;
+};
+
+class PrivateDirectDrawObject;
+
+class DirectDrawObject :
+    virtual public cglfb::FramebufferObject,
+    public cglfb::DirectDrawObject
+{
+    public:
+
+	DirectDrawObject (const boost::shared_ptr <cglfb::DirectDrawStrategies> &,
+			  const boost::shared_ptr <cglfb::FramebufferObject>    &,
+			  const boost::shared_ptr <cglfb::BindableFramebuffer>  &);
+
+	bool allocate (const CompSize &size,
+		       const char *image = NULL,
+		       GLenum format = GL_RGBA,
+		       GLenum type = GL_UNSIGNED_BYTE);
+	bool checkStatus ();
+	GLTexture * tex ();
+
+	void directDraw (const CompRect         &src,
+			 const CompRect         &dst,
+			 cglfb::BlitMask mask,
+			 cglfb::Filter          filter);
+
+    private:
+
+	GLuint getResourceId () const;
+	bool   setBindStatus (GLenum);
+	void   updateAllocation (GLenum);
+
+	PrivateDirectDrawObject *priv;
+};
+
+typedef boost::function <cglfb::BindableFramebuffer * (cglfb::BindableFramebuffer *)>
+    BindReadBufferFunc;
+
+bool rectangleDrawFromReadBuffer (const CompRect             &src,
+				  const CompRect             &dst,
+				  GLbitfield                 mask,
+				  GLenum                     filter,
+				  cglfb::BindableFramebuffer *bindable,
+				  const BindReadBufferFunc   &func,
+				  cglfb::RectangularDraw     strategy);
+}
+}
+}
+
+#endif

=== added directory 'plugins/opengl/src/fbdirectdraw/src'
=== added file 'plugins/opengl/src/fbdirectdraw/src/framebuffer-direct-draw.cpp'
--- plugins/opengl/src/fbdirectdraw/src/framebuffer-direct-draw.cpp	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/fbdirectdraw/src/framebuffer-direct-draw.cpp	2013-02-10 05:18:18 +0000
@@ -0,0 +1,177 @@
+/*
+ * Compiz, opengl plugin, DirectDrawFramebufferStrategies class
+ *
+ * Copyright (c) 2012 Canonical Ltd.
+ * 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 "framebuffer-direct-draw.h"
+
+namespace cglfb = compiz::opengl;
+namespace cglfbi = compiz::opengl::impl;
+
+class GLTexture;
+class GLVertexBuffer;
+
+namespace compiz
+{
+namespace opengl
+{
+namespace impl
+{
+class PrivateDirectDrawStrategies
+{
+    public:
+
+	PrivateDirectDrawStrategies (const cglfb::RectangularDrawList &strategies) :
+	    rectDrawList (strategies)
+	{
+	}
+
+	cglfb::RectangularDrawList rectDrawList;
+};
+
+class PrivateDirectDrawObject
+{
+    public:
+
+	PrivateDirectDrawObject (const boost::shared_ptr <cglfb::DirectDrawStrategies> &strategies,
+				 const boost::shared_ptr <cglfb::FramebufferObject>    &object,
+				 const boost::shared_ptr <cglfb::BindableFramebuffer>  &bindable) :
+	    directDrawStrategies (strategies),
+	    framebufferObject (object),
+	    bindableFramebuffer (bindable)
+	{
+	};
+
+	boost::shared_ptr <cglfb::DirectDrawStrategies> directDrawStrategies;
+	boost::shared_ptr <cglfb::FramebufferObject>    framebufferObject;
+	boost::shared_ptr <cglfb::BindableFramebuffer>  bindableFramebuffer;
+};
+}
+}
+}
+
+cglfbi::DirectDrawObject::DirectDrawObject (const boost::shared_ptr <cglfb::DirectDrawStrategies> &strategies,
+					    const boost::shared_ptr <cglfb::FramebufferObject>    &object,
+					    const boost::shared_ptr <cglfb::BindableFramebuffer>  &bindable) :
+    priv (new cglfbi::PrivateDirectDrawObject (strategies, object, bindable))
+{
+}
+
+bool
+cglfbi::DirectDrawObject::allocate (const CompSize &size, const char *image,
+					       GLenum format, GLenum type)
+{
+    return priv->framebufferObject->allocate (size, image, format, type);
+}
+
+bool
+cglfbi::DirectDrawObject::checkStatus ()
+{
+    return priv->framebufferObject->checkStatus ();
+}
+
+GLTexture *
+cglfbi::DirectDrawObject::tex ()
+{
+    return priv->framebufferObject->tex ();
+}
+
+GLuint
+cglfbi::DirectDrawObject::getResourceId () const
+{
+    return priv->bindableFramebuffer->getResourceId ();
+}
+
+bool
+cglfbi::DirectDrawObject::setBindStatus (GLenum status)
+{
+    return priv->bindableFramebuffer->setBindStatus (status);
+}
+
+void
+cglfbi::DirectDrawObject::updateAllocation (GLenum bindPoint)
+{
+    return priv->bindableFramebuffer->updateAllocation (bindPoint);
+}
+
+void
+cglfbi::DirectDrawObject::directDraw (const CompRect         &src,
+				      const CompRect         &dst,
+				      cglfb::BlitMask mask,
+				      cglfb::Filter	     filter)
+{
+    if (!checkStatus ())
+	return;
+
+    priv->directDrawStrategies->draw (src, dst, mask, filter);
+}
+
+bool
+cglfbi::rectangleDrawFromReadBuffer (const CompRect             &src,
+				     const CompRect             &dst,
+				     GLbitfield                 mask,
+				     GLenum                     filter,
+				     cglfb::BindableFramebuffer *bindable,
+				     const cglfbi::BindReadBufferFunc &bindReadBuffer,
+				     cglfb::RectangularDraw     strategy)
+{
+    bool status = false;
+    /* Bind to the read framebuffer first */
+    cglfb::BindableFramebuffer *old = bindReadBuffer (bindable);
+
+    if (old)
+	status = strategy (src, dst, mask, filter);
+
+    /* Intentionally not rebinding the old one */
+
+    return status;
+}
+
+cglfbi::DirectDrawStrategies::DirectDrawStrategies (const cglfb::RectangularDrawList &strategies) :
+    priv (new cglfbi::PrivateDirectDrawStrategies (strategies))
+{
+}
+
+void
+cglfbi::DirectDrawStrategies::draw (const CompRect         &src,
+				    const CompRect         &dst,
+				    cglfb::BlitMask mask,
+				    cglfb::Filter          filter)
+{
+    if (!mask)
+	return;
+
+    const GLbitfield glMask  = (mask & cglfb::ColorData ? GL_COLOR_BUFFER_BIT : 0) |
+			       (mask & cglfb::StencilData ? GL_STENCIL_BUFFER_BIT : 0);
+    const GLenum glFilter = (filter == cglfb::Fast ? GL_NEAREST : GL_LINEAR);
+
+    while (!priv->rectDrawList.empty ())
+    {
+	const cglfb::RectangularDraw &strategy = priv->rectDrawList.back ();
+
+	/* If one method fails, try the next */
+	if (!strategy (src, dst,  glMask, glFilter))
+	    priv->rectDrawList.pop_back ();
+	else
+	    break;
+    }
+}

=== added directory 'plugins/opengl/src/fbdirectdraw/tests'
=== added file 'plugins/opengl/src/fbdirectdraw/tests/CMakeLists.txt'
--- plugins/opengl/src/fbdirectdraw/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/fbdirectdraw/tests/CMakeLists.txt	2013-02-10 05:18:18 +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_opengl_framebuffer_direct_draw
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-opengl-framebuffer-direct-draw.cpp)
+
+target_link_libraries (compiz_test_opengl_framebuffer_direct_draw
+                       compiz_opengl_framebuffer_direct_draw
+                       ${GTEST_BOTH_LIBRARIES}
+		       ${GMOCK_LIBRARY}
+		       ${GMOCK_MAIN_LIBRARY}
+		       ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
+                       )
+
+compiz_discover_tests (compiz_test_opengl_framebuffer_direct_draw COVERAGE compiz_opengl_framebuffer_direct_draw)

=== added file 'plugins/opengl/src/fbdirectdraw/tests/test-opengl-framebuffer-direct-draw.cpp'
--- plugins/opengl/src/fbdirectdraw/tests/test-opengl-framebuffer-direct-draw.cpp	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/fbdirectdraw/tests/test-opengl-framebuffer-direct-draw.cpp	2013-02-10 05:18:18 +0000
@@ -0,0 +1,236 @@
+/*
+ * Compiz, opengl plugin, DirectDrawFramebufferStrategies class
+ *
+ * Copyright (c) 2012 Canonical Ltd.
+ * 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 <memory>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <opengl/opengl-api.h>
+#include <opengl/framebufferobject.h>
+#include "framebuffer-direct-draw.h"
+
+using ::testing::Return;
+using ::testing::_;
+using ::testing::Expectation;
+using ::testing::StrictMock;
+using ::testing::NiceMock;
+using ::testing::ReturnNull;
+
+namespace cglfb = compiz::opengl;
+namespace cglfbi = compiz::opengl::impl;
+
+namespace
+{
+class MockDrawStrategy
+{
+    public:
+
+	MOCK_METHOD4 (draw, bool (const CompRect &,
+				  const CompRect &,
+				  GLbitfield,
+				  GLenum));
+};
+
+class MockBindLocation :
+    public cglfb::BindLocation
+{
+    public:
+
+	MOCK_METHOD1 (bind, cglfb::BindableFramebuffer * (cglfb::BindableFramebuffer *));
+};
+
+class MockBindable :
+    public cglfb::BindableFramebuffer
+{
+    public:
+
+	MOCK_METHOD1 (updateAllocation, void (GLenum));
+	MOCK_METHOD1 (setBindStatus, bool (GLenum));
+	MOCK_CONST_METHOD0 (getResourceId, GLuint ());
+};
+
+}
+
+class FBDirectDrawStrategies :
+    public ::testing::Test
+{
+    public:
+
+	FBDirectDrawStrategies () :
+	    blitFramebuffer (boost::bind (&MockDrawStrategy::draw, &mpfb, _1, _2, _3, _4)),
+	    rtdraw (boost::bind (&MockDrawStrategy::draw, &mdr,
+				 _1, _2, _3, _4))
+	{
+	}
+
+	void SetUpStrategyList (const cglfb::RectangularDraw &blit,
+				const cglfb::RectangularDraw &draw)
+	{
+	    strategyList.clear ();
+	    strategyList.push_back (draw);
+	    strategyList.push_back (blit);
+	}
+
+	virtual void SetUp ()
+	{
+	    boost::function <cglfb::BindableFramebuffer * (cglfb::BindableFramebuffer *)> readBind
+		    (boost::bind (&MockBindLocation::bind, &mockBindLocation, _1));
+	    blitFramebufferWithReadPushed = boost::bind (&cglfbi::rectangleDrawFromReadBuffer,
+							 _1, _2, _3, _4,
+							 &mockBindable,
+							 readBind,
+							 blitFramebuffer);
+
+	    SetUpStrategyList (blitFramebuffer, rtdraw);
+	    directDraw.reset (new cglfbi::DirectDrawStrategies (strategyList));
+	}
+
+	std::auto_ptr <cglfbi::DirectDrawStrategies> directDraw;
+	MockDrawStrategy        mpfb;
+	cglfb::RectangularDraw     blitFramebuffer;
+	cglfb::RectangularDraw     blitFramebufferWithReadPushed;
+	MockDrawStrategy        mdr;
+	StrictMock <MockBindable>     mockBindable;
+	StrictMock <MockBindLocation> mockBindLocation;
+	cglfb::RectangularDraw     rtdraw;
+	cglfb::RectangularDrawList strategyList;
+
+};
+
+TEST_F (FBDirectDrawStrategies, BufferBitsSet)
+{
+    CompRect srcAndDst (0, 0, 0, 0);
+
+    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, GL_COLOR_BUFFER_BIT |
+						   GL_STENCIL_BUFFER_BIT,
+			     _)).WillOnce (Return (true));
+
+    directDraw->draw (srcAndDst,
+		      srcAndDst,
+		      static_cast <cglfb::BlitMask> (cglfb::ColorData |
+							    cglfb::StencilData),
+		      cglfb::Good);
+}
+
+TEST_F (FBDirectDrawStrategies, BufferNoBitsSet)
+{
+    CompRect srcAndDst (0, 0, 0, 0);
+
+    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, 0,
+			     _)).Times (0);
+
+    directDraw->draw (srcAndDst,
+		      srcAndDst,
+		      static_cast <cglfb::BlitMask> (0),
+		      cglfb::Good);
+}
+
+TEST_F (FBDirectDrawStrategies, GoodToLinear)
+{
+    CompRect srcAndDst (0, 0, 0, 0);
+
+    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, _,
+			     GL_LINEAR)).WillOnce (Return (true));
+
+    directDraw->draw (srcAndDst,
+		      srcAndDst,
+		      cglfb::ColorData,
+		      cglfb::Good);
+}
+
+TEST_F (FBDirectDrawStrategies, FastToNearest)
+{
+    CompRect srcAndDst (0, 0, 0, 0);
+
+    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, _,
+			     GL_NEAREST)).WillOnce (Return (true));
+
+    directDraw->draw (srcAndDst,
+		      srcAndDst,
+		      cglfb::ColorData,
+		      cglfb::Fast);
+}
+
+TEST_F (FBDirectDrawStrategies, RevertToPaintWhenBlitUnavailable)
+{
+    CompRect srcAndDst (0, 0, 0, 0);
+
+    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, _,
+			     _)).WillOnce (Return (false));
+    EXPECT_CALL (mdr, draw (srcAndDst, srcAndDst, _, _));
+
+    directDraw->draw (srcAndDst,
+		      srcAndDst,
+		      cglfb::ColorData,
+		      cglfb::Fast);
+}
+
+TEST_F (FBDirectDrawStrategies, RevertOnBlitUnavailablePermanent)
+{
+    StrictMock <MockDrawStrategy> strictMdr;
+    CompRect srcAndDst (0, 0, 0, 0);
+
+    rtdraw = boost::bind (&MockDrawStrategy::draw, &strictMdr, _1, _2, _3, _4);
+
+    SetUpStrategyList (blitFramebuffer, rtdraw);
+    directDraw.reset (new cglfbi::DirectDrawStrategies (strategyList));
+
+    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, _, _)).WillOnce (Return (false));
+    ON_CALL (strictMdr, draw (_, _, _, _)).WillByDefault (Return (true));
+    EXPECT_CALL (strictMdr, draw (srcAndDst, srcAndDst, _, _)).Times (2);
+
+    directDraw->draw (srcAndDst,
+		      srcAndDst,
+		      cglfb::ColorData,
+		      cglfb::Fast);
+    directDraw->draw (srcAndDst,
+		      srcAndDst,
+		      cglfb::ColorData,
+		      cglfb::Fast);
+}
+
+TEST_F (FBDirectDrawStrategies, BindReadFramebufferOnBlit)
+{
+    CompRect srcAndDst (0, 0, 0, 0);
+
+    SetUpStrategyList (blitFramebufferWithReadPushed, rtdraw);
+    directDraw.reset (new cglfbi::DirectDrawStrategies (strategyList));
+
+    MockBindable backBuffer;
+
+    EXPECT_CALL (mockBindLocation, bind (&mockBindable)).WillOnce (Return (&backBuffer));
+    EXPECT_CALL (mpfb, draw (srcAndDst, srcAndDst, _, _)).WillOnce (Return (false));
+    ON_CALL (mdr, draw (_, _, _, _)).WillByDefault (Return (true));
+    EXPECT_CALL (mdr, draw (srcAndDst, srcAndDst, _, _)).Times (2);
+
+    directDraw->draw (srcAndDst,
+		      srcAndDst,
+		      cglfb::ColorData,
+		      cglfb::Fast);
+    directDraw->draw (srcAndDst,
+		      srcAndDst,
+		      cglfb::ColorData,
+		      cglfb::Fast);
+}

=== 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-02-10 05:18:18 +0000
@@ -22,88 +22,96 @@
  *
  * Authors: Pekka Paalanen <[e-mail]>
  */
-
+#include <memory>
 #include <map>
+#include <opengl/opengl.h>
 #include <opengl/framebufferobject.h>
 #include <opengl/texture.h>
 
+#include "framebuffer-direct-draw.h"
+
+namespace cglfb = compiz::opengl;
+namespace cglfbi = compiz::opengl::impl;
+
+namespace compiz
+{
+namespace opengl
+{
+namespace impl
+{
 struct PrivateGLFramebufferObject
 {
     PrivateGLFramebufferObject () :
 	fboId (0),
-	pushedId (0),
 	glTex (NULL),
 	status (-1)
     {
     }
 
-    void pushFBO ();
-    void popFBO ();
-
     GLuint fboId;
-    GLuint pushedId;
     GLuint rbStencilId;
     GLTexture *glTex;
 
     GLint status;
 
-    static GLuint boundId;
-    static std::map<GLuint, GLFramebufferObject *> idMap;
+    std::auto_ptr <cglfb::DirectDrawStrategies> mDirectDraw;
+    GLVertexBuffer                              *vertexBuffer;
 };
 
-GLuint PrivateGLFramebufferObject::boundId = 0;
-std::map<GLuint, GLFramebufferObject *> PrivateGLFramebufferObject::idMap;
-
-void
-PrivateGLFramebufferObject::pushFBO ()
-{
-    pushedId = boundId;
-    if (boundId != fboId)
-    {
-	(*GL::bindFramebuffer) (GL::FRAMEBUFFER, fboId);
-	boundId = fboId;
-    }
-}
-
-void
-PrivateGLFramebufferObject::popFBO ()
-{
-    if (boundId != pushedId)
-    {
-	(*GL::bindFramebuffer) (GL::FRAMEBUFFER, pushedId);
-	boundId = pushedId;
-    }
-}
-
-GLFramebufferObject::GLFramebufferObject () :
-    priv (new PrivateGLFramebufferObject)
+}
+}
+}
+
+GLuint
+cglfbi::FramebufferObject::getResourceId () const
+{
+    return priv->fboId;
+}
+
+bool
+cglfbi::FramebufferObject::setBindStatus (GLenum status)
+{
+    priv->status = status;
+    return checkStatus ();
+}
+
+void
+cglfbi::FramebufferObject::updateAllocation (GLenum bindingLocation)
+{
+    if (priv->status == -1)
+    {
+	(*GL::framebufferTexture2D) (bindingLocation, GL::COLOR_ATTACHMENT0,
+				     priv->glTex->target (),
+				     priv->glTex->name (), 0);
+	(*GL::framebufferRenderbuffer) (bindingLocation, GL::DEPTH_ATTACHMENT, GL::RENDERBUFFER, priv->rbStencilId);
+	(*GL::framebufferRenderbuffer) (bindingLocation, GL::STENCIL_ATTACHMENT, GL::RENDERBUFFER, priv->rbStencilId);
+    }
+
+}
+
+cglfbi::FramebufferObject::FramebufferObject () :
+    priv (new cglfbi::PrivateGLFramebufferObject ())
 {
     (*GL::genFramebuffers) (1, &priv->fboId);
     (*GL::genRenderbuffers) (1, &priv->rbStencilId);
-
-    if (priv->fboId != 0)
-	PrivateGLFramebufferObject::idMap[priv->fboId] = this;
 }
 
-GLFramebufferObject::~GLFramebufferObject ()
+cglfbi::FramebufferObject::~FramebufferObject ()
 {
     if (priv->glTex)
 	GLTexture::decRef (priv->glTex);
 
-    PrivateGLFramebufferObject::idMap.erase (priv->fboId);
     (*GL::deleteFramebuffers) (1, &priv->fboId);
     (*GL::deleteRenderbuffers) (1, &priv->rbStencilId);
 
-
     delete priv;
 }
 
 bool
-GLFramebufferObject::allocate (const CompSize &size, const char *image,
-			       GLenum format, GLenum type)
+cglfbi::FramebufferObject::allocate (const CompSize &size,
+				     const char *image,
+				     GLenum format, GLenum type)
 {
-    priv->status = -1;
-
     if (!priv->glTex ||
         size.width () != priv->glTex->width () ||
         size.height () != priv->glTex->height ())
@@ -125,86 +133,39 @@
 	    (*GL::bindRenderbuffer) (GL::RENDERBUFFER, priv->rbStencilId);
 	    (*GL::renderbufferStorage) (GL::RENDERBUFFER, GL::DEPTH24_STENCIL8, size.width (), size.height ());
 	}
+
+        priv->status = -1;
     }
 
-    priv->pushFBO ();
-
-    (*GL::framebufferTexture2D) (GL::FRAMEBUFFER, GL::COLOR_ATTACHMENT0,
-                                 priv->glTex->target (),
-                                 priv->glTex->name (), 0);
-
-    priv->status = (*GL::checkFramebufferStatus) (GL::DRAW_FRAMEBUFFER);
-
-    priv->popFBO ();
     return true;
 }
 
-GLFramebufferObject *
-GLFramebufferObject::bind ()
-{
-    GLFramebufferObject *old = NULL;
-
-    if (priv->boundId != 0)
-    {
-	std::map<GLuint, GLFramebufferObject *>::iterator it;
-	it = PrivateGLFramebufferObject::idMap.find (priv->boundId);
-
-	if (it != PrivateGLFramebufferObject::idMap.end ())
-	    old = it->second;
-	else
-	    compLogMessage ("opengl", CompLogLevelError,
-		"An FBO without GLFramebufferObject cannot be restored");
-    }
-
-    (*GL::bindFramebuffer) (GL::FRAMEBUFFER, priv->fboId);
-    priv->boundId = priv->fboId;
-
-    (*GL::framebufferRenderbuffer) (GL::FRAMEBUFFER, GL::DEPTH_ATTACHMENT, GL::RENDERBUFFER, priv->rbStencilId);
-    (*GL::framebufferRenderbuffer) (GL::FRAMEBUFFER, GL::STENCIL_ATTACHMENT, GL::RENDERBUFFER, priv->rbStencilId);
-
-    return old;
-}
-
-// static
-void
-GLFramebufferObject::rebind (GLFramebufferObject *fbo)
-{
-    GLuint id = fbo ? fbo->priv->fboId : 0;
-
-    if (id != fbo->priv->boundId)
-    {
-	(*GL::bindFramebuffer) (GL::FRAMEBUFFER, id);
-	fbo->priv->boundId = id;
-    }
-}
-
-static const char *
+namespace
+{
+const char *
 getFboErrorString (GLint status)
 {
     switch (status)
     {
-	case        GL::FRAMEBUFFER_COMPLETE:
+	case GL::FRAMEBUFFER_COMPLETE:
 	    return "GL::FRAMEBUFFER_COMPLETE";
-	case        GL::FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+	case GL::FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
 	    return "GL::FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
-	case        GL::FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+	case GL::FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
 	    return "GL::FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
-	case        GL::FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+	case GL::FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
 	    return "GL::FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
-	case        GL::FRAMEBUFFER_UNSUPPORTED:
+	case GL::FRAMEBUFFER_UNSUPPORTED:
 	    return "GL::FRAMEBUFFER_UNSUPPORTED";
 	default:
 	    return "unexpected status";
     }
 }
+}
 
 bool
-GLFramebufferObject::checkStatus ()
+cglfbi::FramebufferObject::checkStatus ()
 {
-    priv->pushFBO ();
-    priv-> status = (*GL::checkFramebufferStatus) (GL_FRAMEBUFFER);
-    priv->popFBO ();
-
     if (priv->status == static_cast <GLint> (GL::FRAMEBUFFER_COMPLETE))
 	return true;
 
@@ -215,7 +176,47 @@
 }
 
 GLTexture *
-GLFramebufferObject::tex ()
+cglfbi::FramebufferObject::tex ()
 {
     return priv->glTex;
 }
+
+class cglfbi::FBOBindLocation::Private
+{
+    public:
+
+	Private (GLenum                     binding,
+		 cglfb::BindableFramebuffer *back) :
+	    mCurrentlyBound (back),
+	    mBindPoint (binding)
+	{
+	}
+
+	cglfb::BindableFramebuffer *mCurrentlyBound;
+	GLenum                     mBindPoint;
+};
+
+cglfbi::FBOBindLocation::FBOBindLocation (GLenum                     binding,
+					  cglfb::BindableFramebuffer *back) :
+    priv (new cglfbi::FBOBindLocation::Private (binding, back))
+{
+}
+
+cglfb::BindableFramebuffer *
+cglfbi::FBOBindLocation::bind (cglfb::BindableFramebuffer *next)
+{
+    if (priv->mCurrentlyBound == next)
+	return next;
+
+    (*GL::bindFramebuffer) (priv->mBindPoint, next->getResourceId ());
+    next->updateAllocation (priv->mBindPoint);
+    if (!next->setBindStatus ((*GL::checkFramebufferStatus) (priv->mBindPoint)))
+    {
+	(*GL::bindFramebuffer) (priv->mBindPoint, priv->mCurrentlyBound->getResourceId ());
+	return NULL;
+    }
+
+    cglfb::BindableFramebuffer *last = priv->mCurrentlyBound;
+    priv->mCurrentlyBound = next;
+    return last;
+}

=== modified file 'plugins/opengl/src/paint.cpp'
--- plugins/opengl/src/paint.cpp	2013-01-03 16:05:26 +0000
+++ plugins/opengl/src/paint.cpp	2013-02-10 05:18:18 +0000
@@ -44,6 +44,7 @@
 #define DEG2RAD (M_PI / 180.0f)
 
 using namespace compiz::opengl;
+namespace cglfb = compiz::opengl;
 
 GLScreenPaintAttrib defaultScreenPaintAttrib = {
     0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -DEFAULT_Z_CAMERA
@@ -672,89 +673,16 @@
 }
 
 void
-GLScreen::glPaintCompositedOutput (const CompRegion    &region,
-				   GLFramebufferObject *fbo,
-				   unsigned int         mask)
+GLScreen::glPaintCompositedOutput (const CompRegion			       &region,
+				   compiz::opengl::DirectDrawObject *fbo,
+				   unsigned int				       mask)
 {
     WRAPABLE_HND_FUNCTN (glPaintCompositedOutput, region, fbo, mask)
 
-    GLMatrix sTransform;
-    const GLTexture::Matrix & texmatrix = fbo->tex ()->matrix ();
-    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
-
-    streamingBuffer->begin (GL_TRIANGLES);
-
-    if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
-    {
-	GLfloat tx1 = COMP_TEX_COORD_X (texmatrix, 0.0f);
-	GLfloat tx2 = COMP_TEX_COORD_X (texmatrix, screen->width ());
-	GLfloat ty1 = 1.0 - COMP_TEX_COORD_Y (texmatrix, 0.0f);
-	GLfloat ty2 = 1.0 - COMP_TEX_COORD_Y (texmatrix, screen->height ());
-
-	const GLfloat vertexData[] = {
-	    0.0f,                    0.0f,                     0.0f,
-	    0.0f,                    (float)screen->height (), 0.0f,
-	    (float)screen->width (), 0.0f,                     0.0f,
-
-	    0.0f,                    (float)screen->height (), 0.0f,
-	    (float)screen->width (), (float)screen->height (), 0.0f,
-	    (float)screen->width (), 0.0f,                     0.0f,
-	};
-
-	const GLfloat textureData[] = {
-	    tx1, ty1,
-	    tx1, ty2,
-	    tx2, ty1,
-	    tx1, ty2,
-	    tx2, ty2,
-	    tx2, ty1,
-	};
-
-	streamingBuffer->addVertices (6, &vertexData[0]);
-	streamingBuffer->addTexCoords (0, 6, &textureData[0]);
-    }
-    else
-    {
-	BoxPtr pBox = const_cast <Region> (region.handle ())->rects;
-	int nBox = const_cast <Region> (region.handle ())->numRects;
-
-	while (nBox--)
-	{
-	    GLfloat tx1 = COMP_TEX_COORD_X (texmatrix, pBox->x1);
-	    GLfloat tx2 = COMP_TEX_COORD_X (texmatrix, pBox->x2);
-	    GLfloat ty1 = 1.0 - COMP_TEX_COORD_Y (texmatrix, pBox->y1);
-	    GLfloat ty2 = 1.0 - COMP_TEX_COORD_Y (texmatrix, pBox->y2);
-
-	    const GLfloat vertexData[] = {
-		(float)pBox->x1, (float)pBox->y1, 0.0f,
-		(float)pBox->x1, (float)pBox->y2, 0.0f,
-		(float)pBox->x2, (float)pBox->y1, 0.0f,
-
-		(float)pBox->x1, (float)pBox->y2, 0.0f,
-		(float)pBox->x2, (float)pBox->y2, 0.0f,
-		(float)pBox->x2, (float)pBox->y1, 0.0f,
-	    };
-
-	    const GLfloat textureData[] = {
-		tx1, ty1,
-		tx1, ty2,
-		tx2, ty1,
-		tx1, ty2,
-		tx2, ty2,
-		tx2, ty1,
-	    };
-
-	    streamingBuffer->addVertices (6, &vertexData[0]);
-	    streamingBuffer->addTexCoords (0, 6, &textureData[0]);
-	    pBox++;
-	}
-    }
-
-    streamingBuffer->end ();
-    fbo->tex ()->enable (GLTexture::Fast);
-    sTransform.toScreenSpace (&screen->fullscreenOutput (), -DEFAULT_Z_CAMERA);
-    streamingBuffer->render (sTransform);
-    fbo->tex ()->disable ();
+    /* Draw every rect individually, this could be a little slow
+     * for lots of rects, but the general usecase isn't that */
+    foreach (const CompRect &r, region.rects ())
+	fbo->directDraw (r, r, cglfb::ColorData, cglfb::Fast);
 }
 
 static void

=== modified file 'plugins/opengl/src/privates.h'
--- plugins/opengl/src/privates.h	2013-01-03 16:05:26 +0000
+++ plugins/opengl/src/privates.h	2013-02-10 05:18:18 +0000
@@ -29,22 +29,27 @@
 #define _OPENGL_PRIVATES_H
 
 #include <memory>
-
 #include <composite/composite.h>
 #include <opengl/opengl.h>
 #include <core/atoms.h>
-#include <core/configurerequestbuffer.h>
-
-#ifdef USE_GLES
 #include <opengl/framebufferobject.h>
-#endif
-
 #include <opengl/doublebuffer.h>
 
 #include "privatetexture.h"
 #include "privatevertexbuffer.h"
 #include "opengl_options.h"
 
+namespace compiz
+{
+    namespace opengl
+    {
+	namespace impl
+	{
+	    class DirectDrawObject;
+	}
+    }
+}
+
 extern CompOutput *targetOutput;
 
 class GLDoubleBuffer :
@@ -86,6 +91,17 @@
 	Window mOutput;
 };
 
+namespace compiz
+{
+    namespace opengl
+    {
+	bool blitFramebufferGLX (const CompRect &src,
+				 const CompRect &dst,
+				 GLbitfield     mask,
+				 GLenum         filter);
+    }
+}
+
 #else
 
 class EGLDoubleBuffer :
@@ -109,6 +125,17 @@
 	EGLSurface const & mSurface;
 };
 
+namespace compiz
+{
+    namespace opengl
+    {
+	bool blitFramebufferEGL (const CompRect &src,
+				 const CompRect &dst,
+				 GLbitfield     mask,
+				 GLenum         filter);
+    }
+}
+
 #endif
 
 class GLIcon
@@ -120,6 +147,16 @@
 	GLTexture::List textures;
 };
 
+class BindableBackbuffer :
+    public compiz::opengl::BindableFramebuffer
+{
+    public:
+
+	GLuint getResourceId () const;
+	bool   setBindStatus (GLenum);
+	void   updateAllocation (GLenum);
+};
+
 class PrivateGLScreen :
     public ScreenInterface,
     public compiz::composite::PaintHandler,
@@ -197,8 +234,9 @@
 	GLXDoubleBuffer doubleBuffer;
 	#endif
 
-	GLFramebufferObject *scratchFbo;
-	CompRegion outputRegion;
+	std::auto_ptr <compiz::opengl::DirectDrawObject> scratchFbo;
+	compiz::opengl::BlitFramebufferFunc		 blitFramebuffer;
+	CompRegion					 outputRegion;
 
 	XRectangle lastViewport;
 	bool refreshSubBuffer;
@@ -222,6 +260,9 @@
 	Pixmap rootPixmapCopy;
 	CompSize rootPixmapSize;
 
+	BindableBackbuffer                    backbuffer;
+	compiz::opengl::impl::FBOBindLocation drawFramebufferBinding;
+	compiz::opengl::impl::FBOBindLocation readFramebufferBinding;
 	const char *glVendor, *glRenderer, *glVersion;
 
 	mutable CompString prevRegex;

=== 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-02-10 05:18:18 +0000
@@ -36,6 +36,7 @@
 #include <boost/make_shared.hpp>
 
 #include "privates.h"
+#include "framebuffer-direct-draw.h"
 #include "blacklist/blacklist.h"
 
 #include <dlfcn.h>
@@ -67,6 +68,26 @@
 
 
 using namespace compiz::opengl;
+namespace cglfb = compiz::opengl;
+namespace cgli = compiz::opengl::impl;
+
+namespace compiz
+{
+    namespace opengl
+    {
+#ifndef USE_GLES
+	bool blitFramebufferGLX (const CompRect &src,
+				 const CompRect &dst,
+				 GLbitfield     mask,
+				 GLenum         filter);
+#else
+	bool blitFramebufferEGL (const CompRect &src,
+				 const CompRect &dst,
+				 GLbitfield     mask,
+				 GLenum         filter);
+#endif
+    }
+}
 
 namespace GL {
     #ifdef USE_GLES
@@ -164,11 +185,12 @@
     GLDisableVertexAttribArrayProc disableVertexAttribArray = NULL;
     GLVertexAttribPointerProc      vertexAttribPointer = NULL;
 
-    GLGenRenderbuffersProc genRenderbuffers = NULL;
-    GLDeleteRenderbuffersProc deleteRenderbuffers = NULL;
+    GLGenRenderbuffersProc        genRenderbuffers = NULL;
+    GLDeleteRenderbuffersProc     deleteRenderbuffers = NULL;
     GLFramebufferRenderbufferProc framebufferRenderbuffer = NULL;
-    GLBindRenderbufferProc bindRenderbuffer = NULL;
-    GLRenderbufferStorageProc renderbufferStorage = NULL;
+    GLBindRenderbufferProc        bindRenderbuffer = NULL;
+    GLRenderbufferStorageProc     renderbufferStorage = NULL;
+    GLBlitFramebufferProc         blitFramebuffer = NULL;
 
     bool  textureFromPixmap = true;
     bool  textureRectangle = false;
@@ -299,6 +321,115 @@
     GLScreen *gScreen;
 };
 
+namespace
+{
+bool defaultRectangularFramebufferDraw (GLVertexBuffer       *vertexBuffer,
+					GLFramebufferObject  *fbo,
+					const CompRect       &src,
+					const CompRect       &dst,
+					GLbitfield           mask,
+					GLenum               filter)
+{
+    GLTexture *texture = fbo->tex ();
+    GLMatrix sTransform;
+    const GLTexture::Matrix & texmatrix = texture->matrix ();
+    const GLfloat tx1 = COMP_TEX_COORD_X (texmatrix, src.x1 ());
+    const GLfloat tx2 = COMP_TEX_COORD_X (texmatrix, src.x2 ());
+    const GLfloat ty1 = 1.0 - COMP_TEX_COORD_Y (texmatrix, src.y1 ());
+    const GLfloat ty2 = 1.0 - COMP_TEX_COORD_Y (texmatrix, src.y2 ());
+
+    const GLfloat vx1 = src.x1 ();
+    const GLfloat vx2 = src.x2 ();
+    const GLfloat vy1 = src.y1 ();
+    const GLfloat vy2 = src.y2 ();
+
+    const GLTexture::Filter texFilter =
+	(filter == GL_LINEAR) ? GLTexture::Good :
+				GLTexture::Fast;
+
+    GLfloat vertexData[] = {
+	vx1, vy1, 0.0f,
+	vx1, vy2, 0.0f,
+	vx2, vy1, 0.0f,
+
+	vx1, vy2, 0.0f,
+	vx2, vy2, 0.0f,
+	vx2, vy1, 0.0f,
+    };
+
+    GLfloat textureData[] = {
+	tx1, ty1,
+	tx1, ty2,
+	tx2, ty1,
+	tx1, ty2,
+	tx2, ty2,
+	tx2, ty1,
+    };
+
+    vertexBuffer->begin (GL_TRIANGLES);
+    vertexBuffer->addVertices (6, vertexData);
+    vertexBuffer->addTexCoords (0, 6, textureData);
+
+    if (vertexBuffer->end ())
+    {
+	texture->enable (texFilter);
+	sTransform.toScreenSpace (&screen->fullscreenOutput (), -DEFAULT_Z_CAMERA);
+	vertexBuffer->render (sTransform);
+	texture->disable ();
+    }
+
+    return true;
+}
+
+void initDirectDraw (cgli::DirectDrawStrategies::Ptr        &directDraw,
+		     const compiz::opengl::RectangularDraw  &blitFramebuffer,
+		     const compiz::opengl::RectangularDraw  &rectangularTextureDraw,
+		     const cgli::BindReadBufferFunc         &func,
+		     compiz::opengl::BindableFramebuffer    *bindable)
+{
+    cglfb::RectangularDraw blitFramebufferBound (
+	boost::bind (
+	    cgli::rectangleDrawFromReadBuffer,
+	    _1, _2, _3, _4,
+	    bindable,
+	    func,
+	    blitFramebuffer));
+
+    /* Tries each of these from back to front */
+    cglfb::RectangularDrawList strategies;
+
+    strategies.push_back (rectangularTextureDraw);
+    strategies.push_back (blitFramebufferBound);
+    directDraw.reset (new cgli::DirectDrawStrategies (strategies));
+}
+}
+
+namespace compiz
+{
+namespace opengl
+{
+DirectDrawObject *
+createBlittableFramebufferObjectWithFallback (const CompSize &sz,
+					      GLScreen       *gScreen)
+{
+    boost::shared_ptr <cgli::DirectDrawStrategies> directDraw;
+    boost::shared_ptr <cgli::FramebufferObject> fbo (boost::make_shared <cgli::FramebufferObject> ());
+    cglfb::RectangularDraw rectangularTextureDraw (boost::bind (defaultRectangularFramebufferDraw,
+								GLVertexBuffer::streamingBuffer (),
+								fbo.get (),
+								_1, _2, _3, _4));
+    initDirectDraw (directDraw,
+		    gScreen->blitFramebufferFunc (),
+		    rectangularTextureDraw,
+		    boost::bind (&GLScreen::bindFramebufferForReading, gScreen, _1),
+		    fbo.get ());
+    DirectDrawObject *dd (new cgli::DirectDrawObject (directDraw, fbo, fbo));
+    dd->allocate (*screen, NULL, GL_BGRA);
+    return dd;
+}
+}
+}
+
 #ifndef USE_GLES
 
 namespace compiz
@@ -591,6 +722,7 @@
     if (GL::textureFromPixmap)
 	registerBindPixmap (EglTexture::bindPixmapToTexture);
 
+    priv->blitFramebuffer = boost::bind (compiz::opengl::blitFramebufferEGL, _1, _2, _3, _4);
     priv->incorrectRefreshRate = false;
 
     #else
@@ -779,6 +911,10 @@
 	    GL::fboSupported = true;
     }
 
+    if (GL::fboSupported &&
+        strstr (glExtensions, "GL_EXT_framebuffer_blit"))
+	GL::blitFramebuffer = (GL::GLBlitFramebufferProc) getProcAddress ("glBlitFramebufferEXT");
+
     GL::fboStencilSupported = GL::fboSupported &&
         strstr (glExtensions, "GL_EXT_packed_depth_stencil");
 
@@ -895,13 +1031,13 @@
 
     if (GL::textureFromPixmap)
 	registerBindPixmap (TfpTexture::bindPixmapToTexture);
+
+    priv->blitFramebuffer = boost::bind (compiz::opengl::blitFramebufferGLX, _1, _2, _3, _4);
 #endif
 
     if (GL::fboSupported)
-    {
-	priv->scratchFbo = new GLFramebufferObject;
-	priv->scratchFbo->allocate (*screen, NULL, GL_BGRA);
-    }
+	priv->scratchFbo.reset (compiz::opengl::createBlittableFramebufferObjectWithFallback (*screen,
+											      this));
 
     GLVertexBuffer::streamingBuffer ()->setAutoProgram (priv->autoProgram);
 
@@ -1209,9 +1345,6 @@
 	glXDestroyContext (screen->dpy (), priv->ctx);
     #endif
 
-    if (priv->scratchFbo)
-	delete priv->scratchFbo;
-
     delete priv;
 }
 
@@ -1234,6 +1367,7 @@
     doubleBuffer (screen->dpy (), *screen, surface),
     #endif
     scratchFbo (NULL),
+    blitFramebuffer (),
     outputRegion (),
     refreshSubBuffer (false),
     lastMask (0),
@@ -1246,6 +1380,10 @@
     autoProgram (new GLScreenAutoProgram(gs)),
     rootPixmapCopy (None),
     rootPixmapSize (),
+    drawFramebufferBinding (GL::DRAW_FRAMEBUFFER,
+			    &backbuffer),
+    readFramebufferBinding (GL::READ_FRAMEBUFFER,
+			    &backbuffer),
     glVendor (NULL),
     glRenderer (NULL),
     glVersion (NULL),
@@ -1441,11 +1579,19 @@
 void
 PrivateGLScreen::outputChangeNotify ()
 {
+    compiz::opengl::BindableFramebuffer *previousReadBuffer =
+	    readFramebufferBinding.bind (&backbuffer);
+    compiz::opengl::BindableFramebuffer *previousDrawBuffer =
+	    drawFramebufferBinding.bind (&backbuffer);
+
     screen->outputChangeNotify ();
 
-    if (scratchFbo)
+    if (scratchFbo.get ())
 	scratchFbo->allocate (*screen, NULL, GL_BGRA);
     updateView ();
+
+    readFramebufferBinding.bind (previousReadBuffer);
+    drawFramebufferBinding.bind (previousDrawBuffer);
 }
 
 #ifndef USE_GLES
@@ -1670,9 +1816,9 @@
     WRAPABLE_DEF (projectionMatrix)
 
 void
-GLScreenInterface::glPaintCompositedOutput (const CompRegion    &region,
-					    GLFramebufferObject *fbo,
-					    unsigned int         mask)
+GLScreenInterface::glPaintCompositedOutput (const CompRegion				&region,
+					    compiz::opengl::DirectDrawObject *fbo,
+					    unsigned int				mask)
     WRAPABLE_DEF (glPaintCompositedOutput, region, fbo, mask)
 
 void
@@ -1899,6 +2045,30 @@
 
 }
 
+bool
+cglfb::blitFramebufferGLX (const CompRect &src,
+			   const CompRect &dst,
+			   GLbitfield     mask,
+			   GLenum         filter)
+{
+    /* Must have GL_EXT_blit_framebuffer */
+    if (!GL::blitFramebuffer)
+	return false;
+
+    /* Be sure to invert y-coords too */
+    (*GL::blitFramebuffer) (src.x1 (), // sx0
+			    screen->height () - src.y2 (), // sy0
+			    src.x2 (), // sx1
+			    screen->height () - src.y1 (), // sy1
+			    dst.x1 (), // dx0
+			    screen->height () - dst.y2 (), // dy0
+			    dst.x2 (), // dx1,
+			    screen->height () - dst.y1 (), // dy1
+			    GL_COLOR_BUFFER_BIT,
+			    GL_LINEAR);
+    return true;
+}
+
 #else
 
 EGLDoubleBuffer::EGLDoubleBuffer (Display          *d,
@@ -1957,6 +2127,16 @@
 {
 }
 
+bool
+cglfb::blitFramebufferEGL (const CompRect &src,
+			   const CompRect &dst,
+			   GLbitfield     mask,
+			   GLenum         filter)
+{
+    /* Not supported on OpenGL|ES2 */
+    return false;
+}
+
 #endif
 
 void
@@ -1977,17 +2157,11 @@
     glDepthMask (GL_FALSE);
     glStencilMask (0);
 
-    GLFramebufferObject *oldFbo = NULL;
-    bool useFbo = false;
+    compiz::opengl::BindableFramebuffer *oldFbo = NULL;
 
     /* Clear the color buffer where appropriate */
-    if (GL::fboEnabled && scratchFbo)
-    {
-	oldFbo = scratchFbo->bind ();
-	useFbo = scratchFbo->checkStatus () && scratchFbo->tex ();
-	if (!useFbo)
-	    GLFramebufferObject::rebind (oldFbo);
-    }
+    if (GL::fboEnabled && scratchFbo.get ())
+	oldFbo = drawFramebufferBinding.bind (scratchFbo.get ());
 
 #ifdef UNSAFE_ARM_SGX_FIXME
     refreshSubBuffer = ((lastMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
@@ -2080,13 +2254,10 @@
 
     glViewport (0, 0, screen->width (), screen->height ());
 
-    if (useFbo)
+    if (oldFbo)
     {
-	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);
+	drawFramebufferBinding.bind (oldFbo);
+	gScreen->glPaintCompositedOutput (screen->region (), scratchFbo.get (), mask);
     }
 
     if (cScreen->outputWindowChanged ())
@@ -2101,13 +2272,13 @@
     }
 
     bool alwaysSwap = optionGetAlwaysSwapBuffers ();
-    bool fullscreen = useFbo ||
+    bool fullscreen = oldFbo ||
                       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, oldFbo ? true : false);
     doubleBuffer.set (DoubleBuffer::NEED_PERSISTENT_BACK_BUFFER, alwaysSwap);
     doubleBuffer.render (tmpRegion, fullscreen);
 
@@ -2195,10 +2366,34 @@
     }
 }
 
-GLFramebufferObject *
+compiz::opengl::FramebufferObject *
 GLScreen::fbo ()
 {
-    return priv->scratchFbo;
+    return priv->scratchFbo.get ();
+}
+
+compiz::opengl::BindableFramebuffer *
+GLScreen::backbuffer ()
+{
+    return &priv->backbuffer;
+}
+
+compiz::opengl::BindableFramebuffer *
+GLScreen::bindFramebufferForDrawing (compiz::opengl::BindableFramebuffer *next)
+{
+    return priv->drawFramebufferBinding.bind (next);
+}
+
+compiz::opengl::BindableFramebuffer *
+GLScreen::bindFramebufferForReading (compiz::opengl::BindableFramebuffer *next)
+{
+    return priv->readFramebufferBinding.bind (next);
+}
+
+const cglfb::BlitFramebufferFunc &
+GLScreen::blitFramebufferFunc ()
+{
+    return priv->blitFramebuffer;
 }
 
 GLTexture *
@@ -2240,3 +2435,19 @@
     priv->rasterPos.setY (0);
 }
 
+GLuint
+BindableBackbuffer::getResourceId () const
+{
+    return 0;
+}
+
+bool
+BindableBackbuffer::setBindStatus (GLenum)
+{
+    return true;
+}
+
+void
+BindableBackbuffer::updateAllocation (GLenum)
+{
+}

=== modified file 'plugins/water/src/water.cpp'
--- plugins/water/src/water.cpp	2013-01-28 19:45:04 +0000
+++ plugins/water/src/water.cpp	2013-02-10 05:18:18 +0000
@@ -62,7 +62,11 @@
     if (!useFbo)
 	return false;
 
-    oldFbo = waterFbo[fIndex]->bind ();
+    oldFbo = gScreen->bindFramebufferForDrawing (waterFbo[fIndex]);
+
+    if (!oldFbo)
+	return false;
+
     glGetIntegerv(GL_VIEWPORT,  &oldViewport[0]);
     glViewport (0, 0, texWidth, texHeight);
 
@@ -72,7 +76,7 @@
 void
 WaterScreen::fboEpilogue ()
 {
-    GLFramebufferObject::rebind (oldFbo);
+    gScreen->bindFramebufferForDrawing (oldFbo);
     glViewport (oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
 }
 
@@ -305,28 +309,32 @@
 	    waterFbo[i]->allocate (size, (char *) t0,
 				   GL_BGRA, GL_UNSIGNED_BYTE);
 	    // check if FBOs are working. If not, fallback to software textures
-	    oldFbo = waterFbo[i]->bind ();
-	    waterFbo[i]->rebind (oldFbo);
-	    if (!waterFbo[i]->checkStatus ())
+	    oldFbo = gScreen->bindFramebufferForDrawing (waterFbo[i]);
+	    if (!oldFbo)
 	    {
 		useFbo = false;
 		delete waterFbo[i];
 		break;
 	    }
+	    gScreen->bindFramebufferForDrawing (oldFbo);
 	}
     }
 }
 
 void
-WaterScreen::glPaintCompositedOutput (const CompRegion    &region,
-                                      GLFramebufferObject *fbo,
-                                      unsigned int         mask)
+WaterScreen::glPaintCompositedOutput (const CompRegion				  &region,
+				      compiz::opengl::DirectDrawObject *fbo,
+				      unsigned int				  mask)
 {
     if (count)
     {
 	if (GL::vboEnabled && GL::shaders)
 	{
-	    GLFramebufferObject::rebind (oldFbo);
+	    /* This seems redundant to me */
+	    gScreen->bindFramebufferForDrawing (oldFbo);
+
+	    oldFbo = NULL;
+
 	    glViewport (oldViewport[0], oldViewport[1],
 			oldViewport[2], oldViewport[3]);
 

=== 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-02-10 05:18:18 +0000
@@ -64,9 +64,9 @@
 
 	void handleEvent (XEvent *);
 
-	void glPaintCompositedOutput (const CompRegion    &region,
-				      GLFramebufferObject *fbo,
-				      unsigned int         mask);
+	void glPaintCompositedOutput (const CompRegion				  &region,
+				      compiz::opengl::DirectDrawObject *fbo,
+				      unsigned int				  mask);
 	void preparePaint (int);
 	void donePaint ();
 
@@ -100,7 +100,7 @@
 
 	GLFramebufferObject *waterFbo[TEXTURE_NUM];
 
-	GLFramebufferObject *oldFbo;
+	compiz::opengl::BindableFramebuffer *oldFbo;
 	GLint oldViewport[4];
 	int    fboIndex;
 	bool   useFbo;