VirtualBox

Ignore:
Timestamp:
May 20, 2010 7:57:47 PM (15 years ago)
Author:
vboxsync
Message:

wddm/2D: more impl & fixes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp

    r29671 r29710  
    1313#include "../Helper.h"
    1414
    15 VBOXVHWACMD* vboxVhwaCtlCommandCreate(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd)
    16 {
     15#ifndef VBOXVHWA_WITH_SHGSMI
     16# include <iprt/semaphore.h>
     17# include <iprt/asm.h>
     18#endif
     19
     20
     21
     22DECLINLINE(void) vboxVhwaHdrInit(VBOXVHWACMD* pHdr, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, VBOXVHWACMD_TYPE enmCmd)
     23{
     24    memset(pHdr, 0, sizeof(VBOXVHWACMD));
     25    pHdr->iDisplay = srcId;
     26    pHdr->rc = VERR_GENERAL_FAILURE;
     27    pHdr->enmCmd = enmCmd;
     28#ifndef VBOXVHWA_WITH_SHGSMI
     29    pHdr->cRefs = 1;
     30#endif
     31}
     32
     33#ifdef VBOXVHWA_WITH_SHGSMI
     34static int vboxVhwaCommandSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, HGSMIOFFSET offDr)
     35{
     36    VBoxHGSMIGuestWrite(pDevExt, offDr);
     37    return VINF_SUCCESS;
     38}
     39#else
     40DECLINLINE(void) vbvaVhwaCommandRelease(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
     41{
     42    uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
     43    Assert(cRefs < UINT32_MAX / 2);
     44    if(!cRefs)
     45    {
     46        vboxHGSMIBufferFree(pDevExt, pCmd);
     47    }
     48}
     49
     50DECLINLINE(void) vbvaVhwaCommandRetain(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
     51{
     52    ASMAtomicIncU32(&pCmd->cRefs);
     53}
     54
     55/* do not wait for completion */
     56void vboxVhwaCommandSubmitAsynch(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext)
     57{
     58    pCmd->GuestVBVAReserved1 = (uintptr_t)pfnCompletion;
     59    pCmd->GuestVBVAReserved2 = (uintptr_t)pContext;
     60    vbvaVhwaCommandRetain(pDevExt, pCmd);
     61
     62    vboxHGSMIBufferSubmit(pDevExt, pCmd);
     63
     64    if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH)
     65            || ((pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION)
     66                    && (pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED)))
     67    {
     68        /* the command is completed */
     69        pfnCompletion(pDevExt, pCmd, pContext);
     70    }
     71
     72    vbvaVhwaCommandRelease(pDevExt, pCmd);
     73}
     74
     75static DECLCALLBACK(void) vboxVhwaCompletionSetEvent(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD * pCmd, void * pvContext)
     76{
     77    RTSemEventSignal((RTSEMEVENT)pvContext);
     78}
     79
     80void vboxVhwaCommandSubmitAsynchByEvent(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd, RTSEMEVENT hEvent)
     81{
     82    vboxVhwaCommandSubmitAsynch(pDevExt, pCmd, vboxVhwaCompletionSetEvent, hEvent);
     83}
     84#endif
     85
     86VBOXVHWACMD* vboxVhwaCommandCreate(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd)
     87{
     88#ifdef VBOXVHWA_WITH_SHGSMI
    1789    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)VBoxSHGSMICommandAlloc(&pDevExt->u.primary.hgsmiAdapterHeap,
    1890                              cbCmd + VBOXVHWACMD_HEADSIZE(),
    1991                              HGSMI_CH_VBVA,
    2092                              VBVA_VHWA_CMD);
     93#else
     94    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)vboxHGSMIBufferAlloc(pDevExt,
     95                              cbCmd + VBOXVHWACMD_HEADSIZE(),
     96                              HGSMI_CH_VBVA,
     97                              VBVA_VHWA_CMD);
     98#endif
    2199    Assert(pHdr);
    22100    if (!pHdr)
     
    26104    else
    27105    {
    28         vboxVhwaInitHdr(pHdr, srcId, enmCmd);
     106        vboxVhwaHdrInit(pHdr, srcId, enmCmd);
    29107    }
    30108
     
    32110}
    33111
    34 void vboxVhwaCtlCommandFree(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
    35 {
     112void vboxVhwaCommandFree(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
     113{
     114#ifdef VBOXVHWA_WITH_SHGSMI
    36115    VBoxSHGSMICommandFree(&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
    37 }
    38 
    39 static int vboxVhwaCtlCommandSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, HGSMIOFFSET offDr)
    40 {
    41     VBoxHGSMIGuestWrite(pDevExt, offDr);
    42     return VINF_SUCCESS;
    43 }
    44 
    45 int vboxVhwaCtlCommandSubmit(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
    46 {
     116#else
     117    vbvaVhwaCommandRelease(pDevExt, pCmd);
     118#endif
     119}
     120
     121int vboxVhwaCommandSubmit(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
     122{
     123#ifdef VBOXVHWA_WITH_SHGSMI
    47124    const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
    48125    Assert(pHdr);
     
    56133            if (offCmd != HGSMIOFFSET_VOID)
    57134            {
    58                 rc = vboxVhwaCtlCommandSubmitHgsmi(pDevExt, offCmd);
     135                rc = vboxVhwaCommandSubmitHgsmi(pDevExt, offCmd);
    59136                AssertRC(rc);
    60137                if (RT_SUCCESS(rc))
     
    74151        rc = VERR_INVALID_PARAMETER;
    75152    return rc;
     153#else
     154    RTSEMEVENT hEvent;
     155    int rc = RTSemEventCreate(&hEvent);
     156    AssertRC(rc);
     157    if (RT_SUCCESS(rc))
     158    {
     159        pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ;
     160        vboxVhwaCommandSubmitAsynchByEvent(pDevExt, pCmd, hEvent);
     161        rc = RTSemEventWait(hEvent, RT_INDEFINITE_WAIT);
     162        AssertRC(rc);
     163        if (RT_SUCCESS(rc))
     164            RTSemEventDestroy(hEvent);
     165    }
     166    return rc;
     167#endif
     168}
     169
     170#ifndef VBOXVHWA_WITH_SHGSMI
     171static DECLCALLBACK(void) vboxVhwaCompletionFreeCmd(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD * pCmd, void * pContext)
     172{
     173    vboxVhwaCommandFree(pDevExt, pCmd);
     174}
     175#endif
     176
     177void vboxVhwaCommandSubmitAsynchAndComplete(PDEVICE_EXTENSION pDevExt, VBOXVHWACMD* pCmd)
     178{
     179#ifdef VBOXVHWA_WITH_SHGSMI
     180# error "port me"
     181#else
     182    pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION;
     183
     184    vboxVhwaCommandSubmitAsynch(pDevExt, pCmd, vboxVhwaCompletionFreeCmd, NULL);
     185#endif
    76186}
    77187
     
    79189{
    80190    VBOXVHWACMD* pCmd = VBOXVHWACMD_HEAD(pInfo);
    81     vboxVhwaCtlCommandFree(pDevExt, pCmd);
     191    vboxVhwaCommandFree(pDevExt, pCmd);
    82192}
    83193
     
    85195{
    86196    VBOXVHWACMD* pCmd = VBOXVHWACMD_HEAD(pInfo);
    87     vboxVhwaCtlCommandFree(pDevExt, pCmd);
     197    vboxVhwaCommandFree(pDevExt, pCmd);
    88198}
    89199
    90200VBOXVHWACMD_QUERYINFO1* vboxVHWAQueryHostInfo1(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
    91201{
    92     VBOXVHWACMD* pCmd = vboxVhwaCtlCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO1, sizeof(VBOXVHWACMD_QUERYINFO1));
     202    VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO1, sizeof(VBOXVHWACMD_QUERYINFO1));
    93203    VBOXVHWACMD_QUERYINFO1 *pInfo1;
    94204
     
    106216    pInfo1->u.in.guestVersion.reserved = VBOXVHWA_VERSION_RSV;
    107217
    108     if(vboxVhwaCtlCommandSubmit(pDevExt, pCmd))
     218    if(vboxVhwaCommandSubmit(pDevExt, pCmd))
    109219    {
    110220        if(RT_SUCCESS(pCmd->rc))
     
    114224    }
    115225
    116     vboxVhwaCtlCommandFree(pDevExt, pCmd);
     226    vboxVhwaCommandFree(pDevExt, pCmd);
    117227    return NULL;
    118228}
     
    120230VBOXVHWACMD_QUERYINFO2* vboxVHWAQueryHostInfo2(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId, uint32_t numFourCC)
    121231{
    122     VBOXVHWACMD* pCmd = vboxVhwaCtlCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO2, VBOXVHWAINFO2_SIZE(numFourCC));
     232    VBOXVHWACMD* pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_QUERY_INFO2, VBOXVHWAINFO2_SIZE(numFourCC));
    123233    VBOXVHWACMD_QUERYINFO2 *pInfo2;
    124234    Assert(pCmd);
     
    132242    pInfo2->numFourCC = numFourCC;
    133243
    134     if(vboxVhwaCtlCommandSubmit(pDevExt, pCmd))
     244    if(vboxVhwaCommandSubmit(pDevExt, pCmd))
    135245    {
    136246        if(RT_SUCCESS(pCmd->rc))
     
    143253    }
    144254
    145     vboxVhwaCtlCommandFree(pDevExt, pCmd);
     255    vboxVhwaCommandFree(pDevExt, pCmd);
    146256    return NULL;
    147257}
     
    152262    VBOXVHWACMD* pCmd;
    153263
    154     pCmd = vboxVhwaCtlCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_ENABLE, 0);
     264    pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_ENABLE, 0);
    155265    Assert(pCmd);
    156266    if (!pCmd)
     
    160270    }
    161271
    162     if(vboxVhwaCtlCommandSubmit(pDevExt, pCmd))
     272    if(vboxVhwaCommandSubmit(pDevExt, pCmd))
    163273    {
    164274        if(RT_SUCCESS(pCmd->rc))
     
    168278    }
    169279
    170     vboxVhwaCtlCommandFree(pDevExt, pCmd);
     280    vboxVhwaCommandFree(pDevExt, pCmd);
    171281    return rc;
    172282}
     
    177287    VBOXVHWACMD* pCmd;
    178288
    179     pCmd = vboxVhwaCtlCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_DISABLE, 0);
     289    pCmd = vboxVhwaCommandCreate(pDevExt, srcId, VBOXVHWACMD_TYPE_DISABLE, 0);
    180290    Assert(pCmd);
    181291    if (!pCmd)
     
    185295    }
    186296
    187     if(vboxVhwaCtlCommandSubmit(pDevExt, pCmd))
     297    if(vboxVhwaCommandSubmit(pDevExt, pCmd))
    188298    {
    189299        if(RT_SUCCESS(pCmd->rc))
     
    193303    }
    194304
    195     vboxVhwaCtlCommandFree(pDevExt, pCmd);
     305    vboxVhwaCommandFree(pDevExt, pCmd);
    196306    return rc;
    197307}
    198308
    199 void vboxVHWAInit(PDEVICE_EXTENSION pDevExt)
    200 {
    201     VBOXVHWA_INFO *pSettings = &pDevExt->u.primary.Vhwa;
     309static void vboxVHWAInitSrc(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
     310{
     311    Assert(srcId < pDevExt->cSources);
     312    VBOXVHWA_INFO *pSettings = &pDevExt->aSources[srcId].Vhwa.Settings;
    202313    memset (pSettings, 0, sizeof (VBOXVHWA_INFO));
    203314
    204     VBOXVHWACMD_QUERYINFO1* pInfo1 = vboxVHWAQueryHostInfo1(pDevExt,
    205             0 /*D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId*/);
     315    VBOXVHWACMD_QUERYINFO1* pInfo1 = vboxVHWAQueryHostInfo1(pDevExt, srcId);
    206316    if (pInfo1)
    207317    {
    208318        if (pInfo1->u.out.cfgFlags & VBOXVHWA_CFG_ENABLED)
    209319        {
    210             if (pInfo1->u.out.numOverlays)
     320            if ((pInfo1->u.out.caps & VBOXVHWA_CAPS_OVERLAY)
     321                    && (pInfo1->u.out.caps & VBOXVHWA_CAPS_OVERLAYSTRETCH)
     322                    && (pInfo1->u.out.surfaceCaps & VBOXVHWA_SCAPS_OVERLAY)
     323                    && (pInfo1->u.out.surfaceCaps & VBOXVHWA_SCAPS_FLIP)
     324                    && (pInfo1->u.out.surfaceCaps & VBOXVHWA_SCAPS_LOCALVIDMEM)
     325                    && pInfo1->u.out.numOverlays)
    211326            {
    212                 pSettings->bEnabled = true;
     327                pSettings->fFlags |= VBOXVHWA_F_ENABLED;
     328
     329                if (pInfo1->u.out.caps & VBOXVHWA_CAPS_COLORKEY)
     330                {
     331                    if (pInfo1->u.out.colorKeyCaps & VBOXVHWA_CKEYCAPS_SRCOVERLAY)
     332                    {
     333                        pSettings->fFlags |= VBOXVHWA_F_CKEY_SRC;
     334                        /* todo: VBOXVHWA_CKEYCAPS_SRCOVERLAYONEACTIVE ? */
     335                    }
     336
     337                    if (pInfo1->u.out.colorKeyCaps & VBOXVHWA_CKEYCAPS_DESTOVERLAY)
     338                    {
     339                        pSettings->fFlags |= VBOXVHWA_F_CKEY_DST;
     340                        /* todo: VBOXVHWA_CKEYCAPS_DESTOVERLAYONEACTIVE ? */
     341                    }
     342                }
     343
    213344                pSettings->cFormats = 0;
    214345
     
    218349                ++pSettings->cFormats;
    219350
    220                 if (pInfo1->u.out.numFourCC)
     351                if (pInfo1->u.out.numFourCC
     352                        && (pInfo1->u.out.caps & VBOXVHWA_CAPS_OVERLAYFOURCC))
    221353                {
    222                     VBOXVHWACMD_QUERYINFO2* pInfo2 = vboxVHWAQueryHostInfo2(pDevExt,
    223                             0 /*D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId*/,
    224                             pInfo1->u.out.numFourCC);
     354                    VBOXVHWACMD_QUERYINFO2* pInfo2 = vboxVHWAQueryHostInfo2(pDevExt, srcId, pInfo1->u.out.numFourCC);
    225355                    if (pInfo2)
    226356                    {
     
    238368    }
    239369}
     370
     371void vboxVHWAInit(PDEVICE_EXTENSION pDevExt)
     372{
     373    for (uint32_t i = 0; i < pDevExt->cSources; ++i)
     374    {
     375        vboxVHWAInitSrc(pDevExt, i);
     376    }
     377}
Note: See TracChangeset for help on using the changeset viewer.

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