VirtualBox

Changeset 108641 in vbox


Ignore:
Timestamp:
Mar 20, 2025 12:48:42 PM (2 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
168054
Message:

Removed 2D video acceleration (aka VHWA / VBOX_WITH_VIDEOHWACCEL). bugref:10756

Location:
trunk
Files:
5 deleted
48 edited

Legend:

Unmodified
Added
Removed

  • trunk/Config.kmk

    r108495 r108641  
    667667# Enable Host Guest Shared Memory Interface.
    668668VBOX_WITH_HGSMI = 1
    669 # Enable Video 2D Acceleration.
    670 if1of ($(KBUILD_TARGET), darwin linux win freebsd)
    671  VBOX_WITH_VIDEOHWACCEL = 1
    672 endif
    673669if1of ($(KBUILD_TARGET).$(KBUILD_TARGET_ARCH), win.x86 win.amd64)
    674670 # Enable XPDM Video driver for XP and older guests.
    … …  
    17581754#
    17591755
    1760 # Use the OpenGL module in qt when the video hardware acceleration feature
    1761 # is enabled.
    1762 if defined(VBOX_WITH_VIDEOHWACCEL) && defined(VBOX_WITH_QTGUI)
    1763  VBOX_GUI_USE_QGL = 1
    1764 else
    1765  VBOX_GUI_USE_QGL =
    1766 endif
     1756# The OpenGL module in qt is not being used currently.
     1757VBOX_GUI_USE_QGL =
    17671758
    17681759# Collection macro mainly for deciding whether VBoxDTrace needs shipping.

  • trunk/configure

    r108322 r108641  
    29292929  cnf_append "VBOX_WITH_VMSVGA3D" ""
    29302930  cnf_append "VBOX_WITH_3D_ACCELERATION" ""
    2931   cnf_append "VBOX_WITH_VIDEOHWACCEL" ""
    29322931  cnf_append "VBOX_GUI_USE_QGL" ""
    29332932fi

  • trunk/include/VBox/Graphics/VBoxVideo.h

    r106061 r108641  
    312312#pragma pack()
    313313
    314 #ifdef VBOX_WITH_VIDEOHWACCEL
    315 #pragma pack(1)
    316 
    317 #define VBOXVHWA_VERSION_MAJ 0
    318 #define VBOXVHWA_VERSION_MIN 0
    319 #define VBOXVHWA_VERSION_BLD 6
    320 #define VBOXVHWA_VERSION_RSV 0
    321 
    322 typedef enum
    323 {
    324     VBOXVHWACMD_TYPE_SURF_CANCREATE = 1,
    325     VBOXVHWACMD_TYPE_SURF_CREATE,
    326     VBOXVHWACMD_TYPE_SURF_DESTROY,
    327     VBOXVHWACMD_TYPE_SURF_LOCK,
    328     VBOXVHWACMD_TYPE_SURF_UNLOCK,
    329     VBOXVHWACMD_TYPE_SURF_BLT,
    330     VBOXVHWACMD_TYPE_SURF_FLIP,
    331     VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE,
    332     VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION,
    333     VBOXVHWACMD_TYPE_SURF_COLORKEY_SET,
    334     VBOXVHWACMD_TYPE_QUERY_INFO1,
    335     VBOXVHWACMD_TYPE_QUERY_INFO2,
    336     VBOXVHWACMD_TYPE_ENABLE,
    337     VBOXVHWACMD_TYPE_DISABLE,
    338     VBOXVHWACMD_TYPE_HH_CONSTRUCT,
    339     VBOXVHWACMD_TYPE_HH_RESET
    340 #ifdef VBOX_WITH_WDDM
    341     , VBOXVHWACMD_TYPE_SURF_GETINFO
    342     , VBOXVHWACMD_TYPE_SURF_COLORFILL
    343 #endif
    344     , VBOXVHWACMD_TYPE_HH_DISABLE
    345     , VBOXVHWACMD_TYPE_HH_ENABLE
    346     , VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN
    347     , VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND
    348     , VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM
    349     , VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM
    350 } VBOXVHWACMD_TYPE;
    351 
    352 /** The command processing was asynch, set by the host to indicate asynch
    353  * command completion. Must not be cleared once set, the command completion is
    354  * performed by issuing a host->guest completion command while keeping this
    355  * flag unchanged */
    356 #define VBOXVHWACMD_FLAG_HG_ASYNCH               UINT32_C(0x00010000)
    357 /** asynch completion is performed by issuing the event */
    358 #define VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT         UINT32_C(0x00000001)
    359 /** issue interrupt on asynch completion */
    360 #define VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ           UINT32_C(0x00000002)
    361 /** Guest does not do any op on completion of this command, the host may copy
    362  * the command and indicate that it does not need the command anymore
    363  * by setting the VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED flag */
    364 #define VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION  UINT32_C(0x00000004)
    365 /** the host has copied the VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION command and returned it to the guest */
    366 #define VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED      UINT32_C(0x00020000)
    367 /** this is the host->host cmd, i.e. a configuration command posted by the host to the framebuffer */
    368 #define VBOXVHWACMD_FLAG_HH_CMD                  UINT32_C(0x10000000)
    369 
    370 typedef struct VBOXVHWACMD
    371 {
    372     VBOXVHWACMD_TYPE enmCmd;     /**< command type */
    373     volatile int32_t rc;         /**< command result */
    374     int32_t iDisplay;            /**< display index */
    375     volatile int32_t Flags;      /**< ORed VBOXVHWACMD_FLAG_xxx values */
    376     uint64_t GuestVBVAReserved1; /**< field internally used by the guest VBVA cmd handling, must NOT be modified by clients */
    377     uint64_t GuestVBVAReserved2; /**< field internally used by the guest VBVA cmd handling, must NOT be modified by clients */
    378     volatile uint32_t cRefs;
    379     int32_t Reserved;
    380     union
    381     {
    382         struct VBOXVHWACMD *pNext;
    383         uint32_t            offNext;
    384         uint64_t Data;                  /**< the body is 64-bit aligned */
    385     } u;
    386     char body[1];
    387 } VBOXVHWACMD;
    388 
    389 #define VBOXVHWACMD_HEADSIZE()                          (RT_OFFSETOF(VBOXVHWACMD, body))
    390 #define VBOXVHWACMD_SIZE_FROMBODYSIZE(a_cbBody)         (VBOXVHWACMD_HEADSIZE() + (a_cbBody))
    391 #define VBOXVHWACMD_SIZE(a_tTypeCmd)                    (VBOXVHWACMD_SIZE_FROMBODYSIZE(sizeof(a_tTypeCmd)))
    392 typedef unsigned int VBOXVHWACMD_LENGTH;
    393 typedef uint64_t VBOXVHWA_SURFHANDLE;
    394 #define VBOXVHWA_SURFHANDLE_INVALID                     UINT64_C(0)
    395 #define VBOXVHWACMD_BODY(a_pHdr, a_TypeBody)            ( (a_TypeBody RT_UNTRUSTED_VOLATILE_HSTGST *)&(a_pHdr)->body[0] )
    396 #if !defined(IN_GUEST) && defined(IN_RING3)
    397 # define VBOXVHWACMD_BODY_HOST_HEAP(a_pHdr, a_TypeBody) ( (a_TypeBody *)&(a_pHdr)->body[0] )
    398 #endif
    399 #define VBOXVHWACMD_HEAD(a_pBody)\
    400     ( (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HSTGST *)((uint8_t *)(a_pBody) - RT_OFFSETOF(VBOXVHWACMD, body)))
    401 
    402 typedef struct VBOXVHWA_RECTL
    403 {
    404     int32_t left;
    405     int32_t top;
    406     int32_t right;
    407     int32_t bottom;
    408 } VBOXVHWA_RECTL;
    409 
    410 typedef struct VBOXVHWA_COLORKEY
    411 {
    412     uint32_t low;
    413     uint32_t high;
    414 } VBOXVHWA_COLORKEY;
    415 
    416 typedef struct VBOXVHWA_PIXELFORMAT
    417 {
    418     uint32_t flags;
    419     uint32_t fourCC;
    420     union
    421     {
    422         uint32_t rgbBitCount;
    423         uint32_t yuvBitCount;
    424     } c;
    425 
    426     union
    427     {
    428         uint32_t rgbRBitMask;
    429         uint32_t yuvYBitMask;
    430     } m1;
    431 
    432     union
    433     {
    434         uint32_t rgbGBitMask;
    435         uint32_t yuvUBitMask;
    436     } m2;
    437 
    438     union
    439     {
    440         uint32_t rgbBBitMask;
    441         uint32_t yuvVBitMask;
    442     } m3;
    443 
    444     union
    445     {
    446         uint32_t rgbABitMask;
    447     } m4;
    448 
    449     uint32_t Reserved;
    450 } VBOXVHWA_PIXELFORMAT;
    451 
    452 typedef struct VBOXVHWA_SURFACEDESC
    453 {
    454     uint32_t flags;
    455     uint32_t height;
    456     uint32_t width;
    457     uint32_t pitch;
    458     uint32_t sizeX;
    459     uint32_t sizeY;
    460     uint32_t cBackBuffers;
    461     uint32_t Reserved;
    462     VBOXVHWA_COLORKEY DstOverlayCK;
    463     VBOXVHWA_COLORKEY DstBltCK;
    464     VBOXVHWA_COLORKEY SrcOverlayCK;
    465     VBOXVHWA_COLORKEY SrcBltCK;
    466     VBOXVHWA_PIXELFORMAT PixelFormat;
    467     uint32_t surfCaps;
    468     uint32_t Reserved2;
    469     VBOXVHWA_SURFHANDLE hSurf;
    470     uint64_t offSurface;
    471 } VBOXVHWA_SURFACEDESC;
    472 
    473 typedef struct VBOXVHWA_BLTFX
    474 {
    475     uint32_t flags;
    476     uint32_t rop;
    477     uint32_t rotationOp;
    478     uint32_t rotation;
    479     uint32_t fillColor;
    480     uint32_t Reserved;
    481     VBOXVHWA_COLORKEY DstCK;
    482     VBOXVHWA_COLORKEY SrcCK;
    483 } VBOXVHWA_BLTFX;
    484 
    485 typedef struct VBOXVHWA_OVERLAYFX
    486 {
    487     uint32_t flags;
    488     uint32_t Reserved1;
    489     uint32_t fxFlags;
    490     uint32_t Reserved2;
    491     VBOXVHWA_COLORKEY DstCK;
    492     VBOXVHWA_COLORKEY SrcCK;
    493 } VBOXVHWA_OVERLAYFX;
    494 
    495 #define VBOXVHWA_CAPS_BLT               0x00000040
    496 #define VBOXVHWA_CAPS_BLTCOLORFILL      0x04000000
    497 #define VBOXVHWA_CAPS_BLTFOURCC         0x00000100
    498 #define VBOXVHWA_CAPS_BLTSTRETCH        0x00000200
    499 #define VBOXVHWA_CAPS_BLTQUEUE          0x00000080
    500 
    501 #define VBOXVHWA_CAPS_OVERLAY           0x00000800
    502 #define VBOXVHWA_CAPS_OVERLAYFOURCC     0x00002000
    503 #define VBOXVHWA_CAPS_OVERLAYSTRETCH    0x00004000
    504 #define VBOXVHWA_CAPS_OVERLAYCANTCLIP   0x00001000
    505 
    506 #define VBOXVHWA_CAPS_COLORKEY          0x00400000
    507 #define VBOXVHWA_CAPS_COLORKEYHWASSIST  0x01000000
    508 
    509 #define VBOXVHWA_SCAPS_BACKBUFFER       0x00000004
    510 #define VBOXVHWA_SCAPS_COMPLEX          0x00000008
    511 #define VBOXVHWA_SCAPS_FLIP             0x00000010
    512 #define VBOXVHWA_SCAPS_FRONTBUFFER      0x00000020
    513 #define VBOXVHWA_SCAPS_OFFSCREENPLAIN   0x00000040
    514 #define VBOXVHWA_SCAPS_OVERLAY          0x00000080
    515 #define VBOXVHWA_SCAPS_PRIMARYSURFACE   0x00000200
    516 #define VBOXVHWA_SCAPS_SYSTEMMEMORY     0x00000800
    517 #define VBOXVHWA_SCAPS_VIDEOMEMORY      0x00004000
    518 #define VBOXVHWA_SCAPS_VISIBLE          0x00008000
    519 #define VBOXVHWA_SCAPS_LOCALVIDMEM      0x10000000
    520 
    521 #define VBOXVHWA_PF_PALETTEINDEXED8     0x00000020
    522 #define VBOXVHWA_PF_RGB                 0x00000040
    523 #define VBOXVHWA_PF_RGBTOYUV            0x00000100
    524 #define VBOXVHWA_PF_YUV                 0x00000200
    525 #define VBOXVHWA_PF_FOURCC              0x00000004
    526 
    527 #define VBOXVHWA_LOCK_DISCARDCONTENTS   0x00002000
    528 
    529 #define VBOXVHWA_CFG_ENABLED            0x00000001
    530 
    531 #define VBOXVHWA_SD_BACKBUFFERCOUNT     0x00000020
    532 #define VBOXVHWA_SD_CAPS                0x00000001
    533 #define VBOXVHWA_SD_CKDESTBLT           0x00004000
    534 #define VBOXVHWA_SD_CKDESTOVERLAY       0x00002000
    535 #define VBOXVHWA_SD_CKSRCBLT            0x00010000
    536 #define VBOXVHWA_SD_CKSRCOVERLAY        0x00008000
    537 #define VBOXVHWA_SD_HEIGHT              0x00000002
    538 #define VBOXVHWA_SD_PITCH               0x00000008
    539 #define VBOXVHWA_SD_PIXELFORMAT         0x00001000
    540 /*#define VBOXVHWA_SD_REFRESHRATE       0x00040000*/
    541 #define VBOXVHWA_SD_WIDTH               0x00000004
    542 
    543 #define VBOXVHWA_CKEYCAPS_DESTBLT                  0x00000001
    544 #define VBOXVHWA_CKEYCAPS_DESTBLTCLRSPACE          0x00000002
    545 #define VBOXVHWA_CKEYCAPS_DESTBLTCLRSPACEYUV       0x00000004
    546 #define VBOXVHWA_CKEYCAPS_DESTBLTYUV               0x00000008
    547 #define VBOXVHWA_CKEYCAPS_DESTOVERLAY              0x00000010
    548 #define VBOXVHWA_CKEYCAPS_DESTOVERLAYCLRSPACE      0x00000020
    549 #define VBOXVHWA_CKEYCAPS_DESTOVERLAYCLRSPACEYUV   0x00000040
    550 #define VBOXVHWA_CKEYCAPS_DESTOVERLAYONEACTIVE     0x00000080
    551 #define VBOXVHWA_CKEYCAPS_DESTOVERLAYYUV           0x00000100
    552 #define VBOXVHWA_CKEYCAPS_SRCBLT                   0x00000200
    553 #define VBOXVHWA_CKEYCAPS_SRCBLTCLRSPACE           0x00000400
    554 #define VBOXVHWA_CKEYCAPS_SRCBLTCLRSPACEYUV        0x00000800
    555 #define VBOXVHWA_CKEYCAPS_SRCBLTYUV                0x00001000
    556 #define VBOXVHWA_CKEYCAPS_SRCOVERLAY               0x00002000
    557 #define VBOXVHWA_CKEYCAPS_SRCOVERLAYCLRSPACE       0x00004000
    558 #define VBOXVHWA_CKEYCAPS_SRCOVERLAYCLRSPACEYUV    0x00008000
    559 #define VBOXVHWA_CKEYCAPS_SRCOVERLAYONEACTIVE      0x00010000
    560 #define VBOXVHWA_CKEYCAPS_SRCOVERLAYYUV            0x00020000
    561 #define VBOXVHWA_CKEYCAPS_NOCOSTOVERLAY            0x00040000
    562 
    563 #define VBOXVHWA_BLT_COLORFILL                      0x00000400
    564 #define VBOXVHWA_BLT_DDFX                           0x00000800
    565 #define VBOXVHWA_BLT_EXTENDED_FLAGS                 0x40000000
    566 #define VBOXVHWA_BLT_EXTENDED_LINEAR_CONTENT        0x00000004
    567 #define VBOXVHWA_BLT_EXTENDED_PRESENTATION_STRETCHFACTOR 0x00000010
    568 #define VBOXVHWA_BLT_KEYDESTOVERRIDE                0x00004000
    569 #define VBOXVHWA_BLT_KEYSRCOVERRIDE                 0x00010000
    570 #define VBOXVHWA_BLT_LAST_PRESENTATION              0x20000000
    571 #define VBOXVHWA_BLT_PRESENTATION                   0x10000000
    572 #define VBOXVHWA_BLT_ROP                            0x00020000
    573 
    574 
    575 #define VBOXVHWA_OVER_DDFX                          0x00080000
    576 #define VBOXVHWA_OVER_HIDE                          0x00000200
    577 #define VBOXVHWA_OVER_KEYDEST                       0x00000400
    578 #define VBOXVHWA_OVER_KEYDESTOVERRIDE               0x00000800
    579 #define VBOXVHWA_OVER_KEYSRC                        0x00001000
    580 #define VBOXVHWA_OVER_KEYSRCOVERRIDE                0x00002000
    581 #define VBOXVHWA_OVER_SHOW                          0x00004000
    582 
    583 #define VBOXVHWA_CKEY_COLORSPACE                    0x00000001
    584 #define VBOXVHWA_CKEY_DESTBLT                       0x00000002
    585 #define VBOXVHWA_CKEY_DESTOVERLAY                   0x00000004
    586 #define VBOXVHWA_CKEY_SRCBLT                        0x00000008
    587 #define VBOXVHWA_CKEY_SRCOVERLAY                    0x00000010
    588 
    589 #define VBOXVHWA_BLT_ARITHSTRETCHY                  0x00000001
    590 #define VBOXVHWA_BLT_MIRRORLEFTRIGHT                0x00000002
    591 #define VBOXVHWA_BLT_MIRRORUPDOWN                   0x00000004
    592 
    593 #define VBOXVHWA_OVERFX_ARITHSTRETCHY               0x00000001
    594 #define VBOXVHWA_OVERFX_MIRRORLEFTRIGHT             0x00000002
    595 #define VBOXVHWA_OVERFX_MIRRORUPDOWN                0x00000004
    596 
    597 #define VBOXVHWA_CAPS2_CANRENDERWINDOWED            0x00080000
    598 #define VBOXVHWA_CAPS2_WIDESURFACES                 0x00001000
    599 #define VBOXVHWA_CAPS2_COPYFOURCC                   0x00008000
    600 /*#define VBOXVHWA_CAPS2_FLIPINTERVAL                 0x00200000*/
    601 /*#define VBOXVHWA_CAPS2_FLIPNOVSYNC                  0x00400000*/
    602 
    603 
    604 #define VBOXVHWA_OFFSET64_VOID        (UINT64_MAX)
    605 
    606 typedef struct VBOXVHWA_VERSION
    607 {
    608     uint32_t maj;
    609     uint32_t min;
    610     uint32_t bld;
    611     uint32_t reserved;
    612 } VBOXVHWA_VERSION;
    613 
    614 #define VBOXVHWA_VERSION_INIT(_pv) do { \
    615         (_pv)->maj = VBOXVHWA_VERSION_MAJ; \
    616         (_pv)->min = VBOXVHWA_VERSION_MIN; \
    617         (_pv)->bld = VBOXVHWA_VERSION_BLD; \
    618         (_pv)->reserved = VBOXVHWA_VERSION_RSV; \
    619         } while(0)
    620 
    621 typedef struct VBOXVHWACMD_QUERYINFO1
    622 {
    623     union
    624     {
    625         struct
    626         {
    627             VBOXVHWA_VERSION guestVersion;
    628         } in;
    629 
    630         struct
    631         {
    632             uint32_t cfgFlags;
    633             uint32_t caps;
    634 
    635             uint32_t caps2;
    636             uint32_t colorKeyCaps;
    637 
    638             uint32_t stretchCaps;
    639             uint32_t surfaceCaps;
    640 
    641             uint32_t numOverlays;
    642             uint32_t curOverlays;
    643 
    644             uint32_t numFourCC;
    645             uint32_t reserved;
    646         } out;
    647     } u;
    648 } VBOXVHWACMD_QUERYINFO1;
    649 
    650 typedef struct VBOXVHWACMD_QUERYINFO2
    651 {
    652     uint32_t numFourCC;
    653     uint32_t FourCC[1];
    654 } VBOXVHWACMD_QUERYINFO2;
    655 
    656 #define VBOXVHWAINFO2_SIZE(_cFourCC) RT_UOFFSETOF_DYN(VBOXVHWACMD_QUERYINFO2, FourCC[_cFourCC])
    657 
    658 typedef struct VBOXVHWACMD_SURF_CANCREATE
    659 {
    660     VBOXVHWA_SURFACEDESC SurfInfo;
    661     union
    662     {
    663         struct
    664         {
    665             uint32_t bIsDifferentPixelFormat;
    666             uint32_t Reserved;
    667         } in;
    668 
    669         struct
    670         {
    671             int32_t ErrInfo;
    672         } out;
    673     } u;
    674 } VBOXVHWACMD_SURF_CANCREATE;
    675 
    676 typedef struct VBOXVHWACMD_SURF_CREATE
    677 {
    678     VBOXVHWA_SURFACEDESC SurfInfo;
    679 } VBOXVHWACMD_SURF_CREATE;
    680 
    681 #ifdef VBOX_WITH_WDDM
    682 typedef struct VBOXVHWACMD_SURF_GETINFO
    683 {
    684     VBOXVHWA_SURFACEDESC SurfInfo;
    685 } VBOXVHWACMD_SURF_GETINFO;
    686 #endif
    687 
    688 typedef struct VBOXVHWACMD_SURF_DESTROY
    689 {
    690     union
    691     {
    692         struct
    693         {
    694             VBOXVHWA_SURFHANDLE hSurf;
    695         } in;
    696     } u;
    697 } VBOXVHWACMD_SURF_DESTROY;
    698 
    699 typedef struct VBOXVHWACMD_SURF_LOCK
    700 {
    701     union
    702     {
    703         struct
    704         {
    705             VBOXVHWA_SURFHANDLE hSurf;
    706             uint64_t offSurface;
    707             uint32_t flags;
    708             uint32_t rectValid;
    709             VBOXVHWA_RECTL rect;
    710         } in;
    711     } u;
    712 } VBOXVHWACMD_SURF_LOCK;
    713 
    714 typedef struct VBOXVHWACMD_SURF_UNLOCK
    715 {
    716     union
    717     {
    718         struct
    719         {
    720             VBOXVHWA_SURFHANDLE hSurf;
    721             uint32_t xUpdatedMemValid;
    722             uint32_t reserved;
    723             VBOXVHWA_RECTL xUpdatedMemRect;
    724         } in;
    725     } u;
    726 } VBOXVHWACMD_SURF_UNLOCK;
    727 
    728 typedef struct VBOXVHWACMD_SURF_BLT
    729 {
    730     uint64_t DstGuestSurfInfo;
    731     uint64_t SrcGuestSurfInfo;
    732     union
    733     {
    734         struct
    735         {
    736             VBOXVHWA_SURFHANDLE hDstSurf;
    737             uint64_t offDstSurface;
    738             VBOXVHWA_RECTL dstRect;
    739             VBOXVHWA_SURFHANDLE hSrcSurf;
    740             uint64_t offSrcSurface;
    741             VBOXVHWA_RECTL srcRect;
    742             uint32_t flags;
    743             uint32_t xUpdatedSrcMemValid;
    744             VBOXVHWA_BLTFX desc;
    745             VBOXVHWA_RECTL xUpdatedSrcMemRect;
    746         } in;
    747     } u;
    748 } VBOXVHWACMD_SURF_BLT;
    749 
    750 #ifdef VBOX_WITH_WDDM
    751 typedef struct VBOXVHWACMD_SURF_COLORFILL
    752 {
    753     union
    754     {
    755         struct
    756         {
    757             VBOXVHWA_SURFHANDLE hSurf;
    758             uint64_t offSurface;
    759             uint32_t u32Reserved;
    760             uint32_t cRects;
    761             VBOXVHWA_RECTL aRects[1];
    762         } in;
    763     } u;
    764 } VBOXVHWACMD_SURF_COLORFILL;
    765 #endif
    766 
    767 typedef struct VBOXVHWACMD_SURF_FLIP
    768 {
    769     uint64_t TargGuestSurfInfo;
    770     uint64_t CurrGuestSurfInfo;
    771     union
    772     {
    773         struct
    774         {
    775             VBOXVHWA_SURFHANDLE hTargSurf;
    776             uint64_t offTargSurface;
    777             VBOXVHWA_SURFHANDLE hCurrSurf;
    778             uint64_t offCurrSurface;
    779             uint32_t flags;
    780             uint32_t xUpdatedTargMemValid;
    781             VBOXVHWA_RECTL xUpdatedTargMemRect;
    782         } in;
    783     } u;
    784 } VBOXVHWACMD_SURF_FLIP;
    785 
    786 typedef struct VBOXVHWACMD_SURF_COLORKEY_SET
    787 {
    788     union
    789     {
    790         struct
    791         {
    792             VBOXVHWA_SURFHANDLE hSurf;
    793             uint64_t offSurface;
    794             VBOXVHWA_COLORKEY CKey;
    795             uint32_t flags;
    796             uint32_t reserved;
    797         } in;
    798     } u;
    799 } VBOXVHWACMD_SURF_COLORKEY_SET;
    800 
    801 #define VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_SRCMEMRECT 0x00000001
    802 #define VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_DSTMEMRECT 0x00000002
    803 
    804 typedef struct VBOXVHWACMD_SURF_OVERLAY_UPDATE
    805 {
    806     union
    807     {
    808         struct
    809         {
    810             VBOXVHWA_SURFHANDLE hDstSurf;
    811             uint64_t offDstSurface;
    812             VBOXVHWA_RECTL dstRect;
    813             VBOXVHWA_SURFHANDLE hSrcSurf;
    814             uint64_t offSrcSurface;
    815             VBOXVHWA_RECTL srcRect;
    816             uint32_t flags;
    817             uint32_t xFlags;
    818             VBOXVHWA_OVERLAYFX desc;
    819             VBOXVHWA_RECTL xUpdatedSrcMemRect;
    820             VBOXVHWA_RECTL xUpdatedDstMemRect;
    821         } in;
    822     } u;
    823 }VBOXVHWACMD_SURF_OVERLAY_UPDATE;
    824 
    825 typedef struct VBOXVHWACMD_SURF_OVERLAY_SETPOSITION
    826 {
    827     union
    828     {
    829         struct
    830         {
    831             VBOXVHWA_SURFHANDLE hDstSurf;
    832             uint64_t offDstSurface;
    833             VBOXVHWA_SURFHANDLE hSrcSurf;
    834             uint64_t offSrcSurface;
    835             uint32_t xPos;
    836             uint32_t yPos;
    837             uint32_t flags;
    838             uint32_t reserved;
    839         } in;
    840     } u;
    841 } VBOXVHWACMD_SURF_OVERLAY_SETPOSITION;
    842 
    843 typedef struct VBOXVHWACMD_HH_CONSTRUCT
    844 {
    845     void    *pVM;
    846     /* VRAM info for the backend to be able to properly translate VRAM offsets */
    847     void    *pvVRAM;
    848     uint32_t cbVRAM;
    849 } VBOXVHWACMD_HH_CONSTRUCT;
    850 
    851 typedef struct VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM
    852 {
    853     struct SSMHANDLE * pSSM;
    854 } VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM;
    855 
    856 typedef struct VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM
    857 {
    858     struct SSMHANDLE * pSSM;
    859 } VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM;
    860 
    861 typedef DECLCALLBACKTYPE(void, FNVBOXVHWA_HH_CALLBACK,(void *));
    862 typedef FNVBOXVHWA_HH_CALLBACK *PFNVBOXVHWA_HH_CALLBACK;
    863 
    864 #define VBOXVHWA_HH_CALLBACK_SET(_pCmd, _pfn, _parg) \
    865     do { \
    866         (_pCmd)->GuestVBVAReserved1 = (uint64_t)(uintptr_t)(_pfn); \
    867         (_pCmd)->GuestVBVAReserved2 = (uint64_t)(uintptr_t)(_parg); \
    868     }while(0)
    869 
    870 #define VBOXVHWA_HH_CALLBACK_GET(_pCmd) ((PFNVBOXVHWA_HH_CALLBACK)(_pCmd)->GuestVBVAReserved1)
    871 #define VBOXVHWA_HH_CALLBACK_GET_ARG(_pCmd) ((void*)(_pCmd)->GuestVBVAReserved2)
    872 
    873 #pragma pack()
    874 #endif /* #ifdef VBOX_WITH_VIDEOHWACCEL */
    875 
    876314/* All structures are without alignment. */
    877315#pragma pack(1)
    … …  
    917355#define VBVA_ENABLE       7
    918356#define VBVA_MOUSE_POINTER_SHAPE 8
    919 #ifdef VBOX_WITH_VIDEOHWACCEL
    920 # define VBVA_VHWA_CMD    9
    921 #endif /* # ifdef VBOX_WITH_VIDEOHWACCEL */
    922357#ifdef VBOX_WITH_VDMA
    923358# define VBVA_VDMA_CTL   10 /* setup G<->H DMA channel info */
    … …  
    943378#define VBVAHG_SHGSMI_COMPLETION  3
    944379#endif
    945 
    946 #ifdef VBOX_WITH_VIDEOHWACCEL
    947 #define VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE 1
    948 #pragma pack(1)
    949 typedef struct VBVAHOSTCMDVHWACMDCOMPLETE
    950 {
    951     uint32_t offCmd;
    952 }VBVAHOSTCMDVHWACMDCOMPLETE;
    953 #pragma pack()
    954 #endif /* # ifdef VBOX_WITH_VIDEOHWACCEL */
    955380
    956381#pragma pack(1)

  • trunk/include/VBox/vmm/pdmifs.h

    r106061 r108641  
    803803/** Pointer to a 3D graphics notification. */
    804804typedef struct VBOX3DNOTIFY VBOX3DNOTIFY;
    805 /** Pointer to a 2D graphics acceleration command. */
    806 typedef struct VBOXVHWACMD VBOXVHWACMD;
    807805/** Pointer to a VBVA command header. */
    808806typedef struct VBVACMDHDR *PVBVACMDHDR;
    … …  
    920918     */
    921919    DECLR3CALLBACKMEMBER(void, pfnProcessDisplayData,(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, unsigned uScreenId));
    922 
    923     /**
    924      * Process the guest Video HW Acceleration command.
    925      *
    926      * @param   pInterface          Pointer to this interface.
    927      * @param   enmCmd              The command type (don't re-read from pCmd).
    928      * @param   fGuestCmd           Set if the command origins with the guest and
    929      *                              pCmd must be considered volatile.
    930      * @param   pCmd                Video HW Acceleration Command to be processed.
    931      * @retval  VINF_SUCCESS - command is completed,
    932      * @retval  VINF_CALLBACK_RETURN if command will by asynchronously completed via
    933      *          complete callback.
    934      * @retval  VERR_INVALID_STATE if the command could not be processed (most
    935      *          likely because the framebuffer was disconnected) - the post should
    936      *          be retried later.
    937      * @thread  EMT
    938      */
    939     DECLR3CALLBACKMEMBER(int, pfnVHWACommandProcess,(PPDMIDISPLAYCONNECTOR pInterface, int enmCmd, bool fGuestCmd,
    940                                                      VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd));
    941920
    942921    /**
    … …  
    22892268#endif /* VBOX_WITH_HGCM */
    22902269
    2291 
    2292 /** Pointer to a display VBVA callbacks interface. */
    2293 typedef struct PDMIDISPLAYVBVACALLBACKS *PPDMIDISPLAYVBVACALLBACKS;
    2294 /**
    2295  * Display VBVA callbacks interface (up).
    2296  */
    2297 typedef struct PDMIDISPLAYVBVACALLBACKS
    2298 {
    2299 
    2300     /**
    2301      * Informs guest about completion of processing the given Video HW Acceleration
    2302      * command, does not wait for the guest to process the command.
    2303      *
    2304      * @returns ???
    2305      * @param   pInterface          Pointer to this interface.
    2306      * @param   pCmd                The Video HW Acceleration Command that was
    2307      *                              completed.
    2308      */
    2309     DECLR3CALLBACKMEMBER(int, pfnVHWACommandCompleteAsync,(PPDMIDISPLAYVBVACALLBACKS pInterface,
    2310                                                            VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd));
    2311 } PDMIDISPLAYVBVACALLBACKS;
    2312 /** PDMIDISPLAYVBVACALLBACKS  */
    2313 #define PDMIDISPLAYVBVACALLBACKS_IID            "37f34c9c-0491-47dc-a0b3-81697c44a416"
    2314 
    23152270/** Pointer to a PCI raw connector interface. */
    23162271typedef struct PDMIPCIRAWCONNECTOR *PPDMIPCIRAWCONNECTOR;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h

    r106061 r108641  
    673673    uint32_t            u32AdapterCaps;  /* VBOXWDDM_QAI_CAP_* */
    674674    uint32_t            cInfos;          /* Number of initialized elements in aInfos (equal to number of guest
    675                                           * displays). 0 if VBOX_WITH_VIDEOHWACCEL is not defined. */
     675                                          * displays). Always 0 currently. */
    676676    VBOXVHWA_INFO       aInfos[VBOX_VIDEO_MAX_SCREENS]; /* cInfos elements are initialized. */
    677677    union

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/common/xpdm/VBoxVideoIOCTL.h

    r106061 r108641  
    156156} HGSMIHANDLERENABLE;
    157157
    158 #ifdef VBOX_WITH_VIDEOHWACCEL
    159 /* Data returned by IOCTL_VIDEO_VHWA_QUERY_INFO. */
    160 typedef struct _VHWAQUERYINFO
    161 {
    162     ULONG_PTR offVramBase;
    163 } VHWAQUERYINFO;
    164 #endif
    165158#pragma pack()
    166159

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/Makefile.kmk

    r107086 r108641  
    4848 VBoxDisp_DEFS          = VBOX_WITH_DDRAW
    4949 VBoxDisp_DEFS         += LOG_TO_BACKDOOR #LOG_ENABLED
    50  ifdef VBOX_WITH_VIDEOHWACCEL
    51   VBoxDisp_DEFS        += VBOX_WITH_VIDEOHWACCEL
    52  endif
    5350 #VBoxDisp_DEFS         += VBOX_VBVA_ADJUST_RECT
    5451 VBoxDisp_INCS          = \
    … …  
    7774        $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/VBVABase.cpp \
    7875        $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/Modesetting.cpp
    79  ifdef VBOX_WITH_VIDEOHWACCEL
    80   VBoxDisp_SOURCES += \
    81         xpdm/VBoxDispVHWA.cpp \
    82         xpdm/VBoxDispDDrawVHWA.cpp
    83  endif
    8476
    8577 VBoxDisp_LIBS = \
    … …  
    123115 ifdef VBOXWDDM_WITH_VBVA
    124116  VBoxDispD3D_DEFS  += VBOXWDDM_WITH_VBVA
    125  endif
    126  ifdef VBOX_WITH_VIDEOHWACCEL
    127   VBoxDispD3D_DEFS  += VBOX_WITH_VIDEOHWACCEL
    128117 endif
    129118 # Avoid "src\VBox\Additions\3D\mesa\mesa-21.3.8\include\c99_compat.h(99): warning C4668: '__STDC_VERSION__'

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp

    r106582 r108641  
    106106                                   PVBOXWDDMDISP_ADAPTER *ppAdapter)
    107107{
    108 #ifdef VBOX_WITH_VIDEOHWACCEL
    109     Assert(pAdapterInfo->cInfos >= 1);
    110     PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_UOFFSETOF_DYN(VBOXWDDMDISP_ADAPTER,
    111                                                                                          aHeads[pAdapterInfo->cInfos]));
    112 #else
    113108    Assert(pAdapterInfo->cInfos == 0);
    114109    PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof(VBOXWDDMDISP_ADAPTER));
    115 #endif
    116     AssertReturn(pAdapter, E_OUTOFMEMORY);
     110    AssertPtrReturn(pAdapter, E_OUTOFMEMORY);
    117111
    118112    pAdapter->hAdapter    = pOpenData->hAdapter;
    … …  
    126120    pAdapter->f3D         =    RT_BOOL(pAdapterInfo->u32AdapterCaps & VBOXWDDM_QAI_CAP_3D)
    127121                            && !vboxDispIsDDraw(pOpenData);
    128 #ifdef VBOX_WITH_VIDEOHWACCEL
    129     pAdapter->cHeads      = pAdapterInfo->cInfos;
    130     for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
    131         pAdapter->aHeads[i].Vhwa.Settings = pAdapterInfo->aInfos[i];
    132 #endif
    133122
    134123    *ppAdapter = pAdapter;
    … …  
    163152                    WARN(("VBoxDispD3DOpen failed, hr (%d)", hr));
    164153            }
    165 #ifdef VBOX_WITH_VIDEOHWACCEL
    166             else
    167             {
    168                 /* 2D adapter. */
    169                 hr = VBoxDispD3DGlobal2DFormatsInit(pAdapter);
    170                 if (FAILED(hr))
    171                     WARN(("VBoxDispD3DGlobal2DFormatsInit failed hr 0x%x", hr));
    172             }
    173 #endif
    174154        }
    175155    }

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.h

    r106061 r108641  
    5656#define VBOXWDDMDISP_IS_TEXTURE(_f) ((_f).Texture || (_f).Value == 0)
    5757
    58 #ifdef VBOX_WITH_VIDEOHWACCEL
    59 typedef struct VBOXDISPVHWA_INFO
    60 {
    61     VBOXVHWA_INFO Settings;
    62 }VBOXDISPVHWA_INFO;
    63 
    64 /* represents settings secific to
    65  * display device (head) on the multiple-head graphics card
    66  * currently used for 2D (overlay) only since in theory its settings
    67  * can differ per each frontend's framebuffer. */
    68 typedef struct VBOXWDDMDISP_HEAD
    69 {
    70     VBOXDISPVHWA_INFO Vhwa;
    71 } VBOXWDDMDISP_HEAD;
    72 #endif
    73 
    7458typedef struct VBOXWDDMDISP_ADAPTER
    7559{
    … …  
    8973    VBOXWDDM_QAI AdapterInfo;
    9074
    91 #ifdef VBOX_WITH_VIDEOHWACCEL
    92     uint32_t cHeads;
    93     VBOXWDDMDISP_HEAD aHeads[1];
    94 #endif
    9575} VBOXWDDMDISP_ADAPTER, *PVBOXWDDMDISP_ADAPTER;
    9676

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.cpp

    r106061 r108641  
    320320        },
    321321};
    322 
    323 #ifdef VBOX_WITH_VIDEOHWACCEL
    324 
    325 static void vboxVhwaPopulateOverlayFourccSurfDesc(DDSURFACEDESC *pDesc, uint32_t fourcc)
    326 {
    327     memset(pDesc, 0, sizeof (DDSURFACEDESC));
    328 
    329     pDesc->dwSize = sizeof (DDSURFACEDESC);
    330     pDesc->dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT;
    331     pDesc->ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
    332     pDesc->ddpfPixelFormat.dwFlags = DDPF_FOURCC;
    333     pDesc->ddpfPixelFormat.dwFourCC = fourcc;
    334     pDesc->ddsCaps.dwCaps = DDSCAPS_BACKBUFFER
    335             | DDSCAPS_COMPLEX
    336             | DDSCAPS_FLIP
    337             | DDSCAPS_FRONTBUFFER
    338             | DDSCAPS_LOCALVIDMEM
    339             | DDSCAPS_OVERLAY
    340             | DDSCAPS_VIDEOMEMORY
    341             | DDSCAPS_VISIBLE;
    342 }
    343 
    344 static bool vboxPixFormatMatch(DDPIXELFORMAT *pFormat1, DDPIXELFORMAT *pFormat2)
    345 {
    346     return !memcmp(pFormat1, pFormat2, sizeof (DDPIXELFORMAT));
    347 }
    348 
    349 HRESULT vboxSurfDescMerge(DDSURFACEDESC *paDescs, uint32_t *pcDescs, uint32_t cMaxDescs, DDSURFACEDESC *pDesc)
    350 {
    351     uint32_t cDescs = *pcDescs;
    352 
    353     Assert(cMaxDescs >= cDescs);
    354     Assert(pDesc->dwFlags == (DDSD_CAPS | DDSD_PIXELFORMAT));
    355     if (pDesc->dwFlags != (DDSD_CAPS | DDSD_PIXELFORMAT))
    356         return E_INVALIDARG;
    357 
    358     for (uint32_t i = 0; i < cDescs; ++i)
    359     {
    360         DDSURFACEDESC *pCur = &paDescs[i];
    361         if (vboxPixFormatMatch(&pCur->ddpfPixelFormat, &pDesc->ddpfPixelFormat))
    362         {
    363             if (pDesc->dwFlags & DDSD_CAPS)
    364             {
    365                 pCur->dwFlags |= DDSD_CAPS;
    366                 pCur->ddsCaps.dwCaps |= pDesc->ddsCaps.dwCaps;
    367             }
    368             return S_OK;
    369         }
    370     }
    371 
    372     if (cMaxDescs > cDescs)
    373     {
    374         paDescs[cDescs] = *pDesc;
    375         ++cDescs;
    376         *pcDescs = cDescs;
    377         return VINF_SUCCESS;
    378     }
    379     return E_FAIL;
    380 }
    381 
    382 HRESULT vboxFormatOpsMerge(FORMATOP *paOps, uint32_t *pcOps, uint32_t cMaxOps, FORMATOP *pOp)
    383 {
    384     uint32_t cOps = *pcOps;
    385 
    386     Assert(cMaxOps >= cOps);
    387 
    388     for (uint32_t i = 0; i < cOps; ++i)
    389     {
    390         FORMATOP *pCur = &paOps[i];
    391         if (pCur->Format == pOp->Format)
    392         {
    393             pCur->Operations |= pOp->Operations;
    394             Assert(pCur->FlipMsTypes == pOp->FlipMsTypes);
    395             Assert(pCur->BltMsTypes == pOp->BltMsTypes);
    396             Assert(pCur->PrivateFormatBitCount == pOp->PrivateFormatBitCount);
    397             return S_OK;
    398         }
    399     }
    400 
    401     if (cMaxOps > cOps)
    402     {
    403         paOps[cOps] = *pOp;
    404         ++cOps;
    405         *pcOps = cOps;
    406         return VINF_SUCCESS;
    407     }
    408     return E_FAIL;
    409 }
    410 
    411 HRESULT VBoxDispD3DGlobal2DFormatsInit(PVBOXWDDMDISP_ADAPTER pAdapter)
    412 {
    413     HRESULT hr = S_OK;
    414     memset(&pAdapter->D3D, 0, sizeof (pAdapter->D3D));
    415     memset(&pAdapter->Formats, 0, sizeof (pAdapter->Formats));
    416 
    417     /* just calc the max number of formats */
    418     uint32_t cFormats = RT_ELEMENTS(gVBoxFormatOpsBase);
    419     uint32_t cSurfDescs = RT_ELEMENTS(gVBoxSurfDescsBase);
    420     uint32_t cOverlayFormats = 0;
    421     for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
    422     {
    423         VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
    424         if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
    425         {
    426             cOverlayFormats += pVhwa->Settings.cFormats;
    427         }
    428     }
    429 
    430     cFormats += cOverlayFormats;
    431     cSurfDescs += cOverlayFormats;
    432 
    433     uint32_t cbFormatOps = cFormats * sizeof (FORMATOP);
    434     cbFormatOps = (cbFormatOps + 7) & ~3;
    435     /* ensure the surf descs are 8 byte aligned */
    436     uint32_t offSurfDescs = (cbFormatOps + 7) & ~3;
    437     uint32_t cbSurfDescs = cSurfDescs * sizeof (DDSURFACEDESC);
    438     uint32_t cbBuf = offSurfDescs + cbSurfDescs;
    439     uint8_t* pvBuf = (uint8_t*)RTMemAllocZ(cbBuf);
    440     if (pvBuf)
    441     {
    442         pAdapter->Formats.paFormatOps = (FORMATOP*)pvBuf;
    443         memcpy ((void*)pAdapter->Formats.paFormatOps , gVBoxFormatOpsBase, sizeof (gVBoxFormatOpsBase));
    444         pAdapter->Formats.cFormatOps = RT_ELEMENTS(gVBoxFormatOpsBase);
    445 
    446         FORMATOP fo = {D3DDDIFMT_UNKNOWN, 0, 0, 0, 0};
    447         for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
    448         {
    449             VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
    450             if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
    451             {
    452                 for (uint32_t j = 0; j < pVhwa->Settings.cFormats; ++j)
    453                 {
    454                     fo.Format = pVhwa->Settings.aFormats[j];
    455                     fo.Operations = FORMATOP_OVERLAY;
    456                     hr = vboxFormatOpsMerge((FORMATOP *)pAdapter->Formats.paFormatOps, &pAdapter->Formats.cFormatOps, cFormats, &fo);
    457                     if (FAILED(hr))
    458                     {
    459                         WARN(("vboxFormatOpsMerge failed, hr 0x%x", hr));
    460                     }
    461                 }
    462             }
    463         }
    464 
    465         pAdapter->Formats.paSurfDescs = (DDSURFACEDESC*)(pvBuf + offSurfDescs);
    466         memcpy ((void*)pAdapter->Formats.paSurfDescs , gVBoxSurfDescsBase, sizeof (gVBoxSurfDescsBase));
    467         pAdapter->Formats.cSurfDescs = RT_ELEMENTS(gVBoxSurfDescsBase);
    468 
    469         DDSURFACEDESC sd;
    470         for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
    471         {
    472             VBOXDISPVHWA_INFO *pVhwa = &pAdapter->aHeads[i].Vhwa;
    473             if (pVhwa->Settings.fFlags & VBOXVHWA_F_ENABLED)
    474             {
    475                 for (uint32_t j = 0; j < pVhwa->Settings.cFormats; ++j)
    476                 {
    477                     uint32_t fourcc = vboxWddmFormatToFourcc(pVhwa->Settings.aFormats[j]);
    478                     if (fourcc)
    479                     {
    480                         vboxVhwaPopulateOverlayFourccSurfDesc(&sd, fourcc);
    481                         hr = vboxSurfDescMerge((DDSURFACEDESC *)pAdapter->Formats.paSurfDescs, &pAdapter->Formats.cSurfDescs, cSurfDescs, &sd);
    482                         if (FAILED(hr))
    483                         {
    484                             WARN(("vboxFormatOpsMerge failed, hr 0x%x", hr));
    485                         }
    486                     }
    487                 }
    488             }
    489         }
    490     }
    491     else
    492     {
    493         WARN(("RTMemAllocZ failed"));
    494         return E_FAIL;
    495     }
    496     return S_OK;
    497 }
    498 
    499 void VBoxDispD3DGlobal2DFormatsTerm(PVBOXWDDMDISP_ADAPTER pAdapter)
    500 {
    501     if (pAdapter->Formats.paFormatOps)
    502     {
    503         RTMemFree((void *)pAdapter->Formats.paFormatOps);
    504         pAdapter->Formats.paFormatOps = NULL;
    505     }
    506 }
    507 
    508 #endif
    509322
    510323static CRITICAL_SECTION g_VBoxDispD3DGlobalCritSect;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.h

    r106061 r108641  
    7373void VBoxDispD3DGlobalClose(PVBOXWDDMDISP_D3D pD3D, PVBOXWDDMDISP_FORMATS pFormats);
    7474
    75 #ifdef VBOX_WITH_VIDEOHWACCEL
    76 HRESULT VBoxDispD3DGlobal2DFormatsInit(struct VBOXWDDMDISP_ADAPTER *pAdapter);
    77 void VBoxDispD3DGlobal2DFormatsTerm(struct VBOXWDDMDISP_ADAPTER *pAdapter);
    78 #endif
    79 
    8075#ifdef DEBUG
    8176void vboxDispCheckCapsLevel(const D3DCAPS9 *pCaps);

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDdi.cpp

    r106507 r108641  
    49464946        VBoxDispD3DGlobalClose(&pAdapter->D3D, &pAdapter->Formats);
    49474947    }
    4948 #ifdef VBOX_WITH_VIDEOHWACCEL
    4949     else
    4950     {
    4951         VBoxDispD3DGlobal2DFormatsTerm(pAdapter);
    4952     }
    4953 #endif
    49544948
    49554949    RTMemFree(pAdapter);
    … …  
    49654959};
    49664960
    4967 #ifdef VBOX_WITH_VIDEOHWACCEL
    4968 static bool vboxVhwaHasCKeying(PVBOXWDDMDISP_ADAPTER pAdapter)
    4969 {
    4970     for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
    4971     {
    4972         VBOXVHWA_INFO* pSettings = &pAdapter->aHeads[i].Vhwa.Settings;
    4973         if (   (pSettings->fFlags & VBOXVHWA_F_ENABLED)
    4974             && (   (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
    4975                 || (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)))
    4976             return true;
    4977     }
    4978     return false;
    4979 }
    4980 #endif
    4981 
    49824961HRESULT APIENTRY GaDdiAdapterGetCaps(HANDLE hAdapter, const D3DDDIARG_GETCAPS *pData)
    49834962{
    … …  
    49964975            Assert(pData->DataSize == sizeof(DDRAW_CAPS));
    49974976            if (pData->DataSize >= sizeof(DDRAW_CAPS))
    4998             {
    49994977                memset(pData->pData, 0, sizeof(DDRAW_CAPS));
    5000 #ifdef VBOX_WITH_VIDEOHWACCEL
    5001                 if (!VBOXDISPMODE_IS_3D(pAdapter))
    5002                 {
    5003                     if (vboxVhwaHasCKeying(pAdapter))
    5004                     {
    5005                         DDRAW_CAPS *pCaps = (DDRAW_CAPS*)pData->pData;
    5006                         pCaps->Caps |= DDRAW_CAPS_COLORKEY;
    5007 //                        pCaps->Caps2 |= DDRAW_CAPS2_FLIPNOVSYNC;
    5008                     }
    5009                 }
    5010                 else
    5011                 {
    5012                     WARN(("D3DDDICAPS_DDRAW query for D3D mode!"));
    5013                 }
    5014 #endif
    5015             }
    50164978            else
    50174979                hr = E_INVALIDARG;
    … …  
    50284990                /* Do not overwrite the first "Head" field, zero starting with the one following "Head", i.e. Caps. */
    50294991                memset(&pCaps->Caps, 0, sizeof(DDRAW_MODE_SPECIFIC_CAPS) - RT_UOFFSETOF(DDRAW_MODE_SPECIFIC_CAPS, Caps));
    5030 #ifdef VBOX_WITH_VIDEOHWACCEL
    5031                 if (!VBOXDISPMODE_IS_3D(pAdapter))
    5032                 {
    5033                     VBOXVHWA_INFO *pSettings = &pAdapter->aHeads[pCaps->Head].Vhwa.Settings;
    5034                     if (pSettings->fFlags & VBOXVHWA_F_ENABLED)
    5035                     {
    5036                         pCaps->Caps |= MODE_CAPS_OVERLAY | MODE_CAPS_OVERLAYSTRETCH;
    5037 
    5038                         if (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
    5039                         {
    5040                             pCaps->CKeyCaps |= MODE_CKEYCAPS_DESTOVERLAY
    5041                                     | MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */
    5042                                     ;
    5043                         }
    5044 
    5045                         if (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)
    5046                         {
    5047                             pCaps->CKeyCaps |= MODE_CKEYCAPS_SRCOVERLAY
    5048                                     | MODE_CKEYCAPS_SRCOVERLAYCLRSPACE /* ?? */
    5049                                     | MODE_CKEYCAPS_SRCOVERLAYCLRSPACEYUV /* ?? */
    5050                                     | MODE_CKEYCAPS_SRCOVERLAYYUV /* ?? */
    5051                                     ;
    5052                         }
    5053 
    5054                         pCaps->FxCaps = MODE_FXCAPS_OVERLAYSHRINKX
    5055                                 | MODE_FXCAPS_OVERLAYSHRINKY
    5056                                 | MODE_FXCAPS_OVERLAYSTRETCHX
    5057                                 | MODE_FXCAPS_OVERLAYSTRETCHY;
    5058 
    5059 
    5060                         pCaps->MaxVisibleOverlays = pSettings->cOverlaysSupported;
    5061                         pCaps->MinOverlayStretch = 1;
    5062                         pCaps->MaxOverlayStretch = 32000;
    5063                     }
    5064                 }
    5065                 else
    5066                 {
    5067                     WARN(("D3DDDICAPS_DDRAW_MODE_SPECIFIC query for D3D mode!"));
    5068                 }
    5069 #endif
    50704992            }
    50714993            else

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDisp.h

    r106061 r108641  
    142142#ifdef VBOX_WITH_DDRAW
    143143    VBOXDDLOCKINFO ddpsLock;                 /* Primary surface DirectDraw lock information */
    144 #endif
    145 
    146 #ifdef VBOX_WITH_VIDEOHWACCEL
    147     VBOXDISPVHWAINFO  vhwa;                  /* VHWA Info */
    148144#endif
    149145

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDraw.cpp

    r106061 r108641  
    3838    PDD_SURFACEDESC lpDDS = lpCanCreateSurface->lpDDSurfaceDesc;
    3939
    40 #ifdef VBOX_WITH_VIDEOHWACCEL
    41     PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpCanCreateSurface->lpDD->dhpdev;
    42     if(pDev->vhwa.bEnabled)
    43     {
    44         uint32_t unsupportedSCaps = VBoxDispVHWAUnsupportedDDSCAPS(lpDDS->ddsCaps.dwCaps);
    45         if(unsupportedSCaps)
    46         {
    47             WARN(("unsupported ddscaps: %#x", unsupportedSCaps));
    48             lpCanCreateSurface->ddRVal = DDERR_INVALIDCAPS;
    49             return DDHAL_DRIVER_HANDLED;
    50         }
    51 
    52         unsupportedSCaps = VBoxDispVHWAUnsupportedDDPFS(lpDDS->ddpfPixelFormat.dwFlags);
    53         if(unsupportedSCaps)
    54         {
    55             WARN(("unsupported pixel format: %#x", unsupportedSCaps));
    56             lpCanCreateSurface->ddRVal = DDERR_INVALIDPIXELFORMAT;
    57             return DDHAL_DRIVER_HANDLED;
    58         }
    59 
    60         VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST * pCmd
    61             = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_CANCREATE, sizeof(VBOXVHWACMD_SURF_CANCREATE));
    62         if (pCmd)
    63         {
    64             int rc;
    65             VBOXVHWACMD_SURF_CANCREATE RT_UNTRUSTED_VOLATILE_HOST  *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CANCREATE);
    66 
    67             rc = VBoxDispVHWAFromDDSURFACEDESC(&pBody->SurfInfo, lpDDS);
    68             pBody->u.in.bIsDifferentPixelFormat = lpCanCreateSurface->bIsDifferentPixelFormat;
    69 
    70             VBoxDispVHWACommandSubmit(pDev, pCmd);
    71 
    72             if (RT_SUCCESS(pCmd->rc))
    73             {
    74                 if(pBody->u.out.ErrInfo)
    75                 {
    76                     WARN(("pBody->u.out.ErrInfo = %#x", pBody->u.out.ErrInfo));
    77                     lpCanCreateSurface->ddRVal = DDERR_GENERIC;
    78                 }
    79                 else
    80                 {
    81                     lpCanCreateSurface->ddRVal = DD_OK;
    82                 }
    83             }
    84             else
    85             {
    86                 WARN(("VBoxDispVHWACommandSubmit failed with rc=%#x", rc));
    87                 lpCanCreateSurface->ddRVal = DDERR_GENERIC;
    88             }
    89             VBoxDispVHWACommandRelease(pDev, pCmd);
    90         }
    91         else
    92         {
    93             WARN(("VBoxDispVHWACommandCreate failed!"));
    94             lpCanCreateSurface->ddRVal = DDERR_GENERIC;
    95         }
    96         return DDHAL_DRIVER_HANDLED;
    97     }
    98 #endif /*VBOX_WITH_VIDEOHWACCEL*/
    99 
    10040    if (lpDDS->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
    10141    {
    … …  
    14484    pSurf->lpGbl->dwReserved1 = 0;
    14585
    146 #ifdef VBOX_WITH_VIDEOHWACCEL
    147     PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpCreateSurface->lpDD->dhpdev;
    148     if(pDev->vhwa.bEnabled)
    149     {
    150         VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd
    151             = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_CREATE, sizeof(VBOXVHWACMD_SURF_CREATE));
    152         if (pCmd)
    153         {
    154             VBOXVHWACMD_SURF_CREATE RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE);
    155             PVBOXVHWASURFDESC pDesc;
    156             int rc;
    157 
    158             rc = VBoxDispVHWAFromDDSURFACEDESC(&pBody->SurfInfo, lpCreateSurface->lpDDSurfaceDesc);
    159             VBOX_WARNRC(rc);
    160 
    161             pBody->SurfInfo.surfCaps = VBoxDispVHWAFromDDSCAPS(pSurf->ddsCaps.dwCaps);
    162             pBody->SurfInfo.flags |= DDSD_CAPS;
    163 
    164             pBody->SurfInfo.height = pSurf->lpGbl->wHeight;
    165             pBody->SurfInfo.width = pSurf->lpGbl->wWidth;
    166             pBody->SurfInfo.flags |= DDSD_HEIGHT | DDSD_WIDTH;
    167 
    168             VBoxDispVHWAFromDDPIXELFORMAT(&pBody->SurfInfo.PixelFormat, &pSurf->lpGbl->ddpfSurface);
    169             pBody->SurfInfo.flags |= VBOXVHWA_SD_PIXELFORMAT;
    170 
    171             if (pSurf->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    172             {
    173                 pBody->SurfInfo.offSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, 0);
    174             }
    175             else
    176             {
    177                 pBody->SurfInfo.offSurface = VBOXVHWA_OFFSET64_VOID;
    178             }
    179 
    180             pDesc = VBoxDispVHWASurfDescAlloc();
    181             if (pDesc)
    182             {
    183                 VBoxDispVHWACommandSubmit(pDev, pCmd);
    184                 if (RT_SUCCESS(pCmd->rc))
    185                 {
    186                     pDesc->hHostHandle = pBody->SurfInfo.hSurf;
    187 
    188                     if(!!(pSurf->ddsCaps.dwCaps & DDSCAPS_OVERLAY)
    189                        && !!(pSurf->ddsCaps.dwCaps & DDSCAPS_VISIBLE))
    190                     {
    191                         pDesc->bVisible = true;
    192                     }
    193 
    194                     pSurf->lpGbl->dwBlockSizeX = pBody->SurfInfo.sizeX;
    195                     pSurf->lpGbl->dwBlockSizeY = pBody->SurfInfo.sizeY;
    196                     pSurf->lpGbl->lPitch       = pBody->SurfInfo.pitch;
    197 
    198                     lpCreateSurface->lpDDSurfaceDesc->lPitch = pSurf->lpGbl->lPitch;
    199                     lpCreateSurface->lpDDSurfaceDesc->dwFlags |= DDSD_PITCH;
    200 
    201 
    202                     /** @todo it's probably a memory leak, because DDDestroySurface wouldn't be called for
    203                      *       primary surfaces.
    204                      */
    205                     pSurf->lpGbl->dwReserved1 = (ULONG_PTR)pDesc;
    206                 }
    207                 else
    208                 {
    209                     WARN(("VBoxDispVHWACommandSubmit failed with rc=%#x", rc));
    210                     VBoxDispVHWASurfDescFree(pDesc);
    211                 }
    212             }
    213             else
    214             {
    215                 WARN(("VBoxDispVHWASurfDescAlloc failed"));
    216             }
    217             VBoxDispVHWACommandRelease(pDev, pCmd);
    218         }
    219         else
    220         {
    221             WARN(("VBoxDispVHWACommandCreate failed"));
    222         }
    223         return DDHAL_DRIVER_NOTHANDLED;
    224     }
    225 #endif /*VBOX_WITH_VIDEOHWACCEL*/
    226 
    22786    LPDDSURFACEDESC pDesc = lpCreateSurface->lpDDSurfaceDesc;
    22887
    … …  
    261120    lpDestroySurface->ddRVal = DD_OK;
    262121
    263 #ifdef VBOX_WITH_VIDEOHWACCEL
    264     PVBOXDISPDEV pDev = (PVBOXDISPDEV) lpDestroySurface->lpDD->dhpdev;
    265     if (pDev->vhwa.bEnabled)
    266     {
    267         VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST  *pCmd
    268             = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_DESTROY, sizeof(VBOXVHWACMD_SURF_DESTROY));
    269         if (pCmd)
    270         {
    271             PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpDestroySurface->lpDDSurface->lpGbl->dwReserved1;
    272             if (pDesc)
    273             {
    274                 VBOXVHWACMD_SURF_DESTROY RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY);
    275                 pBody->u.in.hSurf = pDesc->hHostHandle;
    276 
    277                 VBoxDispVHWACommandSubmit(pDev, pCmd);
    278 
    279                 VBoxDispVHWACommandRelease(pDev, pCmd);
    280 
    281                 VBoxDispVHWASurfDescFree(pDesc);
    282 
    283                 lpDestroySurface->lpDDSurface->lpGbl->dwReserved1 = (ULONG_PTR)NULL;
    284             }
    285             else
    286             {
    287                 WARN(("!pDesc, memory overwrite somewhere?"));
    288                 lpDestroySurface->ddRVal = DDERR_GENERIC;
    289             }
    290         }
    291         else
    292         {
    293             WARN(("VBoxDispVHWACommandCreate failed!"));
    294             lpDestroySurface->ddRVal = DDERR_GENERIC;
    295         }
    296     }
    297     else
    298 #endif /*VBOX_WITH_VIDEOHWACCEL*/
    299 
    300122    LOGF_LEAVE();
    301123    return DDHAL_DRIVER_NOTHANDLED;
    … …  
    351173
    352174    lpLock->ddRVal = DD_OK;
    353 
    354 #ifdef VBOX_WITH_VIDEOHWACCEL
    355     if(pDev->vhwa.bEnabled)
    356     {
    357         PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC) pSurf->lpGbl->dwReserved1;
    358         RECTL tmpRect, *pRect;
    359 
    360         if (!pDesc)
    361         {
    362             WARN(("!pDesc, memory overwrite somewhere?"));
    363             lpLock->ddRVal = DDERR_GENERIC;
    364             return DDHAL_DRIVER_HANDLED;
    365         }
    366 
    367         /* Check if host is still processing drawing commands */
    368         if (ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
    369             || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr)
    370             || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
    371             || ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg))
    372         {
    373             VBoxDispVHWACommandCheckHostCmds(pDev);
    374             if(ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
    375                || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr)
    376                || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
    377                || ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg))
    378             {
    379                 lpLock->ddRVal = DDERR_WASSTILLDRAWING;
    380                 return DDHAL_DRIVER_HANDLED;
    381             }
    382         }
    383 
    384         if (lpLock->bHasRect)
    385         {
    386             pRect = &lpLock->rArea;
    387         }
    388         else
    389         {
    390             tmpRect.left = 0;
    391             tmpRect.top = 0;
    392             tmpRect.right = pSurf->lpGbl->wWidth-1;
    393             tmpRect.bottom = pSurf->lpGbl->wHeight-1;
    394             pRect = &tmpRect;
    395         }
    396 
    397         if (lpLock->dwFlags & DDLOCK_DISCARDCONTENTS)
    398         {
    399             VBoxDispVHWARegionTrySubstitute(&pDesc->NonupdatedMemRegion, pRect);
    400             VBoxDispVHWARegionAdd(&pDesc->UpdatedMemRegion, pRect);
    401         }
    402         else if (!VBoxDispVHWARegionIntersects(&pDesc->NonupdatedMemRegion, pRect))
    403         {
    404             VBoxDispVHWARegionAdd(&pDesc->UpdatedMemRegion, pRect);
    405         }
    406         else
    407         {
    408             VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd
    409                 = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_LOCK, sizeof(VBOXVHWACMD_SURF_LOCK));
    410             if (pCmd)
    411             {
    412                 VBOXVHWACMD_SURF_LOCK RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK);
    413 
    414                 pBody->u.in.offSurface = VBoxDispVHWAVramOffsetFromPDEV(pDev, pSurf->lpGbl->fpVidMem);
    415 
    416                 VBoxDispVHWAFromRECTL(&pBody->u.in.rect, &pDesc->NonupdatedMemRegion.Rect);
    417                 pBody->u.in.rectValid = 1;
    418 
    419                 pBody->u.in.hSurf = pDesc->hHostHandle;
    420 
    421                 /* wait for the surface to be locked and memory buffer updated */
    422                 VBoxDispVHWACommandSubmit(pDev, pCmd);
    423                 VBOX_WARNRC(pCmd->rc);
    424                 VBoxDispVHWACommandRelease(pDev, pCmd);
    425                 VBoxDispVHWARegionClear(&pDesc->NonupdatedMemRegion);
    426             }
    427             else
    428             {
    429                 WARN(("VBoxDispVHWACommandCreate failed!"));
    430                 lpLock->ddRVal = DDERR_GENERIC;
    431             }
    432         }
    433 
    434         return DDHAL_DRIVER_NOTHANDLED;
    435     }
    436 #endif /*VBOX_WITH_VIDEOHWACCEL*/
    437175
    438176    /* We only care about primary surface as we'd have to report dirty rectangles to the host in the DDUnlock*/
    … …  
    466204    lpUnlock->ddRVal = DD_OK;
    467205
    468 #ifdef VBOX_WITH_VIDEOHWACCEL
    469     if(pDev->vhwa.bEnabled)
    470     {
    471         DD_SURFACE_LOCAL *pSurf = lpUnlock->lpDDSurface;
    472         PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC) pSurf->lpGbl->dwReserved1;
    473 
    474         if (!pDesc)
     206    if (pDev->ddpsLock.bLocked)
     207    {
     208        pDev->ddpsLock.bLocked = FALSE;
     209
     210        if (pDev->hgsmi.bSupported && VBoxVBVABufferBeginUpdate(&pDev->vbvaCtx, &pDev->hgsmi.ctx))
    475211        {
    476             WARN(("!pDesc, memory overwrite somewhere?"));
    477             lpUnlock->ddRVal = DDERR_GENERIC;
    478             return DDHAL_DRIVER_HANDLED;
    479         }
    480 
    481         if((pSurf->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) && pDesc->UpdatedMemRegion.bValid
    482            && VBoxVBVABufferBeginUpdate(&pDev->vbvaCtx, &pDev->hgsmi.ctx))
    483         {
    484             vbvaReportDirtyRect(pDev, &pDesc->UpdatedMemRegion.Rect);
     212            vbvaReportDirtyRect(pDev, &pDev->ddpsLock.rect);
    485213
    486214            if (pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET)
    … …  
    492220            if (pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_VRDP)
    493221            {
    494                 vrdpReportDirtyRect(pDev, &pDesc->UpdatedMemRegion.Rect);
     222                vrdpReportDirtyRect(pDev, &pDev->ddpsLock.rect);
    495223            }
    496224
    497225            VBoxVBVABufferEndUpdate(&pDev->vbvaCtx);
    498226        }
    499         else if ((pSurf->ddsCaps.dwCaps & DDSCAPS_VISIBLE)
    500                  || ((pSurf->ddsCaps.dwCaps & DDSCAPS_OVERLAY) && pDesc->bVisible))
    501         {
    502             VBOXVHWACMD RT_UNTRUSTED_VOLATILE_HOST *pCmd
    503                 = VBoxDispVHWACommandCreate(pDev, VBOXVHWACMD_TYPE_SURF_UNLOCK, sizeof(VBOXVHWACMD_SURF_UNLOCK));
    504             if (pCmd)
    505             {
    506                 VBOXVHWACMD_SURF_UNLOCK RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK);
    507 
    508                 pBody->u.in.hSurf = pDesc->hHostHandle;
    509                 if(pDesc->UpdatedMemRegion.bValid)
    510                 {
    511                     pBody->u.in.xUpdatedMemValid = 1;
    512                     VBoxDispVHWAFromRECTL(&pBody->u.in.xUpdatedMemRect, &pDesc->UpdatedMemRegion.Rect);
    513                     VBoxDispVHWARegionClear(&pDesc->UpdatedMemRegion);
    514                 }
    515 
    516                 VBoxDispVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
    517             }
    518             else
    519             {
    520                 WARN(("VBoxDispVHWACommandCreate failed!"));
    521                 lpUnlock->ddRVal = DDERR_GENERIC;
    522             }
    523 
    524         }
    525 
    526         return DDHAL_DRIVER_NOTHANDLED;
    527     }
    528 #endif /*VBOX_WITH_VIDEOHWACCEL*/
    529 
    530     if (pDev->ddpsLock.bLocked)
    531     {
    532         pDev->ddpsLock.bLocked = FALSE;
    533 
    534         if (pDev->hgsmi.bSupported && VBoxVBVABufferBeginUpdate(&pDev->vbvaCtx, &pDev->hgsmi.ctx))
    535         {
    536             vbvaReportDirtyRect(pDev, &pDev->ddpsLock.rect);
    537 
    538             if (pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET)
    539             {
    540                 vrdpReset(pDev);
    541                 pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents &= ~VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
    542             }
    543 
    544             if (pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_VRDP)
    545             {
    546                 vrdpReportDirtyRect(pDev, &pDev->ddpsLock.rect);
    547             }
    548 
    549             VBoxVBVABufferEndUpdate(&pDev->vbvaCtx);
    550         }
    551     }
    552 
    553     LOGF_LEAVE();
    554     return DDHAL_DRIVER_NOTHANDLED;
    555 }
     227    }
     228
     229    LOGF_LEAVE();
     230    return DDHAL_DRIVER_NOTHANDLED;
     231}

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDraw.h

    r106061 r108641  
    4141DWORD APIENTRY VBoxDispDDMapMemory(PDD_MAPMEMORYDATA lpMapMemory);
    4242
    43 #ifdef VBOX_WITH_VIDEOHWACCEL
    44 int VBoxDispVHWAUpdateDDHalInfo(PVBOXDISPDEV pDev, DD_HALINFO *pHalInfo);
    45 
    46 DWORD APIENTRY VBoxDispDDGetDriverInfo(DD_GETDRIVERINFODATA *lpData);
    47 DWORD APIENTRY VBoxDispDDSetColorKey(PDD_SETCOLORKEYDATA lpSetColorKey);
    48 DWORD APIENTRY VBoxDispDDAddAttachedSurface(PDD_ADDATTACHEDSURFACEDATA lpAddAttachedSurface);
    49 DWORD APIENTRY VBoxDispDDBlt(PDD_BLTDATA lpBlt);
    50 DWORD APIENTRY VBoxDispDDFlip(PDD_FLIPDATA lpFlip);
    51 DWORD APIENTRY VBoxDispDDGetBltStatus(PDD_GETBLTSTATUSDATA lpGetBltStatus);
    52 DWORD APIENTRY VBoxDispDDGetFlipStatus(PDD_GETFLIPSTATUSDATA lpGetFlipStatus);
    53 DWORD APIENTRY VBoxDispDDSetOverlayPosition(PDD_SETOVERLAYPOSITIONDATA lpSetOverlayPosition);
    54 DWORD APIENTRY VBoxDispDDUpdateOverlay(PDD_UPDATEOVERLAYDATA lpUpdateOverlay);
    55 #endif
    56 
    5743#endif /* !GA_INCLUDED_SRC_WINNT_Graphics_Video_disp_xpdm_VBoxDispDDraw_h */

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDriver.cpp

    r106061 r108641  
    637637    }
    638638
    639 #ifdef VBOX_WITH_VIDEOHWACCEL
    640     VBoxDispVHWAEnable(pDev);
    641 #endif
    642 
    643639    /* Set device palette if needed */
    644640    if (pDev->mode.ulBitsPerPel == 8)
    … …  
    809805    {
    810806        LOGF(("!bEnable"));
    811 #ifdef VBOX_WITH_VIDEOHWACCEL
    812         /* tells we can not process host commands any more and ensures that
    813          * we've completed processing of the host VHWA commands
    814          */
    815         VBoxDispVHWADisable(pDev);
    816 #endif
    817807
    818808        /* disable VBVA */
    … …  
    852842                                        (uint16_t)pDev->mode.ulBitsPerPel, VBVA_SCREEN_F_ACTIVE);
    853843        }
    854 
    855 #ifdef VBOX_WITH_VIDEOHWACCEL
    856         /* tells we can process host commands */
    857        VBoxDispVHWAEnable(pDev);
    858 #endif
    859844
    860845        /* Associate back GDI bitmap residing in our framebuffer memory with GDI's handle to our device */

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDriverDDraw.cpp

    r106061 r108641  
    7575                             VIDEOMEMORY *pvmList, DWORD *pdwNumFourCCCodes, DWORD *pdwFourCC)
    7676{
     77    RT_NOREF(pdwFourCC);
     78
    7779    PVBOXDISPDEV pDev = (PVBOXDISPDEV)dhpdev;
    7880    LOGF_ENTER();
    7981
    8082    VBoxDispGetDDHalInfo(pDev, pHalInfo);
    81 
    82 #ifdef VBOX_WITH_VIDEOHWACCEL
    83     int rc;
    84 
    85     if (!pvmList && !pdwFourCC) /* first call */
    86     {
    87         rc = VBoxDispVHWAInitHostInfo1(pDev);
    88         VBOX_WARNRC_NOBP(rc);
    89     }
    90 
    91     if (pDev->vhwa.bEnabled)
    92     {
    93         rc = VBoxDispVHWAUpdateDDHalInfo(pDev, pHalInfo);
    94         VBOX_WARNRC(rc);
    95 
    96         pDev->vhwa.bEnabled = RT_SUCCESS(rc);
    97     }
    98 #else
    99     RT_NOREF(pdwFourCC);
    100 #endif
    10183
    10284    /* we could only have 1 heap, so it's not really a list */
    … …  
    10688        pvmList->fpStart = pDev->layout.offDDrawHeap;
    10789        pvmList->fpEnd   = pDev->layout.offDDrawHeap + pDev->layout.cbDDrawHeap - 1;
    108 #ifdef VBOX_WITH_VIDEOHWACCEL
    109         if (pDev->vhwa.bEnabled)
    110         {
    111             pvmList->ddsCaps.dwCaps = 0;
    112         }
    113         else
    114 #endif
    115         {
    116             pvmList->ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
    117         }
     90        pvmList->ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
    11891        pvmList->ddsCapsAlt.dwCaps = 0;
    119 
    12092    }
    12193
    … …  
    12395    *pdwNumHeaps = (pDev->layout.cbDDrawHeap>0) ? 1:0;
    12496
    125 #ifndef VBOX_WITH_VIDEOHWACCEL
    12697    *pdwNumFourCCCodes = 0;
    127 #else
    128     if (pDev->vhwa.bEnabled)
    129     {
    130         *pdwNumFourCCCodes = pDev->vhwa.numFourCC;
    131         if (pdwFourCC && pDev->vhwa.numFourCC)
    132         {
    133             rc = VBoxDispVHWAInitHostInfo2(pDev, pdwFourCC);
    134             VBOX_WARNRC(rc);
    135 
    136             if (RT_FAILURE(rc))
    137             {
    138                 *pdwNumFourCCCodes = 0;
    139                 pDev->vhwa.numFourCC = 0;
    140             }
    141         }
    142 
    143         pHalInfo->GetDriverInfo = VBoxDispDDGetDriverInfo;
    144         pHalInfo->dwFlags |= DDHALINFO_GETDRIVERINFOSET;
    145     }
    146 #endif
    14798
    14899    LOGF_LEAVE();
    … …  
    154105                            DD_PALETTECALLBACKS *pPaletteCallBacks)
    155106{
     107    RT_NOREF(dhpdev);
     108
    156109    LOGF_ENTER();
    157110
    … …  
    169122    pPaletteCallBacks->dwSize           = sizeof(DD_PALETTECALLBACKS);
    170123    pPaletteCallBacks->dwFlags          = 0;
    171 
    172 #ifdef VBOX_WITH_VIDEOHWACCEL
    173     PVBOXDISPDEV pDev = (PVBOXDISPDEV)dhpdev;
    174 
    175     if (pDev->vhwa.bEnabled)
    176     {
    177         pSurfaceCallBacks->DestroySurface = VBoxDispDDDestroySurface;
    178         pSurfaceCallBacks->Flip = VBoxDispDDFlip;
    179         pSurfaceCallBacks->GetFlipStatus = VBoxDispDDGetFlipStatus;
    180         pSurfaceCallBacks->Blt = VBoxDispDDBlt;
    181         pSurfaceCallBacks->GetBltStatus = VBoxDispDDGetBltStatus;
    182         pSurfaceCallBacks->SetColorKey = VBoxDispDDSetColorKey;
    183         pSurfaceCallBacks->dwFlags |= DDHAL_SURFCB32_DESTROYSURFACE|
    184                                       DDHAL_SURFCB32_FLIP|DDHAL_SURFCB32_GETFLIPSTATUS|
    185                                       DDHAL_SURFCB32_BLT|DDHAL_SURFCB32_GETBLTSTATUS|
    186                                       DDHAL_SURFCB32_SETCOLORKEY;
    187 
    188         if(pDev->vhwa.caps & VBOXVHWA_CAPS_OVERLAY)
    189         {
    190             pSurfaceCallBacks->UpdateOverlay = VBoxDispDDUpdateOverlay;
    191             pSurfaceCallBacks->SetOverlayPosition = VBoxDispDDSetOverlayPosition;
    192             pSurfaceCallBacks->dwFlags |= DDHAL_SURFCB32_UPDATEOVERLAY|DDHAL_SURFCB32_SETOVERLAYPOSITION;
    193         }
    194     }
    195 #else
    196     RT_NOREF(dhpdev);
    197 #endif
    198124
    199125    LOGF_LEAVE();

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispInternal.h

    r106061 r108641  
    5454
    5555typedef struct _VBOXDISPDEV *PVBOXDISPDEV;
    56 
    57 #ifdef VBOX_WITH_VIDEOHWACCEL
    58 # include "VBoxDispVHWA.h"
    59 #endif
    6056
    6157/* 4bytes tag passed to EngAllocMem.

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispMini.cpp

    r106061 r108641  
    288288}
    289289
    290 #ifdef VBOX_WITH_VIDEOHWACCEL
    291 int VBoxDispMPVHWAQueryInfo(HANDLE hDriver, VHWAQUERYINFO *pInfo)
    292 {
    293     DWORD dwrc;
    294     ULONG cbReturned;
    295     LOGF_ENTER();
    296 
    297     memset(pInfo, 0, sizeof(VHWAQUERYINFO));
    298     dwrc = EngDeviceIoControl(hDriver, IOCTL_VIDEO_VHWA_QUERY_INFO, NULL, 0,
    299                               pInfo, sizeof(VHWAQUERYINFO), &cbReturned);
    300     VBOX_CHECK_WINERR_RETRC(dwrc, VERR_DEV_IO_ERROR);
    301     VBOX_WARN_IOCTLCB_RETRC("IOCTL_VIDEO_VHWA_QUERY_INFO", cbReturned, sizeof(VHWAQUERYINFO), VERR_DEV_IO_ERROR);
    302 
    303     LOGF_LEAVE();
    304     return VINF_SUCCESS;
    305 }
    306 #endif
    307 
    308290int VBoxDispMPSetColorRegisters(HANDLE hDriver, PVIDEO_CLUT pClut, DWORD cbClut)
    309291{

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispMini.h

    r106061 r108641  
    4242int VBoxDispMPQueryHGSMICallbacks(HANDLE hDriver, HGSMIQUERYCALLBACKS *pCallbacks);
    4343int VBoxDispMPHGSMIQueryPortProcs(HANDLE hDriver, HGSMIQUERYCPORTPROCS *pPortProcs);
    44 #ifdef VBOX_WITH_VIDEOHWACCEL
    45 int VBoxDispMPVHWAQueryInfo(HANDLE hDriver, VHWAQUERYINFO *pInfo);
    46 #endif
    4744int VBoxDispMPSetColorRegisters(HANDLE hDriver, PVIDEO_CLUT pClut, DWORD cbClut);
    4845int VBoxDispMPDisablePointer(HANDLE hDriver);

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVBVA.cpp

    r106061 r108641  
    364364                                        0, NULL, &cbReturned);
    365365        VBOX_WARN_WINERR(dwrc);
    366 
    367 #ifdef VBOX_WITH_VIDEOHWACCEL
    368         if (NO_ERROR == dwrc)
    369         {
    370             VBoxDispVHWAInit(pDev);
    371         }
    372 #endif
    373366    }
    374367

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/Makefile.kmk

    r106454 r108641  
    4141 VBoxVideo_DEFS         += LOG_TO_BACKDOOR #LOG_ENABLED
    4242 VBoxVideo_DEFS         += VBOX_SVN_REV=$(VBOX_SVN_REV)
    43  ifdef VBOX_WITH_VIDEOHWACCEL
    44   VBoxVideo_DEFS        += VBOX_WITH_VIDEOHWACCEL
    45  endif
    4643 VBoxVideo_INCS          = \
    4744        ../../../include \
    … …  
    9592 VBoxWddm_DEFS            += WIN9X_COMPAT_SPINLOCK
    9693 VBoxWddm_DEFS            += VBOX_WITH_8BPP_MODES
    97  ifdef VBOX_WITH_VIDEOHWACCEL
    98   VBoxWddm_DEFS           += VBOX_WITH_VIDEOHWACCEL
    99  endif
    10094 ifdef VBOXWDDM_WITH_VBVA
    10195  VBoxWddm_DEFS           += VBOXWDDM_WITH_VBVA
    … …  
    141135  VBoxWddm_SOURCES        += \
    142136        wddm/VBoxMPVbva.cpp
    143  endif
    144  ifdef VBOX_WITH_VIDEOHWACCEL
    145   VBoxWddm_SOURCES        += \
    146         wddm/VBoxMPVhwa.cpp
    147137 endif
    148138

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPDevExt.h

    r106061 r108641  
    157157
    158158   BOOLEAN f3DEnabled;
    159    BOOLEAN fCmdVbvaEnabled;
     159   BOOLEAN fCmdVbvaEnabled; /** @todo r=andy Remove this too for @bugref{10756}? */
    160160   BOOLEAN fComplexTopologiesEnabled;
    161161
    … …  
    164164   VBOXVTLIST CtlList;
    165165   VBOXVTLIST DmaCmdList;
    166 #ifdef VBOX_WITH_VIDEOHWACCEL
    167    VBOXVTLIST VhwaCmdList;
    168 #endif
     166
    169167   BOOLEAN bNotifyDxDpc;
    170168
    171169   BOOLEAN fDisableTargetUpdate;
    172 
    173 
    174170
    175171   BOOL bVSyncTimerEnabled;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPLegacy.cpp

    r106061 r108641  
    3030#include "common/VBoxMPCommon.h"
    3131#include "common/VBoxMPHGSMI.h"
    32 #ifdef VBOX_WITH_VIDEOHWACCEL
    33 # include "VBoxMPVhwa.h"
    34 #endif
    3532#include "VBoxMPVidPn.h"
    3633#include "VBoxMPLegacy.h"
    … …  
    15371534        vboxVtListInit(&CtlList);
    15381535
    1539 #ifdef VBOX_WITH_VIDEOHWACCEL
    1540         VBOXVTLIST VhwaCmdList;
    1541         vboxVtListInit(&VhwaCmdList);
    1542 #endif
    1543 
    15441536        uint32_t flags = VBoxCommonFromDeviceExt(pDevExt)->hostCtx.pfHostFlags->u32HostFlags;
    15451537        bOur = (flags & HGSMIHOSTFLAGS_IRQ);
    … …  
    15831575                            switch (chInfo)
    15841576                            {
    1585 #ifdef VBOX_WITH_VIDEOHWACCEL
    1586                                 case VBVA_VHWA_CMD:
    1587                                 {
    1588                                     vboxVhwaPutList(&VhwaCmdList, (VBOXVHWACMD*)pvCmd);
    1589                                     break;
    1590                                 }
    1591 #endif /* # ifdef VBOX_WITH_VIDEOHWACCEL */
    15921577                                default:
    15931578                                    AssertBreakpoint();
    … …  
    16131598            bNeedDpc = TRUE;
    16141599        }
    1615 #ifdef VBOX_WITH_VIDEOHWACCEL
    1616         if (!vboxVtListIsEmpty(&VhwaCmdList))
    1617         {
    1618             vboxVtListCat(&pDevExt->VhwaCmdList, &VhwaCmdList);
    1619             bNeedDpc = TRUE;
    1620         }
    1621 #endif
    16221600
    16231601        if (pDevExt->bNotifyDxDpc)
    … …  
    16751653{
    16761654    VBOXVTLIST CtlList;
    1677 #ifdef VBOX_WITH_VIDEOHWACCEL
    1678     VBOXVTLIST VhwaCmdList;
    1679 #endif
    16801655    LIST_ENTRY CompletedDdiCmdQueue;
    16811656    BOOL bNotifyDpc;
    … …  
    16931668    PVBOXMP_DEVEXT pDevExt = pdc->pDevExt;
    16941669    vboxVtListDetach2List(&pDevExt->CtlList, &pdc->data.CtlList);
    1695 #ifdef VBOX_WITH_VIDEOHWACCEL
    1696     vboxVtListDetach2List(&pDevExt->VhwaCmdList, &pdc->data.VhwaCmdList);
    1697 #endif
    16981670
    16991671    pdc->data.bNotifyDpc = pDevExt->bNotifyDxDpc;
    … …  
    17341706        AssertRC(rc);
    17351707    }
    1736 #ifdef VBOX_WITH_VIDEOHWACCEL
    1737     if (!vboxVtListIsEmpty(&context.data.VhwaCmdList))
    1738     {
    1739         vboxVhwaCompletionListProcess(pDevExt, &context.data.VhwaCmdList);
    1740     }
    1741 #endif
    17421708
    17431709//    LOGF(("LEAVE, context(0x%p)", MiniportDeviceContext));

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPTypes.h

    r106061 r108641  
    110110} VBOXWDDM_GLOBAL_POINTER_INFO, *PVBOXWDDM_GLOBAL_POINTER_INFO;
    111111
    112 #ifdef VBOX_WITH_VIDEOHWACCEL
    113 typedef struct VBOXWDDM_VHWA
    114 {
    115     VBOXVHWA_INFO Settings;
    116     volatile uint32_t cOverlaysCreated;
    117 } VBOXWDDM_VHWA;
    118 #endif
    119 
    120112typedef struct VBOXWDDM_ADDR
    121113{
    … …  
    153145    BOOLEAN bBlankedByPowerOff;
    154146    VBOXVBVAINFO Vbva;
    155 #ifdef VBOX_WITH_VIDEOHWACCEL
    156     /* @todo: in our case this seems more like a target property,
    157      * but keep it here for now */
    158     VBOXWDDM_VHWA Vhwa;
    159     volatile uint32_t cOverlays;
    160     LIST_ENTRY OverlayList;
    161     KSPIN_LOCK OverlayListLock;
    162 #endif
    163147    KSPIN_LOCK AllocationLock;
    164148    POINT VScreenPos;
    … …  
    191175    VBOXWDDM_ALLOC_TYPE enmType;
    192176    D3DDDI_RESOURCEFLAGS fRcFlags;
    193 #ifdef VBOX_WITH_VIDEOHWACCEL
    194     VBOXVHWA_SURFHANDLE hHostHandle;
    195 #endif
    196177    BOOLEAN fDeleted;
    197178    BOOLEAN bVisible;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp

    r106061 r108641  
    2929#include "common/VBoxMPCommon.h"
    3030#include "VBoxMPVdma.h"
    31 #ifdef VBOX_WITH_VIDEOHWACCEL
    32 #include "VBoxMPVhwa.h"
    33 #endif
    3431#include <iprt/asm.h>
    3532#include <iprt/mem.h>

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

    r106061 r108641  
    2929#include "common/VBoxMPCommon.h"
    3030#include "common/VBoxMPHGSMI.h"
    31 #ifdef VBOX_WITH_VIDEOHWACCEL
    32 # include "VBoxMPVhwa.h"
    33 #endif
    3431#include "VBoxMPVidPn.h"
    3532#include "VBoxMPLegacy.h"
    … …  
    10901087                    vboxShRcTreeInit(pDevExt);
    10911088#endif
    1092 
    1093 #ifdef VBOX_WITH_VIDEOHWACCEL
    1094                     vboxVhwaInit(pDevExt);
    1095 #endif
    10961089                    VBoxWddmSlInit(pDevExt);
    10971090
    … …  
    12761269
    12771270    /* do everything we did on DxgkDdiStartDevice in the reverse order */
    1278 #ifdef VBOX_WITH_VIDEOHWACCEL
    1279     vboxVhwaFree(pDevExt);
    1280 #endif
    12811271#if 0
    12821272    vboxShRcTreeTerm(pDevExt);
    … …  
    16871677                pCaps->NumberOfSwizzlingRanges = 0;
    16881678                pCaps->MaxOverlays = 0;
    1689 #ifdef VBOX_WITH_VIDEOHWACCEL
    1690                 for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
    1691                 {
    1692                     if ( pDevExt->aSources[i].Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
    1693                         pCaps->MaxOverlays += pDevExt->aSources[i].Vhwa.Settings.cOverlaysSupported;
    1694                 }
    1695 #endif
    16961679                pCaps->GammaRampCaps.Value = 0;
    16971680                pCaps->PresentationCaps.Value = 0;
    … …  
    18611844                        GaQueryInfo(pDevExt->pGa, pDevExt->enmHwType, &pQAI->u.vmsvga.HWInfo);
    18621845#endif
    1863 
    1864 #ifdef VBOX_WITH_VIDEOHWACCEL
    1865                     pQAI->cInfos = VBoxCommonFromDeviceExt(pDevExt)->cDisplays;
    1866                     for (uint32_t i = 0; i < pQAI->cInfos; ++i)
    1867                     {
    1868                         pQAI->aInfos[i] = pDevExt->aSources[i].Vhwa.Settings;
    1869                     }
    1870 #endif
    18711846                }
    18721847                else
    … …  
    21772152                            break;
    21782153                        case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
    2179 #ifdef VBOX_WITH_VIDEOHWACCEL
    2180                             if (pAllocInfo->fFlags.Overlay)
     2154                        {
     2155                            RT_NOREF(pDevExt);
     2156
     2157                            Assert(pAllocation->AllocData.SurfDesc.bpp);
     2158                            Assert(pAllocation->AllocData.SurfDesc.pitch);
     2159                            Assert(pAllocation->AllocData.SurfDesc.cbSize);
     2160
     2161                            /*
     2162                             * Mark the allocation as visible to the CPU so we can
     2163                             * lock it in the user mode driver for SYSTEM pool allocations.
     2164                             * See @bugref{8040} for further information.
     2165                             */
     2166                            if (!pAllocInfo->fFlags.SharedResource && !pAllocInfo->hostID)
     2167                                pAllocationInfo->Flags.CpuVisible = 1;
     2168
     2169                            if (pAllocInfo->fFlags.SharedResource)
    21812170                            {
    2182                                 /* actually we can not "properly" issue create overlay commands to the host here
    2183                                  * because we do not know source VidPn id here, i.e.
    2184                                  * the primary which is supposed to be overlayed,
    2185                                  * however we need to get some info like pitch & size from the host here */
    2186                                 int rc = vboxVhwaHlpGetSurfInfo(pDevExt, pAllocation);
    2187                                 AssertRC(rc);
    2188                                 if (RT_SUCCESS(rc))
     2171                                pAllocation->hSharedHandle = (HANDLE)pAllocInfo->hSharedHandle;
     2172#if 0
     2173                                if (pAllocation->hSharedHandle)
    21892174                                {
    2190                                     pAllocationInfo->Flags.Overlay = 1;
    2191                                     pAllocationInfo->Flags.CpuVisible = 1;
    2192                                     pAllocationInfo->Size = pAllocation->AllocData.SurfDesc.cbSize;
    2193 
    2194                                     pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_HIGH;
    2195                                 }
    2196                                 else
    2197                                     Status = STATUS_UNSUCCESSFUL;
    2198                             }
    2199                             else
    2200 #endif
    2201                             {
    2202                                 RT_NOREF(pDevExt);
    2203 
    2204                                 Assert(pAllocation->AllocData.SurfDesc.bpp);
    2205                                 Assert(pAllocation->AllocData.SurfDesc.pitch);
    2206                                 Assert(pAllocation->AllocData.SurfDesc.cbSize);
    2207 
    2208                                 /*
    2209                                  * Mark the allocation as visible to the CPU so we can
    2210                                  * lock it in the user mode driver for SYSTEM pool allocations.
    2211                                  * See @bugref{8040} for further information.
    2212                                  */
    2213                                 if (!pAllocInfo->fFlags.SharedResource && !pAllocInfo->hostID)
    2214                                     pAllocationInfo->Flags.CpuVisible = 1;
    2215 
    2216                                 if (pAllocInfo->fFlags.SharedResource)
    2217                                 {
    2218                                     pAllocation->hSharedHandle = (HANDLE)pAllocInfo->hSharedHandle;
    2219 #if 0
    2220                                     if (pAllocation->hSharedHandle)
    2221                                     {
    2222                                         vboxShRcTreePut(pDevExt, pAllocation);
    2223                                     }
    2224 #endif
    2225                                 }
    2226 
    2227 #if 0
    2228                                 /* Allocation from the CPU invisible second segment does not
    2229                                  * work apparently and actually fails on Vista.
    2230                                  *
    2231                                  * @todo Find out what exactly is wrong.
    2232                                  */
    2233 //                                if (pAllocInfo->hostID)
    2234                                 {
    2235                                     pAllocationInfo->SupportedReadSegmentSet = 2;
    2236                                     pAllocationInfo->SupportedWriteSegmentSet = 2;
     2175                                    vboxShRcTreePut(pDevExt, pAllocation);
    22372176                                }
    22382177#endif
    22392178                            }
     2179
     2180#if 0
     2181                            /* Allocation from the CPU invisible second segment does not
     2182                             * work apparently and actually fails on Vista.
     2183                             *
     2184                             * @todo Find out what exactly is wrong.
     2185                             */
     2186//                                if (pAllocInfo->hostID)
     2187                            {
     2188                                pAllocationInfo->SupportedReadSegmentSet = 2;
     2189                                pAllocationInfo->SupportedWriteSegmentSet = 2;
     2190                            }
     2191#endif
    22402192                            break;
     2193                        }
    22412194                        case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
    22422195                        case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
    … …  
    26782631    {
    26792632#ifdef DEBUG_sunlover
    2680         /** @todo Remove VBOX_WITH_VIDEOHWACCEL code, because the host does not support it anymore. */
    26812633        AssertFailed(); /* Should not be here, because this is not used with 3D gallium driver. */
    26822634#endif
    … …  
    43324284    DXGKARG_CREATEOVERLAY  *pCreateOverlay)
    43334285{
    4334     LOGF(("ENTER, hAdapter(0x%p)", hAdapter));
    4335 
    4336     NTSTATUS Status = STATUS_SUCCESS;
    4337 
    4338 #ifdef VBOX_WITH_VIDEOHWACCEL
    4339     PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)hAdapter;
    4340     PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)vboxWddmMemAllocZero(sizeof (VBOXWDDM_OVERLAY));
    4341     Assert(pOverlay);
    4342     if (pOverlay)
    4343     {
    4344         int rc = vboxVhwaHlpOverlayCreate(pDevExt, pCreateOverlay->VidPnSourceId, &pCreateOverlay->OverlayInfo, pOverlay);
    4345         AssertRC(rc);
    4346         if (RT_SUCCESS(rc))
    4347         {
    4348             pCreateOverlay->hOverlay = pOverlay;
    4349         }
    4350         else
    4351         {
    4352             vboxWddmMemFree(pOverlay);
    4353             Status = STATUS_UNSUCCESSFUL;
    4354         }
    4355     }
    4356     else
    4357         Status = STATUS_NO_MEMORY;
    4358 #else
    43594286    RT_NOREF(hAdapter, pCreateOverlay);
    4360 #endif
    4361 
    4362     LOGF(("LEAVE, hAdapter(0x%p)", hAdapter));
    4363 
    4364     return Status;
     4287    return STATUS_SUCCESS;
    43654288}
    43664289
    … …  
    44654388                    break;
    44664389                }
    4467 
    4468 #ifdef VBOX_WITH_VIDEOHWACCEL
    4469                 PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
    4470 
    4471                 if (pRcInfo->RcDesc.fFlags.Overlay)
    4472                 {
    4473                     /* we have queried host for some surface info, like pitch & size,
    4474                      * need to return it back to the UMD (User Mode Drive) */
    4475                     pAllocInfo->SurfDesc = pAllocation->AllocData.SurfDesc;
    4476                     /* success, just continue */
    4477                 }
    4478 #endif
    44794390            }
    44804391
    … …  
    45844495    CONST DXGKARG_UPDATEOVERLAY  *pUpdateOverlay)
    45854496{
    4586     LOGF(("ENTER, hOverlay(0x%p)", hOverlay));
    4587 
    4588     NTSTATUS Status = STATUS_SUCCESS;
    4589 
    4590 #ifdef VBOX_WITH_VIDEOHWACCEL
    4591     PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay;
    4592     AssertPtr(pOverlay);
    4593     int rc = vboxVhwaHlpOverlayUpdate(pOverlay, &pUpdateOverlay->OverlayInfo);
    4594     AssertRC(rc);
    4595     if (RT_FAILURE(rc))
    4596         Status = STATUS_UNSUCCESSFUL;
    4597 #else
    45984497    RT_NOREF(hOverlay, pUpdateOverlay);
    4599 #endif
    4600 
    4601     LOGF(("LEAVE, hOverlay(0x%p)", hOverlay));
    4602     return Status;
     4498    return STATUS_SUCCESS;
    46034499}
    46044500
    … …  
    46094505    CONST DXGKARG_FLIPOVERLAY  *pFlipOverlay)
    46104506{
    4611     LOGF(("ENTER, hOverlay(0x%p)", hOverlay));
    4612 
    4613     NTSTATUS Status = STATUS_SUCCESS;
    4614 
    4615 #ifdef VBOX_WITH_VIDEOHWACCEL
    4616     PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay;
    4617     AssertPtr(pOverlay);
    4618     int rc = vboxVhwaHlpOverlayFlip(pOverlay, pFlipOverlay);
    4619     AssertRC(rc);
    4620     if (RT_FAILURE(rc))
    4621         Status = STATUS_UNSUCCESSFUL;
    4622 #else
    46234507    RT_NOREF(hOverlay, pFlipOverlay);
    4624 #endif
    4625 
    4626     LOGF(("LEAVE, hOverlay(0x%p)", hOverlay));
    4627 
    4628     return Status;
     4508    return STATUS_SUCCESS;
    46294509}
    46304510
    … …  
    46344514    CONST HANDLE  hOverlay)
    46354515{
    4636     LOGF(("ENTER, hOverlay(0x%p)", hOverlay));
    4637 
    4638     NTSTATUS Status = STATUS_SUCCESS;
    4639 
    4640 #ifdef VBOX_WITH_VIDEOHWACCEL
    4641     PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay;
    4642     AssertPtr(pOverlay);
    4643     int rc = vboxVhwaHlpOverlayDestroy(pOverlay);
    4644     AssertRC(rc);
    4645     if (RT_SUCCESS(rc))
    4646         vboxWddmMemFree(pOverlay);
    4647     else
    4648         Status = STATUS_UNSUCCESSFUL;
    4649 #else
    46504516    RT_NOREF(hOverlay);
    4651 #endif
    4652 
    4653     LOGF(("LEAVE, hOverlay(0x%p)", hOverlay));
    4654 
    4655     return Status;
     4517    return STATUS_SUCCESS;
    46564518}
    46574519

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPDriver.cpp

    r106504 r108641  
    557557        }
    558558
    559 #ifdef VBOX_WITH_VIDEOHWACCEL
    560         /* Returns framebuffer offset. */
    561         case IOCTL_VIDEO_VHWA_QUERY_INFO:
    562         {
    563             STARTIO_OUT(VHWAQUERYINFO, pInfo);
    564 
    565             bResult = VBoxMPVhwaQueryInfo(pExt, pInfo, pStatus);
    566             break;
    567         }
    568 #endif
    569 
    570559        case IOCTL_VIDEO_VBOX_ISANYX:
    571560        {
    … …  
    704693    return FALSE;
    705694}
    706 
    707 #ifdef VBOX_WITH_VIDEOHWACCEL
    708 static VOID VBoxMPHGSMIDpc(IN PVOID  HwDeviceExtension, IN PVOID  Context)
    709 {
    710     NOREF(Context);
    711     PVBOXMP_DEVEXT pExt = (PVBOXMP_DEVEXT) HwDeviceExtension;
    712 
    713     VBoxHGSMIProcessHostQueue(&VBoxCommonFromDeviceExt(pExt)->hostCtx);
    714 }
    715 
    716 static BOOLEAN
    717 VBoxDrvInterrupt(PVOID  HwDeviceExtension)
    718 {
    719     PVBOXMP_DEVEXT pExt = (PVBOXMP_DEVEXT) HwDeviceExtension;
    720 
    721     //LOGF_ENTER();
    722 
    723     /* Check if it could be our IRQ*/
    724     if (VBoxCommonFromDeviceExt(pExt)->hostCtx.pfHostFlags)
    725     {
    726         uint32_t flags = VBoxCommonFromDeviceExt(pExt)->hostCtx.pfHostFlags->u32HostFlags;
    727         if ((flags & HGSMIHOSTFLAGS_IRQ) != 0)
    728         {
    729             /* queue a DPC*/
    730             BOOLEAN bResult = pExt->pPrimary->u.primary.VideoPortProcs.pfnQueueDpc(pExt->pPrimary, VBoxMPHGSMIDpc, NULL);
    731 
    732             if (!bResult)
    733             {
    734                 LOG(("VideoPortQueueDpc failed!"));
    735             }
    736 
    737             /* clear the IRQ */
    738             VBoxHGSMIClearIrq(&VBoxCommonFromDeviceExt(pExt)->hostCtx);
    739             //LOGF_LEAVE();
    740             return TRUE;
    741         }
    742     }
    743 
    744     //LOGF_LEAVE();
    745     return FALSE;
    746 }
    747 #endif
    748695
    749696/* Video Miniport Driver entry point */
    … …  
    780727    /*Optional callbacks*/
    781728    vhwData.HwResetHw     = VBoxDrvResetHW;
    782 #ifdef VBOX_WITH_VIDEOHWACCEL
    783     vhwData.HwInterrupt   = VBoxDrvInterrupt;
    784 #endif
    785729
    786730    /*Our private storage space*/

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPIOCTL.cpp

    r106061 r108641  
    647647}
    648648
    649 #ifdef VBOX_WITH_VIDEOHWACCEL
    650 /* Called for IOCTL_VIDEO_VHWA_QUERY_INFO.
    651  * Returns framebuffer offset.
    652  */
    653 BOOLEAN VBoxMPVhwaQueryInfo(PVBOXMP_DEVEXT pExt, VHWAQUERYINFO *pInfo, PSTATUS_BLOCK pStatus)
    654 {
    655     BOOLEAN fRc = TRUE;
    656     LOGF_ENTER();
    657 
    658     if (VBoxCommonFromDeviceExt(pExt)->bHGSMI)
    659     {
    660         pInfo->offVramBase = (ULONG_PTR)pExt->ulFrameBufferOffset;
    661 
    662         pStatus->Information = sizeof (VHWAQUERYINFO);
    663     }
    664     else
    665     {
    666         pStatus->Status = ERROR_INVALID_FUNCTION;
    667         fRc=FALSE;
    668     }
    669 
    670     LOGF_LEAVE();
    671     return fRc;
    672 }
    673 #endif
    674 
    675649BOOLEAN VBoxMPQueryRegistryFlags(PVBOXMP_DEVEXT pExt, ULONG *pulFlags, PSTATUS_BLOCK pStatus)
    676650{

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/xpdm/VBoxMPInternal.h

    r106061 r108641  
    7575BOOLEAN VBoxMPQueryHgsmiInfo(PVBOXMP_DEVEXT pExt, QUERYHGSMIRESULT *pResult, PSTATUS_BLOCK pStatus);
    7676BOOLEAN VBoxMPHgsmiHandlerEnable(PVBOXMP_DEVEXT pExt, HGSMIHANDLERENABLE *pChannel, PSTATUS_BLOCK pStatus);
    77 #ifdef VBOX_WITH_VIDEOHWACCEL
    78 BOOLEAN VBoxMPVhwaQueryInfo(PVBOXMP_DEVEXT pExt, VHWAQUERYINFO *pInfo, PSTATUS_BLOCK pStatus);
    79 #endif
    8077BOOLEAN VBoxMPQueryRegistryFlags(PVBOXMP_DEVEXT pExt, ULONG *pulFlags, PSTATUS_BLOCK pStatus);
    8178

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r108047 r108641  
    33193319            case VGA_PORT_HGSMI_HOST: /* Host */
    33203320            {
    3321 # if defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM)
     3321# if defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM)
    33223322                if (u32 == HGSMIOFFSET_VOID)
    33233323                {
    … …  
    47744774    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
    47754775    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYPORT, &pThisCC->IPort);
    4776 # if defined(VBOX_WITH_HGSMI) && defined(VBOX_WITH_VIDEOHWACCEL)
    4777     PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYVBVACALLBACKS, &pThisCC->IVBVACallbacks);
    4778 # endif
     4776    /* pThisCC->IVBVACallbacks not used currently. */
    47794777    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds);
    47804778    return NULL;
    … …  
    55705568        PDMDevHlpTimerSetMillies(pDevIns, hTimer, pThis->cMilliesRefreshInterval);
    55715569
    5572 # ifdef VBOX_WITH_VIDEOHWACCEL
    5573     vbvaTimerCb(pDevIns, pThis, pThisCC);
    5574 # endif
    5575 
    55765570# ifdef VBOX_WITH_VMSVGA
    55775571    /*
    … …  
    58275821static DECLCALLBACK(int) vgaR3SavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    58285822{
    5829 # ifdef VBOX_WITH_VIDEOHWACCEL
    5830     RT_NOREF(pSSM);
    5831     return vboxVBVASaveStatePrep(pDevIns);
    5832 # else
    58335823    RT_NOREF(pDevIns, pSSM);
    58345824    return VINF_SUCCESS;
    5835 # endif
    58365825}
    58375826
    … …  
    58425831static DECLCALLBACK(int) vgaR3SaveDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    58435832{
    5844 # ifdef VBOX_WITH_VIDEOHWACCEL
    5845     RT_NOREF(pSSM);
    5846     return vboxVBVASaveStateDone(pDevIns);
    5847 # else
    58485833    RT_NOREF(pDevIns, pSSM);
    58495834    return VINF_SUCCESS;
    5850 # endif
    58515835}
    58525836
    … …  
    62586242                        rc = VERR_INTERNAL_ERROR;
    62596243                    }
    6260 # ifdef VBOX_WITH_VIDEOHWACCEL
    6261                     if(rc == VINF_SUCCESS)
    6262                     {
    6263                         rc = vbvaVHWAConstruct(pDevIns, pThis, pThisCC);
    6264                         if (rc != VERR_NOT_IMPLEMENTED)
    6265                             AssertRC(rc);
    6266                     }
    6267 # endif
    62686244                }
    62696245                else
    … …  
    63766352    }
    63776353
    6378 # if defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM)
     6354# if defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM)
    63796355    PDMDevHlpCritSectDelete(pDevIns, &pThis->CritSectIRQ);
    63806356# endif
    … …  
    66296605    PDMPciDevSetClassBase(pPciDev,              0x03);
    66306606    PDMPciDevSetHeaderType(pPciDev,             0x00);
    6631 # if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM))
     6607# if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM))
    66326608    PDMPciDevSetInterruptPin(pPciDev,           1);
    66336609# endif
    … …  
    66586634    pThisCC->IPort.pfnReportHostCursorCapabilities = vgaR3PortReportHostCursorCapabilities;
    66596635    pThisCC->IPort.pfnReportHostCursorPosition = vgaR3PortReportHostCursorPosition;
    6660 
    6661 # if defined(VBOX_WITH_HGSMI) && defined(VBOX_WITH_VIDEOHWACCEL)
    6662     pThisCC->IVBVACallbacks.pfnVHWACommandCompleteAsync = vbvaR3VHWACommandCompleteAsync;
    6663 # endif
    66646636
    66656637    pThisCC->ILeds.pfnQueryStatusLed    = vgaR3PortQueryStatusLed;

  • trunk/src/VBox/Devices/Graphics/DevVGA.h

    r106061 r108641  
    281281#endif
    282282
    283 #ifdef VBOX_WITH_VIDEOHWACCEL
    284 #define VBOX_VHWA_MAX_PENDING_COMMANDS 1000
    285 
    286 typedef struct _VBOX_VHWA_PENDINGCMD
    287 {
    288     RTLISTNODE Node;
    289     VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand;
    290 } VBOX_VHWA_PENDINGCMD;
    291 #endif
    292 
    293 
    294283/**
    295284 * The shared VGA state data.
    … …  
    577566    /** LUN\#0: The display port interface. */
    578567    PDMIDISPLAYPORT             IPort;
    579 #ifdef VBOX_WITH_HGSMI
    580     /** LUN\#0: VBVA callbacks interface */
    581     PDMIDISPLAYVBVACALLBACKS    IVBVACallbacks;
    582 #endif
    583568    /** Status LUN: Leds interface. */
    584569    PDMILEDPORTS                ILeds;
    … …  
    728713#endif
    729714
    730 # ifdef VBOX_WITH_VIDEOHWACCEL
    731 DECLCALLBACK(int) vbvaR3VHWACommandCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface,
    732                                                  VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd);
    733 int vbvaVHWAConstruct(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
    734 
    735 void vbvaTimerCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
    736 
    737 int vboxVBVASaveStatePrep(PPDMDEVINS pDevIns);
    738 int vboxVBVASaveStateDone(PPDMDEVINS pDevIns);
    739 # endif
    740 
    741715int vboxVBVASaveStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM);
    742716int vboxVBVALoadStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t u32Version);

  • trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp

    r107630 r108641  
    4343#include <iprt/string.h>
    4444#include <iprt/param.h>
    45 #ifdef VBOX_WITH_VIDEOHWACCEL
    46 #include <iprt/semaphore.h>
    47 #endif
    4845
    4946#include "DevVGA.h"
    … …  
    857854#define VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC 0x9abcdef0
    858855
    859 #ifdef VBOX_WITH_VIDEOHWACCEL
    860 
    861 static void vbvaVHWAHHCommandReinit(VBOXVHWACMD* pHdr, VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay)
    862 {
    863     memset(pHdr, 0, VBOXVHWACMD_HEADSIZE());
    864     pHdr->cRefs = 1;
    865     pHdr->iDisplay = iDisplay;
    866     pHdr->rc = VERR_NOT_IMPLEMENTED;
    867     pHdr->enmCmd = enmCmd;
    868     pHdr->Flags = VBOXVHWACMD_FLAG_HH_CMD;
    869 }
    870 
    871 static VBOXVHWACMD *vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay, VBOXVHWACMD_LENGTH cbCmd)
    872 {
    873     VBOXVHWACMD *pHdr = (VBOXVHWACMD *)RTMemAllocZ(cbCmd + VBOXVHWACMD_HEADSIZE());
    874     Assert(pHdr);
    875     if (pHdr)
    876         vbvaVHWAHHCommandReinit(pHdr, enmCmd, iDisplay);
    877 
    878     return pHdr;
    879 }
    880 
    881 DECLINLINE(void) vbvaVHWAHHCommandRelease(VBOXVHWACMD *pCmd)
    882 {
    883     uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
    884     if (!cRefs)
    885         RTMemFree(pCmd);
    886 }
    887 
    888 DECLINLINE(void) vbvaVHWAHHCommandRetain(VBOXVHWACMD *pCmd)
    889 {
    890     ASMAtomicIncU32(&pCmd->cRefs);
    891 }
    892 
    893 static void vbvaVHWACommandComplete(PVGASTATECC pThisCC, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
    894 {
    895     if (fAsyncCommand)
    896     {
    897         Assert(pCommand->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
    898         vbvaR3VHWACommandCompleteAsync(&pThisCC->IVBVACallbacks, pCommand);
    899     }
    900     else
    901     {
    902         Log(("VGA Command <<< Sync rc %d %#p, %d\n", pCommand->rc, pCommand, pCommand->enmCmd));
    903         pCommand->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
    904     }
    905 
    906 }
    907 
    908 static void vbvaVHWACommandCompleteAllPending(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, int rc)
    909 {
    910     if (!ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending))
    911         return;
    912 
    913     int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    914     PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    915 
    916     VBOX_VHWA_PENDINGCMD *pIter, *pNext;
    917     RTListForEachSafe(&pThis->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
    918     {
    919         pIter->pCommand->rc = rc;
    920         vbvaVHWACommandComplete(pThisCC, pIter->pCommand, true);
    921 
    922         /* the command is submitted/processed, remove from the pend list */
    923         RTListNodeRemove(&pIter->Node);
    924         ASMAtomicDecU32(&pThis->pendingVhwaCommands.cPending);
    925         RTMemFree(pIter);
    926     }
    927 
    928     PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    929 }
    930 
    931 static void vbvaVHWACommandClearAllPending(PPDMDEVINS pDevIns, PVGASTATE pThis)
    932 {
    933     if (!ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending))
    934         return;
    935 
    936     int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    937     PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    938 
    939     VBOX_VHWA_PENDINGCMD *pIter, *pNext;
    940     RTListForEachSafe(&pThis->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
    941     {
    942         RTListNodeRemove(&pIter->Node);
    943         ASMAtomicDecU32(&pThis->pendingVhwaCommands.cPending);
    944         RTMemFree(pIter);
    945     }
    946 
    947     PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    948 }
    949 
    950 static void vbvaVHWACommandPend(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
    951                                 VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand)
    952 {
    953     int rc = VERR_BUFFER_OVERFLOW;
    954 
    955     if (ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
    956     {
    957         VBOX_VHWA_PENDINGCMD *pPend = (VBOX_VHWA_PENDINGCMD *)RTMemAlloc(sizeof(*pPend));
    958         if (pPend)
    959         {
    960             pCommand->Flags |= VBOXVHWACMD_FLAG_HG_ASYNCH;
    961             pPend->pCommand = pCommand;
    962 
    963             int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    964             PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    965 
    966             if (ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
    967             {
    968                 RTListAppend(&pThis->pendingVhwaCommands.PendingList, &pPend->Node);
    969                 ASMAtomicIncU32(&pThis->pendingVhwaCommands.cPending);
    970                 PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    971                 return;
    972             }
    973             PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    974             LogRel(("VBVA: Pending command count has reached its threshold.. completing them all.."));
    975             RTMemFree(pPend);
    976         }
    977         else
    978             rc = VERR_NO_MEMORY;
    979     }
    980     else
    981         LogRel(("VBVA: Pending command count has reached its threshold, completing them all.."));
    982 
    983     vbvaVHWACommandCompleteAllPending(pDevIns, pThis, pThisCC, rc);
    984 
    985     pCommand->rc = rc;
    986 
    987     vbvaVHWACommandComplete(pThisCC, pCommand, false);
    988 }
    989 
    990 static bool vbvaVHWACommandCanPend(VBOXVHWACMD_TYPE enmCmd)
    991 {
    992     switch (enmCmd)
    993     {
    994         case VBOXVHWACMD_TYPE_HH_CONSTRUCT:
    995         case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN:
    996         case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND:
    997         case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM:
    998         case VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM:
    999             return false;
    1000         default:
    1001             return true;
    1002     }
    1003 }
    1004 
    1005 static int vbvaVHWACommandSavePending(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PVGASTATECC pThisCC, PSSMHANDLE pSSM)
    1006 {
    1007     int rc = pHlp->pfnSSMPutU32(pSSM, pThis->pendingVhwaCommands.cPending);
    1008     AssertRCReturn(rc, rc);
    1009 
    1010     VBOX_VHWA_PENDINGCMD *pIter;
    1011     RTListForEach(&pThis->pendingVhwaCommands.PendingList, pIter, VBOX_VHWA_PENDINGCMD, Node)
    1012     {
    1013         AssertContinue((uintptr_t)pIter->pCommand - (uintptr_t)pThisCC->pbVRam < pThis->vram_size);
    1014         rc = pHlp->pfnSSMPutU32(pSSM, (uint32_t)(((uint8_t *)pIter->pCommand) - ((uint8_t *)pThisCC->pbVRam)));
    1015         AssertRCReturn(rc, rc);
    1016     }
    1017     return rc;
    1018 }
    1019 
    1020 static int vbvaVHWACommandLoadPending(PPDMDEVINS pDevIns, PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PVGASTATECC pThisCC,
    1021                                       PSSMHANDLE pSSM, uint32_t u32Version)
    1022 {
    1023     if (u32Version < VGA_SAVEDSTATE_VERSION_WITH_PENDVHWA)
    1024         return VINF_SUCCESS;
    1025 
    1026     uint32_t u32;
    1027     int rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    1028     AssertRCReturn(rc, rc);
    1029     for (uint32_t i = 0; i < u32; ++i)
    1030     {
    1031         uint32_t off32;
    1032         rc = pHlp->pfnSSMGetU32(pSSM, &off32);
    1033         AssertRCReturn(rc, rc);
    1034         VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand
    1035             = (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)((uint8_t volatile *)pThisCC->pbVRam + off32);
    1036         vbvaVHWACommandPend(pDevIns, pThis, pThisCC, pCommand);
    1037     }
    1038     return rc;
    1039 }
    1040 
    1041 
    1042 /** Worker for vbvaVHWACommandSubmit. */
    1043 static bool vbvaVHWACommandSubmitInner(PVGASTATE pThis, PVGASTATECC pThisCC,
    1044                                        VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool *pfPending)
    1045 {
    1046     *pfPending = false;
    1047 
    1048     /*
    1049      * Read the command type and validate it and our driver state.
    1050      */
    1051     VBOXVHWACMD_TYPE enmCmd = pCommand->enmCmd;
    1052     RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
    1053 
    1054     bool fGuestCmd = (uintptr_t)pCommand - (uintptr_t)pThisCC->pbVRam < pThis->vram_size;
    1055     ASSERT_GUEST_LOGREL_MSG_STMT_RETURN(   !fGuestCmd
    1056                                         || (   enmCmd != VBOXVHWACMD_TYPE_HH_CONSTRUCT
    1057                                             && enmCmd != VBOXVHWACMD_TYPE_HH_RESET
    1058                                             && enmCmd != VBOXVHWACMD_TYPE_HH_DISABLE
    1059                                             && enmCmd != VBOXVHWACMD_TYPE_HH_ENABLE
    1060                                             && enmCmd != VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN
    1061                                             && enmCmd != VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND
    1062                                             && enmCmd != VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM
    1063                                             && enmCmd != VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM),
    1064                                         ("enmCmd=%d\n", enmCmd),
    1065                                         pCommand->rc = VERR_INVALID_PARAMETER,
    1066                                         true);
    1067     ASSERT_GUEST_STMT_RETURN(pThisCC->pDrv->pfnVHWACommandProcess, pCommand->rc = VERR_INVALID_STATE, true);
    1068     RT_UNTRUSTED_VALIDATED_FENCE();
    1069 
    1070     /*
    1071      * Call the driver to process the command.
    1072      */
    1073     Log(("VGA Command >>> %#p, %d\n", pCommand, enmCmd));
    1074     int rc = pThisCC->pDrv->pfnVHWACommandProcess(pThisCC->pDrv, enmCmd, fGuestCmd, pCommand);
    1075     if (rc == VINF_CALLBACK_RETURN)
    1076     {
    1077         Log(("VGA Command --- Going Async %#p, %d\n", pCommand, enmCmd));
    1078         *pfPending = true;
    1079         return true; /* Command will be completed asynchronously by the driver and need not be put in the pending list. */
    1080     }
    1081 
    1082     if (rc == VERR_INVALID_STATE)
    1083     {
    1084         Log(("VGA Command --- Trying Pend %#p, %d\n", pCommand, enmCmd));
    1085         if (vbvaVHWACommandCanPend(enmCmd))
    1086         {
    1087             Log(("VGA Command --- Can Pend %#p, %d\n", pCommand, enmCmd));
    1088             *pfPending = true;
    1089             return false; /* put on pending list so it can be retried?? */
    1090         }
    1091 
    1092         Log(("VGA Command --- Can NOT Pend %#p, %d\n", pCommand, enmCmd));
    1093     }
    1094     else
    1095         Log(("VGA Command --- Going Complete Sync rc %d %#p, %d\n", rc, pCommand, enmCmd));
    1096 
    1097     /* the command was completed, take a special care about it (see caller) */
    1098     pCommand->rc = rc;
    1099     return true;
    1100 }
    1101 
    1102 
    1103 static bool vbvaVHWACommandSubmit(PVGASTATE pThis, PVGASTATECC pThisCC,
    1104                                   VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
    1105 {
    1106     bool fPending = false;
    1107     bool fRet = vbvaVHWACommandSubmitInner(pThis, pThisCC, pCommand, &fPending);
    1108     if (!fPending)
    1109         vbvaVHWACommandComplete(pThisCC, pCommand, fAsyncCommand);
    1110     return fRet;
    1111 }
    1112 
    1113 
    1114 /**
    1115  * @returns false if commands are pending, otherwise true.
    1116  */
    1117 static bool vbvaVHWACheckPendingCommands(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    1118 {
    1119     if (!ASMAtomicUoReadU32(&pThis->pendingVhwaCommands.cPending))
    1120         return true;
    1121 
    1122     int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY);
    1123     PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    1124 
    1125     VBOX_VHWA_PENDINGCMD *pIter, *pNext;
    1126     RTListForEachSafe(&pThis->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
    1127     {
    1128         if (!vbvaVHWACommandSubmit(pThis, pThisCC, pIter->pCommand, true))
    1129         {
    1130             PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    1131             return false; /* the command should be still pending */
    1132         }
    1133 
    1134         /* the command is submitted/processed, remove from the pend list */
    1135         RTListNodeRemove(&pIter->Node);
    1136         ASMAtomicDecU32(&pThis->pendingVhwaCommands.cPending);
    1137         RTMemFree(pIter);
    1138     }
    1139 
    1140     PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
    1141 
    1142     return true;
    1143 }
    1144 
    1145 void vbvaTimerCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    1146 {
    1147     vbvaVHWACheckPendingCommands(pDevIns, pThis, pThisCC);
    1148 }
    1149 
    1150 static void vbvaVHWAHandleCommand(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
    1151                                   VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
    1152 {
    1153     if (vbvaVHWACheckPendingCommands(pDevIns, pThis, pThisCC))
    1154     {
    1155         if (vbvaVHWACommandSubmit(pThis, pThisCC, pCmd, false))
    1156             return;
    1157     }
    1158 
    1159     vbvaVHWACommandPend(pDevIns, pThis, pThisCC, pCmd);
    1160 }
    1161 
    1162 static DECLCALLBACK(void) vbvaVHWAHHCommandSetEventCallback(void * pContext)
    1163 {
    1164     RTSemEventSignal((RTSEMEVENT)pContext);
    1165 }
    1166 
    1167 static int vbvaVHWAHHCommandPost(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, VBOXVHWACMD *pCmd)
    1168 {
    1169     RTSEMEVENT hComplEvent;
    1170     int rc = RTSemEventCreate(&hComplEvent);
    1171     AssertRC(rc);
    1172     if (RT_SUCCESS(rc))
    1173     {
    1174         /* ensure the cmd is not deleted until we process it */
    1175         vbvaVHWAHHCommandRetain(pCmd);
    1176 
    1177         VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandSetEventCallback, (void *)hComplEvent);
    1178         vbvaVHWAHandleCommand(pDevIns, pThis, pThisCC, pCmd);
    1179 
    1180         if ((ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags) & VBOXVHWACMD_FLAG_HG_ASYNCH) != 0)
    1181             rc = RTSemEventWaitNoResume(hComplEvent, RT_INDEFINITE_WAIT); /** @todo Why the NoResume and event leaking here? */
    1182         /* else: the command is completed */
    1183 
    1184         AssertRC(rc);
    1185         if (RT_SUCCESS(rc))
    1186             RTSemEventDestroy(hComplEvent);
    1187 
    1188         vbvaVHWAHHCommandRelease(pCmd);
    1189     }
    1190     return rc;
    1191 }
    1192 
    1193 int vbvaVHWAConstruct(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    1194 {
    1195     pThis->pendingVhwaCommands.cPending = 0;
    1196     RTListInit(&pThis->pendingVhwaCommands.PendingList);
    1197 
    1198     VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_CONSTRUCT, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
    1199     Assert(pCmd);
    1200     if(pCmd)
    1201     {
    1202         uint32_t iDisplay = 0;
    1203         int rc = VINF_SUCCESS;
    1204         VBOXVHWACMD_HH_CONSTRUCT *pBody = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
    1205 
    1206         for (;;)
    1207         {
    1208             memset(pBody, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
    1209 
    1210             PVM pVM = PDMDevHlpGetVM(pDevIns);
    1211 
    1212             pBody->pVM = pVM;
    1213             pBody->pvVRAM = pThisCC->pbVRam;
    1214             pBody->cbVRAM = pThis->vram_size;
    1215 
    1216             rc = vbvaVHWAHHCommandPost(pDevIns, pThis, pThisCC, pCmd);
    1217             ASMCompilerBarrier();
    1218 
    1219             AssertRC(rc);
    1220             if (RT_SUCCESS(rc))
    1221             {
    1222                 rc = pCmd->rc;
    1223                 AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
    1224                 if(rc == VERR_NOT_IMPLEMENTED)
    1225                 {
    1226                     /** @todo set some flag in pThis indicating VHWA is not supported */
    1227                     /* VERR_NOT_IMPLEMENTED is not a failure, we just do not support it */
    1228                     rc = VINF_SUCCESS;
    1229                 }
    1230 
    1231                 if (!RT_SUCCESS(rc))
    1232                     break;
    1233             }
    1234             else
    1235                 break;
    1236 
    1237             ++iDisplay;
    1238             if (iDisplay >= pThis->cMonitors)
    1239                 break;
    1240             vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_CONSTRUCT, (int32_t)iDisplay);
    1241         }
    1242 
    1243         vbvaVHWAHHCommandRelease(pCmd);
    1244 
    1245         return rc;
    1246     }
    1247     return VERR_OUT_OF_RESOURCES;
    1248 }
    1249 
    1250 static int vbvaVHWAReset(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    1251 {
    1252     vbvaVHWACommandClearAllPending(pDevIns, pThis);
    1253 
    1254     /* ensure we have all pending cmds processed and h->g cmds disabled */
    1255     VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_RESET, 0, 0);
    1256     Assert(pCmd);
    1257     if (pCmd)
    1258     {
    1259         int rc = VINF_SUCCESS;
    1260         uint32_t iDisplay = 0;
    1261 
    1262         do
    1263         {
    1264             rc = vbvaVHWAHHCommandPost(pDevIns, pThis, pThisCC, pCmd);
    1265             AssertRC(rc);
    1266             if(RT_SUCCESS(rc))
    1267             {
    1268                 rc = pCmd->rc;
    1269                 AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
    1270                 if (rc == VERR_NOT_IMPLEMENTED)
    1271                     rc = VINF_SUCCESS;
    1272             }
    1273 
    1274             if (!RT_SUCCESS(rc))
    1275                 break;
    1276 
    1277             ++iDisplay;
    1278             if (iDisplay >= pThis->cMonitors)
    1279                 break;
    1280             vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_RESET, (int32_t)iDisplay);
    1281 
    1282         } while (true);
    1283 
    1284         vbvaVHWAHHCommandRelease(pCmd);
    1285 
    1286         return rc;
    1287     }
    1288     return VERR_OUT_OF_RESOURCES;
    1289 }
    1290 
    1291 typedef DECLCALLBACKTYPE(bool, FNVBOXVHWAHHCMDPRECB,(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, VBOXVHWACMD *pCmd,
    1292                                                 uint32_t iDisplay, void *pvContext));
    1293 typedef FNVBOXVHWAHHCMDPRECB *PFNVBOXVHWAHHCMDPRECB;
    1294 
    1295 typedef DECLCALLBACKTYPE(bool, FNVBOXVHWAHHCMDPOSTCB,(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, VBOXVHWACMD *pCmd,
    1296                                                  uint32_t iDisplay, int rc, void *pvContext));
    1297 typedef FNVBOXVHWAHHCMDPOSTCB *PFNVBOXVHWAHHCMDPOSTCB;
    1298 
    1299 static int vbvaVHWAHHPost(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, VBOXVHWACMD *pCmd,
    1300                           PFNVBOXVHWAHHCMDPRECB pfnPre, PFNVBOXVHWAHHCMDPOSTCB pfnPost, void *pvContext)
    1301 {
    1302     const VBOXVHWACMD_TYPE enmType = pCmd->enmCmd;
    1303     int rc = VINF_SUCCESS;
    1304     uint32_t iDisplay = 0;
    1305 
    1306     do
    1307     {
    1308         if (!pfnPre || pfnPre(pDevIns, pThis, pThisCC, pCmd, iDisplay, pvContext))
    1309         {
    1310             rc = vbvaVHWAHHCommandPost(pDevIns, pThis, pThisCC, pCmd);
    1311             AssertRC(rc);
    1312             if (pfnPost)
    1313             {
    1314                 if (!pfnPost(pDevIns, pThis, pThisCC, pCmd, iDisplay, rc, pvContext))
    1315                 {
    1316                     rc = VINF_SUCCESS;
    1317                     break;
    1318                 }
    1319                 rc = VINF_SUCCESS;
    1320             }
    1321             else if(RT_SUCCESS(rc))
    1322             {
    1323                 rc = pCmd->rc;
    1324                 AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
    1325                 if(rc == VERR_NOT_IMPLEMENTED)
    1326                 {
    1327                     rc = VINF_SUCCESS;
    1328                 }
    1329             }
    1330 
    1331             if (!RT_SUCCESS(rc))
    1332                 break;
    1333         }
    1334 
    1335         ++iDisplay;
    1336         if (iDisplay >= pThis->cMonitors)
    1337             break;
    1338         vbvaVHWAHHCommandReinit(pCmd, enmType, (int32_t)iDisplay);
    1339     } while (true);
    1340 
    1341     return rc;
    1342 }
    1343 
    1344 /** @todo call this also on reset? */
    1345 static int vbvaVHWAEnable(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, bool bEnable)
    1346 {
    1347     const VBOXVHWACMD_TYPE enmType = bEnable ? VBOXVHWACMD_TYPE_HH_ENABLE : VBOXVHWACMD_TYPE_HH_DISABLE;
    1348     VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(enmType, 0, 0);
    1349     Assert(pCmd);
    1350     if(pCmd)
    1351     {
    1352         int rc = vbvaVHWAHHPost(pDevIns, pThis, pThisCC, pCmd, NULL, NULL, NULL);
    1353         vbvaVHWAHHCommandRelease(pCmd);
    1354         return rc;
    1355     }
    1356     return VERR_OUT_OF_RESOURCES;
    1357 }
    1358 
    1359 int vboxVBVASaveStatePrep(PPDMDEVINS pDevIns)
    1360 {
    1361     /* ensure we have no pending commands */
    1362     return vbvaVHWAEnable(pDevIns, PDMDEVINS_2_DATA(pDevIns, PVGASTATE), PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC), false);
    1363 }
    1364 
    1365 int vboxVBVASaveStateDone(PPDMDEVINS pDevIns)
    1366 {
    1367     /* ensure we have no pending commands */
    1368     return vbvaVHWAEnable(pDevIns, PDMDEVINS_2_DATA(pDevIns, PVGASTATE), PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC), true);
    1369 }
    1370 
    1371 
    1372 /**
    1373  * @interface_method_impl{PDMIDISPLAYVBVACALLBACKS,pfnVHWACommandCompleteAsync}
    1374  */
    1375 DECLCALLBACK(int) vbvaR3VHWACommandCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface,
    1376                                                  VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
    1377 {
    1378     PVGASTATECC pThisCC = RT_FROM_MEMBER(pInterface, VGASTATECC, IVBVACallbacks);
    1379     PPDMDEVINS  pDevIns = pThisCC->pDevIns;
    1380     PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
    1381     int rc;
    1382 
    1383     Log(("VGA Command <<< Async rc %d %#p, %d\n", pCmd->rc, pCmd, pCmd->enmCmd));
    1384 
    1385     if ((uintptr_t)pCmd - (uintptr_t)pThisCC->pbVRam < pThis->vram_size)
    1386     {
    1387         PHGSMIINSTANCE pIns = pThisCC->pHGSMI;
    1388         Assert(!(pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD));
    1389         Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
    1390 #ifdef VBOX_WITH_WDDM
    1391         if (pThis->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD)
    1392         {
    1393             rc = HGSMICompleteGuestCommand(pIns, pCmd, !!(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
    1394             AssertRC(rc);
    1395         }
    1396         else
    1397 #endif
    1398         {
    1399             VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_GUEST *pHostCmd = NULL; /* Shut up MSC. */
    1400             if (pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT)
    1401             {
    1402                 rc = HGSMIHostCommandAlloc(pIns,
    1403                                            (void RT_UNTRUSTED_VOLATILE_GUEST **)&pHostCmd,
    1404                                            VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)),
    1405                                            HGSMI_CH_VBVA,
    1406                                            VBVAHG_EVENT);
    1407                 AssertRC(rc);
    1408                 if (RT_SUCCESS(rc))
    1409                 {
    1410                     memset((void *)pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)));
    1411                     pHostCmd->iDstID = pCmd->iDisplay;
    1412                     pHostCmd->customOpCode = 0;
    1413                     VBVAHOSTCMDEVENT RT_UNTRUSTED_VOLATILE_GUEST *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDEVENT);
    1414                     pBody->pEvent = pCmd->GuestVBVAReserved1;
    1415                 }
    1416             }
    1417             else
    1418             {
    1419                 HGSMIOFFSET offCmd = HGSMIPointerToOffsetHost(pIns, pCmd);
    1420                 Assert(offCmd != HGSMIOFFSET_VOID);
    1421                 if (offCmd != HGSMIOFFSET_VOID)
    1422                 {
    1423                     rc = HGSMIHostCommandAlloc(pIns,
    1424                                                (void RT_UNTRUSTED_VOLATILE_GUEST **)&pHostCmd,
    1425                                                VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)),
    1426                                                HGSMI_CH_VBVA,
    1427                                                VBVAHG_DISPLAY_CUSTOM);
    1428                     AssertRC(rc);
    1429                     if (RT_SUCCESS(rc))
    1430                     {
    1431                         memset((void *)pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)));
    1432                         pHostCmd->iDstID = pCmd->iDisplay;
    1433                         pHostCmd->customOpCode = VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE;
    1434                         VBVAHOSTCMDVHWACMDCOMPLETE RT_UNTRUSTED_VOLATILE_GUEST *pBody
    1435                             = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE);
    1436                         pBody->offCmd = offCmd;
    1437                     }
    1438                 }
    1439                 else
    1440                     rc = VERR_INVALID_PARAMETER;
    1441             }
    1442 
    1443             if (RT_SUCCESS(rc))
    1444             {
    1445                 rc = HGSMIHostCommandSubmitAndFreeAsynch(pIns, pHostCmd, RT_BOOL(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
    1446                 AssertRC(rc);
    1447                 if (RT_SUCCESS(rc))
    1448                     return rc;
    1449 
    1450                 HGSMIHostCommandFree (pIns, pHostCmd);
    1451             }
    1452         }
    1453     }
    1454     else
    1455     {
    1456         Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD);
    1457         PFNVBOXVHWA_HH_CALLBACK pfn = VBOXVHWA_HH_CALLBACK_GET(pCmd);
    1458         if (pfn)
    1459             pfn(VBOXVHWA_HH_CALLBACK_GET_ARG(pCmd));
    1460         rc = VINF_SUCCESS;
    1461     }
    1462     return rc;
    1463 }
    1464 
    1465 typedef struct VBOXVBVASAVEDSTATECBDATA
    1466 {
    1467     PSSMHANDLE pSSM;
    1468     int rc;
    1469     bool ab2DOn[VBOX_VIDEO_MAX_SCREENS];
    1470 } VBOXVBVASAVEDSTATECBDATA, *PVBOXVBVASAVEDSTATECBDATA;
    1471 
    1472 /**
    1473  * @callback_method_impl{FNVBOXVHWAHHCMDPOSTCB}
    1474  */
    1475 static DECLCALLBACK(bool) vboxVBVASaveStateBeginPostCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
    1476                                                        VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext)
    1477 {
    1478     RT_NOREF(pDevIns, pThis, pThisCC, pCmd);
    1479     PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
    1480     if (RT_FAILURE(pData->rc))
    1481         return false;
    1482     if (RT_FAILURE(rc))
    1483     {
    1484         pData->rc = rc;
    1485         return false;
    1486     }
    1487 
    1488     Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
    1489     if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
    1490     {
    1491         pData->rc = VERR_INVALID_PARAMETER;
    1492         return false;
    1493     }
    1494 
    1495     Assert(RT_SUCCESS(pCmd->rc) || pCmd->rc == VERR_NOT_IMPLEMENTED);
    1496     if (RT_SUCCESS(pCmd->rc))
    1497     {
    1498         pData->ab2DOn[iDisplay] = true;
    1499     }
    1500     else if (pCmd->rc != VERR_NOT_IMPLEMENTED)
    1501     {
    1502         pData->rc = pCmd->rc;
    1503         return false;
    1504     }
    1505 
    1506     return true;
    1507 }
    1508 
    1509 /**
    1510  * @callback_method_impl{FNVBOXVHWAHHCMDPRECB}
    1511  */
    1512 static DECLCALLBACK(bool) vboxVBVASaveStatePerformPreCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
    1513                                                         VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
    1514 {
    1515     RT_NOREF(pThis, pThisCC, pCmd);
    1516     PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
    1517     if (RT_FAILURE(pData->rc))
    1518         return false;
    1519 
    1520     Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
    1521     if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
    1522     {
    1523         pData->rc = VERR_INVALID_PARAMETER;
    1524         return false;
    1525     }
    1526 
    1527     int rc;
    1528     PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
    1529 
    1530     if (pData->ab2DOn[iDisplay])
    1531     {
    1532         rc = pHlp->pfnSSMPutU32(pData->pSSM, VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC); AssertRC(rc);
    1533         if (RT_FAILURE(rc))
    1534         {
    1535             pData->rc = rc;
    1536             return false;
    1537         }
    1538         return true;
    1539     }
    1540 
    1541     rc = pHlp->pfnSSMPutU32(pData->pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC); AssertRC(rc);
    1542     if (RT_FAILURE(rc))
    1543     {
    1544         pData->rc = rc;
    1545         return false;
    1546     }
    1547 
    1548     return false;
    1549 }
    1550 
    1551 /**
    1552  * @callback_method_impl{FNVBOXVHWAHHCMDPOSTCB}
    1553  */
    1554 static DECLCALLBACK(bool) vboxVBVASaveStateEndPreCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
    1555                                                     VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
    1556 {
    1557     RT_NOREF(pDevIns, pThis, pThisCC, pCmd);
    1558     PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
    1559     Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
    1560     if (pData->ab2DOn[iDisplay])
    1561         return true;
    1562     return false;
    1563 }
    1564 
    1565 /**
    1566  * @callback_method_impl{FNVBOXVHWAHHCMDPOSTCB}
    1567  */
    1568 static DECLCALLBACK(bool) vboxVBVALoadStatePerformPostCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
    1569                                                          VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext)
    1570 {
    1571     RT_NOREF(pThis, pThisCC, pCmd);
    1572     PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
    1573     if (RT_FAILURE(pData->rc))
    1574         return false;
    1575     if (RT_FAILURE(rc))
    1576     {
    1577         pData->rc = rc;
    1578         return false;
    1579     }
    1580 
    1581     Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
    1582     if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
    1583     {
    1584         pData->rc = VERR_INVALID_PARAMETER;
    1585         return false;
    1586     }
    1587 
    1588     PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
    1589     Assert(RT_SUCCESS(pCmd->rc) || pCmd->rc == VERR_NOT_IMPLEMENTED);
    1590     if (pCmd->rc == VERR_NOT_IMPLEMENTED)
    1591     {
    1592         pData->rc = pHlp->pfnSSMSkipToEndOfUnit(pData->pSSM);
    1593         AssertRC(pData->rc);
    1594         return false;
    1595     }
    1596     if (RT_FAILURE(pCmd->rc))
    1597     {
    1598         pData->rc = pCmd->rc;
    1599         return false;
    1600     }
    1601 
    1602     return true;
    1603 }
    1604 
    1605 /**
    1606  * @callback_method_impl{FNVBOXVHWAHHCMDPOSTCB}
    1607  */
    1608 static DECLCALLBACK(bool) vboxVBVALoadStatePerformPreCb(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
    1609                                                         VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
    1610 {
    1611     RT_NOREF(pThis, pThisCC, pCmd);
    1612     PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
    1613     if (RT_FAILURE(pData->rc))
    1614         return false;
    1615 
    1616     Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
    1617     if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
    1618     {
    1619         pData->rc = VERR_INVALID_PARAMETER;
    1620         return false;
    1621     }
    1622 
    1623     PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
    1624     int rc;
    1625     uint32_t u32;
    1626     rc = pHlp->pfnSSMGetU32(pData->pSSM, &u32); AssertRC(rc);
    1627     if (RT_FAILURE(rc))
    1628     {
    1629         pData->rc = rc;
    1630         return false;
    1631     }
    1632 
    1633     switch (u32)
    1634     {
    1635         case VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC:
    1636             pData->ab2DOn[iDisplay] = true;
    1637             return true;
    1638         case VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC:
    1639             pData->ab2DOn[iDisplay] = false;
    1640             return false;
    1641         default:
    1642             pData->rc = VERR_INVALID_STATE;
    1643             return false;
    1644     }
    1645 }
    1646 
    1647 #endif /* VBOX_WITH_VIDEOHWACCEL */
    1648 
    1649856static int vboxVBVASaveDevStateExec(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PVGASTATECC pThisCC, PSSMHANDLE pSSM)
    1650857{
    … …  
    1775982    PVGASTATECC     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
    1776983    PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
    1777     int rc;
    1778 #ifdef VBOX_WITH_VIDEOHWACCEL
    1779     VBOXVBVASAVEDSTATECBDATA VhwaData = {0};
    1780     VhwaData.pSSM = pSSM;
    1781     uint32_t cbCmd = sizeof (VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM); /* maximum cmd size */
    1782     VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN, 0, cbCmd);
    1783     Assert(pCmd);
    1784     if (pCmd)
    1785     {
    1786         vbvaVHWAHHPost(pDevIns, pThis, pThisCC, pCmd, NULL, vboxVBVASaveStateBeginPostCb, &VhwaData);
    1787         rc = VhwaData.rc;
    1788         AssertRC(rc);
    1789         if (RT_SUCCESS(rc))
    1790         {
    1791 #endif
    1792             rc = vboxVBVASaveDevStateExec(pHlp, pThis, pThisCC, pSSM);
    1793             AssertRC(rc);
    1794 #ifdef VBOX_WITH_VIDEOHWACCEL
    1795             if (RT_SUCCESS(rc))
    1796             {
    1797                 vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM, 0);
    1798                 VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM);
    1799                 pSave->pSSM = pSSM;
    1800                 vbvaVHWAHHPost(pDevIns, pThis, pThisCC, pCmd, vboxVBVASaveStatePerformPreCb, NULL, &VhwaData);
    1801                 rc = VhwaData.rc;
    1802                 AssertRC(rc);
    1803                 if (RT_SUCCESS(rc))
    1804                 {
    1805                     rc = vbvaVHWACommandSavePending(pHlp, pThis, pThisCC, pSSM);
    1806                     AssertRCReturn(rc, rc);
    1807 
    1808                     vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND, 0);
    1809                     vbvaVHWAHHPost(pDevIns, pThis, pThisCC, pCmd, vboxVBVASaveStateEndPreCb, NULL, &VhwaData);
    1810                     rc = VhwaData.rc;
    1811                     AssertRC(rc);
    1812                 }
    1813             }
    1814         }
    1815 
    1816         vbvaVHWAHHCommandRelease(pCmd);
    1817     }
    1818     else
    1819         rc = VERR_OUT_OF_RESOURCES;
    1820 #else
     984
     985    int rc = vboxVBVASaveDevStateExec(pHlp, pThis, pThisCC, pSSM);
    1821986    if (RT_SUCCESS(rc))
    1822987    {
    … …  
    1830995    /* no pending commands */
    1831996    pHlp->pfnSSMPutU32(pSSM, 0);
    1832 #endif
     997
    1833998    return rc;
    1834999}
    … …  
    20171182            if (uVersion > VGA_SAVEDSTATE_VERSION_WDDM)
    20181183            {
    2019                 bool fLoadCommands;
    2020 
    2021                 if (uVersion < VGA_SAVEDSTATE_VERSION_FIXED_PENDVHWA)
     1184                /* Skip loading VHWA (2D Video Hardware Acceleration) state from older saved states. */
     1185                if (uVersion < VGA_SAVEDSTATE_VERSION_VHWA_REMOVED)
    20221186                {
    2023                     const char *pcszOsArch = pHlp->pfnSSMHandleHostOSAndArch(pSSM);
    2024                     Assert(pcszOsArch);
    2025                     fLoadCommands = !pcszOsArch || RTStrNCmp(pcszOsArch, RT_STR_TUPLE("solaris"));
    2026                 }
    2027                 else
    2028                     fLoadCommands = true;
    2029 
    2030 #ifdef VBOX_WITH_VIDEOHWACCEL
    2031                 uint32_t cbCmd = sizeof (VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM); /* maximum cmd size */
    2032                 VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM, 0, cbCmd);
    2033                 Assert(pCmd);
    2034                 if(pCmd)
    2035                 {
    2036                     VBOXVBVASAVEDSTATECBDATA VhwaData = {0};
    2037                     VhwaData.pSSM = pSSM;
    2038                     VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM);
    2039                     pLoad->pSSM = pSSM;
    2040                     vbvaVHWAHHPost(pDevIns, pThis, pThisCC, pCmd, vboxVBVALoadStatePerformPreCb,
    2041                                    vboxVBVALoadStatePerformPostCb, &VhwaData);
    2042                     rc = VhwaData.rc;
    2043                     vbvaVHWAHHCommandRelease(pCmd);
    2044                     AssertRCReturn(rc, rc);
    2045 
     1187                    bool fLoadCommands;
     1188                    if (uVersion < VGA_SAVEDSTATE_VERSION_FIXED_PENDVHWA)
     1189                    {
     1190                        const char *pcszOsArch = pHlp->pfnSSMHandleHostOSAndArch(pSSM);
     1191                        AssertPtr(pcszOsArch);
     1192                        fLoadCommands = !pcszOsArch || RTStrNCmp(pcszOsArch, RT_STR_TUPLE("solaris"));
     1193                    }
     1194                    else
     1195                        fLoadCommands = true;
     1196
     1197                    uint32_t u32;
     1198                    for (uint32_t i = 0; i < pThis->cMonitors; ++i)
     1199                    {
     1200                        rc = pHlp->pfnSSMGetU32(pSSM, &u32); /* VHWA [un]available magic. */
     1201                        AssertRCReturn(rc, rc);
     1202                    }
     1203
     1204                    /* Pending VHWA commands. */
    20461205                    if (fLoadCommands)
    20471206                    {
    2048                         rc = vbvaVHWACommandLoadPending(pDevIns, pHlp, pThis, pThisCC, pSSM, uVersion);
     1207                        rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    20491208                        AssertRCReturn(rc, rc);
     1209                        for (uint32_t i = 0; i < u32; ++i)
     1210                        {
     1211                            rc = pHlp->pfnSSMSkip(pSSM, sizeof(uint32_t));
     1212                            AssertRCReturn(rc, rc);
     1213                        }
    20501214                    }
    20511215                }
    2052                 else
    2053                 {
    2054                     rc = VERR_OUT_OF_RESOURCES;
    2055                 }
    2056 #else
    2057                 uint32_t u32;
    2058 
    2059                 for (uint32_t i = 0; i < pThis->cMonitors; ++i)
    2060                 {
    2061                     rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    2062                     AssertRCReturn(rc, rc);
    2063 
    2064                     if (u32 != VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC)
    2065                     {
    2066                         LogRel(("VBVA: 2D data while 2D is not supported\n"));
    2067                         return VERR_NOT_SUPPORTED;
    2068                     }
    2069                 }
    2070 
    2071                 if (fLoadCommands)
    2072                 {
    2073                     rc = pHlp->pfnSSMGetU32(pSSM, &u32);
    2074                     AssertRCReturn(rc, rc);
    2075 
    2076                     if (u32)
    2077                     {
    2078                         LogRel(("VBVA: 2D pending command while 2D is not supported\n"));
    2079                         return VERR_NOT_SUPPORTED;
    2080                     }
    2081                 }
    2082 #endif
    20831216            }
    20841217
    … …  
    24331566static DECLCALLBACK(void) vbvaNotifyGuest(void *pvCallback)
    24341567{
    2435 #if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM))
     1568#if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM))
    24361569    PPDMDEVINS pDevIns = (PPDMDEVINS)pvCallback;
    24371570    PVGASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
    … …  
    25851718            break;
    25861719
    2587 
    2588 #ifdef VBOX_WITH_VIDEOHWACCEL
    2589         case VBVA_VHWA_CMD:
    2590             if (cbBuffer >= VBOXVHWACMD_HEADSIZE())
    2591             {
    2592                 vbvaVHWAHandleCommand(pDevIns, pThis, pThisCC, (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
    2593                 rc = VINF_SUCCESS;
    2594             }
    2595             else
    2596                 rc = VERR_INVALID_PARAMETER;
    2597             break;
    2598 #endif
    2599 
    26001720#ifdef VBOX_WITH_WDDM
    26011721        case VBVA_INFO_CAPS:
    … …  
    27411861
    27421862    VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThisCC->pHGSMI);
    2743 
    2744 #ifdef VBOX_WITH_VIDEOHWACCEL
    2745     vbvaVHWAReset(pDevIns, pThis, pThisCC);
    2746 #endif
    27471863
    27481864    HGSMIReset(pThisCC->pHGSMI);

  • trunk/src/VBox/Devices/Makefile.kmk

    r108237 r108641  
    312312  VBoxDD_DEFS           += VBOXWDDM_WITH_VBVA
    313313 endif
    314  ifdef VBOX_WITH_VIDEOHWACCEL
    315   VBoxDD_DEFS           += VBOX_WITH_VIDEOHWACCEL
    316  endif
    317314
    318315 ifdef VBOX_WITH_HGSMI
    … …  
    11181115        USB/DevXHCI.cpp
    11191116   endif
    1120   endif
    1121 
    1122   ifdef VBOX_WITH_VIDEOHWACCEL
    1123    VBoxDDRC_DEFS        += VBOX_WITH_VIDEOHWACCEL
    11241117  endif
    11251118
    … …  
    13861379  VBoxDDR0_DEFS         += VBOX_WITH_HGSMI
    13871380 endif
    1388  ifdef VBOX_WITH_VIDEOHWACCEL
    1389   VBoxDDR0_DEFS         += VBOX_WITH_VIDEOHWACCEL
    1390  endif
    13911381
    13921382 if1of ($(VBOX_LDR_FMT), pe lx)

  • trunk/src/VBox/Devices/testcase/Makefile.kmk

    r108258 r108641  
    5353        $(if $(VBOX_WITH_USB),VBOX_WITH_USB,) \
    5454        $(if $(VBOX_WITH_VDMA),VBOX_WITH_VDMA,) \
    55         $(if $(VBOX_WITH_VIDEOHWACCEL),VBOX_WITH_VIDEOHWACCEL,) \
    5655        $(if $(VBOX_WITH_VIRTIO),VBOX_WITH_VIRTIO,) \
    5756        $(if $(VBOX_WITH_VMSVGA),VBOX_WITH_VMSVGA,) \

  • trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp

    r106061 r108641  
    355355    GEN_CHECK_OFF(VGASTATE, IBase);
    356356    GEN_CHECK_OFF(VGASTATE, IPort);
    357 #if defined(VBOX_WITH_HGSMI) && defined(VBOX_WITH_VIDEOHWACCEL)
    358     GEN_CHECK_OFF(VGASTATE, IVBVACallbacks);
    359 #endif
    360357    GEN_CHECK_OFF(VGASTATE, pDrvBase);
    361358    GEN_CHECK_OFF(VGASTATE, pDrv);

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

    r108046 r108641  
    15471547    SHOW_ULONG_PROP(pGraphicsAdapter, MonitorCount,             "monitorcount",             Info::tr("Monitor count:"), "");
    15481548    SHOW_BOOLEAN_METHOD(pGraphicsAdapter, IsFeatureEnabled(GraphicsFeature_Acceleration3D, &f), "accelerate3d", "3D Acceleration:");
    1549 #ifdef VBOX_WITH_VIDEOHWACCEL
    1550     SHOW_BOOLEAN_METHOD(pGraphicsAdapter, IsFeatureEnabled(GraphicsFeature_Acceleration2DVideo, &f), "accelerate2dvideo", "2D Video Acceleration:");
    1551 #endif
    15521549    SHOW_BOOLEAN_PROP(    machine,  TeleporterEnabled,          "teleporterenabled",        Info::tr("Teleporter Enabled:"));
    15531550    SHOW_ULONG_PROP(      machine,  TeleporterPort,             "teleporterport",           Info::tr("Teleporter Port:"), "");

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

    r108003 r108641  
    8383    MODIFYVM_MONITORCOUNT,
    8484    MODIFYVM_ACCELERATE3D,
    85 #ifdef VBOX_WITH_VIDEOHWACCEL
    86     MODIFYVM_ACCELERATE2DVIDEO,
    87 #endif
     85    MODIFYVM_ACCELERATE2DVIDEO,  // deprecated
    8886    /*
    8987     * Firmware-specific stuff.
    … …  
    311309    OPT2("--monitor-count",                 "--monitorcount",           MODIFYVM_MONITORCOUNT,              RTGETOPT_REQ_UINT32),
    312310    OPT2("--accelerate-3d",                 "--accelerate3d",           MODIFYVM_ACCELERATE3D,              RTGETOPT_REQ_BOOL_ONOFF),
    313 #ifdef VBOX_WITH_VIDEOHWACCEL
     311    /* { Kept for backwards-compatibility*/
    314312    OPT2("--accelerate-2d-video",           "--accelerate2dvideo",      MODIFYVM_ACCELERATE2DVIDEO,         RTGETOPT_REQ_BOOL_ONOFF),
    315 #endif
     313    /* } */
    316314    OPT1("--firmware-logo-fade-in",                                     MODIFYVM_FWLOGOFADEIN,              RTGETOPT_REQ_BOOL_ONOFF),
    317315    OPT1("--firmware-logo-fade-out",                                    MODIFYVM_FWLOGOFADEOUT,             RTGETOPT_REQ_BOOL_ONOFF),
    … …  
    11481146            }
    11491147
    1150 #ifdef VBOX_WITH_VIDEOHWACCEL
     1148            /* Kept for backwards-compatibility. */
    11511149            case MODIFYVM_ACCELERATE2DVIDEO:
    11521150            {
    1153                 CHECK_ERROR(pGraphicsAdapter, SetFeature(GraphicsFeature_Acceleration2DVideo, ValueUnion.f));
    1154                 break;
    1155             }
    1156 #endif
     1151                RTStrmPrintf(g_pStdErr, ModifyVM::tr("Warning: '--accelerate-2d-video' is deprecated and will be removed in a future version\n"));
     1152                break;
     1153            }
     1154
    11571155            case MODIFYVM_FWLOGOFADEIN:
    11581156            {

  • trunk/src/VBox/Frontends/VBoxShell/vboxshell.py

    r108046 r108641  
    10161016
    10171017    print("  Hardware 3d acceleration [accelerate3DEnabled]: " + asState(mach.graphicsAdapter.isFeatureEnabled(ctx['const'].GraphicsFeature_Acceleration3D)))
    1018     print("  Hardware 2d video acceleration [accelerate2DVideoEnabled]: " + asState(mach.graphicsAdapter.isFeatureEnabled(ctx['const'].GraphicsFeature_Acceleration2DVideo)))
    10191018    print("  Use universal time [RTCUseUTC]: %s" % (asState(mach.platform.RTCUseUTC)))
    10201019    audioAdp = mach.audioSettings.adapter

  • trunk/src/VBox/Installer/win/Makefile.kmk

    r108581 r108641  
    551551        -E 'VBOX_WITH_VBOX_IMG=$(if $(VBOX_WITH_VBOX_IMG),yes,no)' \
    552552        -E 'VBOX_WITH_VBOXSDL=$(if $(VBOX_WITH_VBOXSDL),yes,no)' \
    553         -E 'VBOX_WITH_VIDEOHWACCEL=$(if $(VBOX_WITH_VIDEOHWACCEL),yes,no)' \
    554         -E 'VBOX_WITH_VIDEOHWACCEL=$(if $(VBOX_WITH_VIDEOHWACCEL),yes,no)' \
    555553        -E 'VBOX_WITH_VMSVGA3D=$(if $(VBOX_WITH_VMSVGA3D),yes,no)' \
    556554        -E 'VBOX_WITH_VRDP=$(if-expr defined(VBOX_WITH_VRDP) && !defined(VBOX_WITH_EXTPACK_PUEL),yes,no)' \

  • trunk/src/VBox/Main/Makefile.kmk

    r107588 r108641  
    10341034        $(if $(VBOX_WITH_EFI),VBOX_WITH_EFI,) \
    10351035        $(if $(VBOX_WITH_HGSMI),VBOX_WITH_HGSMI,) \
    1036         $(if $(VBOX_WITH_VIDEOHWACCEL),VBOX_WITH_VIDEOHWACCEL,) \
    10371036        $(if $(VBOX_WITH_3D_ACCELERATION),VBOX_WITH_3D_ACCELERATION,) \
    10381037        $(if $(VBOX_WITH_DRAG_AND_DROP),VBOX_WITH_DRAG_AND_DROP,) \

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r108355 r108641  
    69196919  <enum
    69206920    name="GraphicsFeature"
    6921     uuid="5cd900a5-ec77-4a08-8f8d-c0a36f462a7c"
     6921    uuid="1BC430F8-D061-45FB-8830-155058FF3F66"
    69226922    >
    69236923    <desc>Graphics features.</desc>
    … …  
    69256925      <desc>No feature specified, invalid.</desc>
    69266926    </const>
    6927     <const name="Acceleration2DVideo" value="1">
    6928       <desc>2D video acceleration.</desc>
    6929     </const>
     6927    <!-- Value 1 was Acceleration2DVideo which was removed in VBox 7.2. -->
    69306928    <const name="Acceleration3D" value="2">
    69316929      <desc>3D acceleration.</desc>
    … …  
    1394313941  <interface
    1394413942    name="IGuestOSType" extends="$unknown"
    13945     uuid="ceb482fc-41b9-42a8-8538-9835ea33b6f2"
     13943    uuid="c6e30023-751e-487d-9bd1-595c22b104ba"
    1394613944    wsmap="struct"
    1394713945    rest="managed"
    … …  
    1399813996    <attribute name="recommendedVRAM" type="unsigned long" readonly="yes">
    1399913997      <desc>Recommended video RAM size in Megabytes.</desc>
    14000     </attribute>
    14001 
    14002     <attribute name="recommended2DVideoAcceleration" type="boolean" readonly="yes">
    14003       <desc>Returns @c true if 2D video acceleration is recommended for this OS type.</desc>
    1400413998    </attribute>
    1400513999
    … …  
    2189021884  <interface
    2189121885    name="IDisplay" extends="$unknown"
    21892     uuid="4680b2de-8690-11e9-b83d-5719e53cf1de"
     21886    uuid="14fd6676-ee6b-441a-988b-c83025ab693a"
    2189321887    wsmap="managed"
    2189421888    wrap-hint-server-addinterfaces="IEventListener"
    … …  
    2223022224          The guest screen to redraw.
    2223122225        </desc>
    22232       </param>
    22233     </method>
    22234 
    22235     <method name="completeVHWACommand">
    22236       <desc>
    22237         Signals that the Video HW Acceleration command has completed.
    22238       </desc>
    22239 
    22240       <param name="command" type="octet" mod="ptr" dir="in">
    22241         <desc>Pointer to VBOXVHWACMD containing the completed command.</desc>
    2224222226      </param>
    2224322227    </method>

  • trunk/src/VBox/Main/include/DisplayImpl.h

    r106061 r108641  
    164164    void i_handleUpdateGuestVBVACapabilities(uint32_t fNewCapabilities);
    165165    void i_handleUpdateVBVAInputMapping(int32_t xOrigin, int32_t yOrigin, uint32_t cx, uint32_t cy);
    166 #ifdef VBOX_WITH_VIDEOHWACCEL
    167     int  i_handleVHWACommandProcess(int enmCmd, bool fGuestCmd, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand);
    168 #endif
    169166    int  i_handle3DNotifyProcess(VBOX3DNOTIFY *p3DNotify);
    170167
    … …  
    270267    virtual HRESULT invalidateAndUpdate();
    271268    virtual HRESULT invalidateAndUpdateScreen(ULONG aScreenId);
    272     virtual HRESULT completeVHWACommand(BYTE *aCommand);
    273269    virtual HRESULT viewportChanged(ULONG aScreenId,
    274270                                    ULONG aX,
    … …  
    326322                                                                   void *pvVRAM, unsigned uScreenId);
    327323
    328 #ifdef VBOX_WITH_VIDEOHWACCEL
    329     static DECLCALLBACK(int)  i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, int enmCmd, bool fGuestCmd,
    330                                                           VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand);
    331 #endif
    332324    static DECLCALLBACK(int)  i_display3DNotifyProcess(PPDMIDISPLAYCONNECTOR pInterface,
    333325                                                       VBOX3DNOTIFY *p3DNotify);

  • trunk/src/VBox/Main/src-client/DisplayImpl.cpp

    r106061 r108641  
    5252#include <VBox/vmm/pdmdrv.h>
    5353
    54 #ifdef VBOX_WITH_VIDEOHWACCEL
    55 # include <VBoxVideo.h>
    56 #endif
    5754#include <VBoxVideo3D.h>
    5855
    … …  
    8380    /** Our display connector interface. */
    8481    PDMIDISPLAYCONNECTOR        IConnector;
    85 #if defined(VBOX_WITH_VIDEOHWACCEL)
    86     /** VBVA callbacks */
    87     PPDMIDISPLAYVBVACALLBACKS   pVBVACallbacks;
    88 #endif
    8982} DRVMAINDISPLAY, *PDRVMAINDISPLAY;
    9083
    … …  
    27092702}
    27102703
    2711 HRESULT Display::completeVHWACommand(BYTE *aCommand)
    2712 {
    2713 #ifdef VBOX_WITH_VIDEOHWACCEL
    2714     AssertPtr(mpDrv->pVBVACallbacks);
    2715     mpDrv->pVBVACallbacks->pfnVHWACommandCompleteAsync(mpDrv->pVBVACallbacks, (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)aCommand);
    2716     return S_OK;
    2717 #else
    2718     RT_NOREF(aCommand);
    2719     return E_NOTIMPL;
    2720 #endif
    2721 }
    2722 
    27232704HRESULT Display::viewportChanged(ULONG aScreenId, ULONG aX, ULONG aY, ULONG aWidth, ULONG aHeight)
    27242705{
    … …  
    32783259    pDrv->pDisplay->processDisplayData(pvVRAM, uScreenId);
    32793260}
    3280 
    3281 #ifdef VBOX_WITH_VIDEOHWACCEL
    3282 
    3283 int Display::i_handleVHWACommandProcess(int enmCmd, bool fGuestCmd, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand)
    3284 {
    3285     /* bugref:9691 Disable the legacy VHWA interface.
    3286      * Keep the host commands enabled because they are needed when an old saved state is loaded.
    3287      */
    3288     if (fGuestCmd)
    3289         return VERR_NOT_IMPLEMENTED;
    3290 
    3291     unsigned id = (unsigned)pCommand->iDisplay;
    3292     if (id >= mcMonitors)
    3293         return VERR_INVALID_PARAMETER;
    3294 
    3295     ComPtr<IFramebuffer> pFramebuffer;
    3296     AutoReadLock arlock(this COMMA_LOCKVAL_SRC_POS);
    3297     pFramebuffer = maFramebuffers[id].pFramebuffer;
    3298     bool fVHWASupported = RT_BOOL(maFramebuffers[id].u32Caps & FramebufferCapabilities_VHWA);
    3299     arlock.release();
    3300 
    3301     if (pFramebuffer == NULL || !fVHWASupported)
    3302         return VERR_NOT_IMPLEMENTED; /* Implementation is not available. */
    3303 
    3304     HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE *)pCommand, enmCmd, fGuestCmd);
    3305     if (hr == S_FALSE)
    3306         return VINF_SUCCESS;
    3307     if (SUCCEEDED(hr))
    3308         return VINF_CALLBACK_RETURN;
    3309     if (hr == E_ACCESSDENIED)
    3310         return VERR_INVALID_STATE; /* notify we can not handle request atm */
    3311     if (hr == E_NOTIMPL)
    3312         return VERR_NOT_IMPLEMENTED;
    3313     return VERR_GENERAL_FAILURE;
    3314 }
    3315 
    3316 DECLCALLBACK(int) Display::i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, int enmCmd, bool fGuestCmd,
    3317                                                        VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand)
    3318 {
    3319     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
    3320 
    3321     return pDrv->pDisplay->i_handleVHWACommandProcess(enmCmd, fGuestCmd, pCommand);
    3322 }
    3323 
    3324 #endif /* VBOX_WITH_VIDEOHWACCEL */
    33253261
    33263262int Display::i_handle3DNotifyProcess(VBOX3DNOTIFY *p3DNotify)
    … …  
    38553791        pThis->pDisplay->mParent->i_recordingStop();
    38563792#endif
    3857 #if defined(VBOX_WITH_VIDEOHWACCEL)
    3858         pThis->pVBVACallbacks = NULL;
    3859 #endif
    38603793    }
    38613794}
    … …  
    38923825        pThis->pDisplay->mParent->i_recordingStop();
    38933826#endif
    3894 #if defined(VBOX_WITH_VIDEOHWACCEL)
    3895         pThis->pVBVACallbacks = NULL;
    3896 #endif
    3897 
    38983827        pThis->pDisplay->mpDrv = NULL;
    38993828        pThis->pDisplay = NULL;
    39003829    }
    3901 #if defined(VBOX_WITH_VIDEOHWACCEL)
    3902     pThis->pVBVACallbacks = NULL;
    3903 #endif
    39043830}
    39053831
    … …  
    39373863    pThis->IConnector.pfnProcessAdapterData    = Display::i_displayProcessAdapterDataCallback;
    39383864    pThis->IConnector.pfnProcessDisplayData    = Display::i_displayProcessDisplayDataCallback;
    3939 #ifdef VBOX_WITH_VIDEOHWACCEL
    3940     pThis->IConnector.pfnVHWACommandProcess    = Display::i_displayVHWACommandProcess;
    3941 #endif
    39423865#ifdef VBOX_WITH_HGSMI
    39433866    pThis->IConnector.pfnVBVAEnable            = Display::i_displayVBVAEnable;
    … …  
    39633886        return VERR_PDM_MISSING_INTERFACE_ABOVE;
    39643887    }
    3965 #if defined(VBOX_WITH_VIDEOHWACCEL)
    3966     pThis->pVBVACallbacks = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIDISPLAYVBVACALLBACKS);
    3967 #endif
     3888
    39683889    /*
    39693890     * Get the Display object pointer and update the mpDrv member.

  • trunk/src/VBox/Main/src-server/GraphicsAdapterImpl.cpp

    r106081 r108641  
    309309        switch (aFeature)
    310310        {
    311             case GraphicsFeature_Acceleration2DVideo:
    312                 pfSetting = &mData->fAccelerate2DVideo;
    313                 break;
    314 
    315311            case GraphicsFeature_Acceleration3D:
    316312                pfSetting = &mData->fAccelerate3D;
    … …  
    482478    switch (aFeature)
    483479    {
    484         case GraphicsFeature_Acceleration2DVideo: return &mData->fAccelerate2DVideo;
    485         case GraphicsFeature_Acceleration3D:      return &mData->fAccelerate3D;
     480        case GraphicsFeature_Acceleration3D: return &mData->fAccelerate3D;
    486481        default:
    487482            break;
    … …  
    506501    FEATUREMEMBER2ENUM aFeatures[] =
    507502    {
    508         { &mData->fAccelerate2DVideo, GraphicsFeature_Acceleration2DVideo },
    509         { &mData->fAccelerate3D,      GraphicsFeature_Acceleration3D },
     503        { &mData->fAccelerate3D, GraphicsFeature_Acceleration3D }
    510504    };
    511505

  • trunk/src/VBox/Main/src-server/MachineImpl.cpp

    r108566 r108641  
    1529115291    if (FAILED(hrc)) return hrc;
    1529215292
    15293     BOOL fAccelerate2DVideoEnabled;
    15294     hrc = osType->COMGETTER(Recommended2DVideoAcceleration)(&fAccelerate2DVideoEnabled);
    15295     if (FAILED(hrc)) return hrc;
    15296 
    15297     hrc = mGraphicsAdapter->SetFeature(GraphicsFeature_Acceleration2DVideo, fAccelerate2DVideoEnabled);
    15298     if (FAILED(hrc))
    15299     {
    15300         if (hrc != VBOX_E_NOT_SUPPORTED)
    15301             return hrc;
    15302     }
    15303 
    1530415293    BOOL fAccelerate3DEnabled;
    1530515294    hrc = osType->COMGETTER(Recommended3DAcceleration)(&fAccelerate3DEnabled);
    1530615295    if (FAILED(hrc)) return hrc;
    15307 
    15308     hrc = mGraphicsAdapter->SetFeature(GraphicsFeature_Acceleration2DVideo, fAccelerate3DEnabled);
    15309     if (FAILED(hrc))
    15310     {
    15311         if (hrc != VBOX_E_NOT_SUPPORTED)
    15312             return hrc;
    15313     }
    1531415296
    1531515297    /* Apply network adapters defaults */

  • trunk/src/VBox/Main/src-server/SystemPropertiesImpl.cpp

    r107930 r108641  
    11561156    static const GraphicsFeature_T s_aGraphicsFeatures[] =
    11571157    {
    1158 # ifdef VBOX_WITH_VIDEOHWACCEL
    1159         GraphicsFeature_Acceleration2DVideo,
    1160 # endif
    11611158# ifdef VBOX_WITH_3D_ACCELERATION
    11621159        GraphicsFeature_Acceleration3D

  • trunk/src/VBox/ValidationKit/testdriver/vbox.py

    r107205 r108641  
    23742374                fAccelerate3DEnabled = \
    23752375                    oVM.graphicsAdapter.isFeatureEnabled(vboxcon.GraphicsFeature_Acceleration3D);
    2376                 fAccelerate2DVideoEnabled = \
    2377                     oVM.graphicsAdapter.isFeatureEnabled(vboxcon.GraphicsFeature_Acceleration2DVideo);
     2376                if self.fpApiVer < 7.2: # 2D video acceleration was removed with 7.2.
     2377                    fAccelerate2DVideoEnabled = \
     2378                        oVM.graphicsAdapter.isFeatureEnabled(vboxcon.GraphicsFeature_Acceleration2DVideo);
    23782379            else:
    23792380                fAccelerate3DEnabled      = oVM.graphicsAdapter.accelerate3DEnabled;
    … …  
    23832384            fAccelerate2DVideoEnabled = oVM.accelerate2DVideoEnabled;
    23842385        reporter.log("  3D acceleration:    %s" % (fAccelerate3DEnabled,));
    2385         reporter.log("  2D acceleration:    %s" % (fAccelerate2DVideoEnabled,));
     2386        if self.fpApiVer < 7.2:
     2387            reporter.log("  2D acceleration:    %s" % (fAccelerate2DVideoEnabled,));
    23862388        reporter.log("  TeleporterEnabled:  %s" % (oVM.teleporterEnabled,));
    23872389        reporter.log("  TeleporterPort:     %s" % (oVM.teleporterPort,));
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette