Changeset 22776 in vbox for trunk/src/VBox

Timestamp:

Sep 4, 2009 12:45:02 PM (16 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

51952

Message:

video hw accel: more accurate shaders

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• VirtualBoxShaders.qrc (modified) (1 diff)
• include/VBoxFrameBuffer.h (modified) (1 diff)
• shaders/cconvAYUV.c (modified) (1 diff)
• shaders/cconvAYUV_void.c (modified) (1 diff)
• shaders/cconvApplyAYUV.c (modified) (1 diff)
• shaders/cconvBGR.c (modified) (1 diff)
• shaders/cconvBGR_void.c (modified) (1 diff)
• shaders/cconvUYVY.c (modified) (2 diffs)
• shaders/cconvUYVY_void.c (modified) (1 diff)
• shaders/cconvYUY2.c (modified) (2 diffs)
• shaders/cconvYUY2_void.c (modified) (1 diff)
• shaders/cconvYV12.c (modified) (1 diff)
• shaders/cconvYV12_void.c (modified) (1 diff)
• shaders/ckeyDst.c (modified) (2 diffs)
• shaders/ckeyDst_void.c (modified) (1 diff)
• shaders/mainOverlay.c (modified) (1 diff)
• shaders/splitBGRA.c (modified) (1 diff)
• src/VBoxFBQGL.cpp (modified) (15 diffs)

trunk/src/VBox/Frontends/VirtualBox/VirtualBoxShaders.qrc ¶

@@ -2 +2 @@
  <qresource prefix="/">
     <file alias="cconvApplyAYUV.c">shaders/cconvApplyAYUV.c</file>
-    <file alias="cconvAYUV_void.c">shaders/cconvAYUV_void.c</file>
     <file alias="cconvAYUV.c">shaders/cconvAYUV.c</file>
-    <file alias="cconvBGR_void.c">shaders/cconvBGR_void.c</file>
     <file alias="cconvBGR.c">shaders/cconvBGR.c</file>
-    <file alias="cconvUYVY_void.c">shaders/cconvUYVY_void.c</file>
     <file alias="cconvUYVY.c">shaders/cconvUYVY.c</file>
-    <file alias="cconvYUY2_void.c">shaders/cconvYUY2_void.c</file>
     <file alias="cconvYUY2.c">shaders/cconvYUY2.c</file>
-    <file alias="cconvYV12_void.c">shaders/cconvYV12_void.c</file>
     <file alias="cconvYV12.c">shaders/cconvYV12.c</file>
     <file alias="ckeyDst_void.c">shaders/ckeyDst_void.c</file>
     <file alias="ckeyDst.c">shaders/ckeyDst.c</file>
     <file alias="mainOverlay.c">shaders/mainOverlay.c</file>
+    <file alias="mainOverlayNoCKey.c">shaders/mainOverlayNoCKey.c</file>
     <file alias="splitBGRA.c">shaders/splitBGRA.c</file>
  </qresource>

trunk/src/VBox/Frontends/VirtualBox/include/VBoxFrameBuffer.h ¶

@@ -299 +299 @@
 #include "iprt/stream.h"
 #define VBOXQGLLOG(_m) RTPrintf _m
+#define VBOXQGLLOGREL(_m) do { RTPrintf _m ; LogRel( _m ); } while(0)
 #else
 #define VBOXQGLLOG(_m)
+#define VBOXQGLLOGREL(_m) LogRel( _m )
 #endif
 #define VBOXQGLLOG_ENTER(_m)

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvAYUV.c ¶

@@ -1 +1 @@
 #extension GL_ARB_texture_rectangle : enable
-
 uniform sampler2DRect uSrcTex;
-
-void cconvApplyAYUV(vec4 color);
-void cconvAYUV(vec2 srcCoord)
+void vboxCConvApplyAYUV(vec4 color);
+void vboxCConv(int srcI)
 {
+    vec2 srcCoord = vec2(gl_TexCoord[srcI]);
     vec4 color = texture2DRect(uSrcTex, srcCoord);
-    cconvApplyAYUV(color);
+    vboxCConvApplyAYUV(color);
 }

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvAYUV_void.c ¶

@@ -1 @@
-void cconvAYUV(vec2 srcCoord)
+void vboxCConv(int srcI)
 {}

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvApplyAYUV.c ¶

@@ -1 @@
-/* AYUV <-> GL_BGRA_EXT
- * A <-> B
- * Y <-> G
- * U <-> R
- * V <-> A */
-void cconvApplyAYUV(vec4 color)
+void vboxCConvApplyAYUV(vec4 color)
 {
     float y, u, v, r, g, b;

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvBGR.c ¶

@@ -1 +1 @@
 #extension GL_ARB_texture_rectangle : enable
-
 uniform sampler2DRect uSrcTex;
-
-void cconvBGR(vec2 srcCoord)
+void vboxCConv(int srcI)
 {
+    vec2 srcCoord = vec2(gl_TexCoord[srcI]);
     gl_FragColor = texture2DRect(uSrcTex, vec2(srcCoord.x, srcCoord.y));
 }

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvBGR_void.c ¶

@@ -1 @@
-void cconvBGR(vec2 srcCoord)
+void vboxCConv(int srcI)
 {}

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvUYVY.c ¶

@@ -1 +1 @@
 #extension GL_ARB_texture_rectangle : enable
-
 uniform sampler2DRect uSrcTex;
-
-void cconvApplyAYUV(vec4 color);
-/* texture internalFormat: 4
- * size: width/2 X height
- * data format: GL_BGRA_EXT
- * UYVY ->
- * U = B
- * V = R
- * for even -> Y = G
- * for odd  -> Y = A
-/* UYVY-rgb888 conversion shader */
-/* this is also Y422 and UYNV */
-void cconvUYVY(vec2 srcCoord)
+void vboxCConvApplyAYUV(vec4 color);
+void vboxCConv(int srcI)
 {
+    vec2 srcCoord = vec2(gl_TexCoord[srcI]);
     float x = srcCoord.x;
     vec4 srcClr = texture2DRect(uSrcTex, vec2(x, srcCoord.y));
@@ -31 +20 @@
         y = srcClr.a;
     }
-    /* convert it to AYUV (for the GL_BGRA_EXT texture this is mapped as follows:
-     * A -> B
-     * Y -> G
-     * U -> R
-     * V -> A */
-    cconvApplyAYUV(vec4(u, y, 0.0, v));}
+    vboxCConvApplyAYUV(vec4(u, y, 0.0, v));}
+}

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvUYVY_void.c ¶

@@ -1 @@
-void cconvUYVY(vec2 srcCoord)
+void vboxCConv(int srcI)
 {}

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvYUY2.c ¶

@@ -1 +1 @@
 #extension GL_ARB_texture_rectangle : enable
-
 uniform sampler2DRect uSrcTex;
-
-void cconvApplyAYUV(vec4 color);
-/* texture internalFormat: 4
- * size: width/2 X height
- * data format: GL_BGRA_EXT
- * YUYV ->
- * U = G
- * V = A
- * for even -> Y = B
- * for odd  -> Y = R
-/* UYVY-rgb888 conversion shader */
-/* this is also YUNV, V422 and YUYV */
-void cconvYUY2(vec2 srcCoord)
+void vboxCConvApplyAYUV(vec4 color);
+void vboxCConv(int srcI)
 {
+    vec2 srcCoord = vec2(gl_TexCoord[srcI]);
     float x = srcCoord.x;
     vec4 srcClr = texture2DRect(uSrcTex, vec2(x, srcCoord.y));
@@ -31 +20 @@
         y = srcClr.r;
     }
-    /* convert it to AYUV (for the GL_BGRA_EXT texture this is mapped as follows:
-     * A -> B
-     * Y -> G
-     * U -> R
-     * V -> A */
-    cconvApplyAYUV(vec4(u, y, 0.0, v));
+    vboxCConvApplyAYUV(vec4(u, y, 0.0, v));
 }

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvYUY2_void.c ¶

@@ -1 @@
-void cconvYUY2(vec2 srcCoord)
+void vboxCConv(int srcI)
 {}

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvYV12.c ¶

@@ -1 +1 @@
 #extension GL_ARB_texture_rectangle : enable
-
 uniform sampler2DRect uSrcTex;
 uniform sampler2DRect uVTex;
 uniform sampler2DRect uUTex;
-
-float splitBGRA(vec4 color, float coord);
-void cconvApplyAYUV(vec4 color);
-/* texture internalFormat: GL_LUMINANCE
- * size: width X height
- * data format: GL_LUMINANCE
- *
-/* YV12-rgb888 conversion shader */
-void cconvYV12(vec2 srcCoord)
+float vboxSplitBGRA(vec4 color, float coord);
+void vboxCConvApplyAYUV(vec4 color);
+void vboxCConv(int srcI)
 {
-    vec4 clrY = texture2DRect(uSrcTex, srcCoord);
-    vec4 clrV = texture2DRect(uVTex, vec2(gl_TexCoord[2]));
-    vec4 clrU = texture2DRect(uUTex, vec2(gl_TexCoord[3]));
-    float y = splitBGRA(clrY, srcCoord.x);
-    float v = splitBGRA(clrV, gl_TexCoord[2].x);
-    float u = splitBGRA(clrU, gl_TexCoord[3].x);
-
-    /* convert it to AYUV (for the GL_BGRA_EXT texture this is mapped as follows:
-     * A -> B
-     * Y -> G
-     * U -> R
-     * V -> A */
-    cconvApplyAYUV(vec4(u, y, 0.0, v));
-//    gl_FragColor = vec4(clrY.r,clrY.r,clrY.r,1.0);
+    vec2 coordY = vec2(gl_TexCoord[srcI]);
+    vec2 coordV = vec2(gl_TexCoord[srcI+1]);
+    vec2 coordU = vec2(gl_TexCoord[srcI+2]);
+    vec4 clrY = texture2DRect(uSrcTex, vec2(coordY));
+    vec4 clrV = texture2DRect(uVTex, vec2(coordV));
+    vec4 clrU = texture2DRect(uUTex, vec2(coordU));
+    float y = vboxSplitBGRA(clrY, coordY.x);
+    float v = vboxSplitBGRA(clrV, coordV.x);
+    float u = vboxSplitBGRA(clrU, coordU.x);
+    vboxCConvApplyAYUV(vec4(u, y, 0.0, v));
 }

trunk/src/VBox/Frontends/VirtualBox/shaders/cconvYV12_void.c ¶

@@ -1 @@
-void cconvYV12(vec2 srcCoord)
+void vboxCConv(int srcI)
 {}

trunk/src/VBox/Frontends/VirtualBox/shaders/ckeyDst.c ¶

@@ -1 +1 @@
 #extension GL_ARB_texture_rectangle : enable
-
 uniform sampler2DRect uDstTex;
 uniform vec4 uDstClr;
-
-vec2 ckeyDst(void)
+int vboxCKeyDst(void)
 {
     vec4 dstClr = texture2DRect(uDstTex, vec2(gl_TexCoord[0]));
@@ -11 +9 @@
         || any(lessThan(difClr, vec3(-0.01, -0.01, -0.01))))
             discard;
-//    /* gl_FragColor = texture2DRect(uSrcTex, vec2(gl_TexCoord[1])); */
-    return vec2(gl_TexCoord[1]);
+    return 1;
 }

trunk/src/VBox/Frontends/VirtualBox/shaders/ckeyDst_void.c ¶

@@ -1 @@
-vec2 ckeyDst(void)
+int vboxCKeyDst(void)
 {
-    return vec2(gl_TexCoord[0]);
+    return 0;
 }

trunk/src/VBox/Frontends/VirtualBox/shaders/mainOverlay.c ¶

@@ -1 @@
-vec2 ckeyDst(void);
-void cconvYV12(vec2 srcCoord);
-void cconvUYVY(vec2 srcCoord);
-void cconvYUY2(vec2 srcCoord);
-void cconvAYUV(vec2 srcCoord);
-void cconvBGR(vec2 srcCoord);
-
+int vboxCKeyDst(void);
+void vboxCConv(int srcI);
 void main(void)
 {
-        vec2 srcCoord = ckeyDst();
-
-        cconvYV12(srcCoord);
-        cconvUYVY(srcCoord);
-        cconvYUY2(srcCoord);
-        cconvAYUV(srcCoord);
-        cconvBGR(srcCoord);
+        int srci = vboxCKeyDst();
+        vboxCConv(srci);
 }

trunk/src/VBox/Frontends/VirtualBox/shaders/splitBGRA.c ¶

@@ -1 @@
-
-float splitBGRA(vec4 color, float coord)
+float vboxSplitBGRA(vec4 color, float coord)
 {
     int pix = int(coord);
         float part = coord - float(pix);
-        /* todo: do not use if */
         if(part < 0.25)
                 return color.b;

trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBQGL.cpp ¶

@@ -20 +20 @@
  */
 #if defined (VBOX_GUI_USE_QGL)
+
+#define LOG_GROUP LOG_GROUP_GUI
 
 #include "VBoxFrameBuffer.h"
@@ -517 +519 @@
         glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxUnits);
 
-        VBOXQGLLOG(("Max Tex Coords (%d), Img Units (%d)\n", maxCoords, maxUnits));
+        VBOXQGLLOGREL(("Max Tex Coords (%d), Img Units (%d)\n", maxCoords, maxUnits));
         /* take the minimum of those */
         if(maxUnits < maxCoords)
@@ -523 +525 @@
         if(maxUnits < 2)
         {
-            VBOXQGLLOG(("Max Tex Coord or Img Units < 2 disabling MultiTex support\n"));
+            VBOXQGLLOGREL(("Max Tex Coord or Img Units < 2 disabling MultiTex support\n"));
                 break;
         }
@@ -709 +711 @@
             );
 
-    VBOXQGLLOG (("gl version string: 0%s\n", str));
+    VBOXQGLLOGREL (("gl version string: 0%s\n", str));
 
     g_vboxVHWAGlVersion = vboxVHWAGlParseVersion(str);
@@ -719 +721 @@
     else
     {
-        VBOXQGLLOG (("gl version: 0x%x\n", g_vboxVHWAGlVersion));
+        VBOXQGLLOGREL (("gl version: 0x%x\n", g_vboxVHWAGlVersion));
         VBOXQGL_CHECKERR(
                 str = glGetString(GL_EXTENSIONS);
@@ -726 +728 @@
         const char * pos = strstr((const char *)str, "GL_ARB_multitexture");
         g_GL_ARB_multitexture = pos != NULL;
-        VBOXQGLLOG (("GL_ARB_multitexture: %d\n", g_GL_ARB_multitexture));
+        VBOXQGLLOGREL (("GL_ARB_multitexture: %d\n", g_GL_ARB_multitexture));
 
         pos = strstr((const char *)str, "GL_ARB_shader_objects");
         g_GL_ARB_shader_objects = pos != NULL;
-        VBOXQGLLOG (("GL_ARB_shader_objects: %d\n", g_GL_ARB_shader_objects));
+        VBOXQGLLOGREL (("GL_ARB_shader_objects: %d\n", g_GL_ARB_shader_objects));
 
         pos = strstr((const char *)str, "GL_ARB_fragment_shader");
         g_GL_ARB_fragment_shader = pos != NULL;
-        VBOXQGLLOG (("GL_ARB_fragment_shader: %d\n", g_GL_ARB_fragment_shader));
+        VBOXQGLLOGREL (("GL_ARB_fragment_shader: %d\n", g_GL_ARB_fragment_shader));
 
         pos = strstr((const char *)str, "GL_ARB_pixel_buffer_object");
         g_GL_ARB_pixel_buffer_object = pos != NULL;
-        VBOXQGLLOG (("GL_ARB_pixel_buffer_object: %d\n", g_GL_ARB_pixel_buffer_object));
+        VBOXQGLLOGREL (("GL_ARB_pixel_buffer_object: %d\n", g_GL_ARB_pixel_buffer_object));
 
         pos = strstr((const char *)str, "GL_ARB_texture_rectangle");
         g_GL_ARB_texture_rectangle = pos != NULL;
-        VBOXQGLLOG (("GL_ARB_texture_rectangle: %d\n", g_GL_ARB_texture_rectangle));
+        VBOXQGLLOGREL (("GL_ARB_texture_rectangle: %d\n", g_GL_ARB_texture_rectangle));
 
         pos = strstr((const char *)str, "GL_EXT_texture_rectangle");
         g_GL_EXT_texture_rectangle = pos != NULL;
-        VBOXQGLLOG (("GL_EXT_texture_rectangle: %d\n", g_GL_EXT_texture_rectangle));
+        VBOXQGLLOGREL (("GL_EXT_texture_rectangle: %d\n", g_GL_EXT_texture_rectangle));
 
         pos = strstr((const char *)str, "GL_NV_texture_rectangle");
         g_GL_NV_texture_rectangle = pos != NULL;
-        VBOXQGLLOG (("GL_NV_texture_rectangle: %d\n", g_GL_NV_texture_rectangle));
+        VBOXQGLLOGREL (("GL_NV_texture_rectangle: %d\n", g_GL_NV_texture_rectangle));
 
         pos = strstr((const char *)str, "GL_ARB_texture_non_power_of_two");
         g_GL_ARB_texture_non_power_of_two = pos != NULL;
-        VBOXQGLLOG (("GL_ARB_texture_non_power_of_two: %d\n", g_GL_ARB_texture_non_power_of_two));
+        VBOXQGLLOGREL (("GL_ARB_texture_non_power_of_two: %d\n", g_GL_ARB_texture_non_power_of_two));
 
         vboxVHWAGlInitExtSupport(*pContext);
@@ -974 +976 @@
     QByteArray asciiStr = program.toAscii();
     const char * contents = asciiStr.constData();
-    GLint length = (GLint)strlen(contents);
+    GLint length = -1;
 
     VBOXQGL_CHECKERR(
@@ -1437 +1439 @@
         mShaderCConvApplyAYUV(":/cconvApplyAYUV.c", GL_FRAGMENT_SHADER),
         mShaderCConvAYUV(":/cconvAYUV.c", GL_FRAGMENT_SHADER),
-        mShaderCConvAYUVVoid(":/cconvAYUV_void.c", GL_FRAGMENT_SHADER),
+//        mShaderCConvAYUVVoid(":/cconvAYUV_void.c", GL_FRAGMENT_SHADER),
         mShaderCConvBGR(":/cconvBGR.c", GL_FRAGMENT_SHADER),
-        mShaderCConvBGRVoid(":/cconvBGR_void.c", GL_FRAGMENT_SHADER),
+//        mShaderCConvBGRVoid(":/cconvBGR_void.c", GL_FRAGMENT_SHADER),
         mShaderCConvUYVY(":/cconvUYVY.c", GL_FRAGMENT_SHADER),
-        mShaderCConvUYVYVoid(":/cconvUYVY_void.c", GL_FRAGMENT_SHADER),
+//        mShaderCConvUYVYVoid(":/cconvUYVY_void.c", GL_FRAGMENT_SHADER),
         mShaderCConvYUY2(":/cconvYUY2.c", GL_FRAGMENT_SHADER),
-        mShaderCConvYUY2Void(":/cconvYUY2_void.c", GL_FRAGMENT_SHADER),
+//        mShaderCConvYUY2Void(":/cconvYUY2_void.c", GL_FRAGMENT_SHADER),
         mShaderCConvYV12(":/cconvYV12.c", GL_FRAGMENT_SHADER),
-        mShaderCConvYV12Void(":/cconvYV12_void.c", GL_FRAGMENT_SHADER),
+//        mShaderCConvYV12Void(":/cconvYV12_void.c", GL_FRAGMENT_SHADER),
         mShaderSplitBGRA(":/splitBGRA.c", GL_FRAGMENT_SHADER),
         mShaderCKeyDst(":/ckeyDst.c", GL_FRAGMENT_SHADER),
-        mShaderCKeyDstVoid(":/ckeyDst_void.c", GL_FRAGMENT_SHADER),
+//        mShaderCKeyDstVoid(":/ckeyDst_void.c", GL_FRAGMENT_SHADER),
     //  mShaderCKeySrc;
     //  mShaderCKeySrcVoid;
-        mShaderMainOverlay(":/mainOverlay.c", GL_FRAGMENT_SHADER)
+        mShaderMainOverlay(":/mainOverlay.c", GL_FRAGMENT_SHADER),
+        mShaderMainOverlayNoCKey(":/mainOverlayNoCKey.c", GL_FRAGMENT_SHADER)
     {}
 
@@ -1477 +1480 @@
 
     VBoxVHWAGlShader mShaderCConvAYUV;
-    VBoxVHWAGlShader mShaderCConvAYUVVoid;
+//    VBoxVHWAGlShader mShaderCConvAYUVVoid;
     VBoxVHWAGlShader mShaderCConvBGR;
-    VBoxVHWAGlShader mShaderCConvBGRVoid;
+//    VBoxVHWAGlShader mShaderCConvBGRVoid;
     VBoxVHWAGlShader mShaderCConvUYVY;
-    VBoxVHWAGlShader mShaderCConvUYVYVoid;
+//    VBoxVHWAGlShader mShaderCConvUYVYVoid;
     VBoxVHWAGlShader mShaderCConvYUY2;
-    VBoxVHWAGlShader mShaderCConvYUY2Void;
+//    VBoxVHWAGlShader mShaderCConvYUY2Void;
     VBoxVHWAGlShader mShaderCConvYV12;
-    VBoxVHWAGlShader mShaderCConvYV12Void;
+//    VBoxVHWAGlShader mShaderCConvYV12Void;
     VBoxVHWAGlShader mShaderSplitBGRA;
 
     VBoxVHWAGlShader mShaderCKeyDst;
-    VBoxVHWAGlShader mShaderCKeyDstVoid;
+//    VBoxVHWAGlShader mShaderCKeyDstVoid;
 //    VBoxVHWAGlShader mShaderCKeySrc;
 //    VBoxVHWAGlShader mShaderCKeySrcVoid;
 
     VBoxVHWAGlShader mShaderMainOverlay;
+    VBoxVHWAGlShader mShaderMainOverlayNoCKey;
 
     friend class VBoxVHWAGlProgramVHWA;
@@ -1512 +1516 @@
         apShaders[cShaders++] = &mShaderCKeyDst;
     }
-    else
-    {
-        apShaders[cShaders++] = &mShaderCKeyDstVoid;
-    }
+// ensure we don't have empty functions /* paranoya for for ATI on linux */
+//    else
+//    {
+//        apShaders[cShaders++] = &mShaderCKeyDstVoid;
+//    }
 
     if(type & VBOXVHWA_PROGRAM_SRCCOLORKEY)
@@ -1532 +1537 @@
             bFound = true;
         }
-        else
-        {
-            apShaders[cShaders++] = &mShaderCConvUYVYVoid;
-        }
-
-        if(fourcc == FOURCC_YUY2)
+        else if(fourcc == FOURCC_YUY2)
         {
             apShaders[cShaders++] = &mShaderCConvYUY2;
             bFound = true;
         }
-        else
-        {
-            apShaders[cShaders++] = &mShaderCConvYUY2Void;
-        }
-
-        if(fourcc == FOURCC_YV12)
+        else if(fourcc == FOURCC_YV12)
         {
             apShaders[cShaders++] = &mShaderSplitBGRA;
@@ -1553 +1548 @@
             bFound = true;
         }
-        else
-        {
-            apShaders[cShaders++] = &mShaderCConvYV12Void;
-        }
-
-        if(fourcc == FOURCC_AYUV)
+        else if(fourcc == FOURCC_AYUV)
         {
             apShaders[cShaders++] = &mShaderCConvAYUV;
             bFound = true;
         }
-        else
-        {
-            apShaders[cShaders++] = &mShaderCConvAYUVVoid;
-        }
     }
 
@@ -1573 +1559 @@
         type |= VBOXVHWA_PROGRAM_COLORCONV;
         apShaders[0] = &mShaderCConvApplyAYUV;
-        apShaders[cShaders++] = &mShaderCConvBGRVoid;
     }
     else
@@ -1581 +1566 @@
     }
 
-    apShaders[cShaders++] = &mShaderMainOverlay;
+    if(type &  VBOXVHWA_PROGRAM_DSTCOLORKEY)
+    {
+        apShaders[cShaders++] = &mShaderMainOverlay;
+    }
+    else
+    {
+        // ensure we don't have empty functions /* paranoya for for ATI on linux */
+        apShaders[cShaders++] = &mShaderMainOverlayNoCKey;
+    }
 
     Assert(cShaders <= RT_ELEMENTS(apShaders));
@@ -4802 +4795 @@
     pDisplay->init(NULL, mUsesGuestVRAM ? re->VRAM() : NULL);
     mDisplay.setVGA(pDisplay);
-    VBOXQGLLOG(("\n\n*******\n\n     viewport size is: (%d):(%d)\n\n*******\n\n", size().width(), size().height()));
+//    VBOXQGLLOG(("\n\n*******\n\n     viewport size is: (%d):(%d)\n\n*******\n\n", size().width(), size().height()));
     mViewport = QRect(0,0,displayWidth, displayHeight);
     adjustViewport(dispSize, mViewport);