VirtualBox

Ignore:
Timestamp:
May 19, 2009 12:16:28 PM (16 years ago)
Author:
vboxsync
Message:

IFramebuffer cleanup next part:

  • removed obsolete internal framebuffer
  • removed IFramebuffer::setupInternalFramebuffer(), IFramebuffer::lockFramebuffer(), IFramebuffer::unlockFramebuffer(), IFramebuffer::registerExternalFramebuffer()
  • removed unused finished parameter of IFramebuffer::NotifyUpdate()
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/DisplayImpl.cpp

    r19798 r19817  
    2323
    2424#include "DisplayImpl.h"
    25 #include "FramebufferImpl.h"
    2625#include "ConsoleImpl.h"
    2726#include "ConsoleVRDPServer.h"
     
    8685    mpVMMDev = NULL;
    8786    mfVMMDevInited = false;
    88     RTSemEventMultiCreate(&mUpdateSem);
    8987
    9088    mLastAddress = NULL;
     
    124122    unconst (mParent) = aParent;
    125123
    126     /* reset the event sems */
    127     RTSemEventMultiReset (mUpdateSem);
    128 
    129124    // by default, we have an internal framebuffer which is
    130125    // NULL, i.e. a black hole for no display output
    131     mInternalFramebuffer = true;
    132126    mFramebufferOpened = false;
    133     mSupportedAccelOps = 0;
    134127
    135128    ULONG ul;
     
    185178    for (ul = 0; ul < mcMonitors; ul++)
    186179        maFramebuffers[ul].pFramebuffer = NULL;
    187 
    188     RTSemEventMultiDestroy (mUpdateSem);
    189180
    190181    if (mParent)
     
    507498    pFramebuffer->Lock();
    508499
    509     /* special processing for the internal framebuffer */
    510     if (mInternalFramebuffer)
    511     {
    512         pFramebuffer->Unlock();
    513     } else
    514     {
    515         /* callback into the framebuffer to notify it */
    516         BOOL finished = FALSE;
    517 
    518         RTSemEventMultiReset(mUpdateSem);
    519 
    520         checkCoordBounds (&x, &y, &w, &h, mpDrv->Connector.cx, mpDrv->Connector.cy);
    521 
    522         if (w == 0 || h == 0)
    523         {
    524             /* Nothing to be updated. */
    525             finished = TRUE;
    526         }
    527         else
    528         {
    529             pFramebuffer->NotifyUpdate(x, y, w, h, &finished);
    530         }
    531 
    532         if (!finished)
    533         {
    534             /*
    535              *  the framebuffer needs more time to process
    536              *  the event so we have to halt the VM until it's done
    537              */
    538             pFramebuffer->Unlock();
    539             RTSemEventMultiWait(mUpdateSem, RT_INDEFINITE_WAIT);
    540         } else
    541         {
    542             pFramebuffer->Unlock();
    543         }
    544 
    545         if (!mfVideoAccelEnabled)
    546         {
    547             /* When VBVA is enabled, the VRDP server is informed in the VideoAccelFlush.
    548              * Inform the server here only if VBVA is disabled.
    549              */
    550             if (maFramebuffers[uScreenId].u32ResizeStatus == ResizeStatus_Void)
    551             {
    552                 mParent->consoleVRDPServer()->SendUpdateBitmap(uScreenId, x, y, w, h);
    553             }
    554         }
    555     }
    556     return;
     500    checkCoordBounds (&x, &y, &w, &h, mpDrv->Connector.cx, mpDrv->Connector.cy);
     501
     502    if (w != 0 && h != 0)
     503        pFramebuffer->NotifyUpdate(x, y, w, h);
     504
     505    pFramebuffer->Unlock();
     506
     507    if (!mfVideoAccelEnabled)
     508    {
     509        /* When VBVA is enabled, the VRDP server is informed in the VideoAccelFlush.
     510         * Inform the server here only if VBVA is disabled.
     511         */
     512        if (maFramebuffers[uScreenId].u32ResizeStatus == ResizeStatus_Void)
     513            mParent->consoleVRDPServer()->SendUpdateBitmap(uScreenId, x, y, w, h);
     514    }
    557515}
    558516
     
    13441302/////////////////////////////////////////////////////////////////////////////
    13451303
    1346 STDMETHODIMP Display::SetupInternalFramebuffer (ULONG depth)
     1304STDMETHODIMP Display::SetFramebuffer (ULONG aScreenId,
     1305    IFramebuffer *aFramebuffer)
    13471306{
    13481307    LogFlowFunc (("\n"));
     1308
     1309    if (aFramebuffer != NULL)
     1310        CheckComArgOutPointerValid(aFramebuffer);
    13491311
    13501312    AutoCaller autoCaller (this);
     
    13531315    AutoWriteLock alock (this);
    13541316
    1355     /*
    1356      *  Create an internal framebuffer only if depth is not zero. Otherwise, we
    1357      *  reset back to the "black hole" state as it was at Display construction.
    1358      */
    1359     ComPtr <IFramebuffer> frameBuf;
    1360     if (depth)
    1361     {
    1362         ComObjPtr <InternalFramebuffer> internal;
    1363         internal.createObject();
    1364         internal->init (640, 480, depth);
    1365         frameBuf = internal; // query interface
    1366     }
    1367 
    13681317    Console::SafeVMPtrQuiet pVM (mParent);
    13691318    if (pVM.isOk())
    13701319    {
    1371         /* Must leave the lock here because the changeFramebuffer will also obtain it. */
     1320        /* Must leave the lock here because the changeFramebuffer will
     1321         * also obtain it. */
    13721322        alock.leave ();
    13731323
     
    13751325        PVMREQ pReq = NULL;
    13761326        int vrc = VMR3ReqCall (pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    1377                                (PFNRT) changeFramebuffer, 4,
    1378                                this, static_cast <IFramebuffer *> (frameBuf),
    1379                                true /* aInternal */, VBOX_VIDEO_PRIMARY_SCREEN);
     1327            (PFNRT) changeFramebuffer, 3, this, aFramebuffer, aScreenId);
    13801328        if (RT_SUCCESS (vrc))
    13811329            vrc = pReq->iStatus;
     
    13891337    {
    13901338        /* No VM is created (VM is powered off), do a direct call */
    1391         int vrc = changeFramebuffer (this, frameBuf, true /* aInternal */, VBOX_VIDEO_PRIMARY_SCREEN);
    1392         ComAssertRCRet (vrc, E_FAIL);
    1393     }
    1394 
    1395     return S_OK;
    1396 }
    1397 
    1398 STDMETHODIMP Display::LockFramebuffer (BYTE **address)
    1399 {
    1400     CheckComArgOutPointerValid(address);
    1401 
    1402     AutoCaller autoCaller (this);
    1403     CheckComRCReturnRC (autoCaller.rc());
    1404 
    1405     AutoWriteLock alock (this);
    1406 
    1407     /* only allowed for internal framebuffers */
    1408     if (mInternalFramebuffer && !mFramebufferOpened
    1409         && !maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer.isNull())
    1410     {
    1411         CHECK_CONSOLE_DRV (mpDrv);
    1412 
    1413         maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer->Lock();
    1414         mFramebufferOpened = true;
    1415         *address = mpDrv->Connector.pu8Data;
    1416         return S_OK;
    1417     }
    1418 
    1419     return setError (VBOX_E_NOT_SUPPORTED,
    1420         tr ("Framebuffer locking is allowed only for the internal framebuffer"));
    1421 }
    1422 
    1423 STDMETHODIMP Display::UnlockFramebuffer()
    1424 {
    1425     AutoCaller autoCaller (this);
    1426     CheckComRCReturnRC (autoCaller.rc());
    1427 
    1428     AutoWriteLock alock (this);
    1429 
    1430     if (mFramebufferOpened)
    1431     {
    1432         CHECK_CONSOLE_DRV (mpDrv);
    1433 
    1434         maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer->Unlock();
    1435         mFramebufferOpened = false;
    1436         return S_OK;
    1437     }
    1438 
    1439     return setError (VBOX_E_NOT_SUPPORTED,
    1440         tr ("Framebuffer locking is allowed only for the internal framebuffer"));
    1441 }
    1442 
    1443 STDMETHODIMP Display::RegisterExternalFramebuffer (IFramebuffer *frameBuf)
    1444 {
    1445     LogFlowFunc (("\n"));
    1446 
    1447     CheckComArgNotNull(frameBuf);
    1448 
    1449     AutoCaller autoCaller (this);
    1450     CheckComRCReturnRC (autoCaller.rc());
    1451 
    1452     AutoWriteLock alock (this);
    1453 
    1454     Console::SafeVMPtrQuiet pVM (mParent);
    1455     if (pVM.isOk())
    1456     {
    1457         /* Must leave the lock here because the changeFramebuffer will
    1458          * also obtain it. */
    1459         alock.leave ();
    1460 
    1461         /* send request to the EMT thread */
    1462         PVMREQ pReq = NULL;
    1463         int vrc = VMR3ReqCall (pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    1464             (PFNRT) changeFramebuffer, 4, this, frameBuf, false /* aInternal */,
    1465             VBOX_VIDEO_PRIMARY_SCREEN);
    1466         if (RT_SUCCESS (vrc))
    1467             vrc = pReq->iStatus;
    1468         VMR3ReqFree (pReq);
    1469 
    1470         alock.enter ();
    1471 
    1472         ComAssertRCRet (vrc, E_FAIL);
    1473     }
    1474     else
    1475     {
    1476         /* No VM is created (VM is powered off), do a direct call */
    1477         int vrc = changeFramebuffer (this, frameBuf, false /* aInternal */,
    1478             VBOX_VIDEO_PRIMARY_SCREEN);
    1479         ComAssertRCRet (vrc, E_FAIL);
    1480     }
    1481 
    1482     return S_OK;
    1483 }
    1484 
    1485 STDMETHODIMP Display::SetFramebuffer (ULONG aScreenId,
    1486     IFramebuffer *aFramebuffer)
    1487 {
    1488     LogFlowFunc (("\n"));
    1489 
    1490     CheckComArgOutPointerValid(aFramebuffer);
    1491 
    1492     AutoCaller autoCaller (this);
    1493     CheckComRCReturnRC (autoCaller.rc());
    1494 
    1495     AutoWriteLock alock (this);
    1496 
    1497     Console::SafeVMPtrQuiet pVM (mParent);
    1498     if (pVM.isOk())
    1499     {
    1500         /* Must leave the lock here because the changeFramebuffer will
    1501          * also obtain it. */
    1502         alock.leave ();
    1503 
    1504         /* send request to the EMT thread */
    1505         PVMREQ pReq = NULL;
    1506         int vrc = VMR3ReqCall (pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
    1507             (PFNRT) changeFramebuffer, 4, this, aFramebuffer, false /* aInternal */,
    1508             aScreenId);
    1509         if (RT_SUCCESS (vrc))
    1510             vrc = pReq->iStatus;
    1511         VMR3ReqFree (pReq);
    1512 
    1513         alock.enter ();
    1514 
    1515         ComAssertRCRet (vrc, E_FAIL);
    1516     }
    1517     else
    1518     {
    1519         /* No VM is created (VM is powered off), do a direct call */
    1520         int vrc = changeFramebuffer (this, aFramebuffer, false /* aInternal */,
    1521             aScreenId);
     1339        int vrc = changeFramebuffer (this, aFramebuffer, aScreenId);
    15221340        ComAssertRCRet (vrc, E_FAIL);
    15231341    }
     
    18231641
    18241642    /* this is only valid for external framebuffers */
    1825     if (mInternalFramebuffer)
     1643    if (maFramebuffers[aScreenId].pFramebuffer == NULL)
    18261644        return setError (VBOX_E_NOT_SUPPORTED,
    18271645            tr ("Resize completed notification is valid only "
     
    18591677
    18601678    /* this is only valid for external framebuffers */
    1861     if (mInternalFramebuffer)
     1679    if (maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer == NULL)
    18621680        return setError (VBOX_E_NOT_SUPPORTED,
    18631681            tr ("Resize completed notification is valid only "
    18641682                "for external framebuffers"));
    1865 
    1866     maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer->Lock();
    1867     /* signal our semaphore */
    1868     RTSemEventMultiSignal(mUpdateSem);
    1869     maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN].pFramebuffer->Unlock();
    18701683
    18711684    return S_OK;
     
    19721785/* static */
    19731786DECLCALLBACK(int) Display::changeFramebuffer (Display *that, IFramebuffer *aFB,
    1974                                               bool aInternal, unsigned uScreenId)
     1787                                              unsigned uScreenId)
    19751788{
    19761789    LogFlowFunc (("uScreenId = %d\n", uScreenId));
    19771790
    19781791    AssertReturn (that, VERR_INVALID_PARAMETER);
    1979     AssertReturn (aFB || aInternal, VERR_INVALID_PARAMETER);
    19801792    AssertReturn (uScreenId < that->mcMonitors, VERR_INVALID_PARAMETER);
    19811793
     
    19871799    DISPLAYFBINFO *pDisplayFBInfo = &that->maFramebuffers[uScreenId];
    19881800    pDisplayFBInfo->pFramebuffer = aFB;
    1989 
    1990     that->mInternalFramebuffer = aInternal;
    1991     that->mSupportedAccelOps = 0;
    19921801
    19931802    that->mParent->consoleVRDPServer()->SendResize ();
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