Changeset 20906 in vbox for trunk

Timestamp:

Jun 24, 2009 10:32:18 PM (16 years ago)

Author:

vboxsync

Message:

video hw accel: color keying & color conversion basics impl for QGL Framebuffer

Location:

trunk

Files:

• include/VBox/VBoxVideo.h (modified) (3 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/driver.h (modified) (1 diff)
• src/VBox/Frontends/VirtualBox/include/VBoxFrameBuffer.h (modified) (10 diffs)

trunk/include/VBox/VBoxVideo.h

@@ -263 +263 @@
     VBOXVHWACMD_TYPE_SURF_UNLOCK,
     VBOXVHWACMD_TYPE_SURF_BLT,
+    VBOXVHWACMD_TYPE_SURF_FLIP,
+    VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE,
+    VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION,
     VBOXVHWACMD_TYPE_QUERY_INFO1,
     VBOXVHWACMD_TYPE_QUERY_INFO2,
@@ -361 +364 @@
 } VBOXVHWA_SURFACEDESC;
 
+typedef struct _VBOXVHWA_BLTDESC
+{
+    uint32_t flags;
+    uint32_t rop;
+    uint32_t rotationOp;
+    uint32_t rotation;
+    VBOXVHWA_COLORKEY DstCK;
+    VBOXVHWA_COLORKEY SrcCK;
+} VBOXVHWA_BLTDESC;
+
+typedef struct _VBOXVHWA_OVERLAYDESC
+{
+    uint32_t flags;
+    uint32_t Reserved1;
+    uint32_t rotationOp;
+    uint32_t Reserved2;
+    VBOXVHWA_COLORKEY DstCK;
+    VBOXVHWA_COLORKEY SrcCK;
+} VBOXVHWA_OVERLAYDESC;
+
 #define VBOXVHWA_CAPS_BLT             0x00000001
 #define VBOXVHWA_CAPS_BLTCOLORFILL    0x00000002
@@ -511 +534 @@
             uint32_t flags;
             uint32_t reserved;
+            VBOXVHWA_BLTDESC desc;
         } in;
     } u;
 } VBOXVHWACMD_SURF_BLT;
+
+typedef struct _VBOXVHWACMD_SURF_OVERLAY_UPDATE
+{
+    union
+    {
+        struct
+        {
+            VBOXVHWA_SURFHANDLE hDstSurf;
+            uint64_t offDstSurface;
+            VBOXVHWA_RECTL dstRect;
+            VBOXVHWA_SURFHANDLE hSrcSurf;
+            uint64_t offSrcSurface;
+            VBOXVHWA_RECTL srcRect;
+            uint32_t flags;
+            uint32_t reserved;
+            VBOXVHWA_OVERLAYDESC desc;
+        } in;
+    } u;
+}VBOXVHWACMD_SURF_OVERLAY_UPDATE;
+
+typedef struct _VBOXVHWACMD_SURF_OVERLAY_SETPOSITION
+{
+    union
+    {
+        struct
+        {
+            VBOXVHWA_SURFHANDLE hDstSurf;
+            uint64_t offDstSurface;
+            VBOXVHWA_SURFHANDLE hSrcSurf;
+            uint64_t offSrcSurface;
+            uint32_t xPos;
+            uint32_t yPos;
+            uint32_t flags;
+            uint32_t reserved;
+        } in;
+    } u;
+} VBOXVHWACMD_SURF_OVERLAY_SETPOSITION;
 
 #pragma pack()

trunk/src/VBox/Additions/WINNT/Graphics/Display/driver.h

@@ -95 +95 @@
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
+typedef struct _VBOXVHWAREGION
+{
+    RECT DirtyMem;
+    bool bValid;
+}VBOXVHWAREGION, *PVBOXVHWAREGION;
+
 typedef struct _VBOXVHWASURFDESC
 {

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

@@ -386 +386 @@
 };
 
+class VBoxVHWAColorKey
+{
+public:
+    VBoxVHWAColorKey() :
+        mUpper(0),
+        mLower(0)
+    {}
+
+    VBoxVHWAColorKey(uint32_t aUpper, uint32_t aLower) :
+        mUpper(aUpper),
+        mLower(aLower)
+    {}
+
+    uint32_t upper() {return mUpper; }
+    uint32_t lower() {return mLower; }
+private:
+    uint32_t mUpper;
+    uint32_t mLower;
+};
+
+class VBoxVHWAColorFormat
+{
+public:
+
+    VBoxVHWAColorFormat(GLint aInternalFormat, GLenum aFormat, GLenum aType, uint32_t aDataFormat) :
+        mInternalFormat(aInternalFormat),
+        mFormat(aFormat),
+        mType(aType),
+        mDataFormat(aDataFormat)
+    {}
+
+    GLint internalFormat() const {return mInternalFormat; }
+    GLenum format() const {return mFormat; }
+    GLenum type() const {return mType; }
+    uint32_t dataFormat() const {return mDataFormat;}
+
+    void pixel2Normalized(uint32_t pix, float &r, float &g, float &b);
+    uint32_t r(uint32_t pix);
+    uint32_t g(uint32_t pix);
+    uint32_t b(uint32_t pix);
+
+private:
+    GLint mInternalFormat;
+    GLenum mFormat;
+    GLenum mType;
+    uint32_t mDataFormat;
+
+    uint32_t mRMask;
+    uint32_t mGMask;
+    uint32_t mBMask;
+    uint32_t mRRange;
+    uint32_t mGRange;
+    uint32_t mBRange;
+
+};
+
 class VBoxVHWASurfaceBase
 {
 public:
     VBoxVHWASurfaceBase(GLsizei aWidth, GLsizei aHeight,
-            GLint aInternalFormat, GLenum aFormat, GLenum aType);
+            VBoxVHWAColorFormat & aColorFormat,
+            VBoxVHWAColorKey * pSrcBltCKey, VBoxVHWAColorKey * pDstBltCKey,
+            VBoxVHWAColorKey * pSrcOverlayCKey, VBoxVHWAColorKey * pDstOverlayCKey);
 
     virtual ~VBoxVHWASurfaceBase();
@@ -400 +458 @@
     static void globalInit();
 
-    int blt(const QRect * aDstRect, VBoxVHWASurfaceBase * aSrtSurface, const QRect * aSrcRect);
-
-    int lock(const QRect * pRect, uint32_t flags);
-
-    int unlock();
-
-    virtual void makeCurrent() = 0;
+    int blt(const QRect * aDstRect, VBoxVHWASurfaceBase * aSrtSurface, const QRect * aSrcRect, uint32_t flags, struct _VBOXVHWA_BLTDESC * pBltInfo);
+
+    virtual int lock(const QRect * pRect, uint32_t flags);
+
+    virtual int unlock();
 
     void paint(const QRect * aRect);
 
-    void performDisplay() { Assert(mDisplayInitialized); glCallList(mDisplay); }
+    void performDisplay();
 
     static ulong calcBytesPerPixel(GLenum format, GLenum type);
@@ -424 +480 @@
     ulong height() { return mRect.height(); }
 
-    GLenum format() {return mFormat; }
-    GLint  internalFormat() { return mInternalFormat; }
-    GLenum type() { return mType; }
+    GLenum format() {return mColorFormat.format(); }
+    GLint  internalFormat() { return mColorFormat.internalFormat(); }
+    GLenum type() { return mColorFormat.type(); }
+    uint32_t dataFormat() {return mColorFormat.dataFormat(); }
+
     ulong  bytesPerPixel() { return mBytesPerPixel; }
     ulong  bytesPerLine() { return mBytesPerLine; }
 
+    const VBoxVHWAColorKey * dstBltCKey() { return mDstBltCKeyValid ? &mDstBltCKey : NULL; }
+    const VBoxVHWAColorKey * srcBltCKey() { return mSrcBltCKeyValid ? &mSrcBltCKey : NULL; }
+    const VBoxVHWAColorKey * dstOverlayCKey() { return mDstOverlayCKeyValid ? &mDstOverlayCKey : NULL; }
+    const VBoxVHWAColorKey * srcOverlayCKey() { return mSrcOverlayCKeyValid ? &mSrcOverlayCKey : NULL; }
+    const VBoxVHWAColorFormat & colorFormat() {return mColorFormat; }
+
     /* clients should treat the returned texture as read-only */
     GLuint textureSynched(const QRect * aRect) { synchTexture(aRect); return mTexture; }
@@ -437 +501 @@
     const QRect& rect() {return mRect;}
 
-    virtual bool isPrimary() = 0;
+//    /* surface currently being displayed in a flip chain */
+//    virtual bool isPrimary() = 0;
+//    /* surface representing the main framebuffer. */
+//    virtual bool isMainFramebuffer() = 0;
+    virtual void makeCurrent() = 0;
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    virtual class VBoxVHWAGlProgramMngr * getGlProgramMngr() = 0;
+#endif
 private:
     void initDisplay();
@@ -453 +524 @@
     GLuint mTexture;
 
+    VBoxVHWAColorFormat mColorFormat;
+    VBoxVHWAColorKey mSrcBltCKey;
+    VBoxVHWAColorKey mDstBltCKey;
+    VBoxVHWAColorKey mSrcOverlayCKey;
+    VBoxVHWAColorKey mDstOverlayCKey;
+    bool mSrcBltCKeyValid;
+    bool mDstBltCKeyValid;
+    bool mSrcOverlayCKeyValid;
+    bool mDstOverlayCKeyValid;
     GLenum mFormat;
     GLint  mInternalFormat;
@@ -472 +552 @@
 };
 
-class VBoxVHWASurfacePrimary : public VBoxVHWASurfaceBase
-{
-public:
-    VBoxVHWASurfacePrimary(GLsizei aWidth, GLsizei aHeight,
-            GLint aInternalFormat, GLenum aFormat, GLenum aType,
-            class VBoxGLWidget *pWidget) :
+class VBoxVHWASurfaceQGL : public VBoxVHWASurfaceBase
+{
+public:
+    VBoxVHWASurfaceQGL(GLsizei aWidth, GLsizei aHeight,
+            VBoxVHWAColorFormat & aColorFormat,
+            VBoxVHWAColorKey * pSrcBltCKey, VBoxVHWAColorKey * pDstBltCKey,
+            VBoxVHWAColorKey * pSrcOverlayCKey, VBoxVHWAColorKey * pDstOverlayCKey,
+            class VBoxGLWidget *pWidget,
+            bool bBackBuffer) :
                 VBoxVHWASurfaceBase(aWidth, aHeight,
-                        aInternalFormat, aFormat, aType),
-                mWidget(pWidget)
+                        aColorFormat,
+                        pSrcBltCKey, pDstBltCKey, pSrcOverlayCKey, pDstOverlayCKey),
+                mWidget(pWidget),
+                mCreateBuf(bBackBuffer)
     {}
 
-    bool isPrimary() {return true;}
     void makeCurrent();
+
+    void init(uchar *pvMem);
+
+    int unlock()
+    {
+        int rc = VBoxVHWASurfaceBase::unlock();
+        if(!mBuffer)
+            performDisplay();
+        return rc;
+    }
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    class VBoxVHWAGlProgramMngr * getGlProgramMngr();
+#endif
 private:
     class VBoxGLWidget *mWidget;
+    class QGLPixelBuffer *mBuffer;
+    bool mCreateBuf;
 };
 
@@ -492 +591 @@
 {
 public:
-    VBoxGLWidget (QWidget *aParent)
-        : QGLWidget (aParent),
-        pDisplay(NULL),
-        mBitsPerPixel(0),
-        mPixelFormat(0),
-        mUsesGuestVRAM(false)
-    {
-//        /* No need for background drawing */
-//        setAttribute (Qt::WA_OpaquePaintEvent);
-    }
+    VBoxGLWidget (QWidget *aParent);
+    ~VBoxGLWidget();
 
     ulong vboxPixelFormat() { return mPixelFormat; }
@@ -518 +609 @@
 #ifdef VBOX_WITH_VIDEOHWACCEL
     void vboxVHWACmd (struct _VBOXVHWACMD * pCmd) {vboxPerformGLOp(&VBoxGLWidget::vboxDoVHWACmd, pCmd);}
-#endif
-
-    VBoxVHWASurfacePrimary * vboxGetSurface() { return pDisplay; }
+    class VBoxVHWAGlProgramMngr * vboxVHWAGetGlProgramMngr();
+#endif
+
+    VBoxVHWASurfaceQGL * vboxGetSurface() { return pDisplay; }
 protected:
 //    void resizeGL (int height, int width);
@@ -557 +649 @@
 #endif
 
-    VBoxVHWASurfacePrimary * pDisplay;
+    VBoxVHWASurfaceQGL * pDisplay;
     /* we need to do all opengl stuff in the paintGL context,
      * submit the operation to be performed */
@@ -568 +660 @@
     ulong  mPixelFormat;
     bool   mUsesGuestVRAM;
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    class VBoxVHWAGlProgramMngr *mpMngr;
+#endif
 };