VirtualBox

Changeset 19844 in vbox for trunk/src


Ignore:
Timestamp:
May 19, 2009 11:12:55 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
47505
Message:

HGSMI: post host VBVA commands to display; Video HW Accel: mechanism for passing/processing commands to framebuffer

Location:
trunk/src/VBox
Files:
26 edited

Legend:

Unmodified
Added
Removed

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

    r19464 r19844  
    164164    HGSMIHEAP hgsmiDisplayHeap;
    165165    VBVABUFFER *pVBVA; /* Pointer to the pjScreen + layout->offVBVABuffer. NULL if VBVA is not enabled. */
     166
     167    HVBOXVIDEOHGSMI hMpHGSMI; /* context handler passed to miniport HGSMI callbacks */
     168    PFNVBOXVIDEOHGSMICOMPLETION pfnHGSMICommandComplete; /* called to complete the command we receive from the miniport */
    166169#endif /* VBOX_WITH_HGSMI */
    167170
    … …  
    249252void drvLoadEng (void);
    250253
    251 #ifdef VBOX_WITH_VIDEOHWACCEL
    252 VBVAVHWACMD_HDR* vboxVHWACreateCommand (PPDEV ppdev, VBVAVHWACMD_LENGTH cbCmd);
    253 void vboxVHWAFreeCommand (PPDEV ppdev, VBVAVHWACMD_HDR* pCmd);
    254 void vboxVHWASubmitCommand (PPDEV ppdev, VBVAVHWACMD_HDR* pCmd);
     254#ifdef VBOX_WITH_HGSMI
     255DECLCALLBACK(int) vboxVHWACommandHanlder(void *pvHandler, uint16_t u16ChannelInfo, void *pvBuffer, HGSMISIZE cbBuffer);
     256
     257 #ifdef VBOX_WITH_VIDEOHWACCEL
     258VBOXVHWACMD* vboxVHWACreateCommand (PPDEV ppdev, VBOXVHWACMD_LENGTH cbCmd);
     259void vboxVHWAFreeCommand (PPDEV ppdev, VBOXVHWACMD* pCmd);
     260void vboxVHWASubmitCommand (PPDEV ppdev, VBOXVHWACMD* pCmd);
     261 #endif
    255262#endif
    256263

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

    r19711 r19844  
    101101    if (ppdev->bHGSMISupported)
    102102    {
     103        HGSMIQUERYCALLBACKS Callbacks;
     104        DWORD err;
     105        RtlZeroMemory(&Callbacks, sizeof(Callbacks));
     106
    103107        iDevice = info.iDevice;
    104108        u32DisplayInfoSize = info.u32DisplayInfoSize;
    105109        u32MinVBVABufferSize = info.u32MinVBVABufferSize;
     110
     111        err = EngDeviceIoControl(ppdev->hDriver,
     112                IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS,
     113                NULL,
     114                0,
     115                &Callbacks,
     116                sizeof(Callbacks),
     117                &returnedDataLength);
     118        Assert(!err);
     119        if(!err)
     120        {
     121            HGSMIHANDLERREGISTER HandlerReg;
     122            RtlZeroMemory(&HandlerReg, sizeof(HandlerReg));
     123
     124            ppdev->hMpHGSMI = Callbacks.hContext;
     125            ppdev->pfnHGSMICommandComplete = Callbacks.pfnCompletionHandler;
     126            HandlerReg.pfnHandler = vboxVHWACommandHanlder;
     127            HandlerReg.pvHandler = ppdev;
     128            HandlerReg.u8Channel = HGSMI_CH_VBVA;
     129            err = EngDeviceIoControl(ppdev->hDriver,
     130                    IOCTL_VIDEO_HGSMI_HANDLER_REGISTER,
     131                    &HandlerReg,
     132                    sizeof(HandlerReg),
     133                    NULL,
     134                    0,
     135                    &returnedDataLength);
     136            Assert(!err);
     137        }
     138
     139        if(err)
     140        {
     141            ppdev->bHGSMISupported = FALSE;
     142        }
     143
    106144    }
    107145#endif /* VBOX_WITH_HGSMI */

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

    r19464 r19844  
    692692# ifdef VBOX_WITH_VIDEOHWACCEL
    693693
    694 VBVAVHWACMD_HDR* vboxVHWACreateCommand (PPDEV ppdev, VBVAVHWACMD_LENGTH cbCmd)
    695 {
    696     VBVAVHWACMD_HDR* pHdr = (VBVAVHWACMD_HDR*)HGSMIHeapAlloc (&ppdev->hgsmiDisplayHeap,
     694VBOXVHWACMD* vboxVHWACreateCommand (PPDEV ppdev, VBOXVHWACMD_LENGTH cbCmd)
     695{
     696    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)HGSMIHeapAlloc (&ppdev->hgsmiDisplayHeap,
    697697                              cbCmd,
    698698                              HGSMI_CH_VBVA,
    … …  
    706706}
    707707
    708 void vboxVHWAFreeCommand (PPDEV ppdev, VBVAVHWACMD_HDR* pCmd)
     708void vboxVHWAFreeCommand (PPDEV ppdev, VBOXVHWACMD* pCmd)
    709709{
    710710    HGSMIHeapFree (&ppdev->hgsmiDisplayHeap, pCmd);
    711711}
    712712
    713 void vboxVHWASubmitCommand (PPDEV ppdev, VBVAVHWACMD_HDR* pCmd)
     713void vboxVHWASubmitCommand (PPDEV ppdev, VBOXVHWACMD* pCmd)
    714714{
    715715    vboxHGSMIBufferSubmit (ppdev, pCmd);
     716    if(pCmd->rc == VINF_VHWA_CMD_PENDING)
     717    {
     718
     719    }
     720}
     721
     722/* do not wait for completion */
     723void vboxVHWASubmitCommandAssynch (PPDEV ppdev, VBOXVHWACMD* pCmd)
     724{
     725    vboxHGSMIBufferSubmit (ppdev, pCmd);
     726}
     727
     728static int vboxVHWAHanldeVHWACmdCompletion(PPDEV ppdev, void *pvBuffer, HGSMISIZE cbBuffer)
     729{
     730    Assert(0);
     731
     732    ppdev->pfnHGSMICommandComplete(ppdev->hMpHGSMI, pvBuffer);
     733    return 0;
    716734}
    717735
    718736# endif
    719737
     738DECLCALLBACK(int) vboxVHWACommandHanlder(void *pvHandler, uint16_t u16ChannelInfo, void *pvBuffer, HGSMISIZE cbBuffer)
     739{
     740    int rc = VINF_SUCCESS;
     741    PPDEV ppdev = (PPDEV)pvHandler;
     742
     743    switch(u16ChannelInfo)
     744    {
     745# ifdef VBOX_WITH_VIDEOHWACCEL
     746        case VBVAHG_VHWA_CMDCOMPLETE:
     747        {
     748            vboxVHWAHanldeVHWACmdCompletion(ppdev, pvBuffer, cbBuffer);
     749            break;
     750        }
     751# endif
     752        default:
     753        {
     754            ppdev->pfnHGSMICommandComplete(ppdev->hMpHGSMI, pvBuffer);
     755        }
     756
     757    }
     758    return rc;
     759}
     760
    720761#endif /* VBOX_WITH_HGSMI */

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp

    r19711 r19844  
    18751875            break;
    18761876        }
     1877        case IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS:
     1878        {
     1879            dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS\n"));
     1880
     1881            if (RequestPacket->OutputBufferLength < sizeof(HGSMIQUERYCALLBACKS))
     1882            {
     1883                dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small: %d needed: %d!!!\n",
     1884                         RequestPacket->OutputBufferLength, sizeof(HGSMIQUERYCALLBACKS)));
     1885                RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
     1886                return FALSE;
     1887            }
     1888
     1889            if (!pDevExt->pPrimary->u.primary.bHGSMI)
     1890            {
     1891                RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
     1892                return FALSE;
     1893            }
     1894
     1895            HGSMIQUERYCALLBACKS *pInfo = (HGSMIQUERYCALLBACKS *)RequestPacket->OutputBuffer;
     1896
     1897            pInfo->hContext = pDevExt->pPrimary;
     1898            pInfo->pfnCompletionHandler = hgsmiHostCmdHandlerComplete;
     1899
     1900            RequestPacket->StatusBlock->Information = sizeof(HGSMIQUERYCALLBACKS);
     1901            Result = TRUE;
     1902            break;
     1903        }
     1904        case IOCTL_VIDEO_HGSMI_HANDLER_REGISTER:
     1905        {
     1906            dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_HGSMI_HANDLER_REGISTER\n"));
     1907
     1908            if (RequestPacket->InputBufferLength< sizeof(HGSMIHANDLERREGISTER))
     1909            {
     1910                dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small: %d needed: %d!!!\n",
     1911                         RequestPacket->InputBufferLength, sizeof(HGSMIHANDLERREGISTER)));
     1912                RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
     1913                return FALSE;
     1914            }
     1915
     1916            if (!pDevExt->pPrimary->u.primary.bHGSMI)
     1917            {
     1918                RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
     1919                return FALSE;
     1920            }
     1921
     1922            HGSMIHANDLERREGISTER *pInfo = (HGSMIHANDLERREGISTER *)RequestPacket->InputBuffer;
     1923
     1924            int rc = vboxHGSMIChannelDisplayRegister (pDevExt->pPrimary,
     1925                    pDevExt->iDevice, /* negative would mean this is a miniport handler */
     1926                    pInfo->u8Channel,
     1927                    pInfo->pfnHandler,
     1928                    pInfo->pvHandler);
     1929            if(RT_FAILURE(rc))
     1930            {
     1931                RequestPacket->StatusBlock->Status = ERROR_INVALID_NAME;
     1932            }
     1933            Result = TRUE;
     1934            break;
     1935        }
     1936        case IOCTL_VIDEO_HGSMI_HANDLER_DEREGISTER:
     1937        {
     1938            /* TODO: implement */
     1939            if (!pDevExt->pPrimary->u.primary.bHGSMI)
     1940            {
     1941                RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
     1942                return FALSE;
     1943            }
     1944            break;
     1945        }
    18771946#endif /* VBOX_WITH_HGSMI */
    18781947

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h

    r19711 r19844  
    2929#include <VBox/HGSMI/HGSMI.h>
    3030#include <VBox/HGSMI/HGSMIChSetup.h>
     31#include "VBoxHGSMI.h"
    3132#endif /* VBOX_WITH_HGSMI */
    3233
    … …  
    256257                                PVIDEO_POINTER_ATTRIBUTES pointerAttr,
    257258                                uint32_t cbLength);
     259
     260DECLCALLBACK(void) hgsmiHostCmdHandlerComplete (HVBOXVIDEOHGSMI hHGSMI, void * pvMem);
     261
     262int vboxHGSMIChannelDisplayRegister (PDEVICE_EXTENSION PrimaryExtension,
     263        int iDisplay, /* negative would mean this is a miniport handler */
     264        uint8_t u8Channel,
     265        PFNHGSMICHANNELHANDLER pfnChannelHandler,
     266        void *pvChannelHandler);
    258267#endif /* VBOX_WITH_HGSMI */
    259268} /* extern "C" */

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/vboxioctl.h

    r17704 r19844  
    2727#ifdef VBOX_WITH_HGSMI
    2828#include <VBox/HGSMI/HGSMI.h>
     29#include "VBoxHGSMI.h"
    2930#endif /* VBOX_WITH_HGSMI */
    3031
    … …  
    4849#define IOCTL_VIDEO_QUERY_HGSMI_INFO \
    4950    CTL_CODE(FILE_DEVICE_VIDEO, 0x430, METHOD_BUFFERED, FILE_ANY_ACCESS)
     51
     52#define IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS \
     53    CTL_CODE(FILE_DEVICE_VIDEO, 0x431, METHOD_BUFFERED, FILE_ANY_ACCESS)
     54
     55#define IOCTL_VIDEO_HGSMI_HANDLER_REGISTER \
     56    CTL_CODE(FILE_DEVICE_VIDEO, 0x432, METHOD_BUFFERED, FILE_ANY_ACCESS)
     57
     58#define IOCTL_VIDEO_HGSMI_HANDLER_DEREGISTER \
     59    CTL_CODE(FILE_DEVICE_VIDEO, 0x433, METHOD_BUFFERED, FILE_ANY_ACCESS)
     60
    5061#endif /* VBOX_WITH_HGSMI */
    5162
    … …  
    109120    uint32_t u32MinVBVABufferSize;
    110121} QUERYHGSMIRESULT;
     122
     123/**
     124 * Data returned by IOCTL_VIDEO_HGSMI_QUERY_CALLBACKS.
     125 *
     126 */
     127typedef struct _HGSMIQUERYCALLBACKS
     128{
     129    HVBOXVIDEOHGSMI hContext;
     130    PFNVBOXVIDEOHGSMICOMPLETION pfnCompletionHandler;
     131} HGSMIQUERYCALLBACKS;
     132
     133/**
     134 * Data returned by IOCTL_VIDEO_HGSMI_HANDLER_REGISTER.
     135 *
     136 */
     137typedef struct _HGSMIHANDLERREGISTER
     138{
     139    PFNHGSMICHANNELHANDLER pfnHandler;
     140    void * pvHandler;
     141    uint8_t u8Channel;
     142} HGSMIHANDLERREGISTER;
     143
     144/**
     145 * Data passed by IOCTL_VIDEO_HGSMI_HANDLER_DEREGISTER.
     146 *
     147 */
     148typedef struct _HGSMIHANDLERDEREGISTER
     149{
     150    PFNHGSMICHANNELHANDLER pfnHandler;
     151    uint8_t u8Channel;
     152} HGSMIHANDLERDEREGISTER;
     153
    111154#endif /* VBOX_WITH_HGSMI */
    112155#pragma pack()

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

    r19711 r19844  
    45544554        case PDMINTERFACE_DISPLAY_PORT:
    45554555            return &pThis->Port;
     4556#if defined(VBOX_WITH_HGSMI) && defined(VBOX_WITH_VIDEOHWACCEL)
     4557        case PDMINTERFACE_DISPLAY_VBVA_CALLBACKS:
     4558            return &pThis->VBVACallbacks;
     4559#endif
    45564560        default:
    45574561            return NULL;
    … …  
    55735577    pThis->Port.pfnSetRenderVRAM        = vgaPortSetRenderVRAM;
    55745578
     5579#if defined(VBOX_WITH_HGSMI) && defined(VBOX_WITH_VIDEOHWACCEL)
     5580    pThis->VBVACallbacks.pfnVHWACommandCompleteAsynch = vbvaVHWACommandCompleteAsynch;
     5581#endif
    55755582
    55765583    /*

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

    r18720 r19844  
    309309    /** The display port interface. */
    310310    PDMIDISPLAYPORT             Port;
     311#if defined(VBOX_WITH_HGSMI) && defined(VBOX_WITH_VIDEOHWACCEL)
     312    /** VBVA callbacks interface */
     313    PDMDDISPLAYVBVACALLBACKS    VBVACallbacks;
     314#endif
    311315    /** Pointer to base interface of the driver. */
    312316    R3PTRTYPE(PPDMIBASE)        pDrvBase;
    … …  
    443447void     VBVADestroy    (PVGASTATE pVGAState);
    444448int      VBVAUpdateDisplay (PVGASTATE pVGAState);
     449
     450# ifdef VBOX_WITH_VIDEOHWACCEL
     451int vbvaVHWACommandCompleteAsynch(PPDMDDISPLAYVBVACALLBACKS pInterface, PVBOXVHWACMD pCmd);
     452# endif
    445453#endif /* VBOX_WITH_HGSMI */
    446454

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

    r19839 r19844  
    574574endif
    575575ifdef VBOX_WITH_VIDEOHWACCEL
    576  VBoxDDGC_DEFS         += VBOX_WITH_VIDEOHWACCEL
     576 VBoxDDR0_DEFS         += VBOX_WITH_VIDEOHWACCEL
    577577endif
    578578

  • trunk/src/VBox/Frontends/VBoxBFE/Framebuffer.h

    r19817 r19844  
    5050    virtual HRESULT SetVisibleRegion(BYTE *aRectangles, ULONG aCount) = 0;
    5151
     52    virtual HRESULT ProcessVHWACommand(BYTE *pCommand) = 0;
     53
    5254    virtual void    repaint() = 0;
    5355    virtual void    resize() = 0;

  • trunk/src/VBox/Frontends/VBoxBFE/SDLFramebuffer.cpp

    r19817 r19844  
    336336}
    337337
     338HRESULT SDLFramebuffer::ProcessVHWACommand(BYTE *pCommand)
     339{
     340    return E_NOTIMPL;
     341}
     342
    338343//
    339344// Internal public methods

  • trunk/src/VBox/Frontends/VBoxBFE/SDLFramebuffer.h

    r19817 r19844  
    5555    virtual HRESULT SetVisibleRegion(BYTE *aRectangles, ULONG aCount);
    5656
     57    virtual HRESULT ProcessVHWACommand(BYTE *pCommand);
     58
    5759    virtual void    repaint();
    5860    virtual void    resize();

  • trunk/src/VBox/Frontends/VBoxHeadless/VideoCapture/FFmpegFB.cpp

    r19817 r19844  
    634634}
    635635
    636 
     636STDMETHODIMP FFmpegFB::ProcessVHWACommand(BYTE *pCommand)
     637{
     638    return E_NOTIMPL;
     639}
    637640// Private Methods
    638641//////////////////////////////////////////////////////////////////////////

  • trunk/src/VBox/Frontends/VBoxHeadless/VideoCapture/FFmpegFB.h

    r19817 r19844  
    107107    STDMETHOD(GetVisibleRegion)(BYTE *rectangles, ULONG count, ULONG *countCopied);
    108108    STDMETHOD(SetVisibleRegion)(BYTE *rectangles, ULONG count);
     109
     110    STDMETHOD(ProcessVHWACommand)(BYTE *pCommand);
    109111
    110112private:

  • trunk/src/VBox/Frontends/VBoxSDL/Framebuffer.cpp

    r19817 r19844  
    578578}
    579579
     580STDMETHODIMP VBoxSDLFB::ProcessVHWACommand(BYTE *pCommand)
     581{
     582    return E_NOTIMPL;
     583}
    580584//
    581585// Internal public methods

  • trunk/src/VBox/Frontends/VBoxSDL/Framebuffer.h

    r19817 r19844  
    109109    STDMETHOD(GetVisibleRegion)(BYTE *aRectangles, ULONG aCount, ULONG *aCountCopied);
    110110    STDMETHOD(SetVisibleRegion)(BYTE *aRectangles, ULONG aCount);
     111
     112    STDMETHOD(ProcessVHWACommand)(BYTE *pCommand);
    111113
    112114    // internal public methods

  • trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

    r19837 r19844  
    434434endif
    435435
     436ifdef VBOX_WITH_VIDEOHWACCEL
     437 VirtualBox_DEFS += VBOX_WITH_VIDEOHWACCEL
     438endif
     439
    436440# The Qt modules we're using.
    437441# (The include directory and lib/framework for each module will be added by the Qt4 unit.)

  • trunk/src/VBox/Frontends/VirtualBox/include/VBoxConsoleView.h

    r18654 r19844  
    218218    bool isRunning() { return mLastState == KMachineState_Running; }
    219219
     220#ifdef VBOX_WITH_VIDEOHWACCEL
     221    void handleVHWACommand(struct _VBOXVHWACMD *pCommand);
     222#endif
     223
    220224    static void dimImage (QImage &img);
    221225

  • trunk/src/VBox/Frontends/VirtualBox/include/VBoxDefs.h

    r19670 r19844  
    126126        AddVDMUrlsEventType,
    127127        ChangeDockIconUpdateEventType
     128#ifdef VBOX_WITH_VIDEOHWACCEL
     129        ,
     130        VHWACommandProcessType
     131#endif
    128132    };
    129133

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

    r19817 r19844  
    114114};
    115115
     116#ifdef VBOX_WITH_VIDEOHWACCEL
     117class VBoxVHWACommandProcessEvent : public QEvent
     118{
     119public:
     120    VBoxVHWACommandProcessEvent (struct _VBOXVHWACMD * pCmd)
     121        : QEvent ((QEvent::Type) VBoxDefs::VHWACommandProcessType)
     122        , mpCmd (pCmd) {}
     123    struct _VBOXVHWACMD * command() { return mpCmd; }
     124private:
     125    struct _VBOXVHWACMD * mpCmd;
     126};
     127
     128#endif
     129
    116130/////////////////////////////////////////////////////////////////////////////
    117131
    … …  
    205219    STDMETHOD(GetVisibleRegion)(BYTE *aRectangles, ULONG aCount, ULONG *aCountCopied);
    206220    STDMETHOD(SetVisibleRegion)(BYTE *aRectangles, ULONG aCount);
     221
     222    STDMETHOD(ProcessVHWACommand)(BYTE *pCommand);
    207223
    208224    ulong width() { return mWdt; }

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxConsoleView.cpp

    r19817 r19844  
    9292# include <VBox/err.h>
    9393#endif /* defined (Q_WS_MAC) */
     94
     95#ifdef VBOX_WITH_VIDEOHWACCEL
     96#include <VBox/VBoxVideo.h>
     97#endif
    9498
    9599#if defined (Q_WS_WIN32)
    … …  
    16891693            }
    16901694#endif
     1695#ifdef VBOX_WITH_VIDEOHWACCEL
     1696            case VBoxDefs::VHWACommandProcessType:
     1697            {
     1698                VBoxVHWACommandProcessEvent *cmde = (VBoxVHWACommandProcessEvent *)e;
     1699                handleVHWACommand(cmde->command());
     1700                return true;
     1701            }
     1702#endif
    16911703            default:
    16921704                break;
    … …  
    16961708    return QAbstractScrollArea::event (e);
    16971709}
     1710
     1711#ifdef VBOX_WITH_VIDEOHWACCEL
     1712void VBoxConsoleView::handleVHWACommand(struct _VBOXVHWACMD *pCmd)
     1713{
     1714    switch(pCmd->enmCmd)
     1715    {
     1716        case VBOXVHWACMD_TYPE_SURF_CREATE:
     1717        {
     1718            VBOXVHWACMD_SURF_CREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE);
     1719            pCmd->rc = VERR_NOT_IMPLEMENTED;
     1720            break;
     1721        } break;
     1722        case VBOXVHWACMD_TYPE_SURF_DESTROY:
     1723        {
     1724            VBOXVHWACMD_SURF_DESTROY * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY);
     1725            pCmd->rc = VERR_NOT_IMPLEMENTED;
     1726            break;
     1727        } break;
     1728    }
     1729
     1730    CDisplay display = mConsole.GetDisplay();
     1731    Assert (!display.isNull());
     1732
     1733    display.CompleteVHWACommand((BYTE*)pCmd);
     1734}
     1735#endif
    16981736
    16991737bool VBoxConsoleView::eventFilter (QObject *watched, QEvent *e)

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxFrameBuffer.cpp

    r19817 r19844  
    260260}
    261261
     262STDMETHODIMP VBoxFrameBuffer::ProcessVHWACommand(BYTE *pCommand)
     263{
     264#ifdef VBOX_WITH_VIDEOHWACCEL
     265    QApplication::postEvent (mView,
     266                             new VBoxVHWACommandProcessEvent ((struct _VBOXVHWACMD*)pCommand));
     267    return S_OK;
     268#else
     269    return E_NOTIMPL;
     270#endif
     271}
     272
    262273//
    263274// VBoxQImageFrameBuffer class

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

    r19817 r19844  
    3838#endif
    3939
     40#ifdef VBOX_WITH_VIDEOHWACCEL
     41# include <VBox/VBoxVideo.h>
     42#endif
    4043/**
    4144 * Display driver instance data.
    … …  
    5154    /** Our display connector interface. */
    5255    PDMIDISPLAYCONNECTOR        Connector;
     56#if defined(VBOX_WITH_VIDEOHWACCEL)
     57    /** VBVA callbacks */
     58    PPDMDDISPLAYVBVACALLBACKS   pVBVACallbacks;
     59#endif
    5360} DRVMAINDISPLAY, *PDRVMAINDISPLAY;
    5461
    … …  
    16831690
    16841691    return S_OK;
     1692}
     1693
     1694STDMETHODIMP Display::CompleteVHWACommand(BYTE *pCommand)
     1695{
     1696#ifdef VBOX_WITH_VIDEOHWACCEL
     1697    mpDrv->pVBVACallbacks->pfnVHWACommandCompleteAsynch(mpDrv->pVBVACallbacks, (PVBOXVHWACMD)pCommand);
     1698    return S_OK;
     1699#else
     1700    return E_NOTIMPL;
     1701#endif
    16851702}
    16861703
    … …  
    22252242}
    22262243
     2244#ifdef VBOX_WITH_VIDEOHWACCEL
     2245
     2246void Display::handleVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
     2247{
     2248    unsigned id = (unsigned)pCommand->iDisplay;
     2249    int rc = VINF_SUCCESS;
     2250    if(id < mcMonitors)
     2251    {
     2252        IFramebuffer *pFramebuffer = maFramebuffers[id].pFramebuffer;
     2253
     2254        // if there is no framebuffer, this call is not interesting
     2255        if (pFramebuffer == NULL)
     2256            return;
     2257
     2258        pFramebuffer->Lock();
     2259
     2260        HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE*)pCommand);
     2261        if(FAILED(hr))
     2262        {
     2263            rc = VERR_GENERAL_FAILURE;
     2264        }
     2265
     2266        pFramebuffer->Unlock();
     2267
     2268    }
     2269    else
     2270    {
     2271        rc = VERR_INVALID_PARAMETER;
     2272    }
     2273
     2274    if(RT_FAILURE(rc))
     2275    {
     2276        /* tell the guest the command is complete */
     2277        pCommand->rc = rc;
     2278    }
     2279}
     2280
     2281DECLCALLBACK(void) Display::displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
     2282{
     2283    PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
     2284
     2285    pDrv->pDisplay->handleVHWACommandProcess(pInterface, pCommand);
     2286}
     2287#endif
     2288
    22272289/**
    22282290 * Queries an interface to the driver.
    … …  
    23132375    pData->Connector.pfnProcessAdapterData = Display::displayProcessAdapterDataCallback;
    23142376    pData->Connector.pfnProcessDisplayData = Display::displayProcessDisplayDataCallback;
     2377#ifdef VBOX_WITH_VIDEOHWACCEL
     2378    pData->Connector.pfnVHWACommandProcess = Display::displayVHWACommandProcess;
     2379#endif
    23152380
    23162381    /*
    … …  
    23232388        return VERR_PDM_MISSING_INTERFACE_ABOVE;
    23242389    }
    2325 
     2390#if defined(VBOX_WITH_VIDEOHWACCEL)
     2391    pData->pVBVACallbacks = (PPDMDDISPLAYVBVACALLBACKS)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_DISPLAY_VBVA_CALLBACKS);
     2392    if (!pData->pVBVACallbacks)
     2393    {
     2394        AssertMsgFailed(("Configuration error: No VBVA callback interface above!\n"));
     2395        return VERR_PDM_MISSING_INTERFACE_ABOVE;
     2396    }
     2397#endif
    23262398    /*
    23272399     * Get the Display object pointer and update the mpDrv member.

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

    r19817 r19844  
    592592endif
    593593
     594ifdef VBOX_WITH_VIDEOHWACCEL
     595VBoxC_DEFS += VBOX_WITH_VIDEOHWACCEL
     596endif
     597
    594598ifdef VBOX_WITH_USB
    595599VBoxC_SOURCES += \

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

    r19823 r19844  
    1027610276  <interface
    1027710277     name="IFramebuffer" extends="$unknown"
    10278      uuid="faaf4c24-d534-4171-8781-c15d2b9fe8c3"
     10278     uuid="b7ed347a-5765-40a0-ae1c-f543eb4ddeaf"
    1027910279     wsmap="suppress"
    1028010280     >
    … …  
    1058110581      <param name="count" type="unsigned long" dir="in">
    1058210582        <desc>Number of <tt>RTRECT</tt> elements in the @a rectangles array.</desc>
     10583      </param>
     10584    </method>
     10585   
     10586    <method name="processVHWACommand">
     10587      <desc>
     10588        Posts a Video HW Acceleration Command to the frame buffer for processing.
     10589        The commands used for 2D video acceleration (DDraw surface creation/destroying, blitting, scaling, color covnersion, overlaying, etc.)
     10590        are posted from quest to the host to be processed by the host hardware.
     10591       
     10592        <note>
     10593          The address of the provided command must be in the process space of
     10594          this IFramebuffer object.
     10595        </note>
     10596      </desc>
     10597   
     10598      <param name="command" type="octet" mod="ptr" dir="in">
     10599        <desc>Pointer to VBOXVHWACMD containing the command to execute.</desc>
    1058310600      </param>
    1058410601    </method>
    … …  
    1063410651  <interface
    1063510652     name="IDisplay" extends="$unknown"
    10636      uuid="f1efd4d1-45d4-4f21-a074-29c5a98de8e7"
     10653     uuid="26881797-bc98-444d-ac69-820633b93ec7"
    1063710654     wsmap="suppress"
    1063810655     >
    … …  
    1079410811
    1079510812      </desc>
     10813    </method>
     10814
     10815    <method name="completeVHWACommand">
     10816      <desc>
     10817        Signals that the Video HW Acceleration command has completed.
     10818      </desc>
     10819 
     10820      <param name="command" type="octet" mod="ptr" dir="in">
     10821        <desc>Pointer to VBOXVHWACMD containing the completed command.</desc>
     10822      </param>
    1079610823    </method>
    1079710824

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

    r19817 r19844  
    118118    int handleDisplayResize (unsigned uScreenId, uint32_t bpp, void *pvVRAM, uint32_t cbLine, int w, int h);
    119119    void handleDisplayUpdate (int x, int y, int cx, int cy);
     120#ifdef VBOX_WITH_VIDEOHWACCEL
     121    void handleVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand);
     122#endif
    120123    IFramebuffer *getFramebuffer()
    121124    {
    … …  
    241244    STDMETHOD(UpdateCompleted)();
    242245    STDMETHOD(SetSeamlessMode)(BOOL enabled);
     246
     247    STDMETHOD(CompleteVHWACommand)(BYTE *pCommand);
    243248
    244249    // for VirtualBoxSupportErrorInfoImpl
    … …  
    266271    static DECLCALLBACK(void)  displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, unsigned uScreenId);
    267272
     273#ifdef VBOX_WITH_VIDEOHWACCEL
     274    static DECLCALLBACK(void) displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand);
     275#endif
     276
    268277    const ComObjPtr <Console, ComWeakRef> mParent;
    269278    /** Pointer to the associated display driver. */
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