VirtualBox

Ignore:
Timestamp:
Nov 25, 2010 1:53:58 AM (14 years ago)
Author:
vboxsync
Message:

Additions/WINNT/Graphics: more refactoring

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Miniport
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r34130 r34349  
    261261                                              uint32_t cbLength)
    262262{
    263     return vboxUpdatePointerShape(pCommon,
     263    return vboxUpdatePointerShape(&pCommon->guestCtx,
    264264                                  pointerAttr->Enable & 0x0000FFFF,
    265265                                  (pointerAttr->Enable >> 16) & 0xFF,

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

    r34346 r34349  
    31943194        if (RT_SUCCESS(rc))
    31953195        {
    3196             rc = VBoxHGSMISendViewInfo (commonFromDeviceExt(PrimaryExtension),
     3196            rc = VBoxHGSMISendViewInfo(&commonFromDeviceExt(PrimaryExtension)->guestCtx,
    31973197                                   commonFromDeviceExt(PrimaryExtension)->cDisplays,
    31983198                                   vbvaInitInfoDisplay,

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

    r34346 r34349  
    7272                                         */
    7373
    74     /** Host HGSMI capabilities the guest can handle */
    75     uint32_t fCaps;
    7674    /** Whether HGSMI is enabled. */
    7775    bool bHGSMI;
    … …  
    136134typedef FNHGSMIFILLVIEWINFO *PFNHGSMIFILLVIEWINFO;
    137135
    138 int VBoxHGSMISendViewInfo(PVBOXVIDEO_COMMON pCommon, uint32_t u32Count, PFNHGSMIFILLVIEWINFO pfnFill, void *pvData);
     136int VBoxHGSMISendViewInfo(PHGSMIGUESTCOMMANDCONTEXT pCtx, uint32_t u32Count, PFNHGSMIFILLVIEWINFO pfnFill, void *pvData);
    139137
    140138void VBoxSetupDisplaysHGSMI (PVBOXVIDEO_COMMON pCommon,
    141139                             uint32_t AdapterMemorySize, uint32_t fCaps);
    142140
    143 bool vboxUpdatePointerShape (PVBOXVIDEO_COMMON pCommon,
     141bool vboxUpdatePointerShape (PHGSMIGUESTCOMMANDCONTEXT pCtx,
    144142                             uint32_t fFlags,
    145143                             uint32_t cHotX,

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

    r34346 r34349  
    111111}
    112112
    113 typedef int FNHGSMICALLINIT (PVBOXVIDEO_COMMON pCommon, void *pvContext, void *pvData);
    114 typedef FNHGSMICALLINIT *PFNHGSMICALLINIT;
    115 
    116 typedef int FNHGSMICALLFINALIZE (PVBOXVIDEO_COMMON pCommon, void *pvContext, void *pvData);
    117 typedef FNHGSMICALLFINALIZE *PFNHGSMICALLFINALIZE;
    118113
    119114void* vboxHGSMIBufferAlloc(PHGSMIGUESTCOMMANDCONTEXT pCtx,
    … …  
    152147}
    153148
    154 static int vboxCallChannel (PVBOXVIDEO_COMMON pCommon,
    155                          uint8_t u8Ch,
    156                          uint16_t u16Op,
    157                          HGSMISIZE cbData,
    158                          PFNHGSMICALLINIT pfnInit,
    159                          PFNHGSMICALLFINALIZE pfnFinalize,
    160                          void *pvContext)
     149
     150static int vboxQueryConfHGSMI(PHGSMIGUESTCOMMANDCONTEXT pCtx, uint32_t u32Index,
     151                              uint32_t *pulValue)
    161152{
    162153    int rc = VINF_SUCCESS;
     154    VBVACONF32 *p;
     155    LogFunc(("u32Index = %d\n", u32Index));
    163156
    164157    /* Allocate the IO buffer. */
    165     void *p = HGSMIHeapAlloc (&pCommon->guestCtx.heapCtx, cbData, u8Ch, u16Op);
    166 
    167     if (!p)
    168     {
     158    p = (VBVACONF32 *)HGSMIHeapAlloc(&pCtx->heapCtx,
     159                                     sizeof(VBVACONF32), HGSMI_CH_VBVA,
     160                                     VBVA_QUERY_CONF32);
     161    if (p)
     162    {
     163        /* Prepare data to be sent to the host. */
     164        p->u32Index = u32Index;
     165        p->u32Value = 0;
     166        rc = vboxHGSMIBufferSubmit(pCtx, p);
     167        if (RT_SUCCESS(rc))
     168        {
     169            *pulValue = p->u32Value;
     170            LogFunc(("u32Value = %d\n", p->u32Value));
     171        }
     172        /* Free the IO buffer. */
     173        HGSMIHeapFree(&pCtx->heapCtx, p);
     174    }
     175    else
    169176        rc = VERR_NO_MEMORY;
     177    LogFunc(("rc = %d\n", rc));
     178    return rc;
     179}
     180
     181
     182static int vboxHGSMIBufferLocation(PHGSMIGUESTCOMMANDCONTEXT pCtx,
     183                                   HGSMIOFFSET offLocation)
     184{
     185    HGSMIBUFFERLOCATION *p;
     186    int rc = VINF_SUCCESS;
     187
     188    /* Allocate the IO buffer. */
     189    p = (HGSMIBUFFERLOCATION *)HGSMIHeapAlloc(&pCtx->heapCtx,
     190                                              sizeof(HGSMIBUFFERLOCATION),
     191                                              HGSMI_CH_HGSMI,
     192                                              HGSMI_CC_HOST_FLAGS_LOCATION);
     193    if (p)
     194    {
     195        /* Prepare data to be sent to the host. */
     196        p->offLocation = offLocation;
     197        p->cbLocation  = sizeof(HGSMIHOSTFLAGS);
     198        rc = vboxHGSMIBufferSubmit(pCtx, p);
     199        /* Free the IO buffer. */
     200        HGSMIHeapFree (&pCtx->heapCtx, p);
    170201    }
    171202    else
     203        rc = VERR_NO_MEMORY;
     204    return rc;
     205}
     206
     207
     208static int vboxHGSMISendCapsInfo(PHGSMIGUESTCOMMANDCONTEXT pCtx,
     209                                 uint32_t fCaps)
     210{
     211    VBVACAPS *pCaps;
     212    int rc = VINF_SUCCESS;
     213
     214    /* Allocate the IO buffer. */
     215    pCaps = (VBVACAPS *)HGSMIHeapAlloc(&pCtx->heapCtx,
     216                                       sizeof(VBVACAPS), HGSMI_CH_VBVA,
     217                                       VBVA_INFO_CAPS);
     218
     219    if (pCaps)
    172220    {
    173221        /* Prepare data to be sent to the host. */
    174         if (pfnInit)
    175         {
    176             rc = pfnInit (pCommon, pvContext, p);
    177         }
    178 
    179         if (RT_SUCCESS (rc))
    180         {
    181             rc = vboxHGSMIBufferSubmit(&pCommon->guestCtx, p);
    182 
    183             if (RT_SUCCESS(rc) && pfnFinalize)
    184             {
    185                 rc = pfnFinalize (pCommon, pvContext, p);
    186             }
    187         }
    188         else
    189         {
    190             AssertFailed ();
    191             rc = VERR_INTERNAL_ERROR;
    192         }
    193 
     222        pCaps->rc    = VERR_NOT_IMPLEMENTED;
     223        pCaps->fCaps = fCaps;
     224        rc = vboxHGSMIBufferSubmit(pCtx, pCaps);
     225        if (RT_SUCCESS(rc))
     226        {
     227            AssertRC(pCaps->rc);
     228            rc = pCaps->rc;
     229        }
    194230        /* Free the IO buffer. */
    195         HGSMIHeapFree (&pCommon->guestCtx.heapCtx, p);
    196     }
    197 
     231        HGSMIHeapFree(&pCtx->heapCtx, pCaps);
     232    }
     233    else
     234        rc = VERR_NO_MEMORY;
    198235    return rc;
    199236}
    200237
    201 static int vboxCallVBVA (PVBOXVIDEO_COMMON pCommon,
    202                          uint16_t u16Op,
    203                          HGSMISIZE cbData,
    204                          PFNHGSMICALLINIT pfnInit,
    205                          PFNHGSMICALLFINALIZE pfnFinalize,
    206                          void *pvContext)
    207 {
    208     return vboxCallChannel (pCommon,
    209                             HGSMI_CH_VBVA,
    210                             u16Op,
    211                             cbData,
    212                             pfnInit,
    213                             pfnFinalize,
    214                             pvContext);
    215 }
    216 
    217 typedef struct _QUERYCONFCTX
    218 {
    219     uint32_t  u32Index;
    220     uint32_t *pulValue;
    221 } QUERYCONFCTX;
    222 
    223 static int vbvaInitQueryConf (PVBOXVIDEO_COMMON, void *pvContext, void *pvData)
    224 {
    225     QUERYCONFCTX *pCtx = (QUERYCONFCTX *)pvContext;
    226     VBVACONF32 *p = (VBVACONF32 *)pvData;
    227 
    228     p->u32Index = pCtx->u32Index;
    229     p->u32Value = 0;
    230 
    231     return VINF_SUCCESS;
    232 }
    233 
    234 static int vbvaFinalizeQueryConf (PVBOXVIDEO_COMMON, void *pvContext, void *pvData)
    235 {
    236     QUERYCONFCTX *pCtx = (QUERYCONFCTX *)pvContext;
    237     VBVACONF32 *p = (VBVACONF32 *)pvData;
    238 
    239     if (pCtx->pulValue)
    240     {
    241         *pCtx->pulValue = p->u32Value;
    242     }
    243 
    244     Log(("VBoxVideo::vboxQueryConf: u32Value = %d\n", p->u32Value));
    245     return VINF_SUCCESS;
    246 }
    247 
    248 static int vboxQueryConfHGSMI (PVBOXVIDEO_COMMON pCommon, uint32_t u32Index, uint32_t *pulValue)
    249 {
    250     Log(("VBoxVideo::vboxQueryConf: u32Index = %d\n", u32Index));
    251 
    252     QUERYCONFCTX context;
    253 
    254     context.u32Index = u32Index;
    255     context.pulValue = pulValue;
    256 
    257     int rc = vboxCallVBVA (pCommon,
    258                            VBVA_QUERY_CONF32,
    259                            sizeof (VBVACONF32),
    260                            vbvaInitQueryConf,
    261                            vbvaFinalizeQueryConf,
    262                            &context);
    263 
    264     Log(("VBoxVideo::vboxQueryConf: rc = %d\n", rc));
    265 
     238
     239static int vboxVBVAInitInfoHeap(PHGSMIGUESTCOMMANDCONTEXT pCtx,
     240                                uint32_t u32HeapOffset, uint32_t u32HeapSize)
     241{
     242    VBVAINFOHEAP *p;
     243    int rc = VINF_SUCCESS;
     244
     245    /* Allocate the IO buffer. */
     246    p = (VBVAINFOHEAP *)HGSMIHeapAlloc(&pCtx->heapCtx,
     247                                       sizeof (VBVAINFOHEAP), HGSMI_CH_VBVA,
     248                                       VBVA_INFO_HEAP);
     249    if (p)
     250    {
     251        /* Prepare data to be sent to the host. */
     252        p->u32HeapOffset = u32HeapOffset;
     253        p->u32HeapSize   = u32HeapSize;
     254        rc = vboxHGSMIBufferSubmit(pCtx, p);
     255        /* Free the IO buffer. */
     256        HGSMIHeapFree(&pCtx->heapCtx, p);
     257    }
     258    else
     259        rc = VERR_NO_MEMORY;
    266260    return rc;
    267261}
    268262
    269 int VBoxHGSMISendViewInfo(PVBOXVIDEO_COMMON pCommon, uint32_t u32Count, PFNHGSMIFILLVIEWINFO pfnFill, void *pvData)
     263
     264int VBoxHGSMISendViewInfo(PHGSMIGUESTCOMMANDCONTEXT pCtx, uint32_t u32Count,
     265                          PFNHGSMIFILLVIEWINFO pfnFill, void *pvData)
    270266{
    271267    int rc;
    272268    /* Issue the screen info command. */
    273     void *p = vboxHGSMIBufferAlloc(&pCommon->guestCtx, sizeof(VBVAINFOVIEW) * u32Count,
    274                                     HGSMI_CH_VBVA, VBVA_INFO_VIEW);
    275     Assert(p);
     269    void *p = vboxHGSMIBufferAlloc(pCtx, sizeof(VBVAINFOVIEW) * u32Count,
     270                                   HGSMI_CH_VBVA, VBVA_INFO_VIEW);
    276271    if (p)
    277272    {
    … …  
    279274        rc = pfnFill(pvData, pInfo);
    280275        if (RT_SUCCESS(rc))
    281             vboxHGSMIBufferSubmit (&pCommon->guestCtx, p);
    282         vboxHGSMIBufferFree (&pCommon->guestCtx, p);
     276            vboxHGSMIBufferSubmit (pCtx, p);
     277        vboxHGSMIBufferFree(pCtx, p);
    283278    }
    284279    else
    … …  
    288283
    289284
    290 int vbvaInitInfoCaps (PVBOXVIDEO_COMMON pCommon, void *pvContext, void *pvData)
    291 {
    292     VBVACAPS *pCaps = (VBVACAPS*)pvData;
    293     pCaps->rc = VERR_NOT_IMPLEMENTED;
    294     pCaps->fCaps = pCommon->fCaps;
    295     return VINF_SUCCESS;
    296 }
    297 
    298 
    299 int vbvaFinalizeInfoCaps (PVBOXVIDEO_COMMON, void *pvContext, void *pvData)
    300 {
    301     VBVACAPS *pCaps = (VBVACAPS*)pvData;
    302     AssertRC(pCaps->rc);
    303     return pCaps->rc;
    304 }
    305 
    306 static int vbvaInitInfoHeap (PVBOXVIDEO_COMMON pCommon, void *pvContext, void *pvData)
    307 {
    308     NOREF (pvContext);
    309     VBVAINFOHEAP *p = (VBVAINFOHEAP *)pvData;
    310 
    311     p->u32HeapOffset = pCommon->cbVRAM
    312                        - pCommon->cbMiniportHeap
    313                        - VBVA_ADAPTER_INFORMATION_SIZE;
    314     p->u32HeapSize = pCommon->cbMiniportHeap;
    315 
    316     return VINF_SUCCESS;
    317 }
    318 
    319 static int hgsmiInitFlagsLocation (PVBOXVIDEO_COMMON pCommon, void *pvContext, void *pvData)
    320 {
    321     NOREF (pvContext);
    322     HGSMIBUFFERLOCATION *p = (HGSMIBUFFERLOCATION *)pvData;
    323 
    324     p->offLocation = pCommon->cbVRAM - sizeof (HGSMIHOSTFLAGS);
    325     p->cbLocation = sizeof (HGSMIHOSTFLAGS);
    326 
    327     return VINF_SUCCESS;
    328 }
    329 
    330 
    331 static int vboxSetupAdapterInfoHGSMI (PVBOXVIDEO_COMMON pCommon)
     285static int vboxSetupAdapterInfoHGSMI(PHGSMIGUESTCOMMANDCONTEXT pCtx,
     286                                     HGSMIOFFSET offBufferLocation,
     287                                     uint32_t fCaps, uint32_t u32HeapOffset,
     288                                     uint32_t u32HeapSize)
    332289{
    333290    Log(("VBoxVideo::vboxSetupAdapterInfo\n"));
    334291
    335292    /* setup the flags first to ensure they are initialized by the time the host heap is ready */
    336     int rc = vboxCallChannel(pCommon,
    337             HGSMI_CH_HGSMI,
    338             HGSMI_CC_HOST_FLAGS_LOCATION,
    339                        sizeof (HGSMIBUFFERLOCATION),
    340                        hgsmiInitFlagsLocation,
    341                        NULL,
    342                        NULL);
     293    int rc = vboxHGSMIBufferLocation(pCtx, offBufferLocation);
    343294    AssertRC(rc);
    344     if (RT_SUCCESS(rc) && pCommon->fCaps)
     295    if (RT_SUCCESS(rc) && fCaps)
    345296    {
    346297        /* Inform about caps */
    347         rc = vboxCallVBVA (pCommon,
    348                                VBVA_INFO_CAPS,
    349                                sizeof (VBVACAPS),
    350                                vbvaInitInfoCaps,
    351                                vbvaFinalizeInfoCaps,
    352                                NULL);
     298        rc = vboxHGSMISendCapsInfo(pCtx, fCaps);
    353299        AssertRC(rc);
    354300    }
    … …  
    356302    {
    357303        /* Report the host heap location. */
    358         rc = vboxCallVBVA (pCommon,
    359                            VBVA_INFO_HEAP,
    360                            sizeof (VBVAINFOHEAP),
    361                            vbvaInitInfoHeap,
    362                            NULL,
    363                            NULL);
     304        rc = vboxVBVAInitInfoHeap(pCtx, u32HeapOffset, u32HeapSize);
    364305        AssertRC(rc);
    365306    }
    366 
    367 
    368307    Log(("VBoxVideo::vboxSetupAdapterInfo finished rc = %d\n", rc));
    369 
    370308    return rc;
    371309}
    … …  
    393331    memset(pCommon, 0, sizeof(*pCommon));
    394332    pCommon->cbVRAM    = AdapterMemorySize;
    395     pCommon->fCaps     = fCaps;
    396333    pCommon->cDisplays = 1;
    397334    pCommon->bHGSMI    = VBoxHGSMIIsSupported ();
    … …  
    449386        /* The miniport heap is used for the host buffers. */
    450387        uint32_t cbMiniportHeap = 0;
    451         vboxQueryConfHGSMI (pCommon, VBOX_VBVA_CONF32_HOST_HEAP_SIZE, &cbMiniportHeap);
     388        vboxQueryConfHGSMI(&pCommon->guestCtx, VBOX_VBVA_CONF32_HOST_HEAP_SIZE,
     389                           &cbMiniportHeap);
    452390
    453391        if (cbMiniportHeap != 0)
    … …  
    516454        /* Query the configured number of displays. */
    517455        uint32_t cDisplays = 0;
    518         vboxQueryConfHGSMI (pCommon, VBOX_VBVA_CONF32_MONITOR_COUNT, &cDisplays);
     456        vboxQueryConfHGSMI(&pCommon->guestCtx, VBOX_VBVA_CONF32_MONITOR_COUNT,
     457                           &cDisplays);
    519458
    520459        Log(("VBoxVideo::VBoxSetupDisplays: cDisplays = %d\n",
    … …  
    532471    {
    533472        /* Setup the information for the host. */
    534         rc = vboxSetupAdapterInfoHGSMI (pCommon);
     473        rc = vboxSetupAdapterInfoHGSMI(&pCommon->guestCtx,
     474                                       pCommon->cbVRAM - sizeof(HGSMIHOSTFLAGS),
     475                                       fCaps,
     476                                         pCommon->cbVRAM
     477                                       - pCommon->cbMiniportHeap
     478                                       - VBVA_ADAPTER_INFORMATION_SIZE,
     479                                       pCommon->cbMiniportHeap);
    535480
    536481        if (RT_FAILURE(rc))
    … …  
    564509}
    565510
    566 /*
    567  * Send the pointer shape to the host.
    568  */
    569 typedef struct _MOUSEPOINTERSHAPECTX
    570 {
    571     uint32_t fFlags;
    572     uint32_t cHotX;
    573     uint32_t cHotY;
    574     uint32_t cWidth;
    575     uint32_t cHeight;
    576     uint32_t cbData;
    577     uint8_t *pPixels;
    578     int32_t  i32Result;
    579 } MOUSEPOINTERSHAPECTX;
    580 
    581 static int vbvaInitMousePointerShape (PVBOXVIDEO_COMMON, void *pvContext, void *pvData)
    582 {
    583     MOUSEPOINTERSHAPECTX *pCtx = (MOUSEPOINTERSHAPECTX *)pvContext;
    584     VBVAMOUSEPOINTERSHAPE *p = (VBVAMOUSEPOINTERSHAPE *)pvData;
    585 
    586     /* Will be updated by the host. */
    587     p->i32Result = VINF_SUCCESS;
    588 
    589     /* We have our custom flags in the field */
    590     p->fu32Flags = pCtx->fFlags;
    591 
    592     p->u32HotX   = pCtx->cHotX;
    593     p->u32HotY   = pCtx->cHotY;
    594     p->u32Width  = pCtx->cWidth;
    595     p->u32Height = pCtx->cHeight;
    596 
    597     if (p->fu32Flags & VBOX_MOUSE_POINTER_SHAPE)
    598     {
     511
     512bool vboxUpdatePointerShape(PHGSMIGUESTCOMMANDCONTEXT pCtx,
     513                            uint32_t fFlags,
     514                            uint32_t cHotX,
     515                            uint32_t cHotY,
     516                            uint32_t cWidth,
     517                            uint32_t cHeight,
     518                            uint8_t *pPixels,
     519                            uint32_t cbLength)
     520{
     521    VBVAMOUSEPOINTERSHAPE *p;
     522    uint32_t cbData = 0;
     523    int rc = VINF_SUCCESS;
     524
     525    if (fFlags & VBOX_MOUSE_POINTER_SHAPE)
     526    {
     527        /* Size of the pointer data: sizeof (AND mask) + sizeof (XOR_MASK) */
     528        cbData = ((((cWidth + 7) / 8) * cHeight + 3) & ~3)
     529                 + cWidth * 4 * cHeight;
    599530        /* If shape is supplied, then always create the pointer visible.
    600531         * See comments in 'vboxUpdatePointerShape'
    601532         */
    602         p->fu32Flags |= VBOX_MOUSE_POINTER_VISIBLE;
    603 
    604         /* Copy the actual pointer data. */
    605         memcpy (p->au8Data, pCtx->pPixels, pCtx->cbData);
    606     }
    607 
    608     return VINF_SUCCESS;
    609 }
    610 
    611 static int vbvaFinalizeMousePointerShape (PVBOXVIDEO_COMMON, void *pvContext, void *pvData)
    612 {
    613     MOUSEPOINTERSHAPECTX *pCtx = (MOUSEPOINTERSHAPECTX *)pvContext;
    614     VBVAMOUSEPOINTERSHAPE *p = (VBVAMOUSEPOINTERSHAPE *)pvData;
    615 
    616     pCtx->i32Result = p->i32Result;
    617 
    618     return VINF_SUCCESS;
    619 }
    620 
    621 bool vboxUpdatePointerShape (PVBOXVIDEO_COMMON pCommon,
    622                              uint32_t fFlags,
    623                              uint32_t cHotX,
    624                              uint32_t cHotY,
    625                              uint32_t cWidth,
    626                              uint32_t cHeight,
    627                              uint8_t *pPixels,
    628                              uint32_t cbLength)
    629 {
    630     uint32_t cbData = 0;
    631 
    632     if (fFlags & VBOX_MOUSE_POINTER_SHAPE)
    633     {
    634         /* Size of the pointer data: sizeof (AND mask) + sizeof (XOR_MASK) */
    635         cbData = ((((cWidth + 7) / 8) * cHeight + 3) & ~3)
    636                  + cWidth * 4 * cHeight;
    637     }
    638 
     533        fFlags |= VBOX_MOUSE_POINTER_VISIBLE;
     534    }
    639535#ifndef DEBUG_misha
    640     Log(("vboxUpdatePointerShape: cbData %d, %dx%d\n",
    641              cbData, cWidth, cHeight));
     536    LogFunc(("cbData %d, %dx%d\n", cbData, cWidth, cHeight));
    642537#endif
    643 
    644538    if (cbData > cbLength)
    645539    {
    646         Log(("vboxUpdatePointerShape: calculated pointer data size is too big (%d bytes, limit %d)\n",
     540        LogFunc(("calculated pointer data size is too big (%d bytes, limit %d)\n",
    647541                 cbData, cbLength));
    648542        return false;
    649543    }
    650 
    651     MOUSEPOINTERSHAPECTX ctx;
    652 
    653     ctx.fFlags    = fFlags;
    654     ctx.cHotX     = cHotX;
    655     ctx.cHotY     = cHotY;
    656     ctx.cWidth    = cWidth;
    657     ctx.cHeight   = cHeight;
    658     ctx.pPixels   = pPixels;
    659     ctx.cbData    = cbData;
    660     ctx.i32Result = VERR_NOT_SUPPORTED;
    661 
    662     int rc = vboxCallVBVA (pCommon, VBVA_MOUSE_POINTER_SHAPE,
    663                            sizeof (VBVAMOUSEPOINTERSHAPE) + cbData,
    664                            vbvaInitMousePointerShape,
    665                            vbvaFinalizeMousePointerShape,
    666                            &ctx);
     544    /* Allocate the IO buffer. */
     545    p = (VBVAMOUSEPOINTERSHAPE *)HGSMIHeapAlloc(&pCtx->heapCtx,
     546                                                  sizeof(VBVAMOUSEPOINTERSHAPE)
     547                                                + cbData,
     548                                                HGSMI_CH_VBVA,
     549                                                VBVA_MOUSE_POINTER_SHAPE);
     550    if (p)
     551    {
     552        /* Prepare data to be sent to the host. */
     553        /* Will be updated by the host. */
     554        p->i32Result = VINF_SUCCESS;
     555        /* We have our custom flags in the field */
     556        p->fu32Flags = fFlags;
     557        p->u32HotX   = cHotX;
     558        p->u32HotY   = cHotY;
     559        p->u32Width  = cWidth;
     560        p->u32Height = cHeight;
     561        if (p->fu32Flags & VBOX_MOUSE_POINTER_SHAPE)
     562            /* Copy the actual pointer data. */
     563            memcpy (p->au8Data, pPixels, cbData);
     564        rc = vboxHGSMIBufferSubmit(pCtx, p);
     565        if (RT_SUCCESS(rc))
     566            rc = p->i32Result;
     567        /* Free the IO buffer. */
     568        HGSMIHeapFree(&pCtx->heapCtx, p);
     569    }
     570    else
     571        rc = VERR_NO_MEMORY;
    667572#ifndef DEBUG_misha
    668     Log(("VBoxVideo::vboxMousePointerShape: rc %d, i32Result = %d\n", rc, ctx.i32Result));
     573    LogFunc(("rc %d\n", rc));
    669574#endif
    670 
    671     return RT_SUCCESS(rc) && RT_SUCCESS(ctx.i32Result);
     575    return RT_SUCCESS(rc);
    672576}
    673577
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