VirtualBox

Ignore:
Timestamp:
Nov 28, 2010 9:56:32 PM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
68211
Message:

VBoxVideoGuest.h, VMMDev.h, Additions/WINNT/Graphics: refactoring of the display driver to make the VBVA infrastructure and modesetting functions OS-independent

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Display
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/Makefile.kmk

    r33241 r34438  
    4747        vrdptext.c \
    4848        vbox.c \
     49        $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/HGSMIBase.cpp \
    4950        VBoxDisp.def \
    5051        VBoxDisp.rc

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/dd.c

    r34129 r34438  
    11761176        if(!!(lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    11771177                && pDesc->UpdatedMemRegion.bValid
    1178                 && vboxHwBufferBeginUpdate (pDev))
     1178                && VBoxVBVABufferBeginUpdate(&pDev->vbvaCtx, &pDev->guestCtx))
    11791179        {
    11801180            vbvaReportDirtyRect (pDev, &pDesc->UpdatedMemRegion.Rect);
    11811181
    1182             if (  pDev->pVBVA->hostFlags.u32HostEvents
     1182            if (  pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents
    11831183                & VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET)
    11841184            {
    11851185                vrdpReset (pDev);
    11861186
    1187                 pDev->pVBVA->hostFlags.u32HostEvents &=
     1187                pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents &=
    11881188                          ~VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
    11891189            }
    11901190
    1191             if (pDev->pVBVA->hostFlags.u32HostEvents
     1191            if (pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents
    11921192                & VBVA_F_MODE_VRDP)
    11931193            {
    … …  
    11951195            }
    11961196
    1197             vboxHwBufferEndUpdate (pDev);
     1197            VBoxVBVABufferEndUpdate(&pDev->vbvaCtx);
    11981198
    11991199            lpUnlock->ddRVal = DD_OK;
    … …  
    12451245        DISPDBG((0, "%d,%d %dx%d\n", pDev->ddLock.rArea.left, pDev->ddLock.rArea.top, pDev->ddLock.rArea.right - pDev->ddLock.rArea.left, pDev->ddLock.rArea.bottom - pDev->ddLock.rArea.top));
    12461246
    1247         if (pDev->bHGSMISupported && vboxHwBufferBeginUpdate (pDev))
     1247        if (   pDev->bHGSMISupported
     1248            && VBoxVBVABufferBeginUpdate(&pDev->vbvaCtx, &pDev->guestCtx))
    12481249        {
    12491250            vbvaReportDirtyRect (pDev, &pDev->ddLock.rArea);
    12501251
    1251             if (  pDev->pVBVA->hostFlags.u32HostEvents
     1252            if (  pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents
    12521253                & VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET)
    12531254            {
    12541255                vrdpReset (pDev);
    12551256
    1256                 pDev->pVBVA->hostFlags.u32HostEvents &=
     1257                pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents &=
    12571258                          ~VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
    12581259            }
    12591260
    1260             if (pDev->pVBVA->hostFlags.u32HostEvents
     1261            if (pDev->vbvaCtx.pVBVA->hostFlags.u32HostEvents
    12611262                & VBVA_F_MODE_VRDP)
    12621263            {
    … …  
    12641265            }
    12651266
    1266             vboxHwBufferEndUpdate (pDev);
     1267            VBoxVBVABufferEndUpdate(&pDev->vbvaCtx);
    12671268        }
    12681269

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

    r33540 r34438  
    3636#include "../Miniport/vboxioctl.h"
    3737
     38#include <VBox/VBoxVideoGuest.h>
    3839#include <VBox/VBoxVideo.h>
    3940#ifdef VBOX_WITH_VIDEOHWACCEL
    … …  
    168169    FLONG   flHooks;
    169170
    170     BOOL             fHwBufferOverflow;
    171     VBVARECORD       *pRecord;
    172171    VRDPBC           cache;
    173172
    … …  
    192191
    193192    BOOLEAN bHGSMISupported;
    194     HGSMIHEAP hgsmiDisplayHeap;
    195     VBVABUFFER *pVBVA; /* Pointer to the pjScreen + layout->offVBVABuffer. NULL if VBVA is not enabled. */
     193    HGSMIGUESTCOMMANDCONTEXT guestCtx;
     194    VBVABUFFERCONTEXT vbvaCtx;
    196195
    197196    HVBOXVIDEOHGSMI hMpHGSMI; /* context handler passed to miniport HGSMI callbacks */
    198197    PFNVBOXVIDEOHGSMICOMPLETION pfnHGSMICommandComplete; /* called to complete the command we receive from the miniport */
    199198    PFNVBOXVIDEOHGSMICOMMANDS   pfnHGSMIRequestCommands; /* called to requests the commands posted to us from the host */
    200 
    201     RTIOPORT IOPortGuestCommand;
    202199
    203200    PVOID pVideoPortContext;
    … …  
    261258} VRDPCLIPRECTS;
    262259
    263 
    264 BOOL vboxVbvaEnable (PPDEV ppdev);
    265 void vboxVbvaDisable (PPDEV ppdev);
    266 
    267 BOOL vboxHwBufferBeginUpdate (PPDEV ppdev);
    268 void vboxHwBufferEndUpdate (PPDEV ppdev);
    269 
    270 BOOL vboxWrite (PPDEV ppdev, const void *pv, uint32_t cb);
    271 
    272 BOOL vboxOrderSupported (PPDEV ppdev, unsigned code);
    273260
    274261void VBoxProcessDisplayInfo(PPDEV ppdev);

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/drv.c

    r33540 r34438  
    106106        PPDEV ppdev = (PPDEV)__psoDest->dhpdev;                        \
    107107                                                                       \
    108         if (ppdev->bHGSMISupported && vboxHwBufferBeginUpdate (ppdev)) \
     108        if (   ppdev->bHGSMISupported                                  \
     109            && VBoxVBVABufferBeginUpdate(&ppdev->vbvaCtx, &ppdev->guestCtx)) \
    109110        {                                                              \
    110111            vbva##__fn __a;                                            \
    111112                                                                       \
    112             if (  ppdev->pVBVA->hostFlags.u32HostEvents                \
     113            if (  ppdev->vbvaCtx.pVBVA->hostFlags.u32HostEvents                \
    113114                & VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET)            \
    114115            {                                                          \
    115116                vrdpReset (ppdev);                                     \
    116117                                                                       \
    117                 ppdev->pVBVA->hostFlags.u32HostEvents &=               \
     118                ppdev->vbvaCtx.pVBVA->hostFlags.u32HostEvents &=               \
    118119                          ~VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;   \
    119120            }                                                          \
    120121                                                                       \
    121             if (ppdev->pVBVA->hostFlags.u32HostEvents                  \
     122            if (ppdev->vbvaCtx.pVBVA->hostFlags.u32HostEvents                  \
    122123                & VBVA_F_MODE_VRDP)                                    \
    123124            {                                                          \
    … …  
    125126            }                                                          \
    126127                                                                       \
    127             vboxHwBufferEndUpdate (ppdev);                             \
     128            VBoxVBVABufferEndUpdate(&ppdev->vbvaCtx);                             \
    128129        }                                                              \
    129130    }                                                                  \
    … …  
    322323        DISPDBG((1, "offscreen->screen\n"));
    323324
    324         if (   ppdev->pVBVA
    325             && (ppdev->pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_ENABLED))
     325        if (   ppdev->vbvaCtx.pVBVA
     326            && (ppdev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_ENABLED))
    326327        {
    327328            if (   (psoSrc->fjBitmap & BMF_DONTCACHE) != 0
    … …  
    729730        PPDEV ppdev = (PPDEV)psoTarget->dhpdev;
    730731
    731         if (   ppdev->pVBVA
    732             && (ppdev->pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_ENABLED))
     732        if (   ppdev->vbvaCtx.pVBVA
     733            && (ppdev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_ENABLED))
    733734        {
    734             if (ppdev->pVBVA->hostFlags.u32HostEvents
     735            if (ppdev->vbvaCtx.pVBVA->hostFlags.u32HostEvents
    735736                & VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET)
    736737            {
    737738                vrdpReset (ppdev);
    738739
    739                 ppdev->pVBVA->hostFlags.u32HostEvents &=
     740                ppdev->vbvaCtx.pVBVA->hostFlags.u32HostEvents &=
    740741                    ~VBOX_VIDEO_INFO_HOST_EVENTS_F_VRDP_RESET;
    741742            }
    742743
    743             if (ppdev->pVBVA->hostFlags.u32HostEvents
     744            if (ppdev->vbvaCtx.pVBVA->hostFlags.u32HostEvents
    744745                & VBVA_F_MODE_VRDP)
    745746            {

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/enable.c

    r33540 r34438  
    126126        ULONG ret = 0;
    127127
    128         if (ppdev && ppdev->pVBVA)
    129         {
    130             if (ppdev->pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_VRDP)
     128        if (ppdev && ppdev->vbvaCtx.pVBVA)
     129        {
     130            if (ppdev->vbvaCtx.pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_VRDP)
    131131            {
    132132                ret = 1;
    133133            }
    134             DISPDBG((0, "VBOXESC_ISVRDPACTIVE -> %d (%x)\n", ret, ppdev->pVBVA->hostFlags.u32HostEvents));
     134            DISPDBG((0, "VBOXESC_ISVRDPACTIVE -> %d (%x)\n", ret, ppdev->vbvaCtx.pVBVA->hostFlags.u32HostEvents));
    135135        }
    136136        else
    … …  
    909909
    910910        /* Free the driver's VBVA resources. */
    911         vboxVbvaDisable ((PPDEV) dhpdev);
     911        if (ppdev->bHGSMISupported)
     912        {
     913            PPDEV ppdev = (PPDEV) dhpdev;
     914            VBoxVBVADisable(&ppdev->vbvaCtx, &ppdev->guestCtx);
     915        }
    912916
    913917        //

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/screen.c

    r33540 r34438  
    221221         * HGSMI event flags in the beginning.
    222222         */
    223         int rc = HGSMIHeapSetup (&ppdev->hgsmiDisplayHeap,
     223        int rc = HGSMIHeapSetup (&ppdev->guestCtx.heapCtx,
    224224                                 (uint8_t *)ppdev->pjScreen + ppdev->layout.offDisplayInformation + sizeof (HGSMIHOSTFLAGS),
    225225                                 ppdev->layout.cbDisplayInformation - sizeof (HGSMIHOSTFLAGS),
    … …  
    239239        else
    240240        {
    241             ppdev->IOPortGuestCommand = info.IOPortGuestCommand;
    242         }
    243     }
     241            ppdev->guestCtx.port = info.IOPortGuestCommand;
     242        }
     243    }
     244    /* Update buffer layout in VBVA context information.  Shouldn't this get
     245     * zeroed if initialising the HGSMI heap fails? */
     246    ppdev->vbvaCtx.offVRAMBuffer = ppdev->layout.offVBVABuffer;
     247    ppdev->vbvaCtx.cbBuffer = ppdev->layout.cbVBVABuffer;
    244248
    245249    DISPDBG((0, "vboxInitVBoxVideo:\n"
    … …  
    405409        {
    406410            /* Enable VBVA for this video mode. */
    407             ppdev->bHGSMISupported = vboxVbvaEnable (ppdev);
     411            VBVABUFFER *pVBVA = (VBVABUFFER *)((uint8_t *)ppdev->pjScreen + ppdev->layout.offVBVABuffer);
     412            ppdev->bHGSMISupported = VBoxVBVAEnable(&ppdev->vbvaCtx,
     413                                                    &ppdev->guestCtx,
     414                                                    pVBVA);
    408415            LogRel(("VBoxDisp[%d]: VBVA %senabled\n", ppdev->iDevice, ppdev->bHGSMISupported? "": "not "));
    409416        }
    … …  
    414421    /* Inform the host about this screen layout. */
    415422    DISPDBG((1, "bInitSURF: %d,%d\n", ppdev->ptlDevOrg.x, ppdev->ptlDevOrg.y));
    416     VBoxProcessDisplayInfo (ppdev);
     423    if (ppdev->bHGSMISupported)
     424    {
     425        VBoxProcessDisplayInfo (ppdev);
     426    }
    417427
    418428#ifdef VBOX_WITH_VIDEOHWACCEL

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/vbox.c

    r33890 r34438  
    2121#include <VBox/VBoxGuest.h>
    2222#include <VBox/err.h>
     23#include <VBox/log.h>
    2324#include <iprt/asm.h>
    2425#include <iprt/asm-amd64-x86.h>
     26#include <iprt/assert.h>
    2527
    2628/*
    2729 * There is a hardware ring buffer in the VBox VMMDev PCI memory space.
    28  * All graphics commands go there serialized by vboxHwBufferBeginUpdate.
     30 * All graphics commands go there serialized by VBoxVBVABufferBeginUpdate.
    2931 * and vboxHwBufferEndUpdate.
    3032 *
    … …  
    3739
    3840/* Forward declarations of internal functions. */
    39 static void vboxHwBufferFlush (PPDEV ppdev);
    40 static void vboxHwBufferPlaceDataAt (PPDEV ppdev, void *p, uint32_t cb, uint32_t offset);
    41 static BOOL vboxHwBufferWrite (PPDEV ppdev, const void *p, uint32_t cb);
    42 
    43 
    44 static void vboxHGSMIBufferSubmit (PPDEV ppdev, void *p)
    45 {
    46     HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&ppdev->hgsmiDisplayHeap, p);
    47 
    48     DISPDBG((0, "VBoxDISP::vboxHGSMIBufferSubmit: offset 0x%x\n", offBuffer));
    49 
    50     ASMOutU32(ppdev->IOPortGuestCommand, offBuffer);
    51 }
    52 
    53 static BOOL vboxVBVAInformHost (PPDEV ppdev, BOOL bEnable)
    54 {
    55     BOOL bRc = FALSE;
    56 
     41static void vboxHwBufferFlush(PHGSMIGUESTCOMMANDCONTEXT pCtx);
     42static void vboxHwBufferPlaceDataAt(PVBVABUFFERCONTEXT pCtx, const void *p,
     43                                    uint32_t cb, uint32_t offset);
     44static bool vboxHwBufferWrite(PVBVABUFFERCONTEXT pCtx,
     45                              PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx,
     46                              const void *p, uint32_t cb);
     47
     48
     49static bool vboxVBVAInformHost(PVBVABUFFERCONTEXT pCtx,
     50                               PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx,
     51                               bool bEnable)
     52{
     53    bool bRc = false;
     54
     55#if 0  /* All callers check this */
    5756    if (ppdev->bHGSMISupported)
    58     {
    59         void *p = HGSMIHeapAlloc (&ppdev->hgsmiDisplayHeap,
    60                                   sizeof (VBVAENABLE),
    61                                   HGSMI_CH_VBVA,
    62                                   VBVA_ENABLE);
     57#endif
     58    {
     59        void *p = VBoxHGSMIBufferAlloc(pHGSMICtx,
     60                                       sizeof (VBVAENABLE),
     61                                       HGSMI_CH_VBVA,
     62                                       VBVA_ENABLE);
    6363        if (!p)
    6464        {
    65             DISPDBG((0, "VBoxDISP::vboxVBVAInformHost: HGSMIHeapAlloc failed\n"));
     65            LogFunc(("HGSMIHeapAlloc failed\n"));
    6666        }
    6767        else
    … …  
    7070
    7171            pEnable->u32Flags  = bEnable? VBVA_F_ENABLE: VBVA_F_DISABLE;
    72             pEnable->u32Offset = ppdev->layout.offVBVABuffer;
     72            pEnable->u32Offset = pCtx->offVRAMBuffer;
    7373            pEnable->i32Result = VERR_NOT_SUPPORTED;
    7474
    75             vboxHGSMIBufferSubmit (ppdev, p);
     75            VBoxHGSMIBufferSubmit(pHGSMICtx, p);
    7676
    7777            if (bEnable)
    … …  
    8181            else
    8282            {
    83                 bRc = TRUE;
     83                bRc = true;
    8484            }
    8585
    86             HGSMIHeapFree (&ppdev->hgsmiDisplayHeap, p);
     86            VBoxHGSMIBufferFree(pHGSMICtx, p);
    8787        }
    8888    }
    … …  
    9494 * Public hardware buffer methods.
    9595 */
    96 BOOL vboxVbvaEnable (PPDEV ppdev)
    97 {
    98     BOOL bRc = FALSE;
    99 
    100     DISPDBG((1, "VBoxDisp::vboxVbvaEnable called ppdev %p, hgsmi %d, vbva %p\n", ppdev, ppdev->bHGSMISupported, ppdev->pVBVA));
    101 
     96RTDECL(bool) VBoxVBVAEnable(PVBVABUFFERCONTEXT pCtx,
     97                            PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx,
     98                            VBVABUFFER *pVBVA)
     99{
     100    bool bRc = false;
     101
     102    LogFlowFunc(("pVBVA %p\n", pVBVA));
     103
     104#if 0  /* All callers check this */
    102105    if (ppdev->bHGSMISupported)
    103     {
    104         VBVABUFFER *pVBVA = (VBVABUFFER *)((uint8_t *)ppdev->pjScreen + ppdev->layout.offVBVABuffer);
    105 
    106         DISPDBG((1, "VBoxDisp::vboxVbvaEnable screen %p vbva off 0x%x\n", ppdev->pjScreen, ppdev->layout.offVBVABuffer));
     106#endif
     107    {
     108        LogFunc(("pVBVA %p vbva off 0x%x\n", pVBVA, pCtx->offVRAMBuffer));
    107109
    108110        pVBVA->hostFlags.u32HostEvents      = 0;
    … …  
    110112        pVBVA->off32Data          = 0;
    111113        pVBVA->off32Free          = 0;
    112         RtlZeroMemory (pVBVA->aRecords, sizeof (pVBVA->aRecords));
     114        memset(pVBVA->aRecords, 0, sizeof (pVBVA->aRecords));
    113115        pVBVA->indexRecordFirst   = 0;
    114116        pVBVA->indexRecordFree    = 0;
    115117        pVBVA->cbPartialWriteThreshold = 256;
    116         pVBVA->cbData             = ppdev->layout.cbVBVABuffer - sizeof (VBVABUFFER) + sizeof (pVBVA->au8Data);
    117 
    118         ppdev->fHwBufferOverflow = FALSE;
    119         ppdev->pRecord           = NULL;
    120         ppdev->pVBVA             = pVBVA;
    121 
    122         bRc = vboxVBVAInformHost (ppdev, TRUE);
     118        pVBVA->cbData             = pCtx->cbBuffer - sizeof (VBVABUFFER) + sizeof (pVBVA->au8Data);
     119
     120        pCtx->fHwBufferOverflow = false;
     121        pCtx->pRecord    = NULL;
     122        pCtx->pVBVA      = pVBVA;
     123
     124        bRc = vboxVBVAInformHost(pCtx, pHGSMICtx, true);
    123125    }
    124126
    125127    if (!bRc)
    126128    {
    127         vboxVbvaDisable (ppdev);
     129        VBoxVBVADisable(pCtx, pHGSMICtx);
    128130    }
    129131
    … …  
    131133}
    132134
    133 void vboxVbvaDisable (PPDEV ppdev)
    134 {
    135     DISPDBG((1, "VBoxDisp::vbvaDisable called.\n"));
    136 
    137     ppdev->fHwBufferOverflow = FALSE;
    138     ppdev->pRecord           = NULL;
    139     ppdev->pVBVA             = NULL;
    140 
    141     vboxVBVAInformHost (ppdev, FALSE);
     135RTDECL(void) VBoxVBVADisable(PVBVABUFFERCONTEXT pCtx,
     136                             PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx)
     137{
     138    LogFlowFunc(("\n"));
     139
     140    pCtx->fHwBufferOverflow = false;
     141    pCtx->pRecord           = NULL;
     142    pCtx->pVBVA             = NULL;
     143
     144    vboxVBVAInformHost(pCtx, pHGSMICtx, false);
    142145
    143146    return;
    144147}
    145148
    146 BOOL vboxHwBufferBeginUpdate (PPDEV ppdev)
    147 {
    148     BOOL bRc = FALSE;
    149 
    150     // DISPDBG((1, "VBoxDisp::vboxHwBufferBeginUpdate called flags = 0x%08X\n",
    151     //          ppdev->pVBVA? ppdev->pVBVA->u32HostEvents: -1));
    152 
    153     if (   ppdev->pVBVA
    154         && (ppdev->pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_ENABLED))
     149RTDECL(bool) VBoxVBVABufferBeginUpdate(PVBVABUFFERCONTEXT pCtx,
     150                                       PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx)
     151{
     152    bool bRc = false;
     153
     154    // LogFunc(("flags = 0x%08X\n", pCtx->pVBVA? pCtx->pVBVA->u32HostEvents: -1));
     155
     156    if (   pCtx->pVBVA
     157        && (pCtx->pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_ENABLED))
    155158    {
    156159        uint32_t indexRecordNext;
    157160
    158         VBVA_ASSERT (!ppdev->fHwBufferOverflow);
    159         VBVA_ASSERT (ppdev->pRecord == NULL);
    160 
    161         indexRecordNext = (ppdev->pVBVA->indexRecordFree + 1) % VBVA_MAX_RECORDS;
    162 
    163         if (indexRecordNext == ppdev->pVBVA->indexRecordFirst)
     161        Assert(!pCtx->fHwBufferOverflow);
     162        Assert(pCtx->pRecord == NULL);
     163
     164        indexRecordNext = (pCtx->pVBVA->indexRecordFree + 1) % VBVA_MAX_RECORDS;
     165
     166        if (indexRecordNext == pCtx->pVBVA->indexRecordFirst)
    164167        {
    165168            /* All slots in the records queue are used. */
    166             vboxHwBufferFlush (ppdev);
    167         }
    168 
    169         if (indexRecordNext == ppdev->pVBVA->indexRecordFirst)
     169            vboxHwBufferFlush (pHGSMICtx);
     170        }
     171
     172        if (indexRecordNext == pCtx->pVBVA->indexRecordFirst)
    170173        {
    171174            /* Even after flush there is no place. Fail the request. */
    172             DISPDBG((1, "VBoxDisp::vboxHwBufferBeginUpdate no space in the queue of records!!! first %d, last %d\n",
    173                      ppdev->pVBVA->indexRecordFirst, ppdev->pVBVA->indexRecordFree));
     175            LogFunc(("no space in the queue of records!!! first %d, last %d\n",
     176                     pCtx->pVBVA->indexRecordFirst, pCtx->pVBVA->indexRecordFree));
    174177        }
    175178        else
    176179        {
    177180            /* Initialize the record. */
    178             VBVARECORD *pRecord = &ppdev->pVBVA->aRecords[ppdev->pVBVA->indexRecordFree];
     181            VBVARECORD *pRecord = &pCtx->pVBVA->aRecords[pCtx->pVBVA->indexRecordFree];
    179182
    180183            pRecord->cbRecord = VBVA_F_RECORD_PARTIAL;
    181184
    182             ppdev->pVBVA->indexRecordFree = indexRecordNext;
    183 
    184             // DISPDBG((1, "VBoxDisp::vboxHwBufferBeginUpdate indexRecordNext = %d\n", indexRecordNext));
     185            pCtx->pVBVA->indexRecordFree = indexRecordNext;
     186
     187            // LogFunc(("indexRecordNext = %d\n", indexRecordNext));
    185188
    186189            /* Remember which record we are using. */
    187             ppdev->pRecord = pRecord;
    188 
    189             bRc = TRUE;
     190            pCtx->pRecord = pRecord;
     191
     192            bRc = true;
    190193        }
    191194    }
    … …  
    194197}
    195198
    196 void vboxHwBufferEndUpdate (PPDEV ppdev)
     199RTDECL(void) VBoxVBVABufferEndUpdate(PVBVABUFFERCONTEXT pCtx)
    197200{
    198201    VBVARECORD *pRecord;
    199202
    200     // DISPDBG((1, "VBoxDisp::vboxHwBufferEndUpdate called\n"));
    201 
    202     VBVA_ASSERT(ppdev->pVBVA);
    203 
    204     pRecord = ppdev->pRecord;
    205     VBVA_ASSERT (pRecord && (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL));
     203    // LogFunc(("\n"));
     204
     205    Assert(pCtx->pVBVA);
     206
     207    pRecord = pCtx->pRecord;
     208    Assert(pRecord && (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL));
    206209
    207210    /* Mark the record completed. */
    208211    pRecord->cbRecord &= ~VBVA_F_RECORD_PARTIAL;
    209212
    210     ppdev->fHwBufferOverflow = FALSE;
    211     ppdev->pRecord = NULL;
     213    pCtx->fHwBufferOverflow = false;
     214    pCtx->pRecord = NULL;
    212215
    213216    return;
    … …  
    224227}
    225228
    226 static void vboxHwBufferFlush (PPDEV ppdev)
     229static void vboxHwBufferFlush(PHGSMIGUESTCOMMANDCONTEXT pCtx)
    227230{
    228231    /* Issue the flush command. */
    229     void *p = HGSMIHeapAlloc (&ppdev->hgsmiDisplayHeap,
    230                               sizeof (VBVAFLUSH),
    231                               HGSMI_CH_VBVA,
    232                               VBVA_FLUSH);
     232    void *p = VBoxHGSMIBufferAlloc(pCtx,
     233                                   sizeof (VBVAFLUSH),
     234                                   HGSMI_CH_VBVA,
     235                                   VBVA_FLUSH);
    233236    if (!p)
    234237    {
    235         DISPDBG((0, "VBoxDISP::vboxHwBufferFlush: HGSMIHeapAlloc failed\n"));
     238        LogFunc(("HGSMIHeapAlloc failed\n"));
    236239    }
    237240    else
    … …  
    241244        pFlush->u32Reserved = 0;
    242245
    243         vboxHGSMIBufferSubmit (ppdev, p);
    244 
    245         HGSMIHeapFree (&ppdev->hgsmiDisplayHeap, p);
     246        VBoxHGSMIBufferSubmit(pCtx, p);
     247
     248        VBoxHGSMIBufferSubmit(pCtx, p);
    246249    }
    247250
    … …  
    249252}
    250253
    251 static void vboxHwBufferPlaceDataAt (PPDEV ppdev, const void *p, uint32_t cb, uint32_t offset)
    252 {
    253     VBVABUFFER *pVBVA = ppdev->pVBVA;
     254static void vboxHwBufferPlaceDataAt(PVBVABUFFERCONTEXT pCtx, const void *p,
     255                                    uint32_t cb, uint32_t offset)
     256{
     257    VBVABUFFER *pVBVA = pCtx->pVBVA;
    254258    uint32_t u32BytesTillBoundary = pVBVA->cbData - offset;
    255259    uint8_t  *dst                 = &pVBVA->au8Data[offset];
    … …  
    271275}
    272276
    273 static BOOL vboxHwBufferWrite (PPDEV ppdev, const void *p, uint32_t cb)
     277static bool vboxHwBufferWrite(PVBVABUFFERCONTEXT pCtx,
     278                              PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx,
     279                              const void *p, uint32_t cb)
    274280{
    275281    VBVARECORD *pRecord;
    … …  
    278284    uint32_t cbWritten = 0;
    279285
    280     VBVABUFFER *pVBVA = ppdev->pVBVA;
    281     VBVA_ASSERT(pVBVA);
    282 
    283     if (!pVBVA || ppdev->fHwBufferOverflow)
    284     {
    285         return FALSE;
    286     }
    287 
    288     VBVA_ASSERT (pVBVA->indexRecordFirst != pVBVA->indexRecordFree);
    289 
    290     pRecord = ppdev->pRecord;
    291     VBVA_ASSERT (pRecord && (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL));
    292 
    293     DISPDBG((1, "VW %d\n", cb));
     286    VBVABUFFER *pVBVA = pCtx->pVBVA;
     287    Assert(pVBVA);
     288
     289    if (!pVBVA || pCtx->fHwBufferOverflow)
     290    {
     291        return false;
     292    }
     293
     294    Assert(pVBVA->indexRecordFirst != pVBVA->indexRecordFree);
     295
     296    pRecord = pCtx->pRecord;
     297    Assert(pRecord && (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL));
     298
     299    LogFunc(("%d\n", cb));
    294300
    295301    cbHwBufferAvail = vboxHwBufferAvail (pVBVA);
    … …  
    299305        uint32_t cbChunk = cb;
    300306
    301         // DISPDBG((1, "VBoxDisp::vboxHwBufferWrite pVBVA->off32Free %d, pRecord->cbRecord 0x%08X, cbHwBufferAvail %d, cb %d, cbWritten %d\n",
     307        // LogFunc(("pVBVA->off32Free %d, pRecord->cbRecord 0x%08X, cbHwBufferAvail %d, cb %d, cbWritten %d\n",
    302308        //             pVBVA->off32Free, pRecord->cbRecord, cbHwBufferAvail, cb, cbWritten));
    303309
    304310        if (cbChunk >= cbHwBufferAvail)
    305311        {
    306             DISPDBG((1, "VBoxDisp::vboxHwBufferWrite 1) avail %d, chunk %d\n", cbHwBufferAvail, cbChunk));
    307 
    308             vboxHwBufferFlush (ppdev);
     312            LogFunc(("1) avail %d, chunk %d\n", cbHwBufferAvail, cbChunk));
     313
     314            vboxHwBufferFlush (pHGSMICtx);
    309315
    310316            cbHwBufferAvail = vboxHwBufferAvail (pVBVA);
    … …  
    312318            if (cbChunk >= cbHwBufferAvail)
    313319            {
    314                 DISPDBG((1, "VBoxDisp::vboxHwBufferWrite: no place for %d bytes. Only %d bytes available after flush. Going to partial writes.\n",
     320                LogFunc(("no place for %d bytes. Only %d bytes available after flush. Going to partial writes.\n",
    315321                            cb, cbHwBufferAvail));
    316322
    317323                if (cbHwBufferAvail <= pVBVA->cbPartialWriteThreshold)
    318324                {
    319                     DISPDBG((1, "VBoxDisp::vboxHwBufferWrite: Buffer overflow!!!\n"));
    320                     ppdev->fHwBufferOverflow = TRUE;
    321                     VBVA_ASSERT(FALSE);
    322                     return FALSE;
     325                    LogFunc(("Buffer overflow!!!\n"));
     326                    pCtx->fHwBufferOverflow = true;
     327                    Assert(false);
     328                    return false;
    323329                }
    324330
    … …  
    327333        }
    328334
    329         VBVA_ASSERT(cbChunk <= cb);
    330         VBVA_ASSERT(cbChunk <= vboxHwBufferAvail (pVBVA));
    331 
    332         vboxHwBufferPlaceDataAt (ppdev, (uint8_t *)p + cbWritten, cbChunk, pVBVA->off32Free);
     335        Assert(cbChunk <= cb);
     336        Assert(cbChunk <= vboxHwBufferAvail (pVBVA));
     337
     338        vboxHwBufferPlaceDataAt (pCtx, (uint8_t *)p + cbWritten, cbChunk, pVBVA->off32Free);
    333339
    334340        pVBVA->off32Free   = (pVBVA->off32Free + cbChunk) % pVBVA->cbData;
    … …  
    340346    }
    341347
    342     return TRUE;
     348    return true;
    343349}
    344350
    … …  
    346352 * Public writer to the hardware buffer.
    347353 */
    348 BOOL vboxWrite (PPDEV ppdev, const void *pv, uint32_t cb)
    349 {
    350     return vboxHwBufferWrite (ppdev, pv, cb);
    351 }
    352 
    353 BOOL vboxOrderSupported (PPDEV ppdev, unsigned code)
    354 {
    355     VBVABUFFER *pVBVA = ppdev->pVBVA;
     354RTDECL(bool) VBoxVBVAWrite(PVBVABUFFERCONTEXT pCtx,
     355                           PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx,
     356                           const void *pv, uint32_t cb)
     357{
     358    return vboxHwBufferWrite (pCtx, pHGSMICtx, pv, cb);
     359}
     360
     361RTDECL(bool) VBoxVBVAOrderSupported(PVBVABUFFERCONTEXT pCtx, unsigned code)
     362{
     363    VBVABUFFER *pVBVA = pCtx->pVBVA;
    356364
    357365    if (!pVBVA)
    … …  
    362370    if (pVBVA->hostFlags.u32SupportedOrders & (1 << code))
    363371    {
    364         return TRUE;
     372        return true;
    365373    }
    366374
    … …  
    368376}
    369377
     378RTDECL(void) VBoxHGSMIProcessDisplayInfo(PHGSMIGUESTCOMMANDCONTEXT pCtx,
     379                                         uint32_t cDisplay,
     380                                         int32_t  cOriginX,
     381                                         int32_t  cOriginY,
     382                                         uint32_t offStart,
     383                                         uint32_t cbPitch,
     384                                         uint32_t cWidth,
     385                                         uint32_t cHeight,
     386                                         uint16_t cBPP)
     387{
     388    /* Issue the screen info command. */
     389    void *p = VBoxHGSMIBufferAlloc(pCtx,
     390                                   sizeof (VBVAINFOSCREEN),
     391                                   HGSMI_CH_VBVA,
     392                                   VBVA_INFO_SCREEN);
     393    if (!p)
     394    {
     395        LogFunc(("HGSMIHeapAlloc failed\n"));
     396    }
     397    else
     398    {
     399        VBVAINFOSCREEN *pScreen = (VBVAINFOSCREEN *)p;
     400
     401        pScreen->u32ViewIndex    = cDisplay;
     402        pScreen->i32OriginX      = cOriginX;
     403        pScreen->i32OriginY      = cOriginY;
     404        pScreen->u32StartOffset  = offStart;
     405        pScreen->u32LineSize     = cbPitch;
     406        pScreen->u32Width        = cWidth;
     407        pScreen->u32Height       = cHeight;
     408        pScreen->u16BitsPerPixel = cBPP;
     409        pScreen->u16Flags        = VBVA_SCREEN_F_ACTIVE;
     410
     411        VBoxHGSMIBufferSubmit(pCtx, p);
     412
     413        VBoxHGSMIBufferFree(pCtx, p);
     414    }
     415}
     416
    370417void VBoxProcessDisplayInfo (PPDEV ppdev)
    371418{
    372419    if (ppdev->bHGSMISupported)
    373420    {
    374         /* Issue the screen info command. */
    375         void *p = HGSMIHeapAlloc (&ppdev->hgsmiDisplayHeap,
    376                                   sizeof (VBVAINFOSCREEN),
    377                                   HGSMI_CH_VBVA,
    378                                   VBVA_INFO_SCREEN);
    379         if (!p)
    380         {
    381             DISPDBG((0, "VBoxDISP::VBoxProcessDisplayInfo: HGSMIHeapAlloc failed\n"));
    382         }
    383         else
    384         {
    385             VBVAINFOSCREEN *pScreen = (VBVAINFOSCREEN *)p;
    386 
    387             pScreen->u32ViewIndex    = ppdev->iDevice;
    388             pScreen->i32OriginX      = ppdev->ptlDevOrg.x;
    389             pScreen->i32OriginY      = ppdev->ptlDevOrg.y;
    390             pScreen->u32StartOffset  = 0;
    391             pScreen->u32LineSize     = ppdev->lDeltaScreen > 0?ppdev->lDeltaScreen: -ppdev->lDeltaScreen;
    392             pScreen->u32Width        = ppdev->cxScreen;
    393             pScreen->u32Height       = ppdev->cyScreen;
    394             pScreen->u16BitsPerPixel = (uint16_t)ppdev->ulBitCount;
    395             pScreen->u16Flags        = VBVA_SCREEN_F_ACTIVE;
    396 
    397             vboxHGSMIBufferSubmit (ppdev, p);
    398 
    399             HGSMIHeapFree (&ppdev->hgsmiDisplayHeap, p);
    400         }
     421        VBoxHGSMIProcessDisplayInfo(&ppdev->guestCtx, ppdev->iDevice,
     422                                     ppdev->ptlDevOrg.x, ppdev->ptlDevOrg.y, 0,
     423                                       ppdev->lDeltaScreen > 0
     424                                     ? ppdev->lDeltaScreen
     425                                     : -ppdev->lDeltaScreen, ppdev->cxScreen,
     426                                     ppdev->cyScreen,
     427                                     (uint16_t)ppdev->ulBitCount);
    401428    }
    402429
    … …  
    408435VBOXVHWACMD* vboxVHWACommandCreate (PPDEV ppdev, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd)
    409436{
    410     VBOXVHWACMD* pHdr = (VBOXVHWACMD*)HGSMIHeapAlloc (&ppdev->hgsmiDisplayHeap,
     437    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)VBoxHGSMIBufferAlloc(&ppdev->guestCtx,
    411438                              cbCmd + VBOXVHWACMD_HEADSIZE(),
    412439                              HGSMI_CH_VBVA,
    … …  
    414441    if (!pHdr)
    415442    {
    416         DISPDBG((0, "VBoxDISP::vboxVHWACommandCreate: HGSMIHeapAlloc failed\n"));
     443        LogFunc(("HGSMIHeapAlloc failed\n"));
    417444    }
    418445    else
    … …  
    433460void vboxVHWACommandFree (PPDEV ppdev, VBOXVHWACMD* pCmd)
    434461{
    435     HGSMIHeapFree (&ppdev->hgsmiDisplayHeap, pCmd);
     462    VBoxHGSMIBufferFree(&ppdev->guestCtx, pCmd);
    436463}
    437464
    … …  
    446473{
    447474    VBVAHOSTCMDVHWACMDCOMPLETE * pComplete = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE);
    448     VBOXVHWACMD* pComplCmd = (VBOXVHWACMD*)HGSMIOffsetToPointer (&ppdev->hgsmiDisplayHeap.area, pComplete->offCmd);
     475    VBOXVHWACMD* pComplCmd = (VBOXVHWACMD*)HGSMIOffsetToPointer (&ppdev->guestCtx.heapCtx.area, pComplete->offCmd);
    449476    PFNVBOXVHWACMDCOMPLETION pfnCompletion = (PFNVBOXVHWACMDCOMPLETION)pComplCmd->GuestVBVAReserved1;
    450477    void * pContext = (void *)pComplCmd->GuestVBVAReserved2;
    … …  
    502529    /* complete it asynchronously by setting event */
    503530    pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT;
    504     vboxHGSMIBufferSubmit (ppdev, pCmd);
     531    VBoxHGSMIBufferSubmit(&ppdev->guestCtx, pCmd);
    505532
    506533    if(!(ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags)  & VBOXVHWACMD_FLAG_HG_ASYNCH))
    … …  
    543570    vbvaVHWACommandRetain(ppdev, pCmd);
    544571
    545     vboxHGSMIBufferSubmit (ppdev, pCmd);
     572    VBoxHGSMIBufferSubmit(&ppdev->guestCtx, pCmd);
    546573
    547574    if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH))
    … …  
    568595    pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION;
    569596
    570     vboxHGSMIBufferSubmit (ppdev, pCmd);
     597    VBoxHGSMIBufferSubmit(&ppdev->guestCtx, pCmd);
    571598
    572599    if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH)

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/vbva.c

    r33002 r34438  
    351351        hdr.h = (uint16_t)(rect.bottom - rect.top);
    352352
    353         vboxWrite (ppdev, &hdr, sizeof(hdr));
     353        VBoxVBVAWrite(&ppdev->vbvaCtx, &ppdev->guestCtx, &hdr, sizeof(hdr));
    354354    }
    355355

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/vrdp.c

    r33595 r34438  
    365365__inline BOOL vrdpWriteHdr (PPDEV ppdev, uint32_t u32Op)
    366366{
    367     return vboxWrite (ppdev, &u32Op, sizeof (u32Op));
     367    return VBoxVBVAWrite(&ppdev->vbvaCtx, &ppdev->guestCtx, &u32Op, sizeof (u32Op));
    368368}
    369369
    … …  
    381381    bits.cbPixel = (uint8_t)bytesPerPixel;
    382382
    383     bRc = vboxWrite (ppdev, &bits, sizeof (bits));
     383    bRc = VBoxVBVAWrite(&ppdev->vbvaCtx, &ppdev->guestCtx, &bits, sizeof (bits));
    384384
    385385    if (bRc)
    … …  
    387387        while (cHeight--)
    388388        {
    389             bRc = vboxWrite (ppdev, pu8Bits, cWidth * bytesPerPixel);
     389            bRc = VBoxVBVAWrite(&ppdev->vbvaCtx, &ppdev->guestCtx, pu8Bits, cWidth * bytesPerPixel);
    390390
    391391            if (!bRc)
    … …  
    503503    if (bRc)
    504504    {
    505         vboxWrite (ppdev, pOrder, cbOrder);
     505        VBoxVBVAWrite(&ppdev->vbvaCtx, &ppdev->guestCtx, pOrder, cbOrder);
    506506    }
    507507
    … …  
    14341434    else if (ppo->fl & PO_ELLIPSE)
    14351435    {
    1436         if (vboxOrderSupported (ppdev, VRDE_ORDER_ELLIPSE))
     1436        if (VBoxVBVAOrderSupported (&ppdev->vbvaCtx, VRDE_ORDER_ELLIPSE))
    14371437        {
    14381438            VRDEORDERELLIPSE order;
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