VirtualBox

Changeset 75307 in vbox for trunk/src/VBox/Main/src-server


Ignore:
Timestamp:
Nov 7, 2018 1:56:14 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
126417
Message:

Recording: Bugfixes for Main and FE/Qt.

Location:
trunk/src/VBox/Main/src-server
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/src-server/CaptureScreenSettingsImpl.cpp

    r75279 r75307  
    8686    m = new Data();
    8787
    88     /* share the parent weakly */
     88    /* Share the parent weakly. */
    8989    unconst(m->pMachine) = aParent;
     90    /* mPeer is left null. */
    9091
    9192    /* Simply copy the settings data. */
    … …  
    9495    m->bd->operator=(data);
    9596
    96     autoInitSpan.setSucceeded();
     97    HRESULT rc = S_OK;
     98
     99    int vrc = i_initInternal();
     100    if (RT_SUCCESS(vrc))
     101    {
     102        autoInitSpan.setSucceeded();
     103    }
     104    else
     105    {
     106        autoInitSpan.setFailed();
     107        rc = E_UNEXPECTED;
     108    }
    97109
    98110    LogFlowThisFuncLeave();
    99     return S_OK;
     111    return rc;
    100112}
    101113
    … …  
    129141    m->bd.share(that->m->bd);
    130142
    131     autoInitSpan.setSucceeded();
     143    HRESULT rc = S_OK;
     144
     145    int vrc = i_initInternal();
     146    if (RT_SUCCESS(vrc))
     147    {
     148        autoInitSpan.setSucceeded();
     149    }
     150    else
     151    {
     152        autoInitSpan.setFailed();
     153        rc = E_UNEXPECTED;
     154    }
    132155
    133156    LogFlowThisFuncLeave();
    134     return S_OK;
     157    return rc;
    135158}
    136159
    … …  
    154177
    155178    unconst(m->pMachine) = aParent;
    156     // mPeer is left null
     179    /* mPeer is left null. */
    157180
    158181    AutoWriteLock thatlock(that COMMA_LOCKVAL_SRC_POS);
    … …  
    161184    m->bd.attachCopy(that->m->bd);
    162185
    163     autoInitSpan.setSucceeded();
     186    HRESULT rc = S_OK;
     187
     188    int vrc = i_initInternal();
     189    if (RT_SUCCESS(vrc))
     190    {
     191        autoInitSpan.setSucceeded();
     192    }
     193    else
     194    {
     195        autoInitSpan.setFailed();
     196        rc = E_UNEXPECTED;
     197    }
    164198
    165199    LogFlowThisFuncLeave();
    166     return S_OK;
     200    return rc;
    167201}
    168202
    … …  
    216250    if (m->bd->fEnabled != RT_BOOL(enabled))
    217251    {
     252        m->bd.backup();
     253        m->bd->fEnabled = RT_BOOL(enabled);
    218254        alock.release();
     255
     256        AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     257        m->pMachine->i_setModified(Machine::IsModified_Capture);
     258        mlock.release();
    219259
    220260        HRESULT rc = m->pMachine->i_onCaptureChange();
    221261        if (FAILED(rc)) return rc;
    222 
    223         m->pMachine->i_setModified(Machine::IsModified_Capture);
    224 
    225         alock.acquire();
    226         m->bd->fEnabled = RT_BOOL(enabled);
    227         alock.release();
    228262
    229263        /** Save settings if online - @todo why is this required? -- @bugref{6818} */
    … …  
    263297    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    264298
    265     m->pMachine->i_setModified(Machine::IsModified_Capture);
    266     m->bd.backup();
    267 
     299    m->bd.backup();
    268300    m->bd->featureMap.clear();
    269301
    … …  
    273305        m->bd->featureMap[CaptureFeature_Video] = true;
    274306
     307    alock.release();
     308
     309    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     310    m->pMachine->i_setModified(Machine::IsModified_Capture);
     311    mlock.release();
     312
    275313    return S_OK;
    276314}
    … …  
    292330    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    293331
    294     m->pMachine->i_setModified(Machine::IsModified_Capture);
    295332    m->bd.backup();
    296333    m->bd->enmDest = aDestination;
    297334
     335    alock.release();
     336
     337    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     338    m->pMachine->i_setModified(Machine::IsModified_Capture);
     339    mlock.release();
     340
    298341    return S_OK;
    299342}
    … …  
    303346    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    304347
    305     if (m->bd->File.strName.isEmpty())
    306         i_getDefaultCaptureFile(aFileName);
    307     else
    308         aFileName = m->bd->File.strName;
     348    aFileName = m->bd->File.strName;
    309349
    310350    return S_OK;
    … …  
    323363        return setError(E_INVALIDARG, tr("Capture file name '%s' is not absolute"), strFile.c_str());
    324364
    325     if (!strFile.isEmpty())
    326     {
    327         Utf8Str defaultFile;
    328         i_getDefaultCaptureFile(defaultFile);
    329         if (!RTPathCompare(strFile.c_str(), defaultFile.c_str()))
    330             strFile.setNull();
    331     }
    332 
    333     m->pMachine->i_setModified(Machine::IsModified_Capture);
    334365    m->bd.backup();
    335366    m->bd->File.strName = strFile;
    336367
     368    alock.release();
     369
     370    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     371    m->pMachine->i_setModified(Machine::IsModified_Capture);
     372    mlock.release();
     373
    337374    return S_OK;
    338375}
    … …  
    354391        return setError(E_INVALIDARG, tr("Cannot change maximum time while capturing is enabled"));
    355392
    356     m->pMachine->i_setModified(Machine::IsModified_Capture);
    357     m->bd.backup();
    358 
     393    m->bd.backup();
    359394    m->bd->ulMaxTimeS = aMaxTimeS;
    360395
     396    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     397    m->pMachine->i_setModified(Machine::IsModified_Capture);
     398    mlock.release();
     399
    361400    return S_OK;
    362401}
    … …  
    378417        return setError(E_INVALIDARG, tr("Cannot change maximum file size while capturing is enabled"));
    379418
    380     m->pMachine->i_setModified(Machine::IsModified_Capture);
    381     m->bd.backup();
    382 
     419    m->bd.backup();
    383420    m->bd->File.ulMaxSizeMB = aMaxFileSize;
    384421
     422    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     423    m->pMachine->i_setModified(Machine::IsModified_Capture);
     424    mlock.release();
     425
    385426    return S_OK;
    386427}
    … …  
    402443        return setError(E_INVALIDARG, tr("Cannot change options string while capturing is enabled"));
    403444
    404     m->pMachine->i_setModified(Machine::IsModified_Capture);
    405     m->bd.backup();
    406 
     445    m->bd.backup();
    407446    m->bd->strOptions = aOptions;
    408447
     448    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     449    m->pMachine->i_setModified(Machine::IsModified_Capture);
     450    mlock.release();
     451
    409452    return S_OK;
    410453}
    … …  
    426469        return setError(E_INVALIDARG, tr("Cannot change audio codec while capturing is enabled"));
    427470
    428     m->pMachine->i_setModified(Machine::IsModified_Capture);
    429     m->bd.backup();
    430 
     471    m->bd.backup();
    431472    m->bd->Audio.enmAudioCodec = aCodec;
    432473
     474    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     475    m->pMachine->i_setModified(Machine::IsModified_Capture);
     476    mlock.release();
     477
    433478    return S_OK;
    434479}
    … …  
    450495        return setError(E_INVALIDARG, tr("Cannot change audio Hertz rate while capturing is enabled"));
    451496
    452     m->pMachine->i_setModified(Machine::IsModified_Capture);
    453     m->bd.backup();
    454 
     497    m->bd.backup();
    455498    m->bd->Audio.uHz = (uint16_t)aHz;
    456499
     500    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     501    m->pMachine->i_setModified(Machine::IsModified_Capture);
     502    mlock.release();
     503
    457504    return S_OK;
    458505}
    … …  
    474521        return setError(E_INVALIDARG, tr("Cannot change audio bits while capturing is enabled"));
    475522
    476     m->pMachine->i_setModified(Machine::IsModified_Capture);
    477     m->bd.backup();
    478 
     523    m->bd.backup();
    479524    m->bd->Audio.cBits = (uint8_t)aBits;
    480525
     526    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     527    m->pMachine->i_setModified(Machine::IsModified_Capture);
     528    mlock.release();
     529
    481530    return S_OK;
    482531}
    … …  
    498547        return setError(E_INVALIDARG, tr("Cannot change audio channels while capturing is enabled"));
    499548
    500     m->pMachine->i_setModified(Machine::IsModified_Capture);
    501     m->bd.backup();
    502 
     549    m->bd.backup();
    503550    m->bd->Audio.cChannels = (uint8_t)aChannels;
    504551
     552    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     553    m->pMachine->i_setModified(Machine::IsModified_Capture);
     554    mlock.release();
     555
    505556    return S_OK;
    506557}
    … …  
    522573        return setError(E_INVALIDARG, tr("Cannot change video codec while capturing is enabled"));
    523574
    524     m->pMachine->i_setModified(Machine::IsModified_Capture);
    525     m->bd.backup();
    526 
     575    m->bd.backup();
    527576    m->bd->Video.enmCodec = aCodec;
    528577
     578    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     579    m->pMachine->i_setModified(Machine::IsModified_Capture);
     580    mlock.release();
     581
    529582    return S_OK;
    530583}
    … …  
    546599        return setError(E_INVALIDARG, tr("Cannot change video width while capturing is enabled"));
    547600
    548     m->pMachine->i_setModified(Machine::IsModified_Capture);
    549     m->bd.backup();
    550 
     601    m->bd.backup();
    551602    m->bd->Video.ulWidth = aVideoWidth;
    552603
     604    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     605    m->pMachine->i_setModified(Machine::IsModified_Capture);
     606    mlock.release();
     607
    553608    return S_OK;
    554609}
    … …  
    570625        return setError(E_INVALIDARG, tr("Cannot change video height while capturing is enabled"));
    571626
    572     m->pMachine->i_setModified(Machine::IsModified_Capture);
    573     m->bd.backup();
    574 
     627    m->bd.backup();
    575628    m->bd->Video.ulHeight = aVideoHeight;
    576629
     630    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     631    m->pMachine->i_setModified(Machine::IsModified_Capture);
     632    mlock.release();
     633
    577634    return S_OK;
    578635}
    … …  
    594651        return setError(E_INVALIDARG, tr("Cannot change video rate while capturing is enabled"));
    595652
    596     m->pMachine->i_setModified(Machine::IsModified_Capture);
    597     m->bd.backup();
    598 
     653    m->bd.backup();
    599654    m->bd->Video.ulRate = aVideoRate;
     655
     656    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     657    m->pMachine->i_setModified(Machine::IsModified_Capture);
     658    mlock.release();
    600659
    601660    return S_OK;
    … …  
    640699        return setError(E_INVALIDARG, tr("Cannot change video FPS while capturing is enabled"));
    641700
    642     m->pMachine->i_setModified(Machine::IsModified_Capture);
    643     m->bd.backup();
    644 
     701    m->bd.backup();
    645702    m->bd->Video.ulFPS = aVideoFPS;
     703
     704    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     705    m->pMachine->i_setModified(Machine::IsModified_Capture);
     706    mlock.release();
    646707
    647708    return S_OK;
    … …  
    685746 * Returns the full path to the default video capture file.
    686747 */
    687 int CaptureScreenSettings::i_getDefaultCaptureFile(Utf8Str &strFile)
     748int CaptureScreenSettings::i_getDefaultFileName(Utf8Str &strFile)
    688749{
    689750    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    696757}
    697758
     759/**
     760 * Initializes data, internal version.
     761 *
     762 * @returns IPRT status code.
     763 */
     764int CaptureScreenSettings::i_initInternal(void)
     765{
     766    Assert(m);
     767    return i_getDefaultFileName(m->bd->File.strName);
     768}
     769

  • trunk/src/VBox/Main/src-server/CaptureSettingsImpl.cpp

    r75287 r75307  
    4444    ComObjPtr<CaptureSettings>  pPeer;
    4545    CaptureScreenSettingsMap    mapScreenSettings;
     46    bool                        fHasMachineLock;
    4647
    4748    // use the XML settings structure in the members for simplicity
    … …  
    8485
    8586    m->bd.allocate();
     87    m->fHasMachineLock = false;
    8688
    8789    autoInitSpan.setSucceeded();
    … …  
    119121    m->bd.share(that->m->bd);
    120122    m->mapScreenSettings = that->m->mapScreenSettings;
     123    m->fHasMachineLock = false;
    121124
    122125    autoInitSpan.setSucceeded();
    … …  
    151154    m->bd.attachCopy(that->m->bd);
    152155    m->mapScreenSettings = that->m->mapScreenSettings;
     156    m->fHasMachineLock = false;
    153157
    154158    autoInitSpan.setSucceeded();
    … …  
    196200HRESULT CaptureSettings::setEnabled(BOOL enable)
    197201{
    198     /* the machine needs to be mutable */
    199     AutoMutableStateDependency adep(m->pMachine);
    200     if (FAILED(adep.rc())) return adep.rc();
    201 
    202202    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    203203
    … …  
    216216        {
    217217            /*
    218              * Normally we would do the actual change _after_ i_onVideoCaptureChange() succeeded.
    219              * We cannot do this because that function uses Machine::GetVideoCaptureEnabled to
     218             * Normally we would do the actual change _after_ i_onCaptureChange() succeeded.
     219             * We cannot do this because that function uses CaptureSettings::GetEnabled to
    220220             * determine if it should start or stop capturing. Therefore we need to manually
    221221             * undo change.
    … …  
    230230            m->pMachine->i_setModified(Machine::IsModified_Capture);
    231231
     232            /* We need to indicate here that we just took the machine lock, as Machine::i_saveSettings() will
     233             * call i_commit(), which in turn also wants to lock the machine for writing. */
     234            m->fHasMachineLock = true;
     235
    232236            /** Save settings if online - @todo why is this required? -- @bugref{6818} */
    233             if (Global::IsOnline(adep.machineState()))
    234                 m->pMachine->i_saveSettings(NULL);
     237            if (Global::IsOnline(m->pMachine->i_getMachineState()))
     238                rc = m->pMachine->i_saveSettings(NULL);
     239
     240            m->fHasMachineLock = false;
    235241        }
    236242    }
    … …  
    251257    {
    252258        itScreenSettings->second.queryInterfaceTo(aCaptureScreenSettings[i].asOutParam());
     259        Assert(aCaptureScreenSettings[i].isNotNull());
    253260        ++i;
    254261        ++itScreenSettings;
    255262    }
    256263
     264    Assert(aCaptureScreenSettings.size() == m->mapScreenSettings.size());
     265
    257266    return S_OK;
    258267}
    … …  
    280289
    281290/**
     291 * Adds a screen settings object to the recording settings.
     292 *
     293 * @returns IPRT status code. VERR_ALREADY_EXISTS if the object in question already exists.
     294 * @param   uScreenId           Screen ID to add settings for.
     295 * @param   data                Recording screen settings to use for that screen.
     296 */
     297int CaptureSettings::i_addScreen(uint32_t uScreenId, const settings::CaptureScreenSettings &data)
     298{
     299    if (m->mapScreenSettings.find(uScreenId) != m->mapScreenSettings.end())
     300    {
     301        AssertFailed();
     302        return VERR_ALREADY_EXISTS;
     303    }
     304
     305    int vrc = VINF_SUCCESS;
     306
     307    ComObjPtr<CaptureScreenSettings> captureScreenSettings;
     308    HRESULT rc = captureScreenSettings.createObject();
     309    if (SUCCEEDED(rc))
     310    {
     311        rc = captureScreenSettings->init(m->pMachine, uScreenId, data);
     312        if (SUCCEEDED(rc))
     313        {
     314            try
     315            {
     316                m->mapScreenSettings[uScreenId] = captureScreenSettings;
     317            }
     318            catch (std::bad_alloc &)
     319            {
     320                vrc = VERR_NO_MEMORY;
     321            }
     322        }
     323    }
     324
     325    return vrc;
     326}
     327
     328/**
    282329 * Loads settings from the given settings.
    283330 * May be called once right after this object creation.
    … …  
    301348    while (itScreen != data.mapScreens.end())
    302349    {
    303         ComObjPtr<CaptureScreenSettings> captureScreenSettings;
    304         rc = captureScreenSettings.createObject();
    305         if (FAILED(rc))
     350        int vrc = i_addScreen(itScreen->first /* uScreenId */, itScreen->second /* Settings */);
     351        if (RT_FAILURE(vrc))
     352        {
     353            rc = E_OUTOFMEMORY;
    306354            break;
    307 
    308         rc = captureScreenSettings->init(m->pMachine, itScreen->first /* uScreenId */, itScreen->second /* Settings */);
    309         if (FAILED(rc))
    310             break;
    311 
    312         m->mapScreenSettings[itScreen->first] = captureScreenSettings;
     355        }
    313356
    314357        ++itScreen;
    315358    }
     359
     360    if (FAILED(rc))
     361        return rc;
    316362
    317363    ComAssertComRC(rc);
    … …  
    378424        {
    379425            /* attach new data to the peer and reshare it */
    380             AutoWriteLock peerlock(m->pPeer COMMA_LOCKVAL_SRC_POS);
     426            AutoWriteLock peerlock(RT_SRC_POS);
     427            if (!m->fHasMachineLock)
     428                peerlock.attach(m->pPeer);
    381429            m->pPeer->m->bd.attach(m->bd);
    382430        }
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