VirtualBox

Changeset 75341 in vbox


Ignore:
Timestamp:
Nov 9, 2018 8:37:28 AM (6 years ago)
Author:
vboxsync
Message:

Recording: Renaming APIs ICapture* -> IRecord* and other terminology to better distinguish from features like mouse capturing and stuff.

Location:
trunk
Files:
32 edited
4 moved

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/log.h

    r75274 r75341  
    354354    /** Main group, IBIOSSettings. */
    355355    LOG_GROUP_MAIN_BIOSSETTINGS,
    356     /** Main group, ICaptureChangedEvent. */
    357     LOG_GROUP_MAIN_CAPTURECHANGEDEVENT,
    358     /** Main group, ICaptureSettings. */
    359     LOG_GROUP_MAIN_CAPTURESETTINGS,
    360     /** Main group, ICaptureScreenSettings. */
    361     LOG_GROUP_MAIN_CAPTURESCREENSETTINGS,
    362356    /** Main group, ICanShowWindowEvent. */
    363357    LOG_GROUP_MAIN_CANSHOWWINDOWEVENT,
    … …  
    600594    /** Main group, IProgressTaskCompletedEvent. */
    601595    LOG_GROUP_MAIN_PROGRESSTASKCOMPLETEDEVENT,
     596    /** Main group, IRecordChangedEvent. */
     597    LOG_GROUP_MAIN_RECORDCHANGEDEVENT,
     598    /** Main group, IRecordSettings. */
     599    LOG_GROUP_MAIN_RECORDSETTINGS,
     600    /** Main group, IRecordScreenSettings. */
     601    LOG_GROUP_MAIN_RECORDSCREENSETTINGS,
    602602    /** Main group, IReusableEvent. */
    603603    LOG_GROUP_MAIN_REUSABLEEVENT,
    … …  
    10041004    "MAIN_BANDWIDTHGROUPCHANGEDEVENT", \
    10051005    "MAIN_BIOSSETTINGS", \
    1006     "MAIN_CAPTURECHANGEDEVENT", \
    1007     "MAIN_CAPTURESETTINGS", \
    1008     "MAIN_CAPTURESCREENSETTINGS", \
    10091006    "MAIN_CANSHOWWINDOWEVENT", \
    10101007    "MAIN_CERTIFICATE", \
    … …  
    11271124    "MAIN_PROGRESSPERCENTAGECHANGEDEVENT", \
    11281125    "MAIN_PROGRESSTASKCOMPLETEDEVENT", \
     1126    "MAIN_RECORDCHANGEDEVENT", \
     1127    "MAIN_RECORDSETTINGS", \
     1128    "MAIN_RECORDSCREENSETTINGS", \
    11291129    "MAIN_REUSABLEEVENT", \
    11301130    "MAIN_RUNTIMEERROREVENT", \

  • trunk/include/VBox/settings.h

    r75279 r75341  
    481481};
    482482
    483 /** List for keeping a capturing feature list. */
    484 typedef std::map<CaptureFeature_T, bool> CaptureFeatureMap;
    485 
    486 struct CaptureScreenSettings
    487 {
    488     CaptureScreenSettings();
    489 
    490     virtual ~CaptureScreenSettings();
     483/** List for keeping a recording feature list. */
     484typedef std::map<RecordFeature_T, bool> RecordFeatureMap;
     485
     486struct RecordScreenSettings
     487{
     488    RecordScreenSettings();
     489
     490    virtual ~RecordScreenSettings();
    491491
    492492    void applyDefaults(void);
    … …  
    494494    bool areDefaultSettings(void) const;
    495495
    496     bool isFeatureEnabled(CaptureFeature_T enmFeature) const;
    497 
    498     bool operator==(const CaptureScreenSettings &d) const;
     496    bool isFeatureEnabled(RecordFeature_T enmFeature) const;
     497
     498    bool operator==(const RecordScreenSettings &d) const;
    499499
    500500    bool                 fEnabled;       // requires settings version 1.14 (VirtualBox 4.3)
    501     CaptureDestination_T enmDest;        // new since VirtualBox 6.0.
    502     CaptureFeatureMap    featureMap;     // new since VirtualBox 6.0.
     501    RecordDestination_T enmDest;        // new since VirtualBox 6.0.
     502    RecordFeatureMap    featureMap;     // new since VirtualBox 6.0.
    503503    uint32_t             ulMaxTimeS;     // requires settings version 1.14 (VirtualBox 4.3)
    504504    com::Utf8Str         strOptions;     // new since VirtualBox 5.2.
    … …  
    507507    {
    508508        Audio()
    509             : enmAudioCodec(CaptureAudioCodec_Opus)
     509            : enmAudioCodec(RecordAudioCodec_Opus)
    510510            , uHz(22050)
    511511            , cBits(16)
    … …  
    513513
    514514        /** The audio codec type to use. */
    515         CaptureAudioCodec_T enmAudioCodec; // new since VirtualBox 6.0.
     515        RecordAudioCodec_T enmAudioCodec; // new since VirtualBox 6.0.
    516516        /** Hz rate. */
    517517        uint16_t            uHz;           // new since VirtualBox 6.0.
    … …  
    525525    {
    526526        Video()
    527             : enmCodec(CaptureVideoCodec_VP8)
     527            : enmCodec(RecordVideoCodec_VP8)
    528528            , ulWidth(1024)
    529529            , ulHeight(768)
    … …  
    531531            , ulFPS(25) { }
    532532
    533         CaptureVideoCodec_T  enmCodec;  // new since VirtualBox 6.0.
     533        RecordVideoCodec_T  enmCodec;  // new since VirtualBox 6.0.
    534534        uint32_t             ulWidth;   // requires settings version 1.14 (VirtualBox 4.3)
    535535        uint32_t             ulHeight;  // requires settings version 1.14 (VirtualBox 4.3)
    … …  
    549549
    550550/** Map for keeping settings per virtual screen. */
    551 typedef std::map<uint32_t, CaptureScreenSettings> CaptureScreenMap;
    552 
    553 /**
    554  * NOTE: If you add any fields in here, you must update a) the constructor and b)
    555  * the operator== which is used by MachineConfigFile::operator==(), or otherwise
    556  * your settings might never get saved.
    557  */
    558 struct CaptureSettings
    559 {
    560     CaptureSettings();
     551typedef std::map<uint32_t, RecordScreenSettings> RecordScreenMap;
     552
     553/**
     554 * NOTE: If you add any fields in here, you must update a) the constructor and b)
     555 * the operator== which is used by MachineConfigFile::operator==(), or otherwise
     556 * your settings might never get saved.
     557 */
     558struct RecordSettings
     559{
     560    RecordSettings();
    561561
    562562    void applyDefaults(void);
    … …  
    564564    bool areDefaultSettings(void) const;
    565565
    566     bool operator==(const CaptureSettings &d) const;
    567 
    568     bool             fEnabled;       // requires settings version 1.14 (VirtualBox 4.3)
    569     CaptureScreenMap mapScreens;
     566    bool operator==(const RecordSettings &d) const;
     567
     568    bool            fEnabled;       // requires settings version 1.14 (VirtualBox 4.3)
     569    RecordScreenMap mapScreens;
    570570};
    571571
    … …  
    10391039
    10401040    BIOSSettings        biosSettings;
    1041     CaptureSettings     captureSettings;
     1041    RecordSettings      recordSettings;
    10421042    USB                 usbSettings;
    10431043    NetworkAdaptersList llNetworkAdapters;

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

    r75253 r75341  
    465465             "   -start-paused, --start-paused     Start the VM in paused state\n"
    466466#ifdef VBOX_WITH_VIDEOREC
    467              "   -c, -capture, --capture           Record the VM screen output to a file\n"
    468              "   -w, --width                       Frame width when recording\n"
    469              "   -h, --height                      Frame height when recording\n"
    470              "   -r, --bitrate                     Recording bit rate when recording\n"
     467             "   -c, -record, --record             Record the VM screen output to a file\n"
     468             "   -w, --videowidth                  Video frame width when recording\n"
     469             "   -h, --videoheight                 Video frame height when recording\n"
     470             "   -r, --videobitrate                Recording bit rate when recording\n"
    471471             "   -f, --filename                    File name when recording. The codec used\n"
    472              "                                       will be chosen based on file extension\n"
     472             "                                     will be chosen based on file extension\n"
    473473#endif
    474474             "\n");
    … …  
    494494 *
    495495 *        Use RTEnvGetEx instead! */
    496     if ((pszEnvTemp = RTEnvGet("VBOX_CAPTUREWIDTH")) != 0)
     496    if ((pszEnvTemp = RTEnvGet("VBOX_RECORDWIDTH")) != 0)
    497497    {
    498498        errno = 0;
    499499        unsigned long ulFrameWidth = strtoul(pszEnvTemp, 0, 10);
    500500        if (errno != 0)
    501             LogError("VBoxHeadless: ERROR: invalid VBOX_CAPTUREWIDTH environment variable", 0);
     501            LogError("VBoxHeadless: ERROR: invalid VBOX_RECORDWIDTH environment variable", 0);
    502502        else
    503503            *pulFrameWidth = ulFrameWidth;
    504504    }
    505     if ((pszEnvTemp = RTEnvGet("VBOX_CAPTUREHEIGHT")) != 0)
     505    if ((pszEnvTemp = RTEnvGet("VBOX_RECORDHEIGHT")) != 0)
    506506    {
    507507        errno = 0;
    508508        unsigned long ulFrameHeight = strtoul(pszEnvTemp, 0, 10);
    509509        if (errno != 0)
    510             LogError("VBoxHeadless: ERROR: invalid VBOX_CAPTUREHEIGHT environment variable", 0);
     510            LogError("VBoxHeadless: ERROR: invalid VBOX_RECORDHEIGHT environment variable", 0);
    511511        else
    512512            *pulFrameHeight = ulFrameHeight;
    513513    }
    514     if ((pszEnvTemp = RTEnvGet("VBOX_CAPTUREBITRATE")) != 0)
     514    if ((pszEnvTemp = RTEnvGet("VBOX_RECORDBITRATE")) != 0)
    515515    {
    516516        errno = 0;
    517517        unsigned long ulBitRate = strtoul(pszEnvTemp, 0, 10);
    518518        if (errno != 0)
    519             LogError("VBoxHeadless: ERROR: invalid VBOX_CAPTUREBITRATE environment variable", 0);
     519            LogError("VBoxHeadless: ERROR: invalid VBOX_RECORDBITRATE environment variable", 0);
    520520        else
    521521            *pulBitRate = ulBitRate;
    522522    }
    523     if ((pszEnvTemp = RTEnvGet("VBOX_CAPTUREFILE")) != 0)
     523    if ((pszEnvTemp = RTEnvGet("VBOX_RECORDFILE")) != 0)
    524524        *ppszFileName = pszEnvTemp;
    525525}
    … …  
    627627    unsigned fPaused = 0;
    628628#ifdef VBOX_WITH_VIDEOREC
    629     bool fCaptureEnabled = false;
    630     uint32_t ulCaptureVideoWidth = 800;
    631     uint32_t ulCaptureVideoHeight = 600;
    632     uint32_t ulCaptureVideoRate = 300000;
    633     char szCaptureFileName[RTPATH_MAX];
    634     const char *pszCaptureFileNameTemplate = "VBox-%d.webm"; /* .webm container by default. */
     629    bool fRecordEnabled = false;
     630    uint32_t ulRecordVideoWidth = 800;
     631    uint32_t ulRecordVideoHeight = 600;
     632    uint32_t ulRecordVideoRate = 300000;
     633    char szRecordFileName[RTPATH_MAX];
     634    const char *pszRecordFileNameTemplate = "VBox-%d.webm"; /* .webm container by default. */
    635635#endif /* VBOX_WITH_VIDEOREC */
    636636#ifdef RT_OS_WINDOWS
    … …  
    645645#ifdef VBOX_WITH_VIDEOREC
    646646    /* Parse the environment */
    647     parse_environ(&ulCaptureVideoWidth, &ulCaptureVideoHeight, &ulCaptureVideoRate, &pszCaptureFileNameTemplate);
     647    parse_environ(&ulRecordVideoWidth, &ulRecordVideoHeight, &ulRecordVideoRate, &pszRecordFileNameTemplate);
    648648#endif
    649649
    … …  
    697697        { "--settingspwfile", OPT_SETTINGSPW_FILE, RTGETOPT_REQ_STRING },
    698698#ifdef VBOX_WITH_VIDEOREC
    699         { "-capture", 'c', 0 },
    700         { "--capture", 'c', 0 },
    701         { "--width", 'w', RTGETOPT_REQ_UINT32 },
    702         { "--height", 'h', RTGETOPT_REQ_UINT32 }, /* great choice of short option! */
    703         { "--bitrate", 'r', RTGETOPT_REQ_UINT32 },
     699        { "-record", 'c', 0 },
     700        { "--record", 'c', 0 },
     701        { "--videowidth", 'w', RTGETOPT_REQ_UINT32 },
     702        { "--videoheight", 'h', RTGETOPT_REQ_UINT32 }, /* great choice of short option! */
     703        { "--videorate", 'r', RTGETOPT_REQ_UINT32 },
    704704        { "--filename", 'f', RTGETOPT_REQ_STRING },
    705705#endif /* VBOX_WITH_VIDEOREC defined */
    … …  
    782782#ifdef VBOX_WITH_VIDEOREC
    783783            case 'c':
    784                 fCaptureEnabled = true;
     784                fRecordEnabled = true;
    785785                break;
    786786            case 'w':
    787                 ulCaptureVideoWidth = ValueUnion.u32;
     787                ulRecordVideoWidth = ValueUnion.u32;
    788788                break;
    789789            case 'r':
    790                 ulCaptureVideoRate = ValueUnion.u32;
     790                ulRecordVideoRate = ValueUnion.u32;
    791791                break;
    792792            case 'f':
    793                 pszCaptureFileNameTemplate = ValueUnion.psz;
     793                pszRecordFileNameTemplate = ValueUnion.psz;
    794794                break;
    795795#endif /* VBOX_WITH_VIDEOREC defined */
    … …  
    798798                if ((GetState.pDef->fFlags & RTGETOPT_REQ_MASK) != RTGETOPT_REQ_NOTHING)
    799799                {
    800                     ulCaptureVideoHeight = ValueUnion.u32;
     800                    ulRecordVideoHeight = ValueUnion.u32;
    801801                    break;
    802802                }
    … …  
    818818
    819819#ifdef VBOX_WITH_VIDEOREC
    820     if (ulCaptureVideoWidth < 512 || ulCaptureVideoWidth > 2048 || ulCaptureVideoWidth % 2)
    821     {
    822         LogError("VBoxHeadless: ERROR: please specify an even frame width between 512 and 2048", 0);
     820    if (ulRecordVideoWidth < 512 || ulRecordVideoWidth > 2048 || ulRecordVideoWidth % 2)
     821    {
     822        LogError("VBoxHeadless: ERROR: please specify an even video frame width between 512 and 2048", 0);
    823823        return 1;
    824824    }
    825     if (ulCaptureVideoHeight < 384 || ulCaptureVideoHeight > 1536 || ulCaptureVideoHeight % 2)
    826     {
    827         LogError("VBoxHeadless: ERROR: please specify an even frame height between 384 and 1536", 0);
     825    if (ulRecordVideoHeight < 384 || ulRecordVideoHeight > 1536 || ulRecordVideoHeight % 2)
     826    {
     827        LogError("VBoxHeadless: ERROR: please specify an even video frame height between 384 and 1536", 0);
    828828        return 1;
    829829    }
    830     if (ulCaptureVideoRate < 300000 || ulCaptureVideoRate > 1000000)
    831     {
    832         LogError("VBoxHeadless: ERROR: please specify an even bitrate between 300000 and 1000000", 0);
     830    if (ulRecordVideoRate < 300000 || ulRecordVideoRate > 1000000)
     831    {
     832        LogError("VBoxHeadless: ERROR: please specify an even video bitrate between 300000 and 1000000", 0);
    833833        return 1;
    834834    }
    835835    /* Make sure we only have %d or %u (or none) in the file name specified */
    836     char *pcPercent = (char*)strchr(pszCaptureFileNameTemplate, '%');
     836    char *pcPercent = (char*)strchr(pszRecordFileNameTemplate, '%');
    837837    if (pcPercent != 0 && *(pcPercent + 1) != 'd' && *(pcPercent + 1) != 'u')
    838838    {
    839         LogError("VBoxHeadless: ERROR: Only %%d and %%u are allowed in the capture file name.", -1);
     839        LogError("VBoxHeadless: ERROR: Only %%d and %%u are allowed in the recording file name.", -1);
    840840        return 1;
    841841    }
    … …  
    843843    if (pcPercent != 0 && strchr(pcPercent + 1, '%') != 0)
    844844    {
    845         LogError("VBoxHeadless: ERROR: Only one format modifier is allowed in the capture file name.", -1);
     845        LogError("VBoxHeadless: ERROR: Only one format modifier is allowed in the recording file name.", -1);
    846846        return 1;
    847847    }
    848     RTStrPrintf(&szCaptureFileName[0], RTPATH_MAX, pszCaptureFileNameTemplate, RTProcSelf());
     848    RTStrPrintf(&szRecordFileName[0], RTPATH_MAX, pszRecordFileNameTemplate, RTProcSelf());
    849849#endif /* defined VBOX_WITH_VIDEOREC */
    850850
    … …  
    959959
    960960#ifdef VBOX_WITH_VIDEOREC
    961         if (fCaptureEnabled)
    962         {
    963             ComPtr<ICaptureSettings> captureSettings;
    964             CHECK_ERROR_BREAK(machine, COMGETTER(CaptureSettings)(captureSettings.asOutParam()));
    965             CHECK_ERROR_BREAK(captureSettings, COMSETTER(Enabled)(TRUE));
    966 
    967             SafeIfaceArray <ICaptureScreenSettings> saCaptureScreenScreens;
    968             CHECK_ERROR_BREAK(captureSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saCaptureScreenScreens)));
     961        if (fRecordEnabled)
     962        {
     963            ComPtr<IRecordSettings> RecordSettings;
     964            CHECK_ERROR_BREAK(machine, COMGETTER(RecordSettings)(RecordSettings.asOutParam()));
     965            CHECK_ERROR_BREAK(RecordSettings, COMSETTER(Enabled)(TRUE));
     966
     967            SafeIfaceArray <IRecordScreenSettings> saRecordScreenScreens;
     968            CHECK_ERROR_BREAK(RecordSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordScreenScreens)));
    969969
    970970            /* Note: For now all screens have the same configuration. */
    971             for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    972             {
    973                 CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(Enabled)(TRUE));
    974                 CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(FileName)(Bstr(szCaptureFileName).raw()));
    975                 CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(VideoWidth)(ulCaptureVideoWidth));
    976                 CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(VideoHeight)(ulCaptureVideoHeight));
    977                 CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(VideoRate)(ulCaptureVideoRate));
     971            for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     972            {
     973                CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Enabled)(TRUE));
     974                CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(FileName)(Bstr(szRecordFileName).raw()));
     975                CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoWidth)(ulRecordVideoWidth));
     976                CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoHeight)(ulRecordVideoHeight));
     977                CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoRate)(ulRecordVideoRate));
    978978            }
    979979        }
    … …  
    12281228
    12291229#ifdef VBOX_WITH_VIDEOREC
    1230         if (fCaptureEnabled)
     1230        if (fRecordEnabled)
    12311231        {
    12321232            if (!machine.isNull())
    12331233            {
    1234                 ComPtr<ICaptureSettings> captureSettings;
    1235                 CHECK_ERROR_BREAK(machine, COMGETTER(CaptureSettings)(captureSettings.asOutParam()));
    1236                 CHECK_ERROR_BREAK(captureSettings, COMSETTER(Enabled)(FALSE));
     1234                ComPtr<IRecordSettings> RecordSettings;
     1235                CHECK_ERROR_BREAK(machine, COMGETTER(RecordSettings)(RecordSettings.asOutParam()));
     1236                CHECK_ERROR_BREAK(RecordSettings, COMSETTER(Enabled)(FALSE));
    12371237            }
    12381238        }

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp

    r75251 r75341  
    18551855        }
    18561856#ifdef VBOX_WITH_VIDEOREC
    1857         else if (!strcmp(a->argv[1], "capture"))
     1857        else if (!strcmp(a->argv[1], "record"))
    18581858        {
    18591859            if (a->argc < 3)
    … …  
    18641864            }
    18651865
    1866             ComPtr<ICaptureSettings> captureSettings;
    1867             CHECK_ERROR_BREAK(machine, COMGETTER(CaptureSettings)(captureSettings.asOutParam()));
    1868 
    1869             SafeIfaceArray <ICaptureScreenSettings> saCaptureScreenScreens;
    1870             CHECK_ERROR_BREAK(captureSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saCaptureScreenScreens)));
     1866            ComPtr<IRecordSettings> RecordSettings;
     1867            CHECK_ERROR_BREAK(machine, COMGETTER(RecordSettings)(RecordSettings.asOutParam()));
     1868
     1869            SafeIfaceArray <IRecordScreenSettings> saRecordScreenScreens;
     1870            CHECK_ERROR_BREAK(RecordSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordScreenScreens)));
    18711871
    18721872            /* Note: For now all screens have the same configuration. */
    … …  
    18761876             *       kept to ensure backwards compatibility.
    18771877             */
    1878             if (!strcmp(a->argv[2], "enable"))
    1879             {
    1880                 CHECK_ERROR_RET(captureSettings, COMSETTER(Enabled)(TRUE), RTEXITCODE_FAILURE);
    1881             }
    1882             else if (!strcmp(a->argv[2], "disable"))
    1883             {
    1884                 CHECK_ERROR_RET(captureSettings, COMSETTER(Enabled)(FALSE), RTEXITCODE_FAILURE);
     1878            if (!strcmp(a->argv[2], "on"))
     1879            {
     1880                CHECK_ERROR_RET(RecordSettings, COMSETTER(Enabled)(TRUE), RTEXITCODE_FAILURE);
     1881            }
     1882            else if (!strcmp(a->argv[2], "off"))
     1883            {
     1884                CHECK_ERROR_RET(RecordSettings, COMSETTER(Enabled)(FALSE), RTEXITCODE_FAILURE);
    18851885            }
    18861886            else if (!strcmp(a->argv[2], "screens"))
    … …  
    19301930                }
    19311931
    1932                 for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    1933                     CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(Enabled)(saScreens[i]));
     1932                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     1933                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Enabled)(saScreens[i]));
    19341934            }
    19351935            else if (!strcmp(a->argv[2], "filename"))
    … …  
    19421942                }
    19431943
    1944                 for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    1945                     CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(FileName)(Bstr(a->argv[2]).raw()));
    1946             }
    1947             else if (   !strcmp(a->argv[2], "res")
    1948                      || !strcmp(a->argv[2], "resolution"))
     1944                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     1945                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(FileName)(Bstr(a->argv[2]).raw()));
     1946            }
     1947            else if (   !strcmp(a->argv[2], "videores")
     1948                     || !strcmp(a->argv[2], "videoresolution"))
    19491949            {
    19501950                if (a->argc != 5)
    … …  
    19721972                }
    19731973
    1974                 for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    1975                 {
    1976                     CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(VideoWidth)(uVal));
    1977                     CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(VideoHeight)(uVal));
     1974                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     1975                {
     1976                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoWidth)(uVal));
     1977                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoHeight)(uVal));
    19781978                }
    19791979            }
    … …  
    19961996                }
    19971997
    1998                 for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    1999                     CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(VideoRate)(uVal));
     1998                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     1999                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoRate)(uVal));
    20002000            }
    20012001            else if (!strcmp(a->argv[2], "videofps"))
    … …  
    20172017                }
    20182018
    2019                 for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    2020                     CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(VideoFPS)(uVal));
     2019                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     2020                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoFPS)(uVal));
    20212021            }
    20222022            else if (!strcmp(a->argv[2], "maxtime"))
    … …  
    20382038                }
    20392039
    2040                 for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    2041                     CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(MaxTime)(uVal));
     2040                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     2041                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(MaxTime)(uVal));
    20422042            }
    20432043            else if (!strcmp(a->argv[2], "maxfilesize"))
    … …  
    20592059                }
    20602060
    2061                 for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    2062                     CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(MaxFileSize)(uVal));
     2061                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     2062                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(MaxFileSize)(uVal));
    20632063            }
    20642064            else if (!strcmp(a->argv[2], "opts"))
    … …  
    20712071                }
    20722072
    2073                 for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    2074                     CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(Options)(Bstr(a->argv[3]).raw()));
     2073                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     2074                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Options)(Bstr(a->argv[3]).raw()));
    20752075            }
    20762076        }

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageHelp.cpp

    r75251 r75341  
    713713#endif
    714714#ifdef VBOX_WITH_VIDEOREC
    715                      "                            [--capture on|off]\n"
    716                      "                            [--capture screens all|<screen ID> [<screen ID> ...]]\n"
    717                      "                            [--capture filename <filename>]\n"
    718                      "                            [--capture resolution <width> <height>]\n"
    719                      "                            [--capture videorate <rate>]\n"
    720                      "                            [--capture videofps <fps>]\n"
    721                      "                            [--capture maxtime <ms>]\n"
    722                      "                            [--capture maxfilesize <MB>]\n"
    723                      "                            [--capture opts <key=value> [,<key=value> ...]]\n"
     715                     "                            [--record on|off]\n"
     716                     "                            [--record screens all|<screen ID> [<screen ID> ...]]\n"
     717                     "                            [--record filename <filename>]\n"
     718                     "                            [--record videores <width> <height>]\n"
     719                     "                            [--record videorate <rate>]\n"
     720                     "                            [--record videofps <fps>]\n"
     721                     "                            [--record maxtime <ms>]\n"
     722                     "                            [--record maxfilesize <MB>]\n"
     723                     "                            [--record opts <key=value> [,<key=value> ...]]\n"
    724724#endif
    725725                     "                            [--defaultfrontend default|<name>]\n"
    … …  
    832832                     "                            screenshotpng <file> [display] |\n"
    833833#ifdef VBOX_WITH_VIDEOREC
    834                      "                            capture on|off |\n"
    835                      "                            capture screens all|none|<screen>,[<screen>...] |\n"
    836                      "                            capture filename <file> |\n"
    837                      "                            capture resolution <width>x<height> |\n"
    838                      "                            capture videorate <rate> |\n"
    839                      "                            capture videofps <fps> |\n"
    840                      "                            capture maxtime <s> |\n"
    841                      "                            capture maxfilesize <MB> |\n"
     834                     "                            record on|off |\n"
     835                     "                            record screens all|none|<screen>,[<screen>...] |\n"
     836                     "                            record filename <file> |\n"
     837                     "                            record videores <width>x<height> |\n"
     838                     "                            record videorate <rate> |\n"
     839                     "                            record videofps <fps> |\n"
     840                     "                            record maxtime <s> |\n"
     841                     "                            record maxfilesize <MB> |\n"
    842842#endif /* VBOX_WITH_VIDEOREC */
    843843                     "                            setcredentials <username>\n"

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

    r75251 r75341  
    23792379# endif
    23802380
    2381         ComPtr<ICaptureSettings> captureSettings;
    2382         CHECK_ERROR_RET(machine, COMGETTER(CaptureSettings)(captureSettings.asOutParam()), rc);
    2383 
    2384         SafeIfaceArray <ICaptureScreenSettings> saCaptureScreenScreens;
    2385         CHECK_ERROR_RET(captureSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saCaptureScreenScreens)), rc);
     2381        ComPtr<IRecordSettings> RecordSettings;
     2382        CHECK_ERROR_RET(machine, COMGETTER(RecordSettings)(RecordSettings.asOutParam()), rc);
     2383
     2384        SafeIfaceArray <IRecordScreenSettings> saCaptureScreenScreens;
     2385        CHECK_ERROR_RET(RecordSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saCaptureScreenScreens)), rc);
    23862386
    23872387        /* For now all screens have the same configuration; so take screen 0 and work with that. */

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

    r75255 r75341  
    215215#endif
    216216#ifdef VBOX_WITH_VIDEOREC
    217     MODIFYVM_CAPTURE,
    218     MODIFYVM_CAPTURE_FEATURES,
    219     MODIFYVM_CAPTURE_SCREENS,
    220     MODIFYVM_CAPTURE_FILENAME,
    221     MODIFYVM_CAPTURE_WIDTH,
    222     MODIFYVM_CAPTURE_HEIGHT,
    223     MODIFYVM_CAPTURE_VIDEO_RES,
    224     MODIFYVM_CAPTURE_VIDEO_RATE,
    225     MODIFYVM_CAPTURE_VIDEO_FPS,
    226     MODIFYVM_CAPTURE_MAXTIME,
    227     MODIFYVM_CAPTURE_MAXSIZE,
    228     MODIFYVM_CAPTURE_OPTIONS,
     217    MODIFYVM_RECORD,
     218    MODIFYVM_RECORD_FEATURES,
     219    MODIFYVM_RECORD_SCREENS,
     220    MODIFYVM_RECORD_FILENAME,
     221    MODIFYVM_RECORD_VIDEO_WIDTH,
     222    MODIFYVM_RECORD_VIDEO_HEIGHT,
     223    MODIFYVM_RECORD_VIDEO_RES,
     224    MODIFYVM_RECORD_VIDEO_RATE,
     225    MODIFYVM_RECORD_VIDEO_FPS,
     226    MODIFYVM_RECORD_MAXTIME,
     227    MODIFYVM_RECORD_MAXSIZE,
     228    MODIFYVM_RECORD_OPTIONS,
    229229#endif
    230230    MODIFYVM_CHIPSET,
    … …  
    395395    { "--chipset",                  MODIFYVM_CHIPSET,                   RTGETOPT_REQ_STRING },
    396396#ifdef VBOX_WITH_VIDEOREC
    397     { "--capture",                  MODIFYVM_CAPTURE,                    RTGETOPT_REQ_BOOL_ONOFF },
    398     { "--capturescreens",           MODIFYVM_CAPTURE_SCREENS,            RTGETOPT_REQ_STRING },
    399     { "--capturefile",              MODIFYVM_CAPTURE_FILENAME,           RTGETOPT_REQ_STRING },
    400     { "--capturemaxtime",           MODIFYVM_CAPTURE_MAXTIME,            RTGETOPT_REQ_INT32  },
    401     { "--capturemaxsize",           MODIFYVM_CAPTURE_MAXSIZE,            RTGETOPT_REQ_INT32  },
    402     { "--captureopts",              MODIFYVM_CAPTURE_OPTIONS,            RTGETOPT_REQ_STRING },
    403     { "--captureoptions",           MODIFYVM_CAPTURE_OPTIONS,            RTGETOPT_REQ_STRING },
    404     { "--capturevideores",          MODIFYVM_CAPTURE_VIDEO_RES,          RTGETOPT_REQ_STRING },
    405     { "--capturevideorate",         MODIFYVM_CAPTURE_VIDEO_RATE,         RTGETOPT_REQ_UINT32 },
    406     { "--capturevideofps",          MODIFYVM_CAPTURE_VIDEO_FPS,          RTGETOPT_REQ_UINT32 },
     397    { "--record",                   MODIFYVM_RECORD,                    RTGETOPT_REQ_BOOL_ONOFF },
     398    { "--recordscreens",            MODIFYVM_RECORD_SCREENS,            RTGETOPT_REQ_STRING },
     399    { "--recordfile",               MODIFYVM_RECORD_FILENAME,           RTGETOPT_REQ_STRING },
     400    { "--recordmaxtime",            MODIFYVM_RECORD_MAXTIME,            RTGETOPT_REQ_INT32  },
     401    { "--recordmaxsize",            MODIFYVM_RECORD_MAXSIZE,            RTGETOPT_REQ_INT32  },
     402    { "--recordopts",               MODIFYVM_RECORD_OPTIONS,            RTGETOPT_REQ_STRING },
     403    { "--recordoptions",            MODIFYVM_RECORD_OPTIONS,            RTGETOPT_REQ_STRING },
     404    { "--recordvideores",           MODIFYVM_RECORD_VIDEO_RES,          RTGETOPT_REQ_STRING },
     405    { "--recordvideorate",          MODIFYVM_RECORD_VIDEO_RATE,         RTGETOPT_REQ_UINT32 },
     406    { "--recordvideofps",           MODIFYVM_RECORD_VIDEO_FPS,          RTGETOPT_REQ_UINT32 },
    407407#endif
    408408    { "--autostart-enabled",        MODIFYVM_AUTOSTART_ENABLED,         RTGETOPT_REQ_BOOL_ONOFF },
    … …  
    29282928            }
    29292929#ifdef VBOX_WITH_VIDEOREC
    2930             case MODIFYVM_CAPTURE:
     2930            case MODIFYVM_RECORD:
    29312931                RT_FALL_THROUGH();
    2932             case MODIFYVM_CAPTURE_SCREENS:
     2932            case MODIFYVM_RECORD_SCREENS:
    29332933                RT_FALL_THROUGH();
    2934             case MODIFYVM_CAPTURE_FILENAME:
     2934            case MODIFYVM_RECORD_FILENAME:
    29352935                RT_FALL_THROUGH();
    2936             case MODIFYVM_CAPTURE_WIDTH:
     2936            case MODIFYVM_RECORD_VIDEO_WIDTH:
    29372937                RT_FALL_THROUGH();
    2938             case MODIFYVM_CAPTURE_HEIGHT:
     2938            case MODIFYVM_RECORD_VIDEO_HEIGHT:
    29392939                RT_FALL_THROUGH();
    2940             case MODIFYVM_CAPTURE_VIDEO_RES:
     2940            case MODIFYVM_RECORD_VIDEO_RES:
    29412941                RT_FALL_THROUGH();
    2942             case MODIFYVM_CAPTURE_VIDEO_RATE:
     2942            case MODIFYVM_RECORD_VIDEO_RATE:
    29432943                RT_FALL_THROUGH();
    2944             case MODIFYVM_CAPTURE_VIDEO_FPS:
     2944            case MODIFYVM_RECORD_VIDEO_FPS:
    29452945                RT_FALL_THROUGH();
    2946             case MODIFYVM_CAPTURE_MAXTIME:
     2946            case MODIFYVM_RECORD_MAXTIME:
    29472947                RT_FALL_THROUGH();
    2948             case MODIFYVM_CAPTURE_MAXSIZE:
     2948            case MODIFYVM_RECORD_MAXSIZE:
    29492949                RT_FALL_THROUGH();
    2950             case MODIFYVM_CAPTURE_OPTIONS:
    2951             {
    2952                 ComPtr<ICaptureSettings> captureSettings;
    2953                 CHECK_ERROR_BREAK(machine, COMGETTER(CaptureSettings)(captureSettings.asOutParam()));
    2954                 SafeIfaceArray <ICaptureScreenSettings> saCaptureScreenScreens;
    2955                 CHECK_ERROR_BREAK(captureSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saCaptureScreenScreens)));
     2950            case MODIFYVM_RECORD_OPTIONS:
     2951            {
     2952                ComPtr<IRecordSettings> RecordSettings;
     2953                CHECK_ERROR_BREAK(machine, COMGETTER(RecordSettings)(RecordSettings.asOutParam()));
     2954                SafeIfaceArray <IRecordScreenSettings> saRecordScreenScreens;
     2955                CHECK_ERROR_BREAK(RecordSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordScreenScreens)));
    29562956
    29572957                switch (c)
    29582958                {
    2959                     case MODIFYVM_CAPTURE:
    2960                     {
    2961                         CHECK_ERROR(captureSettings, COMSETTER(Enabled)(ValueUnion.f));
     2959                    case MODIFYVM_RECORD:
     2960                    {
     2961                        CHECK_ERROR(RecordSettings, COMSETTER(Enabled)(ValueUnion.f));
    29622962                        break;
    29632963                    }
    2964                     case MODIFYVM_CAPTURE_SCREENS:
     2964                    case MODIFYVM_RECORD_SCREENS:
    29652965                    {
    29662966                        ULONG cMonitors = 64;
    … …  
    29742974                        }
    29752975
    2976                         if (cMonitors > saCaptureScreenScreens.size()) /* Paranoia. */
    2977                             cMonitors = (ULONG)saCaptureScreenScreens.size();
     2976                        if (cMonitors > saRecordScreenScreens.size()) /* Paranoia. */
     2977                            cMonitors = (ULONG)saRecordScreenScreens.size();
    29782978
    29792979                        for (size_t i = 0; i < cMonitors; ++i)
    2980                             CHECK_ERROR_BREAK(saCaptureScreenScreens[i], COMSETTER(Enabled)(screens[i]));
     2980                            CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Enabled)(screens[i]));
    29812981                        break;
    29822982                    }
    2983                     case MODIFYVM_CAPTURE_FILENAME:
     2983                    case MODIFYVM_RECORD_FILENAME:
    29842984                    {
    29852985                        Bstr bstr;
    … …  
    29982998                        }
    29992999
    3000                         for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    3001                             CHECK_ERROR(saCaptureScreenScreens[i], COMSETTER(FileName)(bstr.raw()));
     3000                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     3001                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(FileName)(bstr.raw()));
    30023002                        break;
    30033003                    }
    3004                     case MODIFYVM_CAPTURE_WIDTH:
    3005                     {
    3006                         for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    3007                             CHECK_ERROR(saCaptureScreenScreens[i], COMSETTER(VideoWidth)(ValueUnion.u32));
     3004                    case MODIFYVM_RECORD_VIDEO_WIDTH:
     3005                    {
     3006                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     3007                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoWidth)(ValueUnion.u32));
    30083008                        break;
    30093009                    }
    3010                     case MODIFYVM_CAPTURE_HEIGHT:
    3011                     {
    3012                         for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    3013                             CHECK_ERROR(saCaptureScreenScreens[i], COMSETTER(VideoHeight)(ValueUnion.u32));
     3010                    case MODIFYVM_RECORD_VIDEO_HEIGHT:
     3011                    {
     3012                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     3013                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoHeight)(ValueUnion.u32));
    30143014                        break;
    30153015                    }
    3016                     case MODIFYVM_CAPTURE_VIDEO_RES:
     3016                    case MODIFYVM_RECORD_VIDEO_RES:
    30173017                    {
    30183018                        uint32_t uWidth = 0;
    … …  
    30343034                        }
    30353035
    3036                         for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
     3036                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
    30373037                        {
    3038                             CHECK_ERROR(saCaptureScreenScreens[i], COMSETTER(VideoWidth)(uWidth));
    3039                             CHECK_ERROR(saCaptureScreenScreens[i], COMSETTER(VideoHeight)(uHeight));
     3038                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoWidth)(uWidth));
     3039                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoHeight)(uHeight));
    30403040                        }
    30413041                        break;
    30423042                    }
    3043                     case MODIFYVM_CAPTURE_VIDEO_RATE:
    3044                     {
    3045                         for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    3046                             CHECK_ERROR(saCaptureScreenScreens[i], COMSETTER(VideoRate)(ValueUnion.u32));
     3043                    case MODIFYVM_RECORD_VIDEO_RATE:
     3044                    {
     3045                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     3046                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoRate)(ValueUnion.u32));
    30473047                        break;
    30483048                    }
    3049                     case MODIFYVM_CAPTURE_VIDEO_FPS:
    3050                     {
    3051                         for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    3052                             CHECK_ERROR(saCaptureScreenScreens[i], COMSETTER(VideoFPS)(ValueUnion.u32));
     3049                    case MODIFYVM_RECORD_VIDEO_FPS:
     3050                    {
     3051                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     3052                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoFPS)(ValueUnion.u32));
    30533053                        break;
    30543054                    }
    3055                     case MODIFYVM_CAPTURE_MAXTIME:
    3056                     {
    3057                         for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    3058                             CHECK_ERROR(saCaptureScreenScreens[i], COMSETTER(MaxTime)(ValueUnion.u32));
     3055                    case MODIFYVM_RECORD_MAXTIME:
     3056                    {
     3057                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     3058                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(MaxTime)(ValueUnion.u32));
    30593059                        break;
    30603060                    }
    3061                     case MODIFYVM_CAPTURE_MAXSIZE:
    3062                     {
    3063                         for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    3064                             CHECK_ERROR(saCaptureScreenScreens[i], COMSETTER(MaxFileSize)(ValueUnion.u32));
     3061                    case MODIFYVM_RECORD_MAXSIZE:
     3062                    {
     3063                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     3064                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(MaxFileSize)(ValueUnion.u32));
    30653065                        break;
    30663066                    }
    3067                     case MODIFYVM_CAPTURE_OPTIONS:
     3067                    case MODIFYVM_RECORD_OPTIONS:
    30683068                    {
    30693069                        Bstr bstr(ValueUnion.psz);
    3070                         for (size_t i = 0; i < saCaptureScreenScreens.size(); ++i)
    3071                             CHECK_ERROR(saCaptureScreenScreens[i], COMSETTER(Options)(bstr.raw()));
     3070                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
     3071                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(Options)(bstr.raw()));
    30723072                        break;
    30733073                    }

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UIMainEventListener.cpp

    r75291 r75341  
    375375            break;
    376376        }
    377         case KVBoxEventType_OnCaptureChanged:
     377        case KVBoxEventType_OnRecordChanged:
    378378        {
    379379            emit sigRecordingChange();

  • trunk/src/VBox/Frontends/VirtualBox/src/manager/details/UIDetailsElements.cpp

    r75319 r75341  
    4444# include "CMediumAttachment.h"
    4545# include "CAudioAdapter.h"
    46 # include "CCaptureSettings.h"
    47 # include "CCaptureScreenSettings.h"
     46# include "CRecordSettings.h"
     47# include "CRecordScreenSettings.h"
    4848# include "CNetworkAdapter.h"
    4949# include "CSerialPort.h"
    … …  
    450450
    451451        /* Recording info: */
    452         CCaptureSettings comRecordingSettings = machine.GetCaptureSettings();
     452        CRecordSettings comRecordingSettings = machine.GetRecordSettings();
    453453        if (comRecordingSettings.GetEnabled())
    454454        {
    455455            /* For now all screens have the same config: */
    456             CCaptureScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
     456            CRecordScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
    457457
    458458            /** @todo r=andy Refine these texts (wrt audio and/or video). */

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIConsoleEventHandler.cpp

    r75291 r75341  
    188188        << KVBoxEventType_OnVRDEServerChanged
    189189        << KVBoxEventType_OnVRDEServerInfoChanged
    190         << KVBoxEventType_OnCaptureChanged
     190        << KVBoxEventType_OnRecordChanged
    191191        << KVBoxEventType_OnUSBControllerChanged
    192192        << KVBoxEventType_OnUSBDeviceStateChanged

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIIndicatorsPool.cpp

    r75319 r75341  
    4343/* COM includes: */
    4444# include "CAudioAdapter.h"
    45 # include "CCaptureSettings.h"
    46 # include "CCaptureScreenSettings.h"
     45# include "CRecordSettings.h"
     46# include "CRecordScreenSettings.h"
    4747# include "CConsole.h"
    4848# include "CMachine.h"
    … …  
    884884
    885885        /* Update indicator state early: */
    886         CCaptureSettings comRecordingSettings = comMachine.GetCaptureSettings();
     886        CRecordSettings comRecordingSettings = comMachine.GetRecordSettings();
    887887        Assert(comRecordingSettings.isOk());
    888888        if (!comRecordingSettings.GetEnabled())
    … …  
    918918
    919919                /* For now all screens have the same config: */
    920                 CCaptureScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
     920                CRecordScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
    921921                Assert(comRecordingScreen0Settings.isOk());
    922922
    … …  
    943943    void setRotationAngle(double dRotationAngle) { m_dRotationAngle = dRotationAngle; update(); }
    944944
    945     /* Parses CaptureScreenSettings::Options and updates m_enmRecordingMode accordingly. */
     945    /* Parses RecordScreenSettings::Options and updates m_enmRecordingMode accordingly. */
    946946    void updateRecordingMode()
    947947    {
    … …  
    955955            return;
    956956
    957         CCaptureSettings comRecordingSettings = comMachine.GetCaptureSettings();
     957        CRecordSettings comRecordingSettings = comMachine.GetRecordSettings();
    958958        /* For now all screens have the same config: */
    959         CCaptureScreenSettings recordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
    960         if (recordingScreen0Settings.IsFeatureEnabled(KCaptureFeature_Video))
     959        CRecordScreenSettings recordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
     960        if (recordingScreen0Settings.IsFeatureEnabled(KRecordFeature_Video))
    961961            m_enmRecordingMode = (UIIndicatorStateRecordingMode)((int)m_enmRecordingMode | (int)UIIndicatorStateRecordingMode_Video);
    962962
    963         if (recordingScreen0Settings.IsFeatureEnabled(KCaptureFeature_Audio))
     963        if (recordingScreen0Settings.IsFeatureEnabled(KRecordFeature_Audio))
    964964            m_enmRecordingMode = (UIIndicatorStateRecordingMode)((int)m_enmRecordingMode | (int)UIIndicatorStateRecordingMode_Audio);
    965965    }

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineLogic.cpp

    r75319 r75341  
    7777/* COM includes: */
    7878# include "CAudioAdapter.h"
    79 # include "CCaptureSettings.h"
     79# include "CRecordSettings.h"
    8080# include "CVirtualBoxErrorInfo.h"
    8181# include "CMachineDebugger.h"
    … …  
    21042104
    21052105    /* Make sure something had changed: */
    2106     CCaptureSettings comRecordingSettings = machine().GetCaptureSettings();
     2106    CRecordSettings comRecordingSettings = machine().GetRecordSettings();
    21072107    if (comRecordingSettings.GetEnabled() == static_cast<BOOL>(fEnabled))
    21082108        return;

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp

    r75319 r75341  
    6060/* COM includes: */
    6161# include "CAudioAdapter.h"
    62 # include "CCaptureSettings.h"
     62# include "CRecordSettings.h"
    6363# include "CSystemProperties.h"
    6464# include "CStorageController.h"
    … …  
    724724void UISession::sltRecordingChange()
    725725{
    726     CCaptureSettings comRecordingSettings = machine().GetCaptureSettings();
     726    CRecordSettings comRecordingSettings = machine().GetRecordSettings();
    727727
    728728    /* Check/Uncheck Capture action depending on feature status: */

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.cpp

    r75324 r75341  
    3131
    3232/* COM includes: */
    33 # include "CCaptureSettings.h"
    34 # include "CCaptureScreenSettings.h"
     33# include "CRecordSettings.h"
     34# include "CRecordScreenSettings.h"
    3535# include "CExtPack.h"
    3636# include "CExtPackManager.h"
    … …  
    383383
    384384    /* Gather old 'Recording' data: */
    385     CCaptureSettings recordingSettings = m_machine.GetCaptureSettings();
     385    CRecordSettings recordingSettings = m_machine.GetRecordSettings();
    386386    Assert(recordingSettings.isNotNull());
    387387    oldDisplayData.m_fRecordingEnabled = recordingSettings.GetEnabled();
    388388
    389389    /* For now we're using the same settings for all screens; so get settings from screen 0 and work with that. */
    390     CCaptureScreenSettings recordingScreen0Settings = recordingSettings.GetScreenSettings(0);
     390    CRecordScreenSettings recordingScreen0Settings = recordingSettings.GetScreenSettings(0);
    391391    if (!recordingScreen0Settings.isNull())
    392392    {
    … …  
    400400    }
    401401
    402     CCaptureScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
     402    CRecordScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
    403403    oldDisplayData.m_vecRecordingScreens.resize(recordingScreenSettingsVector.size());
    404404    for (int iScreenIndex = 0; iScreenIndex < recordingScreenSettingsVector.size(); ++iScreenIndex)
    405405    {
    406         CCaptureScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
     406        CRecordScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
    407407        if (!recordingScreenSettings.isNull())
    408408            oldDisplayData.m_vecRecordingScreens[iScreenIndex] = recordingScreenSettings.GetEnabled();
    … …  
    15111511        const UIDataSettingsMachineDisplay &newDisplayData = m_pCache->data();
    15121512
    1513         CCaptureSettings recordingSettings = m_machine.GetCaptureSettings();
     1513        CRecordSettings recordingSettings = m_machine.GetRecordSettings();
    15141514        Assert(recordingSettings.isNotNull());
    15151515
    … …  
    15331533                if (fSuccess)
    15341534                {
    1535                     CCaptureScreenSettingsVector captureScreenSettingsVector = recordingSettings.GetScreens();
    1536                     for (int iScreenIndex = 0; fSuccess && iScreenIndex < captureScreenSettingsVector.size(); ++iScreenIndex)
     1535                    CRecordScreenSettingsVector RecordScreenSettingsVector = recordingSettings.GetScreens();
     1536                    for (int iScreenIndex = 0; fSuccess && iScreenIndex < RecordScreenSettingsVector.size(); ++iScreenIndex)
    15371537                    {
    15381538                        if (newDisplayData.m_vecRecordingScreens[iScreenIndex] == oldDisplayData.m_vecRecordingScreens[iScreenIndex])
    15391539                            continue;
    15401540
    1541                         CCaptureScreenSettings recordingScreenSettings = captureScreenSettingsVector.at(iScreenIndex);
     1541                        CRecordScreenSettings recordingScreenSettings = RecordScreenSettingsVector.at(iScreenIndex);
    15421542                        recordingScreenSettings.SetEnabled(newDisplayData.m_vecRecordingScreens[iScreenIndex]);
    15431543                        fSuccess = recordingScreenSettings.isOk();
    … …  
    15481548            else
    15491549            {
    1550                 CCaptureScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
     1550                CRecordScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
    15511551                for (int iScreenIndex = 0; fSuccess && iScreenIndex < recordingScreenSettingsVector.size(); ++iScreenIndex)
    15521552                {
    … …  
    15541554                        continue;
    15551555
    1556                     CCaptureScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
     1556                    CRecordScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
    15571557
    15581558                    // We should save all the options *before* 'Recording' activation.
    … …  
    16231623        else
    16241624        {
    1625             CCaptureScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
     1625            CRecordScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
    16261626            for (int iScreenIndex = 0; fSuccess && iScreenIndex < recordingScreenSettingsVector.size(); ++iScreenIndex)
    16271627            {
    … …  
    16291629                    continue;
    16301630
    1631                 CCaptureScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
     1631                CRecordScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
    16321632
    16331633                /* Save recording file path: */

  • trunk/src/VBox/Frontends/VirtualBox/src/snapshots/UISnapshotDetailsWidget.cpp

    r75319 r75341  
    4848/* COM includes: */
    4949# include "CAudioAdapter.h"
    50 # include "CCaptureSettings.h"
    51 # include "CCaptureScreenSettings.h"
     50# include "CRecordSettings.h"
     51# include "CRecordScreenSettings.h"
    5252# include "CMachine.h"
    5353# include "CMedium.h"
    … …  
    17481748    QStringList aReport;
    17491749    /* Acquire recording status: */
    1750     CCaptureSettings comRecordingSettings = comMachine.GetCaptureSettings();
     1750    CRecordSettings comRecordingSettings = comMachine.GetRecordSettings();
    17511751    /* For now all screens have the same config: */
    1752     CCaptureScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
     1752    CRecordScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
    17531753    if (comRecordingScreen0Settings.GetEnabled())
    17541754    {

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

    r75261 r75341  
    457457        src-server/BandwidthGroupImpl.cpp \
    458458        src-server/BIOSSettingsImpl.cpp \
    459         src-server/CaptureSettingsImpl.cpp \
    460         src-server/CaptureScreenSettingsImpl.cpp \
     459        src-server/RecordSettingsImpl.cpp \
     460        src-server/RecordScreenSettingsImpl.cpp \
    461461        src-server/ClientWatcher.cpp \
    462462        src-server/ClientToken.cpp \

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

    r75326 r75341  
    46904690
    46914691  <enum
    4692     name="CaptureDestination"
    4693     uuid="E54603A9-6751-4255-93F8-C69E61693391"
     4692    name="RecordDestination"
     4693    uuid="F52E217E-CA05-41BA-8851-0FA38B3BA38B"
    46944694    >
    46954695    <desc>
    4696       Capturing destination enumeration.
     4696      Recording destination enumeration.
    46974697    </desc>
    46984698
    … …  
    47064706
    47074707  <enum
    4708     name="CaptureFeature"
    4709     uuid="F606CDDB-91B2-4E41-9DFE-4713D4DBA96F"
     4708    name="RecordFeature"
     4709    uuid="52AEC901-4EF5-4E04-8CA3-EF1478BB0930"
    47104710    >
    47114711    <desc>
    4712       Capturing features enumeration.
     4712      Recording features enumeration.
    47134713    </desc>
    47144714
    … …  
    47174717    </const>
    47184718    <const name="Video"                 value="1">
    4719       <desc>Video capturing.</desc>
     4719      <desc>Video recording.</desc>
    47204720    </const>
    47214721    <const name="Audio"                 value="2">
    4722       <desc>Audio capturing.</desc>
     4722      <desc>Audio recording.</desc>
    47234723    </const>
    47244724  </enum>
    47254725
    47264726  <enum
    4727     name="CaptureAudioCodec"
    4728     uuid="9B80C37F-7984-412C-A755-C18FE5859554"
     4727    name="RecordAudioCodec"
     4728    uuid="B72DD288-0D3F-4652-AE66-D6F621D2F275"
    47294729    >
    47304730    <desc>
    4731       Capturing audio codec enumeration.
     4731      Recording audio codec enumeration.
    47324732    </desc>
    47334733
    … …  
    47454745
    47464746  <enum
    4747     name="CaptureVideoCodec"
    4748     uuid="98BBC021-E119-497D-8C66-4336D539A8D6"
     4747    name="RecordVideoCodec"
     4748    uuid="823F3AD4-151F-4BDB-AFF9-F7C998E46105"
    47494749    >
    47504750    <desc>
    4751       Capturing video codec enumeration.
     4751      Recording video codec enumeration.
    47524752    </desc>
    47534753
    … …  
    47674767
    47684768  <enum
    4769     name="CaptureVideoScalingMethod"
    4770     uuid="8315399B-4F31-416E-970E-D7480BDA1ACF"
     4769    name="RecordVideoScalingMethod"
     4770    uuid="8D656085-BAE6-4F63-86F9-616776EB3773"
    47714771    >
    47724772    <desc>
    4773       Capturing video scaling method enumeration.
     4773      Recording video scaling method enumeration.
    47744774    </desc>
    47754775
    … …  
    47924792
    47934793  <enum
    4794     name="CaptureVideoRateControlMode"
    4795     uuid="5D392E29-04EC-4FD7-989C-82452F54414C"
     4794    name="RecordVideoRateControlMode"
     4795    uuid="11F99274-835F-4F2C-86A5-F8DF8999C21A"
    47964796    >
    47974797    <desc>
    4798       Capturing video rate control mode enumeration.
     4798      Recording video rate control mode enumeration.
    47994799    </desc>
    48004800
    … …  
    48084808
    48094809  <interface
    4810     name="ICaptureScreenSettings" extends="$unknown"
    4811     uuid="B19FFA8A-686C-4221-AB29-3C1FA33946CA"
     4810    name="IRecordScreenSettings" extends="$unknown"
     4811    uuid="7811A5C6-11DB-4F9A-8FAE-1CE238AB4B73"
    48124812    wsmap="managed"
    48134813    >
    48144814
    48154815    <desc>
    4816       The ICaptureScreenSettings interface represents capturing settings of a
    4817       single virtual screen. This is used only in the <link to="ICaptureSettings" />
     4816      The IRecordScreenSettings interface represents recording settings of a
     4817      single virtual screen. This is used only in the <link to="IRecordSettings" />
    48184818      interface.
    48194819    </desc>
    48204820
    48214821    <method name="isFeatureEnabled">
    4822       <desc>Returns whether a particular capturing feature is enabled for this
     4822      <desc>Returns whether a particular recording feature is enabled for this
    48234823        screen or not.</desc>
    4824       <param name="feature" type="CaptureFeature" dir="in">
     4824      <param name="feature" type="RecordFeature" dir="in">
    48254825        <desc>Feature to check for.</desc>
    48264826      </param>
    … …  
    48384838    <attribute name="enabled" type="boolean" default="false">
    48394839      <desc>
    4840         This setting determines whether this screen is enabled while capturing.
     4840        This setting determines whether this screen is enabled while recording.
    48414841      </desc>
    48424842    </attribute>
    48434843
    48444844    <attribute name="features" type="unsigned long">
    4845       <desc>This setting determines all enabled capturing features for this
     4845      <desc>This setting determines all enabled recording features for this
    48464846        screen.</desc>
    48474847    </attribute>
    48484848
    4849     <attribute name="destination" type="CaptureDestination">
    4850       <desc>This setting determines the capturing destination for this
     4849    <attribute name="destination" type="RecordDestination">
     4850      <desc>This setting determines the recording destination for this
    48514851        screen.</desc>
    48524852    </attribute>
    … …  
    48564856        This setting determines the filename VirtualBox uses to save
    48574857        the recorded content. This setting cannot be changed while video
    4858         capturing is enabled.
     4858        recording is enabled.
    48594859        <note>
    48604860          When setting this attribute, the specified path has to be
    … …  
    48684868      <desc>
    48694869        This setting defines the maximum amount of time in milliseconds
    4870         to capture. Capturing will stop as soon as the defined time
    4871         interval has elapsed. If this value is zero, capturing will not be
    4872         limited by time. This setting cannot be changed while capturing is
     4870        to record. Recording will stop as soon as the defined time
     4871        interval has elapsed. If this value is zero, recording will not be
     4872        limited by time. This setting cannot be changed while recording is
    48734873        enabled.
    48744874      </desc>
    … …  
    48774877    <attribute name="maxFileSize" type="unsigned long" default="0">
    48784878      <desc>
    4879         This setting determines the maximal number of captured file
    4880         size in MB. Capturing will stop as soon as the file size has
    4881         reached the defined value. If this value is zero, capturing
     4879        This setting determines the maximal number of recording file
     4880        size in MB. Recording will stop as soon as the file size has
     4881        reached the defined value. If this value is zero, recording
    48824882        will not be limited by the file size. This setting cannot be changed
    4883         while capturing is enabled.
     4883        while recording is enabled.
    48844884      </desc>
    48854885    </attribute>
    … …  
    48874887    <attribute name="options" type="wstring">
    48884888      <desc>
    4889         This setting contains any additional capturing options
     4889        This setting contains any additional recording options
    48904890        required in comma-separated key=value format. This setting
    4891         cannot be changed while capturing is enabled.
     4891        cannot be changed while recording is enabled.
    48924892
    48934893        The following keys and their corresponding values are available:
    … …  
    49064906    </attribute>
    49074907
    4908     <attribute name="audioCodec" type="CaptureAudioCodec">
     4908    <attribute name="audioCodec" type="RecordAudioCodec">
    49094909      <desc>
    49104910        Determines the audio codec to use for encoding the
    4911         recorded audio data. This setting cannot be changed while capturing is
     4911        recorded audio data. This setting cannot be changed while recording is
    49124912        enabled.
    49134913      </desc>
    … …  
    49174917      <desc>
    49184918        Determines the Hertz (Hz) rate of the recorded audio data. This setting
    4919         cannot be changed while capturing is enabled.
     4919        cannot be changed while recording is enabled.
    49204920      </desc>
    49214921    </attribute>
    … …  
    49244924      <desc>
    49254925        Determines the bits per sample of the recorded audio data. This setting
    4926         cannot be changed while capturing is enabled.
     4926        cannot be changed while recording is enabled.
    49274927      </desc>
    49284928    </attribute>
    … …  
    49334933        Specifiy 2 for stereo or 1 for mono. More than stereo (2) channels
    49344934        are not supported at the moment. This setting cannot be changed while
    4935         capturing is enabled.
    4936       </desc>
    4937     </attribute>
    4938 
    4939     <attribute name="videoCodec" type="CaptureVideoCodec">
     4935        recording is enabled.
     4936      </desc>
     4937    </attribute>
     4938
     4939    <attribute name="videoCodec" type="RecordVideoCodec">
    49404940      <desc>
    49414941        Determines the video codec to use for encoding the recorded video data.
    4942         This setting cannot be changed while capturing is enabled.
     4942        This setting cannot be changed while recording is enabled.
    49434943      </desc>
    49444944    </attribute>
    … …  
    49474947      <desc>
    49484948        Determines the horizontal resolution of the recorded video data. This
    4949         setting cannot be changed while capturing is enabled.
     4949        setting cannot be changed while recording is enabled.
    49504950      </desc>
    49514951    </attribute>
    … …  
    49544954      <desc>
    49554955        Determines the vertical resolution of the recorded video data. This
    4956         setting cannot be changed while capturing is enabled.
     4956        setting cannot be changed while recording is enabled.
    49574957      </desc>
    49584958    </attribute>
    … …  
    49624962        Determines the bitrate in kilobits per second. Increasing this value
    49634963        makes the video look better for the cost of an increased file size or
    4964         transfer rate. This setting cannot be changed while capturing is enabled.
    4965       </desc>
    4966     </attribute>
    4967 
    4968     <attribute name="videoRateControlMode" type="CaptureVideoRateControlMode">
     4964        transfer rate. This setting cannot be changed while recording is enabled.
     4965      </desc>
     4966    </attribute>
     4967
     4968    <attribute name="videoRateControlMode" type="RecordVideoRateControlMode">
    49694969      <desc>
    49704970        Determines the rate control mode. This setting cannot be changed
    4971         while capturing is enabled.
     4971        while recording is enabled.
    49724972      </desc>
    49734973    </attribute>
    … …  
    49784978        a higher frequency will be skipped. Reducing this value increases the
    49794979        number of skipped frames and reduces the file size or transfer rate.
    4980         This setting cannot be changed while capturing is enabled.
    4981       </desc>
    4982     </attribute>
    4983 
    4984     <attribute name="videoScalingMethod" type="CaptureVideoScalingMethod">
     4980        This setting cannot be changed while recording is enabled.
     4981      </desc>
     4982    </attribute>
     4983
     4984    <attribute name="videoScalingMethod" type="RecordVideoScalingMethod">
    49854985      <desc>
    49864986        Determines the video scaling method to use.
    4987         This setting cannot be changed while capturing is enabled.
     4987        This setting cannot be changed while recording is enabled.
    49884988      </desc>
    49894989    </attribute>
    … …  
    49924992
    49934993  <interface
    4994     name="ICaptureSettings" extends="$unknown"
    4995     uuid="F35B5C06-F6F0-475D-908A-F5FECC820043"
     4994    name="IRecordSettings" extends="$unknown"
     4995    uuid="7202BACF-2BFE-46AA-AEF6-69B32FDDE236"
    49964996    wsmap="managed"
    49974997    >
    49984998
    49994999    <desc>
    5000       The ICaptureSettings interface represents capturing settings of the virtual
    5001       machine. This is used only in the <link to="IMachine::captureSettings" />
     5000      The IRecordSettings interface represents recording settings of the virtual
     5001      machine. This is used only in the <link to="IMachine::recordSettings" />
    50025002      attribute.
    50035003    </desc>
    50045004
    50055005    <method name="getScreenSettings">
    5006       <desc>Returns the capturing settings for a particular screen.</desc>
     5006      <desc>Returns the recording settings for a particular screen.</desc>
    50075007      <param name="screenId" type="unsigned long" dir="in">
    5008         <desc>Screen ID to retrieve capturing screen settings for.</desc>
    5009       </param>
    5010       <param name="captureScreenSettings" type="ICaptureScreenSettings" dir="return">
    5011         <desc>Capturing screen settings for the requested screen.</desc>
     5008        <desc>Screen ID to retrieve recording screen settings for.</desc>
     5009      </param>
     5010      <param name="recordScreenSettings" type="IRecordScreenSettings" dir="return">
     5011        <desc>Recording screen settings for the requested screen.</desc>
    50125012      </param>
    50135013    </method>
    … …  
    50155015    <attribute name="enabled" type="boolean" default="false">
    50165016      <desc>
    5017         This setting determines whether VirtualBox uses capturing to record a
     5017        This setting determines whether VirtualBox uses recording to record a
    50185018        VM session.</desc>
    50195019    </attribute>
    50205020
    5021     <attribute name="screens" type="ICaptureScreenSettings" readonly="yes" safearray="yes">
    5022       <desc>
    5023         This setting returns an array for capturing settings of all configured
     5021    <attribute name="screens" type="IRecordScreenSettings" readonly="yes" safearray="yes">
     5022      <desc>
     5023        This setting returns an array for recording settings of all configured
    50245024        virtual screens.</desc>
    50255025    </attribute>
    … …  
    52215221  <interface
    52225222    name="IMachine" extends="$unknown"
    5223     uuid="316A9802-03A5-44BE-B2A6-51261A021353"
     5223    uuid="7210DD84-2301-4C3B-8DB3-72DEBD3B91F9"
    52245224    wsmap="managed"
    52255225    wrap-hint-server-addinterfaces="IInternalMachineControl"
    … …  
    55065506    </attribute>
    55075507
    5508     <attribute name="captureSettings" type="ICaptureSettings" readonly="yes">
    5509       <desc>Object containing all capturing settings.</desc>
     5508    <attribute name="recordSettings" type="IRecordSettings" readonly="yes">
     5509      <desc>Object containing all recording settings.</desc>
    55105510    </attribute>
    55115511
    … …  
    2065220652  <interface
    2065320653    name="IInternalSessionControl" extends="$unknown"
    20654     uuid="96BDA9B7-92E6-402F-AA8C-2E77818DAE6E"
     20654    uuid="5CEB7885-5DD5-48E4-96C1-EEF4F4FD9FAC"
    2065520655    internal="yes"
    2065620656    wsmap="suppress"
    … …  
    2095220952    </method>
    2095320953
    20954     <method name="onCaptureChange">
    20955       <desc>
    20956         Triggered when capture settings have changed.
     20954    <method name="onRecordChange">
     20955      <desc>
     20956        Triggered when recording settings have changed.
    2095720957      </desc>
    2095820958    </method>
    … …  
    2313623136      </desc>
    2313723137    </const>
    23138     <const name="OnCaptureChanged" value="91">
    23139       <desc>
    23140         See <link to="ICaptureChangedEvent">ICapturedChangeEvent</link>.
     23138    <const name="OnRecordChanged" value="91">
     23139      <desc>
     23140        See <link to="IRecordChangedEvent">IRecordChangeEvent</link>.
    2314123141      </desc>
    2314223142    </const>
    … …  
    2452324523
    2452424524  <interface
    24525     name="ICaptureChangedEvent" extends="IEvent"
    24526     uuid="C694687C-F432-4435-B457-F2E55B845C81"
    24527     wsmap="managed" autogen="VBoxEvent" id="OnCaptureChanged"
     24525    name="IRecordChangedEvent" extends="IEvent"
     24526    uuid="DA51AA0C-E642-4AA0-9DDD-B07E2911188B"
     24527    wsmap="managed" autogen="VBoxEvent" id="OnRecordChanged"
    2452824528    >
    2452924529    <desc>
    24530       Notification when capture settings have changed.
     24530      Notification when recording settings have changed.
    2453124531    </desc>
    2453224532    <attribute name="midlDoesNotLikeEmptyInterfaces" readonly="yes" type="boolean"/>

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

    r75287 r75341  
    145145    void i_videoRecDestroy(void);
    146146    int i_videoRecEnable(BOOL fEnable, util::AutoWriteLock *pAutoLock);
    147     int i_videoRecGetSettings(settings::CaptureSettings &Settings);
     147    int i_videoRecGetSettings(settings::RecordSettings &Settings);
    148148    int i_videoRecStart(void);
    149149    int i_videoRecStop(void);
    … …  
    179179    HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
    180180    HRESULT i_onVRDEServerChange(BOOL aRestart);
    181     HRESULT i_onCaptureChange();
     181    HRESULT i_onRecordChange();
    182182    HRESULT i_onUSBControllerChange();
    183183    HRESULT i_onSharedFolderChange(BOOL aGlobal);

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

    r75254 r75341  
    4545public:
    4646
    47     int applyConfiguration(const settings::CaptureSettings &Settings);
     47    int applyConfiguration(const settings::RecordSettings &Settings);
    4848
    4949public:
    … …  
    6161    struct DRVAUDIOVIDEOREC         *mpDrv;
    6262    /** Capturing configuration used for configuring the driver. */
    63     struct settings::CaptureSettings mVideoRecCfg;
     63    struct settings::RecordSettings mVideoRecCfg;
    6464};
    6565

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

    r75324 r75341  
    3232#include "ParallelPortImpl.h"
    3333#include "BIOSSettingsImpl.h"
    34 #include "CaptureSettingsImpl.h"
     34#include "RecordSettingsImpl.h"
    3535#include "StorageControllerImpl.h"          // required for MachineImpl.h to compile on Windows
    3636#include "USBControllerImpl.h"              // required for MachineImpl.h to compile on Windows
    … …  
    266266        GraphicsControllerType_T mGraphicsControllerType;
    267267        ULONG               mVRAMSize;
    268         settings::CaptureSettings mCaptureSettings;
     268        settings::RecordSettings mRecordSettings;
    269269        ULONG               mMonitorCount;
    270270        BOOL                mHWVirtExEnabled;
    … …  
    477477        IsModified_Snapshots            = 0x0800,
    478478        IsModified_BandwidthControl     = 0x1000,
    479         IsModified_Capture              = 0x2000
     479        IsModified_Record               = 0x2000
    480480    };
    481481
    … …  
    524524    virtual HRESULT i_onStorageDeviceChange(IMediumAttachment * /* mediumAttachment */, BOOL /* remove */,
    525525                                            BOOL /* silent */) { return S_OK; }
    526     virtual HRESULT i_onCaptureChange() { return S_OK; }
     526    virtual HRESULT i_onRecordChange() { return S_OK; }
    527527
    528528    HRESULT i_saveRegistryEntry(settings::MachineRegistryEntry &data);
    … …  
    777777    const ComObjPtr<USBDeviceFilters>  mUSBDeviceFilters;
    778778    const ComObjPtr<BIOSSettings>      mBIOSSettings;
    779     const ComObjPtr<CaptureSettings>   mCaptureSettings;
     779    const ComObjPtr<RecordSettings>    mRecordSettings;
    780780    const ComObjPtr<BandwidthControl>  mBandwidthControl;
    781781
    … …  
    825825
    826826    friend class Appliance;
    827     friend class CaptureSettings;
    828     friend class CaptureScreenSettings;
     827    friend class RecordSettings;
     828    friend class RecordScreenSettings;
    829829    friend class SessionMachine;
    830830    friend class SnapshotMachine;
    … …  
    880880    HRESULT setMonitorCount(ULONG aMonitorCount);
    881881    HRESULT getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings);
    882     HRESULT getCaptureSettings(ComPtr<ICaptureSettings> &aCaptureSettings);
     882    HRESULT getRecordSettings(ComPtr<IRecordSettings> &aRecordSettings);
    883883    HRESULT getFirmwareType(FirmwareType_T *aFirmwareType);
    884884    HRESULT setFirmwareType(FirmwareType_T aFirmwareType);
    … …  
    13261326    HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
    13271327    HRESULT i_onVRDEServerChange(BOOL aRestart);
    1328     HRESULT i_onCaptureChange();
     1328    HRESULT i_onRecordChange();
    13291329    HRESULT i_onUSBControllerChange();
    13301330    HRESULT i_onUSBDeviceAttach(IUSBDevice *aDevice,

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

    r75340 r75341  
    1818 */
    1919
    20 #ifndef ____H_CAPTURESCREENSETTINGS
    21 #define ____H_CAPTURESCREENSETTINGS
     20#ifndef ____H_RecordScreenSettings
     21#define ____H_RecordScreenSettings
    2222
    23 #include "CaptureScreenSettingsWrap.h"
     23#include "RecordScreenSettingsWrap.h"
    2424
    25 class CaptureSettings;
     25class RecordSettings;
    2626
    2727namespace settings
    2828{
    29     struct CaptureScreenSettings;
     29    struct RecordScreenSettings;
    3030}
    3131
    32 class ATL_NO_VTABLE CaptureScreenSettings :
    33     public CaptureScreenSettingsWrap
     32class ATL_NO_VTABLE RecordScreenSettings :
     33    public RecordScreenSettingsWrap
    3434{
    3535public:
    3636
    37     DECLARE_EMPTY_CTOR_DTOR(CaptureScreenSettings)
     37    DECLARE_EMPTY_CTOR_DTOR(RecordScreenSettings)
    3838
    3939    HRESULT FinalConstruct();
    … …  
    4141
    4242    // public initializer/uninitializer for internal purposes only
    43     HRESULT init(CaptureSettings *aParent, uint32_t uScreenId, const settings::CaptureScreenSettings& data);
    44     HRESULT init(CaptureSettings *aParent, CaptureScreenSettings *that);
    45     HRESULT initCopy(CaptureSettings *aParent, CaptureScreenSettings *that);
     43    HRESULT init(RecordSettings *aParent, uint32_t uScreenId, const settings::RecordScreenSettings& data);
     44    HRESULT init(RecordSettings *aParent, RecordScreenSettings *that);
     45    HRESULT initCopy(RecordSettings *aParent, RecordScreenSettings *that);
    4646    void uninit();
    4747
    4848    // public methods only for internal purposes
    49     HRESULT i_loadSettings(const settings::CaptureScreenSettings &data);
    50     HRESULT i_saveSettings(settings::CaptureScreenSettings &data);
     49    HRESULT i_loadSettings(const settings::RecordScreenSettings &data);
     50    HRESULT i_saveSettings(settings::RecordScreenSettings &data);
    5151
    5252    void i_rollback();
    5353    void i_commit();
    54     void i_copyFrom(CaptureScreenSettings *aThat);
     54    void i_copyFrom(RecordScreenSettings *aThat);
    5555    void i_applyDefaults();
    5656
    5757private:
    5858
    59     // wrapped ICaptureScreenSettings methods
    60     HRESULT isFeatureEnabled(CaptureFeature_T aFeature, BOOL *aEnabled);
     59    // wrapped IRecordScreenSettings methods
     60    HRESULT isFeatureEnabled(RecordFeature_T aFeature, BOOL *aEnabled);
    6161
    62     // wrapped ICaptureScreenSettings properties
     62    // wrapped IRecordScreenSettings properties
    6363    HRESULT getId(ULONG *id);
    6464    HRESULT getEnabled(BOOL *enabled);
    … …  
    6666    HRESULT getFeatures(ULONG *aFeatures);
    6767    HRESULT setFeatures(ULONG aFeatures);
    68     HRESULT getDestination(CaptureDestination_T *aDestination);
    69     HRESULT setDestination(CaptureDestination_T aDestination);
     68    HRESULT getDestination(RecordDestination_T *aDestination);
     69    HRESULT setDestination(RecordDestination_T aDestination);
    7070
    7171    HRESULT getFileName(com::Utf8Str &aFileName);
    … …  
    7878    HRESULT setOptions(const com::Utf8Str &aOptions);
    7979
    80     HRESULT getAudioCodec(CaptureAudioCodec_T *aCodec);
    81     HRESULT setAudioCodec(CaptureAudioCodec_T aCodec);
     80    HRESULT getAudioCodec(RecordAudioCodec_T *aCodec);
     81    HRESULT setAudioCodec(RecordAudioCodec_T aCodec);
    8282    HRESULT getAudioHz(ULONG *aHz);
    8383    HRESULT setAudioHz(ULONG aHz);
    … …  
    8787    HRESULT setAudioChannels(ULONG aChannels);
    8888
    89     HRESULT getVideoCodec(CaptureVideoCodec_T *aCodec);
    90     HRESULT setVideoCodec(CaptureVideoCodec_T aCodec);
     89    HRESULT getVideoCodec(RecordVideoCodec_T *aCodec);
     90    HRESULT setVideoCodec(RecordVideoCodec_T aCodec);
    9191    HRESULT getVideoWidth(ULONG *aVideoWidth);
    9292    HRESULT setVideoWidth(ULONG aVideoWidth);
    … …  
    9595    HRESULT getVideoRate(ULONG *aVideoRate);
    9696    HRESULT setVideoRate(ULONG aVideoRate);
    97     HRESULT getVideoRateControlMode(CaptureVideoRateControlMode_T *aMode);
    98     HRESULT setVideoRateControlMode(CaptureVideoRateControlMode_T aMode);
     97    HRESULT getVideoRateControlMode(RecordVideoRateControlMode_T *aMode);
     98    HRESULT setVideoRateControlMode(RecordVideoRateControlMode_T aMode);
    9999    HRESULT getVideoFPS(ULONG *aVideoFPS);
    100100    HRESULT setVideoFPS(ULONG aVideoFPS);
    101     HRESULT getVideoScalingMethod(CaptureVideoScalingMethod_T *aMode);
    102     HRESULT setVideoScalingMethod(CaptureVideoScalingMethod_T aMode);
     101    HRESULT getVideoScalingMethod(RecordVideoScalingMethod_T *aMode);
     102    HRESULT setVideoScalingMethod(RecordVideoScalingMethod_T aMode);
    103103
    104104private:
    … …  
    113113};
    114114
    115 #endif // ____H_CAPTURESCREENSETTINGS
     115#endif // ____H_RecordScreenSettings
    116116

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

    r75340 r75341  
    1818 */
    1919
    20 #ifndef ____H_CAPTURESETTINGS
    21 #define ____H_CAPTURESETTINGS
     20#ifndef ____H_RecordSettings
     21#define ____H_RecordSettings
    2222
    23 #include "CaptureSettingsWrap.h"
     23#include "RecordSettingsWrap.h"
    2424
    2525namespace settings
    2626{
    27     struct CaptureSettings;
    28     struct CaptureScreenSettings;
     27    struct RecordSettings;
     28    struct RecordScreenSettings;
    2929}
    3030
    31 class CaptureScreenSettings;
     31class RecordScreenSettings;
    3232
    33 class ATL_NO_VTABLE CaptureSettings :
    34     public CaptureSettingsWrap
     33class ATL_NO_VTABLE RecordSettings :
     34    public RecordSettingsWrap
    3535{
    3636public:
    3737
    38     DECLARE_EMPTY_CTOR_DTOR(CaptureSettings)
     38    DECLARE_EMPTY_CTOR_DTOR(RecordSettings)
    3939
    4040    HRESULT FinalConstruct();
    … …  
    4343    // public initializer/uninitializer for internal purposes only
    4444    HRESULT init(Machine *parent);
    45     HRESULT init(Machine *parent, CaptureSettings *that);
    46     HRESULT initCopy(Machine *parent, CaptureSettings *that);
     45    HRESULT init(Machine *parent, RecordSettings *that);
     46    HRESULT initCopy(Machine *parent, RecordSettings *that);
    4747    void uninit();
    4848
    4949    // public methods only for internal purposes
    50     HRESULT i_loadSettings(const settings::CaptureSettings &data);
    51     HRESULT i_saveSettings(settings::CaptureSettings &data);
     50    HRESULT i_loadSettings(const settings::RecordSettings &data);
     51    HRESULT i_saveSettings(settings::RecordSettings &data);
    5252
    5353    void i_rollback();
    5454    void i_commit();
    55     void i_copyFrom(CaptureSettings *aThat);
     55    void i_copyFrom(RecordSettings *aThat);
    5656    void i_applyDefaults(void);
    5757
    … …  
    6363
    6464    /** Map of screen settings objects. The key specifies the screen ID. */
    65     typedef std::map <uint32_t, ComObjPtr<CaptureScreenSettings> > CaptureScreenSettingsMap;
     65    typedef std::map <uint32_t, ComObjPtr<RecordScreenSettings> > RecordScreenSettingsMap;
    6666
    6767    void i_reset(void);
    6868    int i_syncToMachineDisplays(void);
    69     int i_createScreenObj(CaptureScreenSettingsMap &screenSettingsMap, uint32_t uScreenId, const settings::CaptureScreenSettings &data);
    70     int i_destroyScreenObj(CaptureScreenSettingsMap &screenSettingsMap, uint32_t uScreenId);
    71     int i_destroyAllScreenObj(CaptureScreenSettingsMap &screenSettingsMap);
     69    int i_createScreenObj(RecordScreenSettingsMap &screenSettingsMap, uint32_t uScreenId, const settings::RecordScreenSettings &data);
     70    int i_destroyScreenObj(RecordScreenSettingsMap &screenSettingsMap, uint32_t uScreenId);
     71    int i_destroyAllScreenObj(RecordScreenSettingsMap &screenSettingsMap);
    7272
    7373private:
    7474
    75     // wrapped ICaptureSettings properties
     75    // wrapped IRecordSettings properties
    7676    HRESULT getEnabled(BOOL *enabled);
    7777    HRESULT setEnabled(BOOL enable);
    78     HRESULT getScreens(std::vector<ComPtr<ICaptureScreenSettings> > &aCaptureScreenSettings);
     78    HRESULT getScreens(std::vector<ComPtr<IRecordScreenSettings> > &aRecordScreenSettings);
    7979
    80     // wrapped ICaptureSettings methods
    81     HRESULT getScreenSettings(ULONG uScreenId, ComPtr<ICaptureScreenSettings> &aCaptureScreenSettings);
     80    // wrapped IRecordSettings methods
     81    HRESULT getScreenSettings(ULONG uScreenId, ComPtr<IRecordScreenSettings> &aRecordScreenSettings);
    8282
    8383private:
    … …  
    8686    Data *m;
    8787};
    88 #endif // ____H_CAPTURESETTINGS
     88#endif // ____H_RecordSettings
    8989

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

    r75251 r75341  
    102102    HRESULT onCPUExecutionCapChange(ULONG aExecutionCap);
    103103    HRESULT onVRDEServerChange(BOOL aRestart);
    104     HRESULT onCaptureChange();
     104    HRESULT onRecordChange();
    105105    HRESULT onUSBControllerChange();
    106106    HRESULT onSharedFolderChange(BOOL aGlobal);

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

    r75313 r75341  
    4141    CaptureContext(Console *pConsole);
    4242
    43     CaptureContext(Console *pConsole, const settings::CaptureSettings &a_Settings);
     43    CaptureContext(Console *pConsole, const settings::RecordSettings &a_Settings);
    4444
    4545    virtual ~CaptureContext(void);
    … …  
    4747public:
    4848
    49     const settings::CaptureSettings &GetConfig(void) const;
     49    const settings::RecordSettings &GetConfig(void) const;
    5050    CaptureStream *GetStream(unsigned uScreen) const;
    5151    size_t GetStreamCount(void) const;
    5252
    53     int Create(const settings::CaptureSettings &a_Settings);
     53    int Create(const settings::RecordSettings &a_Settings);
    5454    int Destroy(void);
    5555
    … …  
    6464public:
    6565
    66     bool IsFeatureEnabled(CaptureFeature_T enmFeature) const;
     66    bool IsFeatureEnabled(RecordFeature_T enmFeature) const;
    6767    bool IsReady(void) const;
    6868    bool IsReady(uint32_t uScreen, uint64_t uTimeStampMs) const;
    … …  
    7272protected:
    7373
    74     int createInternal(const settings::CaptureSettings &a_Settings);
     74    int createInternal(const settings::RecordSettings &a_Settings);
    7575    int startInternal(void);
    7676    int stopInternal(void);
    … …  
    104104    Console                  *pConsole;
    105105    /** Used recording configuration. */
    106     settings::CaptureSettings Settings;
     106    settings::RecordSettings Settings;
    107107    /** The current state. */
    108108    VIDEORECSTS               enmState;

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

    r75313 r75341  
    111111    CaptureStream(CaptureContext *pCtx);
    112112
    113     CaptureStream(CaptureContext *pCtx, uint32_t uScreen, const settings::CaptureScreenSettings &Settings);
     113    CaptureStream(CaptureContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings);
    114114
    115115    virtual ~CaptureStream(void);
    … …  
    117117public:
    118118
    119     int Init(CaptureContext *pCtx, uint32_t uScreen, const settings::CaptureScreenSettings &Settings);
     119    int Init(CaptureContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings);
    120120    int Uninit(void);
    121121
    … …  
    124124                       uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, uint64_t uTimeStampMs);
    125125
    126     const settings::CaptureScreenSettings &GetConfig(void) const;
     126    const settings::RecordScreenSettings &GetConfig(void) const;
    127127    bool IsLimitReached(uint64_t tsNowMs) const;
    128128    bool IsReady(void) const;
    … …  
    130130protected:
    131131
    132     int open(const settings::CaptureScreenSettings &Settings);
     132    int open(const settings::RecordScreenSettings &Settings);
    133133    int close(void);
    134134
    135     int initInternal(CaptureContext *pCtx, uint32_t uScreen, const settings::CaptureScreenSettings &Settings);
     135    int initInternal(CaptureContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings);
    136136    int uninitInternal(void);
    137137
    … …  
    205205    } Video;
    206206
    207     settings::CaptureScreenSettings ScreenSettings;
     207    settings::RecordScreenSettings ScreenSettings;
    208208    /** Common set of video recording (data) blocks, needed for
    209209     *  multiplexing to all recording streams. */

  • trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

    r75313 r75341  
    56325632# ifdef VBOX_WITH_AUDIO_VIDEOREC
    56335633                    /* Attach the video recording audio driver if required. */
    5634                     if (   Capture.mpVideoRecCtx->IsFeatureEnabled(CaptureFeature_Audio)
     5634                    if (   Capture.mpVideoRecCtx->IsFeatureEnabled(RecordFeature_Audio)
    56355635                        && Capture.mAudioVideoRec)
    56365636                    {
    … …  
    56675667#endif /* VBOX_WITH_VIDEOREC */
    56685668
    5669 HRESULT Console::i_onCaptureChange()
     5669HRESULT Console::i_onRecordChange()
    56705670{
    56715671    AutoCaller autoCaller(this);
    … …  
    56805680    if (ptrVM.isOk())
    56815681    {
    5682         ComPtr<ICaptureSettings> CaptureSettings;
    5683         rc = mMachine->COMGETTER(CaptureSettings)(CaptureSettings.asOutParam());
     5682        ComPtr<IRecordSettings> RecordSettings;
     5683        rc = mMachine->COMGETTER(RecordSettings)(RecordSettings.asOutParam());
    56845684        AssertComRCReturnRC(rc);
    56855685
    56865686        BOOL fEnabled;
    5687         rc = CaptureSettings->COMGETTER(Enabled)(&fEnabled);
     5687        rc = RecordSettings->COMGETTER(Enabled)(&fEnabled);
    56885688        AssertComRCReturnRC(rc);
    56895689
    … …  
    56925692        {
    56935693            alock.release();
    5694             fireCaptureChangedEvent(mEventSource);
     5694            fireRecordChangedEvent(mEventSource);
    56955695        }
    56965696
    … …  
    68826882
    68836883    if (   Capture.mpVideoRecCtx->IsStarted()
    6884         && Capture.mpVideoRecCtx->IsFeatureEnabled(CaptureFeature_Audio))
     6884        && Capture.mpVideoRecCtx->IsFeatureEnabled(RecordFeature_Audio))
    68856885    {
    68866886        return Capture.mpVideoRecCtx->SendAudioFrame(pvData, cbData, uTimestampMs);
    … …  
    68926892
    68936893#ifdef VBOX_WITH_VIDEOREC
    6894 int Console::i_videoRecGetSettings(settings::CaptureSettings &Settings)
     6894int Console::i_videoRecGetSettings(settings::RecordSettings &Settings)
    68956895{
    68966896    Assert(mMachine.isNotNull());
    … …  
    68986898    Settings.applyDefaults();
    68996899
    6900     ComPtr<ICaptureSettings> pCaptureSettings;
    6901     HRESULT hrc = mMachine->COMGETTER(CaptureSettings)(pCaptureSettings.asOutParam());
     6900    ComPtr<IRecordSettings> pRecordSettings;
     6901    HRESULT hrc = mMachine->COMGETTER(RecordSettings)(pRecordSettings.asOutParam());
    69026902    AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    69036903
    69046904    BOOL fTemp;
    6905     hrc = pCaptureSettings->COMGETTER(Enabled)(&fTemp);
     6905    hrc = pRecordSettings->COMGETTER(Enabled)(&fTemp);
    69066906    AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    69076907    Settings.fEnabled = RT_BOOL(fTemp);
    69086908
    6909     SafeIfaceArray<ICaptureScreenSettings> paCaptureScreens;
    6910     hrc = pCaptureSettings->COMGETTER(Screens)(ComSafeArrayAsOutParam(paCaptureScreens));
     6909    SafeIfaceArray<IRecordScreenSettings> paCaptureScreens;
     6910    hrc = pRecordSettings->COMGETTER(Screens)(ComSafeArrayAsOutParam(paCaptureScreens));
    69116911    AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    69126912
    69136913    for (unsigned long i = 0; i < (unsigned long)paCaptureScreens.size(); ++i)
    69146914    {
    6915         settings::CaptureScreenSettings CaptureScreenSettings;
    6916         ComPtr<ICaptureScreenSettings> pCaptureScreenSettings = paCaptureScreens[i];
    6917 
    6918         hrc = pCaptureScreenSettings->COMGETTER(Enabled)(&fTemp);
     6915        settings::RecordScreenSettings RecordScreenSettings;
     6916        ComPtr<IRecordScreenSettings> pRecordScreenSettings = paCaptureScreens[i];
     6917
     6918        hrc = pRecordScreenSettings->COMGETTER(Enabled)(&fTemp);
    69196919        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    6920         CaptureScreenSettings.fEnabled = RT_BOOL(fTemp);
    6921         hrc = pCaptureScreenSettings->COMGETTER(MaxTime)((ULONG *)&CaptureScreenSettings.ulMaxTimeS);
     6920        RecordScreenSettings.fEnabled = RT_BOOL(fTemp);
     6921        hrc = pRecordScreenSettings->COMGETTER(MaxTime)((ULONG *)&RecordScreenSettings.ulMaxTimeS);
    69226922        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    6923         hrc = pCaptureScreenSettings->COMGETTER(MaxFileSize)((ULONG *)&CaptureScreenSettings.File.ulMaxSizeMB);
     6923        hrc = pRecordScreenSettings->COMGETTER(MaxFileSize)((ULONG *)&RecordScreenSettings.File.ulMaxSizeMB);
    69246924        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    69256925        Bstr bstrTemp;
    6926         hrc = pCaptureScreenSettings->COMGETTER(FileName)(bstrTemp.asOutParam());
     6926        hrc = pRecordScreenSettings->COMGETTER(FileName)(bstrTemp.asOutParam());
    69276927        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    6928         CaptureScreenSettings.File.strName = bstrTemp;
    6929         hrc = pCaptureScreenSettings->COMGETTER(Options)(bstrTemp.asOutParam());
     6928        RecordScreenSettings.File.strName = bstrTemp;
     6929        hrc = pRecordScreenSettings->COMGETTER(Options)(bstrTemp.asOutParam());
    69306930        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    6931         CaptureScreenSettings.strOptions = bstrTemp;
    6932         hrc = pCaptureScreenSettings->COMGETTER(VideoWidth)((ULONG *)&CaptureScreenSettings.Video.ulWidth);
     6931        RecordScreenSettings.strOptions = bstrTemp;
     6932        hrc = pRecordScreenSettings->COMGETTER(VideoWidth)((ULONG *)&RecordScreenSettings.Video.ulWidth);
    69336933        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    6934         hrc = pCaptureScreenSettings->COMGETTER(VideoHeight)((ULONG *)&CaptureScreenSettings.Video.ulHeight);
     6934        hrc = pRecordScreenSettings->COMGETTER(VideoHeight)((ULONG *)&RecordScreenSettings.Video.ulHeight);
    69356935        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    6936         hrc = pCaptureScreenSettings->COMGETTER(VideoRate)((ULONG *)&CaptureScreenSettings.Video.ulRate);
     6936        hrc = pRecordScreenSettings->COMGETTER(VideoRate)((ULONG *)&RecordScreenSettings.Video.ulRate);
    69376937        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    6938         hrc = pCaptureScreenSettings->COMGETTER(VideoFPS)((ULONG *)&CaptureScreenSettings.Video.ulFPS);
     6938        hrc = pRecordScreenSettings->COMGETTER(VideoFPS)((ULONG *)&RecordScreenSettings.Video.ulFPS);
    69396939        AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
    69406940
    6941         Settings.mapScreens[i] = CaptureScreenSettings;
     6941        Settings.mapScreens[i] = RecordScreenSettings;
    69426942    }
    69436943
    … …  
    69716971    }
    69726972
    6973     settings::CaptureSettings Settings;
     6973    settings::RecordSettings Settings;
    69746974    rc = i_videoRecGetSettings(Settings);
    69756975    if (RT_SUCCESS(rc))
    … …  
    70437043            mDisplay->i_videoRecScreenChanged(uScreen);
    70447044
    7045         ComPtr<ICaptureSettings> pCaptureSettings;
    7046         HRESULT hrc = mMachine->COMGETTER(CaptureSettings)(pCaptureSettings.asOutParam());
     7045        ComPtr<IRecordSettings> pRecordSettings;
     7046        HRESULT hrc = mMachine->COMGETTER(RecordSettings)(pRecordSettings.asOutParam());
    70477047        ComAssertComRC(hrc);
    7048         hrc = pCaptureSettings->COMSETTER(Enabled)(false);
     7048        hrc = pRecordSettings->COMSETTER(Enabled)(false);
    70497049        ComAssertComRC(hrc);
    70507050
    … …  
    1014610146
    1014710147#ifdef VBOX_WITH_VIDEOREC
    10148         ComPtr<ICaptureSettings> CaptureSettings;
    10149         rc = pConsole->mMachine->COMGETTER(CaptureSettings)(CaptureSettings.asOutParam());
     10148        ComPtr<IRecordSettings> RecordSettings;
     10149        rc = pConsole->mMachine->COMGETTER(RecordSettings)(RecordSettings.asOutParam());
    1015010150        AssertComRCReturnVoid(rc);
    1015110151
    1015210152        BOOL fCaptureEnabled;
    10153         rc = CaptureSettings->COMGETTER(Enabled)(&fCaptureEnabled);
     10153        rc = RecordSettings->COMGETTER(Enabled)(&fCaptureEnabled);
    1015410154        AssertComRCReturnVoid(rc);
    1015510155
    … …  
    1015910159            if (RT_SUCCESS(vrc2))
    1016010160            {
    10161                 fireCaptureChangedEvent(pConsole->mEventSource);
     10161                fireRecordChangedEvent(pConsole->mEventSource);
    1016210162            }
    1016310163            else

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

    r75251 r75341  
    33933393    if (   pCtx
    33943394        && pCtx->IsStarted()
    3395         && pCtx->IsFeatureEnabled(CaptureFeature_Video))
     3395        && pCtx->IsFeatureEnabled(RecordFeature_Video))
    33963396    {
    33973397        do {
    … …  
    38593859    if (   pCtx
    38603860        && pCtx->IsStarted()
    3861         && pCtx->IsFeatureEnabled(CaptureFeature_Video))
     3861        && pCtx->IsFeatureEnabled(RecordFeature_Video))
    38623862    {
    38633863        int rc2 = pCtx->SendVideoFrame(uScreen, x, y,

  • trunk/src/VBox/Main/src-client/DrvAudioVideoRec.cpp

    r75254 r75341  
    10881088 * @param   Settings        Capturing configuration to apply.
    10891089 */
    1090 int AudioVideoRec::applyConfiguration(const settings::CaptureSettings &Settings)
     1090int AudioVideoRec::applyConfiguration(const settings::RecordSettings &Settings)
    10911091{
    10921092    /** @todo Do some validation here. */
    … …  
    11081108    /** @todo For now we're using the configuration of the first screen here audio-wise. */
    11091109    Assert(mVideoRecCfg.mapScreens.size() >= 1);
    1110     const settings::CaptureScreenSettings &Screen0Settings = mVideoRecCfg.mapScreens[0];
     1110    const settings::RecordScreenSettings &Screen0Settings = mVideoRecCfg.mapScreens[0];
    11111111
    11121112    rc = CFGMR3InsertInteger(pLunCfg, "ContainerType", (uint64_t)Screen0Settings.enmDest);
    11131113    AssertRCReturn(rc, rc);
    1114     if (Screen0Settings.enmDest == CaptureDestination_File)
     1114    if (Screen0Settings.enmDest == RecordDestination_File)
    11151115    {
    11161116        rc = CFGMR3InsertString(pLunCfg, "ContainerFileName", Utf8Str(Screen0Settings.File.strName).c_str());

  • trunk/src/VBox/Main/src-client/SessionImpl.cpp

    r75251 r75341  
    725725}
    726726
    727 HRESULT Session::onCaptureChange()
    728 {
    729     LogFlowThisFunc(("\n"));
    730 
    731     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    732     AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
    733     AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
    734 #ifndef VBOX_COM_INPROC_API_CLIENT
    735     AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    736 
    737     return mConsole->i_onCaptureChange();
     727HRESULT Session::onRecordChange()
     728{
     729    LogFlowThisFunc(("\n"));
     730
     731    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     732    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
     733    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
     734#ifndef VBOX_COM_INPROC_API_CLIENT
     735    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
     736
     737    return mConsole->i_onRecordChange();
    738738#else
    739739    return S_OK;

  • trunk/src/VBox/Main/src-client/VideoRec.cpp

    r75313 r75341  
    9494    , enmState(VIDEORECSTS_UNINITIALIZED) { }
    9595
    96 CaptureContext::CaptureContext(Console *a_pConsole, const settings::CaptureSettings &a_Settings)
     96CaptureContext::CaptureContext(Console *a_pConsole, const settings::RecordSettings &a_Settings)
    9797    : pConsole(a_pConsole)
    9898    , enmState(VIDEORECSTS_UNINITIALIZED)
    … …  
    177177 * @param   a_Settings          Capture settings to use for context creation.
    178178 */
    179 int CaptureContext::createInternal(const settings::CaptureSettings &a_Settings)
     179int CaptureContext::createInternal(const settings::RecordSettings &a_Settings)
    180180{
    181181    int rc = RTCritSectInit(&this->CritSect);
    … …  
    183183        return rc;
    184184
    185     settings::CaptureScreenMap::const_iterator itScreen = a_Settings.mapScreens.begin();
     185    settings::RecordScreenMap::const_iterator itScreen = a_Settings.mapScreens.begin();
    186186    while (itScreen != a_Settings.mapScreens.end())
    187187    {
    … …  
    318318}
    319319
    320 const settings::CaptureSettings &CaptureContext::GetConfig(void) const
     320const settings::RecordSettings &CaptureContext::GetConfig(void) const
    321321{
    322322    return this->Settings;
    … …  
    355355}
    356356
    357 int CaptureContext::Create(const settings::CaptureSettings &a_Settings)
     357int CaptureContext::Create(const settings::RecordSettings &a_Settings)
    358358{
    359359    return createInternal(a_Settings);
    … …  
    375375}
    376376
    377 bool CaptureContext::IsFeatureEnabled(CaptureFeature_T enmFeature) const
     377bool CaptureContext::IsFeatureEnabled(RecordFeature_T enmFeature) const
    378378{
    379379    VideoRecStreams::const_iterator itStream = this->vecStreams.begin();

  • trunk/src/VBox/Main/src-client/VideoRecStream.cpp

    r75313 r75341  
    5151}
    5252
    53 CaptureStream::CaptureStream(CaptureContext *a_pCtx, uint32_t uScreen, const settings::CaptureScreenSettings &Settings)
     53CaptureStream::CaptureStream(CaptureContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings)
    5454    : enmState(RECORDINGSTREAMSTATE_UNINITIALIZED)
    5555    , tsStartMs(0)
    … …  
    7474 * @returns IPRT status code.
    7575 */
    76 int CaptureStream::open(const settings::CaptureScreenSettings &Settings)
     76int CaptureStream::open(const settings::RecordScreenSettings &Settings)
    7777{
    7878    /* Sanity. */
    79     Assert(Settings.enmDest != CaptureDestination_None);
     79    Assert(Settings.enmDest != RecordDestination_None);
    8080
    8181    int rc;
    … …  
    8383    switch (Settings.enmDest)
    8484    {
    85         case CaptureDestination_File:
     85        case RecordDestination_File:
    8686        {
    8787            Assert(Settings.File.strName.isNotEmpty());
    … …  
    209209            if (value.compare("false", Utf8Str::CaseInsensitive) == 0)
    210210            {
    211                 this->ScreenSettings.featureMap[CaptureFeature_Video] = false;
     211                this->ScreenSettings.featureMap[RecordFeature_Video] = false;
    212212#ifdef VBOX_WITH_AUDIO_VIDEOREC
    213213                LogRel(("VideoRec: Only audio will be recorded\n"));
    … …  
    220220            if (value.compare("true", Utf8Str::CaseInsensitive) == 0)
    221221            {
    222                 this->ScreenSettings.featureMap[CaptureFeature_Audio] = true;
     222                this->ScreenSettings.featureMap[RecordFeature_Audio] = true;
    223223            }
    224224            else
    … …  
    255255}
    256256
    257 const settings::CaptureScreenSettings &CaptureStream::GetConfig(void) const
     257const settings::RecordScreenSettings &CaptureStream::GetConfig(void) const
    258258{
    259259    return this->ScreenSettings;
    … …  
    277277    }
    278278
    279     if (this->ScreenSettings.enmDest == CaptureDestination_File)
     279    if (this->ScreenSettings.enmDest == RecordDestination_File)
    280280    {
    281281
    … …  
    661661 * @param   Settings            Capturing configuration to use for initialization.
    662662 */
    663 int CaptureStream::Init(CaptureContext *a_pCtx, uint32_t uScreen, const settings::CaptureScreenSettings &Settings)
     663int CaptureStream::Init(CaptureContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings)
    664664{
    665665    return initInternal(a_pCtx, uScreen, Settings);
    … …  
    674674 * @param   Settings            Capturing configuration to use for initialization.
    675675 */
    676 int CaptureStream::initInternal(CaptureContext *a_pCtx, uint32_t uScreen, const settings::CaptureScreenSettings &Settings)
     676int CaptureStream::initInternal(CaptureContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings)
    677677{
    678678    int rc = parseOptionsString(Settings.strOptions);
    … …  
    688688        return rc;
    689689
    690     const bool fVideoEnabled = Settings.isFeatureEnabled(CaptureFeature_Video);
    691     const bool fAudioEnabled = Settings.isFeatureEnabled(CaptureFeature_Audio);
     690    const bool fVideoEnabled = Settings.isFeatureEnabled(RecordFeature_Video);
     691    const bool fAudioEnabled = Settings.isFeatureEnabled(RecordFeature_Audio);
    692692
    693693    if (fVideoEnabled)
    … …  
    699699    switch (this->ScreenSettings.enmDest)
    700700    {
    701         case CaptureDestination_File:
     701        case RecordDestination_File:
    702702        {
    703703            const char *pszFile = this->ScreenSettings.File.strName.c_str();
    … …  
    706706            rc = File.pWEBM->OpenEx(pszFile, &this->File.hFile,
    707707#ifdef VBOX_WITH_AUDIO_VIDEOREC
    708                                       Settings.isFeatureEnabled(CaptureFeature_Audio)
     708                                      Settings.isFeatureEnabled(RecordFeature_Audio)
    709709                                    ? WebMWriter::AudioCodec_Opus : WebMWriter::AudioCodec_None,
    710710#else
    711711                                      WebMWriter::AudioCodec_None,
    712712#endif
    713                                       Settings.isFeatureEnabled(CaptureFeature_Video)
     713                                      Settings.isFeatureEnabled(RecordFeature_Video)
    714714                                    ? WebMWriter::VideoCodec_VP8 : WebMWriter::VideoCodec_None);
    715715            if (RT_FAILURE(rc))
    … …  
    814814        switch (this->ScreenSettings.enmDest)
    815815        {
    816             case CaptureDestination_File:
     816            case RecordDestination_File:
    817817            {
    818818                if (this->File.pWEBM)
    … …  
    839839    switch (this->ScreenSettings.enmDest)
    840840    {
    841         case CaptureDestination_File:
     841        case RecordDestination_File:
    842842        {
    843843            if (RTFileIsValid(this->File.hFile))
    … …  
    891891        return rc;
    892892
    893     if (this->ScreenSettings.isFeatureEnabled(CaptureFeature_Video))
     893    if (this->ScreenSettings.isFeatureEnabled(RecordFeature_Video))
    894894    {
    895895        int rc2 = unitVideo();
    … …  
    10251025{
    10261026#ifdef VBOX_WITH_AUDIO_VIDEOREC
    1027     if (this->ScreenSettings.isFeatureEnabled(CaptureFeature_Audio))
     1027    if (this->ScreenSettings.isFeatureEnabled(RecordFeature_Audio))
    10281028    {
    10291029        /* Sanity. */

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

    r75251 r75341  
    358358        mBIOSSettings->i_applyDefaults(aOsType);
    359359
    360         /* Apply capture defaults. */
    361         mCaptureSettings->i_applyDefaults();
     360        /* Apply record defaults. */
     361        mRecordSettings->i_applyDefaults();
    362362
    363363        /* Apply network adapters defaults */
    … …  
    19401940}
    19411941
    1942 HRESULT Machine::getCaptureSettings(ComPtr<ICaptureSettings> &aCaptureSettings)
    1943 {
    1944     /* mCaptureSettings is constant during life time, no need to lock */
    1945     aCaptureSettings = mCaptureSettings;
     1942HRESULT Machine::getRecordSettings(ComPtr<IRecordSettings> &aRecordSettings)
     1943{
     1944    /* mRecordSettings is constant during life time, no need to lock */
     1945    aRecordSettings = mRecordSettings;
    19461946
    19471947    return S_OK;
    … …  
    82598259    mBIOSSettings->init(this);
    82608260
    8261     /* create associated capture settings object */
    8262     unconst(mCaptureSettings).createObject();
    8263     mCaptureSettings->init(this);
     8261    /* create associated record settings object */
     8262    unconst(mRecordSettings).createObject();
     8263    mRecordSettings->init(this);
    82648264
    82658265    /* create an associated VRDE object (default is disabled) */
    … …  
    83788378    }
    83798379
    8380     if (mCaptureSettings)
    8381     {
    8382         mCaptureSettings->uninit();
    8383         unconst(mCaptureSettings).setNull();
     8380    if (mRecordSettings)
     8381    {
     8382        mRecordSettings->uninit();
     8383        unconst(mRecordSettings).setNull();
    83848384    }
    83858385
    … …  
    88988898        if (FAILED(rc)) return rc;
    88998899
    8900         /* Capture settings */
    8901         rc = mCaptureSettings->i_loadSettings(data.captureSettings);
     8900        /* Record settings */
     8901        rc = mRecordSettings->i_loadSettings(data.recordSettings);
    89028902        if (FAILED(rc)) return rc;
    89038903
    … …  
    1021710217        if (FAILED(rc)) throw rc;
    1021810218
    10219         /* Capture settings (required) */
    10220         rc = mCaptureSettings->i_saveSettings(data.captureSettings);
     10219        /* Record settings (required) */
     10220        rc = mRecordSettings->i_saveSettings(data.recordSettings);
    1022110221        if (FAILED(rc)) throw rc;
    1022210222
    … …  
    1172311723        mBIOSSettings->i_rollback();
    1172411724
    11725     if (mCaptureSettings && (mData->flModifications & IsModified_Capture))
    11726         mCaptureSettings->i_rollback();
     11725    if (mRecordSettings && (mData->flModifications & IsModified_Record))
     11726        mRecordSettings->i_rollback();
    1172711727
    1172811728    if (mVRDEServer && (mData->flModifications & IsModified_VRDEServer))
    … …  
    1183611836
    1183711837    mBIOSSettings->i_commit();
    11838     mCaptureSettings->i_commit();
     11838    mRecordSettings->i_commit();
    1183911839    mVRDEServer->i_commit();
    1184011840    mAudioAdapter->i_commit();
    … …  
    1208912089
    1209012090    mBIOSSettings->i_copyFrom(aThat->mBIOSSettings);
    12091     mCaptureSettings->i_copyFrom(aThat->mCaptureSettings);
     12091    mRecordSettings->i_copyFrom(aThat->mRecordSettings);
    1209212092    mVRDEServer->i_copyFrom(aThat->mVRDEServer);
    1209312093    mAudioAdapter->i_copyFrom(aThat->mAudioAdapter);
    … …  
    1246312463    unconst(mBIOSSettings).createObject();
    1246412464    mBIOSSettings->init(this, aMachine->mBIOSSettings);
    12465     unconst(mCaptureSettings).createObject();
    12466     mCaptureSettings->init(this, aMachine->mCaptureSettings);
     12465    unconst(mRecordSettings).createObject();
     12466    mRecordSettings->init(this, aMachine->mRecordSettings);
    1246712467    /* create another VRDEServer object that will be mutable */
    1246812468    unconst(mVRDEServer).createObject();
    … …  
    1409814098 * @note Locks this object for reading.
    1409914099 */
    14100 HRESULT SessionMachine::i_onCaptureChange()
     14100HRESULT SessionMachine::i_onRecordChange()
    1410114101{
    1410214102    LogFlowThisFunc(("\n"));
    … …  
    1411614116        return S_OK;
    1411714117
    14118     return directControl->OnCaptureChange();
     14118    return directControl->OnRecordChange();
    1411914119}
    1412014120
    … …  
    1505015050    mBIOSSettings->i_applyDefaults(osType);
    1505115051
    15052     /* Initialize default capture settings. */
    15053     mCaptureSettings->i_applyDefaults();
     15052    /* Initialize default record settings. */
     15053    mRecordSettings->i_applyDefaults();
    1505415054
    1505515055    /* Initialize default BIOS settings here */

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

    r75340 r75341  
    1717 */
    1818
    19 #define LOG_GROUP LOG_GROUP_MAIN_CAPTURESCREENSETTINGS
     19#define LOG_GROUP LOG_GROUP_MAIN_RECORDSCREENSETTINGS
    2020#include "LoggingNew.h"
    2121
    22 #include "CaptureScreenSettingsImpl.h"
    23 #include "CaptureSettingsImpl.h"
     22#include "RecordScreenSettingsImpl.h"
     23#include "RecordSettingsImpl.h"
    2424#include "MachineImpl.h"
    2525
    … …  
    3434////////////////////////////////////////////////////////////////////////////////
    3535//
    36 // CaptureScreenSettings private data definition
     36// RecordScreenSettings private data definition
    3737//
    3838////////////////////////////////////////////////////////////////////////////////
    3939
    40 struct CaptureScreenSettings::Data
     40struct RecordScreenSettings::Data
    4141{
    4242    Data()
    … …  
    4444    { }
    4545
    46     CaptureSettings * const          pParent;
    47     ComObjPtr<CaptureScreenSettings> pPeer;
     46    RecordSettings * const          pParent;
     47    ComObjPtr<RecordScreenSettings> pPeer;
    4848    uint32_t                         uScreenId;
    4949
    5050    // use the XML settings structure in the members for simplicity
    51     Backupable<settings::CaptureScreenSettings> bd;
     51    Backupable<settings::RecordScreenSettings> bd;
    5252};
    5353
    … …  
    5555/////////////////////////////////////////////////////////////////////////////
    5656
    57 DEFINE_EMPTY_CTOR_DTOR(CaptureScreenSettings)
    58 
    59 HRESULT CaptureScreenSettings::FinalConstruct()
     57DEFINE_EMPTY_CTOR_DTOR(RecordScreenSettings)
     58
     59HRESULT RecordScreenSettings::FinalConstruct()
    6060{
    6161    return BaseFinalConstruct();
    6262}
    6363
    64 void CaptureScreenSettings::FinalRelease()
     64void RecordScreenSettings::FinalRelease()
    6565{
    6666    uninit();
    … …  
    7676 * @returns COM result indicator
    7777 */
    78 HRESULT CaptureScreenSettings::init(CaptureSettings *aParent, uint32_t uScreenId, const settings::CaptureScreenSettings& data)
     78HRESULT RecordScreenSettings::init(RecordSettings *aParent, uint32_t uScreenId, const settings::RecordScreenSettings& data)
    7979{
    8080    LogFlowThisFuncEnter();
    … …  
    123123 *  it shares data with is destroyed.
    124124 */
    125 HRESULT CaptureScreenSettings::init(CaptureSettings *aParent, CaptureScreenSettings *that)
     125HRESULT RecordScreenSettings::init(RecordSettings *aParent, RecordScreenSettings *that)
    126126{
    127127    LogFlowThisFuncEnter();
    … …  
    166166 *  of the original object passed as an argument.
    167167 */
    168 HRESULT CaptureScreenSettings::initCopy(CaptureSettings *aParent, CaptureScreenSettings *that)
     168HRESULT RecordScreenSettings::initCopy(RecordSettings *aParent, RecordScreenSettings *that)
    169169{
    170170    LogFlowThisFuncEnter();
    … …  
    208208 *  Called either from FinalRelease() or by the parent when it gets destroyed.
    209209 */
    210 void CaptureScreenSettings::uninit()
     210void RecordScreenSettings::uninit()
    211211{
    212212    LogFlowThisFuncEnter();
    … …  
    228228}
    229229
    230 HRESULT CaptureScreenSettings::isFeatureEnabled(CaptureFeature_T aFeature, BOOL *aEnabled)
    231 {
    232     AutoCaller autoCaller(this);
    233     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    234 
    235     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    236 
    237     settings::CaptureFeatureMap::const_iterator itFeature = m->bd->featureMap.find(aFeature);
     230HRESULT RecordScreenSettings::isFeatureEnabled(RecordFeature_T aFeature, BOOL *aEnabled)
     231{
     232    AutoCaller autoCaller(this);
     233    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     234
     235    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     236
     237    settings::RecordFeatureMap::const_iterator itFeature = m->bd->featureMap.find(aFeature);
    238238
    239239    *aEnabled = (   itFeature != m->bd->featureMap.end()
    … …  
    243243}
    244244
    245 HRESULT CaptureScreenSettings::getId(ULONG *id)
     245HRESULT RecordScreenSettings::getId(ULONG *id)
    246246{
    247247    AutoCaller autoCaller(this);
    … …  
    255255}
    256256
    257 HRESULT CaptureScreenSettings::getEnabled(BOOL *enabled)
     257HRESULT RecordScreenSettings::getEnabled(BOOL *enabled)
    258258{
    259259    AutoCaller autoCaller(this);
    … …  
    267267}
    268268
    269 HRESULT CaptureScreenSettings::setEnabled(BOOL enabled)
     269HRESULT RecordScreenSettings::setEnabled(BOOL enabled)
    270270{
    271271    AutoCaller autoCaller(this);
    … …  
    292292}
    293293
    294 HRESULT CaptureScreenSettings::getFeatures(ULONG *aFeatures)
     294HRESULT RecordScreenSettings::getFeatures(ULONG *aFeatures)
    295295{
    296296    AutoCaller autoCaller(this);
    … …  
    301301    *aFeatures = 0;
    302302
    303     settings::CaptureFeatureMap::const_iterator itFeature = m->bd->featureMap.begin();
     303    settings::RecordFeatureMap::const_iterator itFeature = m->bd->featureMap.begin();
    304304    while (itFeature != m->bd->featureMap.end())
    305305    {
    … …  
    313313}
    314314
    315 HRESULT CaptureScreenSettings::setFeatures(ULONG aFeatures)
     315HRESULT RecordScreenSettings::setFeatures(ULONG aFeatures)
    316316{
    317317    AutoCaller autoCaller(this);
    … …  
    326326    m->bd->featureMap.clear();
    327327
    328     if (aFeatures & CaptureFeature_Audio)
    329         m->bd->featureMap[CaptureFeature_Audio] = true;
    330     if (aFeatures & CaptureFeature_Video)
    331         m->bd->featureMap[CaptureFeature_Video] = true;
     328    if (aFeatures & RecordFeature_Audio)
     329        m->bd->featureMap[RecordFeature_Audio] = true;
     330    if (aFeatures & RecordFeature_Video)
     331        m->bd->featureMap[RecordFeature_Video] = true;
    332332
    333333    alock.release();
    … …  
    336336}
    337337
    338 HRESULT CaptureScreenSettings::getDestination(CaptureDestination_T *aDestination)
     338HRESULT RecordScreenSettings::getDestination(RecordDestination_T *aDestination)
    339339{
    340340    AutoCaller autoCaller(this);
    … …  
    348348}
    349349
    350 HRESULT CaptureScreenSettings::setDestination(CaptureDestination_T aDestination)
     350HRESULT RecordScreenSettings::setDestination(RecordDestination_T aDestination)
    351351{
    352352    AutoCaller autoCaller(this);
    … …  
    364364}
    365365
    366 HRESULT CaptureScreenSettings::getFileName(com::Utf8Str &aFileName)
     366HRESULT RecordScreenSettings::getFileName(com::Utf8Str &aFileName)
    367367{
    368368    AutoCaller autoCaller(this);
    … …  
    376376}
    377377
    378 HRESULT CaptureScreenSettings::setFileName(const com::Utf8Str &aFileName)
     378HRESULT RecordScreenSettings::setFileName(const com::Utf8Str &aFileName)
    379379{
    380380    AutoCaller autoCaller(this);
    … …  
    397397}
    398398
    399 HRESULT CaptureScreenSettings::getMaxTime(ULONG *aMaxTimeS)
     399HRESULT RecordScreenSettings::getMaxTime(ULONG *aMaxTimeS)
    400400{
    401401    AutoCaller autoCaller(this);
    … …  
    409409}
    410410
    411 HRESULT CaptureScreenSettings::setMaxTime(ULONG aMaxTimeS)
     411HRESULT RecordScreenSettings::setMaxTime(ULONG aMaxTimeS)
    412412{
    413413    AutoCaller autoCaller(this);
    … …  
    425425}
    426426
    427 HRESULT CaptureScreenSettings::getMaxFileSize(ULONG *aMaxFileSizeMB)
     427HRESULT RecordScreenSettings::getMaxFileSize(ULONG *aMaxFileSizeMB)
    428428{
    429429    AutoCaller autoCaller(this);
    … …  
    437437}
    438438
    439 HRESULT CaptureScreenSettings::setMaxFileSize(ULONG aMaxFileSize)
     439HRESULT RecordScreenSettings::setMaxFileSize(ULONG aMaxFileSize)
    440440{
    441441    AutoCaller autoCaller(this);
    … …  
    453453}
    454454
    455 HRESULT CaptureScreenSettings::getOptions(com::Utf8Str &aOptions)
     455HRESULT RecordScreenSettings::getOptions(com::Utf8Str &aOptions)
    456456{
    457457    AutoCaller autoCaller(this);
    … …  
    465465}
    466466
    467 HRESULT CaptureScreenSettings::setOptions(const com::Utf8Str &aOptions)
     467HRESULT RecordScreenSettings::setOptions(const com::Utf8Str &aOptions)
    468468{
    469469    AutoCaller autoCaller(this);
    … …  
    481481}
    482482
    483 HRESULT CaptureScreenSettings::getAudioCodec(CaptureAudioCodec_T *aCodec)
     483HRESULT RecordScreenSettings::getAudioCodec(RecordAudioCodec_T *aCodec)
    484484{
    485485    AutoCaller autoCaller(this);
    … …  
    493493}
    494494
    495 HRESULT CaptureScreenSettings::setAudioCodec(CaptureAudioCodec_T aCodec)
     495HRESULT RecordScreenSettings::setAudioCodec(RecordAudioCodec_T aCodec)
    496496{
    497497    AutoCaller autoCaller(this);
    … …  
    509509}
    510510
    511 HRESULT CaptureScreenSettings::getAudioHz(ULONG *aHz)
     511HRESULT RecordScreenSettings::getAudioHz(ULONG *aHz)
    512512{
    513513    AutoCaller autoCaller(this);
    … …  
    521521}
    522522
    523 HRESULT CaptureScreenSettings::setAudioHz(ULONG aHz)
     523HRESULT RecordScreenSettings::setAudioHz(ULONG aHz)
    524524{
    525525    AutoCaller autoCaller(this);
    … …  
    537537}
    538538
    539 HRESULT CaptureScreenSettings::getAudioBits(ULONG *aBits)
     539HRESULT RecordScreenSettings::getAudioBits(ULONG *aBits)
    540540{
    541541    AutoCaller autoCaller(this);
    … …  
    549549}
    550550
    551 HRESULT CaptureScreenSettings::setAudioBits(ULONG aBits)
     551HRESULT RecordScreenSettings::setAudioBits(ULONG aBits)
    552552{
    553553    AutoCaller autoCaller(this);
    … …  
    565565}
    566566
    567 HRESULT CaptureScreenSettings::getAudioChannels(ULONG *aChannels)
     567HRESULT RecordScreenSettings::getAudioChannels(ULONG *aChannels)
    568568{
    569569    AutoCaller autoCaller(this);
    … …  
    577577}
    578578
    579 HRESULT CaptureScreenSettings::setAudioChannels(ULONG aChannels)
     579HRESULT RecordScreenSettings::setAudioChannels(ULONG aChannels)
    580580{
    581581    AutoCaller autoCaller(this);
    … …  
    593593}
    594594
    595 HRESULT CaptureScreenSettings::getVideoCodec(CaptureVideoCodec_T *aCodec)
     595HRESULT RecordScreenSettings::getVideoCodec(RecordVideoCodec_T *aCodec)
    596596{
    597597    AutoCaller autoCaller(this);
    … …  
    605605}
    606606
    607 HRESULT CaptureScreenSettings::setVideoCodec(CaptureVideoCodec_T aCodec)
     607HRESULT RecordScreenSettings::setVideoCodec(RecordVideoCodec_T aCodec)
    608608{
    609609    AutoCaller autoCaller(this);
    … …  
    621621}
    622622
    623 HRESULT CaptureScreenSettings::getVideoWidth(ULONG *aVideoWidth)
     623HRESULT RecordScreenSettings::getVideoWidth(ULONG *aVideoWidth)
    624624{
    625625    AutoCaller autoCaller(this);
    … …  
    633633}
    634634
    635 HRESULT CaptureScreenSettings::setVideoWidth(ULONG aVideoWidth)
     635HRESULT RecordScreenSettings::setVideoWidth(ULONG aVideoWidth)
    636636{
    637637    AutoCaller autoCaller(this);
    … …  
    649649}
    650650
    651 HRESULT CaptureScreenSettings::getVideoHeight(ULONG *aVideoHeight)
     651HRESULT RecordScreenSettings::getVideoHeight(ULONG *aVideoHeight)
    652652{
    653653    AutoCaller autoCaller(this);
    … …  
    661661}
    662662
    663 HRESULT CaptureScreenSettings::setVideoHeight(ULONG aVideoHeight)
     663HRESULT RecordScreenSettings::setVideoHeight(ULONG aVideoHeight)
    664664{
    665665    AutoCaller autoCaller(this);
    … …  
    677677}
    678678
    679 HRESULT CaptureScreenSettings::getVideoRate(ULONG *aVideoRate)
     679HRESULT RecordScreenSettings::getVideoRate(ULONG *aVideoRate)
    680680{
    681681    AutoCaller autoCaller(this);
    … …  
    689689}
    690690
    691 HRESULT CaptureScreenSettings::setVideoRate(ULONG aVideoRate)
     691HRESULT RecordScreenSettings::setVideoRate(ULONG aVideoRate)
    692692{
    693693    AutoCaller autoCaller(this);
    … …  
    705705}
    706706
    707 HRESULT CaptureScreenSettings::getVideoRateControlMode(CaptureVideoRateControlMode_T *aMode)
    708 {
    709     AutoCaller autoCaller(this);
    710     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    711 
    712     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    713 
    714     *aMode = CaptureVideoRateControlMode_CBR; /** @todo Implement VBR. */
    715 
    716     return S_OK;
    717 }
    718 
    719 HRESULT CaptureScreenSettings::setVideoRateControlMode(CaptureVideoRateControlMode_T aMode)
     707HRESULT RecordScreenSettings::getVideoRateControlMode(RecordVideoRateControlMode_T *aMode)
     708{
     709    AutoCaller autoCaller(this);
     710    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     711
     712    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     713
     714    *aMode = RecordVideoRateControlMode_CBR; /** @todo Implement VBR. */
     715
     716    return S_OK;
     717}
     718
     719HRESULT RecordScreenSettings::setVideoRateControlMode(RecordVideoRateControlMode_T aMode)
    720720{
    721721    AutoCaller autoCaller(this);
    … …  
    733733}
    734734
    735 HRESULT CaptureScreenSettings::getVideoFPS(ULONG *aVideoFPS)
     735HRESULT RecordScreenSettings::getVideoFPS(ULONG *aVideoFPS)
    736736{
    737737    AutoCaller autoCaller(this);
    … …  
    745745}
    746746
    747 HRESULT CaptureScreenSettings::setVideoFPS(ULONG aVideoFPS)
     747HRESULT RecordScreenSettings::setVideoFPS(ULONG aVideoFPS)
    748748{
    749749    AutoCaller autoCaller(this);
    … …  
    761761}
    762762
    763 HRESULT CaptureScreenSettings::getVideoScalingMethod(CaptureVideoScalingMethod_T *aMode)
    764 {
    765     AutoCaller autoCaller(this);
    766     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    767 
    768     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    769 
    770     *aMode = CaptureVideoScalingMethod_None; /** @todo Implement this. */
    771 
    772     return S_OK;
    773 }
    774 
    775 HRESULT CaptureScreenSettings::setVideoScalingMethod(CaptureVideoScalingMethod_T aMode)
     763HRESULT RecordScreenSettings::getVideoScalingMethod(RecordVideoScalingMethod_T *aMode)
     764{
     765    AutoCaller autoCaller(this);
     766    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     767
     768    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     769
     770    *aMode = RecordVideoScalingMethod_None; /** @todo Implement this. */
     771
     772    return S_OK;
     773}
     774
     775HRESULT RecordScreenSettings::setVideoScalingMethod(RecordVideoScalingMethod_T aMode)
    776776{
    777777    AutoCaller autoCaller(this);
    … …  
    794794 * @returns IPRT status code.
    795795 */
    796 int CaptureScreenSettings::i_initInternal(void)
     796int RecordScreenSettings::i_initInternal(void)
    797797{
    798798    Assert(m);
    … …  
    802802    switch (m->bd->enmDest)
    803803    {
    804         case CaptureDestination_File:
     804        case RecordDestination_File:
    805805        {
    806806            if (m->bd->File.strName.isEmpty())

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

    r75340 r75341  
    1717 */
    1818
    19 #define LOG_GROUP LOG_GROUP_MAIN_CAPTURESETTINGS
     19#define LOG_GROUP LOG_GROUP_MAIN_RECORDSETTINGS
    2020#include "LoggingNew.h"
    2121
    22 #include "CaptureSettingsImpl.h"
    23 #include "CaptureScreenSettingsImpl.h"
     22#include "RecordSettingsImpl.h"
     23#include "RecordScreenSettingsImpl.h"
    2424#include "MachineImpl.h"
    2525
    … …  
    3333////////////////////////////////////////////////////////////////////////////////
    3434//
    35 // CaptureSettings private data definition
     35// RecordSettings private data definition
    3636//
    3737////////////////////////////////////////////////////////////////////////////////
    3838
    39 struct CaptureSettings::Data
     39struct RecordSettings::Data
    4040{
    4141    Data()
    … …  
    4343    { }
    4444
    45     Machine * const             pMachine;
    46     ComObjPtr<CaptureSettings> pPeer;
    47     CaptureScreenSettingsMap    mapScreenObj;
    48     bool                        fHasMachineLock;
     45    Machine * const           pMachine;
     46    ComObjPtr<RecordSettings> pPeer;
     47    RecordScreenSettingsMap   mapScreenObj;
     48    bool                      fHasMachineLock;
    4949
    5050    // use the XML settings structure in the members for simplicity
    51     Backupable<settings::CaptureSettings> bd;
     51    Backupable<settings::RecordSettings> bd;
    5252};
    5353
    54 DEFINE_EMPTY_CTOR_DTOR(CaptureSettings)
    55 
    56 HRESULT CaptureSettings::FinalConstruct()
     54DEFINE_EMPTY_CTOR_DTOR(RecordSettings)
     55
     56HRESULT RecordSettings::FinalConstruct()
    5757{
    5858    return BaseFinalConstruct();
    5959}
    6060
    61 void CaptureSettings::FinalRelease()
     61void RecordSettings::FinalRelease()
    6262{
    6363    uninit();
    … …  
    7070 * @returns COM result indicator
    7171 */
    72 HRESULT CaptureSettings::init(Machine *aParent)
     72HRESULT RecordSettings::init(Machine *aParent)
    7373{
    7474    LogFlowThisFuncEnter();
    … …  
    103103 *  it shares data with is destroyed.
    104104 */
    105 HRESULT CaptureSettings::init(Machine *aParent, CaptureSettings *that)
     105HRESULT RecordSettings::init(Machine *aParent, RecordSettings *that)
    106106{
    107107    LogFlowThisFuncEnter();
    … …  
    136136 *  of the original object passed as an argument.
    137137 */
    138 HRESULT CaptureSettings::initCopy(Machine *aParent, CaptureSettings *that)
     138HRESULT RecordSettings::initCopy(Machine *aParent, RecordSettings *that)
    139139{
    140140    LogFlowThisFuncEnter();
    … …  
    168168 *  Called either from FinalRelease() or by the parent when it gets destroyed.
    169169 */
    170 void CaptureSettings::uninit()
     170void RecordSettings::uninit()
    171171{
    172172    LogFlowThisFuncEnter();
    … …  
    191191}
    192192
    193 // ICaptureSettings properties
     193// IRecordSettings properties
    194194/////////////////////////////////////////////////////////////////////////////
    195195
    196 HRESULT CaptureSettings::getEnabled(BOOL *enabled)
     196HRESULT RecordSettings::getEnabled(BOOL *enabled)
    197197{
    198198    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    203203}
    204204
    205 HRESULT CaptureSettings::setEnabled(BOOL enable)
     205HRESULT RecordSettings::setEnabled(BOOL enable)
    206206{
    207207    LogFlowThisFuncEnter();
    … …  
    219219
    220220        alock.release();
    221         rc = m->pMachine->i_onCaptureChange();
     221        rc = m->pMachine->i_onRecordChange();
    222222        if (FAILED(rc))
    223223        {
    224224            /*
    225225             * Normally we would do the actual change _after_ i_onCaptureChange() succeeded.
    226              * We cannot do this because that function uses CaptureSettings::GetEnabled to
     226             * We cannot do this because that function uses RecordSettings::GetEnabled to
    227227             * determine if it should start or stop capturing. Therefore we need to manually
    228228             * undo change.
    … …  
    234234        {
    235235            AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
    236             m->pMachine->i_setModified(Machine::IsModified_Capture);
     236            m->pMachine->i_setModified(Machine::IsModified_Record);
    237237
    238238            /* We need to indicate here that we just took the machine lock, as Machine::i_saveSettings() will
    … …  
    251251}
    252252
    253 HRESULT CaptureSettings::getScreens(std::vector<ComPtr<ICaptureScreenSettings> > &aCaptureScreenSettings)
     253HRESULT RecordSettings::getScreens(std::vector<ComPtr<IRecordScreenSettings> > &aRecordScreenSettings)
    254254{
    255255    LogFlowThisFuncEnter();
    … …  
    259259    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    260260
    261     aCaptureScreenSettings.clear();
    262     aCaptureScreenSettings.resize(m->mapScreenObj.size());
    263 
    264     CaptureScreenSettingsMap::const_iterator itScreenSettings = m->mapScreenObj.begin();
     261    aRecordScreenSettings.clear();
     262    aRecordScreenSettings.resize(m->mapScreenObj.size());
     263
     264    RecordScreenSettingsMap::const_iterator itScreenSettings = m->mapScreenObj.begin();
    265265    size_t i = 0;
    266266    while (itScreenSettings != m->mapScreenObj.end())
    267267    {
    268         itScreenSettings->second.queryInterfaceTo(aCaptureScreenSettings[i].asOutParam());
    269         Assert(aCaptureScreenSettings[i].isNotNull());
     268        itScreenSettings->second.queryInterfaceTo(aRecordScreenSettings[i].asOutParam());
     269        Assert(aRecordScreenSettings[i].isNotNull());
    270270        ++i;
    271271        ++itScreenSettings;
    272272    }
    273273
    274     Assert(aCaptureScreenSettings.size() == m->mapScreenObj.size());
     274    Assert(aRecordScreenSettings.size() == m->mapScreenObj.size());
    275275
    276276    return S_OK;
    277277}
    278278
    279 HRESULT CaptureSettings::getScreenSettings(ULONG uScreenId, ComPtr<ICaptureScreenSettings> &aCaptureScreenSettings)
     279HRESULT RecordSettings::getScreenSettings(ULONG uScreenId, ComPtr<IRecordScreenSettings> &aRecordScreenSettings)
    280280{
    281281    LogFlowThisFuncEnter();
    … …  
    288288        return setError(E_INVALIDARG, tr("Invalid screen ID specified"));
    289289
    290     CaptureScreenSettingsMap::const_iterator itScreenSettings = m->mapScreenObj.find(uScreenId);
     290    RecordScreenSettingsMap::const_iterator itScreenSettings = m->mapScreenObj.find(uScreenId);
    291291    if (itScreenSettings != m->mapScreenObj.end())
    292292    {
    293         itScreenSettings->second.queryInterfaceTo(aCaptureScreenSettings.asOutParam());
     293        itScreenSettings->second.queryInterfaceTo(aRecordScreenSettings.asOutParam());
    294294        return S_OK;
    295295    }
    … …  
    298298}
    299299
    300 // ICaptureSettings methods
     300// IRecordSettings methods
    301301/////////////////////////////////////////////////////////////////////////////
    302302
    … …  
    312312 * @param   data                Recording screen settings to use for that screen.
    313313 */
    314 int CaptureSettings::i_createScreenObj(CaptureScreenSettingsMap &screenSettingsMap,
    315                                        uint32_t uScreenId, const settings::CaptureScreenSettings &data)
     314int RecordSettings::i_createScreenObj(RecordScreenSettingsMap &screenSettingsMap,
     315                                       uint32_t uScreenId, const settings::RecordScreenSettings &data)
    316316{
    317317    LogFlowThisFunc(("Screen %RU32\n", uScreenId));
    … …  
    325325    int vrc = VINF_SUCCESS;
    326326
    327     ComObjPtr<CaptureScreenSettings> captureScreenSettings;
    328     HRESULT rc = captureScreenSettings.createObject();
     327    ComObjPtr<RecordScreenSettings> RecordScreenSettings;
     328    HRESULT rc = RecordScreenSettings.createObject();
    329329    if (SUCCEEDED(rc))
    330330    {
    331         rc = captureScreenSettings->init(this, uScreenId, data);
     331        rc = RecordScreenSettings->init(this, uScreenId, data);
    332332        if (SUCCEEDED(rc))
    333333        {
    334334            try
    335335            {
    336                 screenSettingsMap[uScreenId] = captureScreenSettings;
     336                screenSettingsMap[uScreenId] = RecordScreenSettings;
    337337            }
    338338            catch (std::bad_alloc &)
    … …  
    353353 * @param   uScreenId           ID of screen to remove.
    354354 */
    355 int CaptureSettings::i_destroyScreenObj(CaptureScreenSettingsMap &screenSettingsMap, uint32_t uScreenId)
     355int RecordSettings::i_destroyScreenObj(RecordScreenSettingsMap &screenSettingsMap, uint32_t uScreenId)
    356356{
    357357    LogFlowThisFunc(("Screen %RU32\n", uScreenId));
    … …  
    359359    AssertReturn(uScreenId > 0, VERR_INVALID_PARAMETER); /* Removing screen 0 isn't a good idea. */
    360360
    361     CaptureScreenSettingsMap::iterator itScreen = screenSettingsMap.find(uScreenId);
     361    RecordScreenSettingsMap::iterator itScreen = screenSettingsMap.find(uScreenId);
    362362    if (itScreen == screenSettingsMap.end())
    363363    {
    … …  
    368368    /* Make sure to consume the pointer before the one of the
    369369     * iterator gets released. */
    370     ComObjPtr<CaptureScreenSettings> pScreenSettings = itScreen->second;
     370    ComObjPtr<RecordScreenSettings> pScreenSettings = itScreen->second;
    371371
    372372    screenSettingsMap.erase(itScreen);
    … …  
    383383 * @param   screenSettingsMap   Map to destroy screen settings objects for.
    384384 */
    385 int CaptureSettings::i_destroyAllScreenObj(CaptureScreenSettingsMap &screenSettingsMap)
    386 {
    387     LogFlowThisFuncEnter();
    388 
    389     CaptureScreenSettingsMap::iterator itScreen = screenSettingsMap.begin();
     385int RecordSettings::i_destroyAllScreenObj(RecordScreenSettingsMap &screenSettingsMap)
     386{
     387    LogFlowThisFuncEnter();
     388
     389    RecordScreenSettingsMap::iterator itScreen = screenSettingsMap.begin();
    390390    if (itScreen != screenSettingsMap.end())
    391391    {
    392392        /* Make sure to consume the pointer before the one of the
    393393         * iterator gets released. */
    394         ComObjPtr<CaptureScreenSettings> pScreenSettings = itScreen->second;
     394        ComObjPtr<RecordScreenSettings> pScreenSettings = itScreen->second;
    395395
    396396        screenSettingsMap.erase(itScreen);
    … …  
    412412 * @note Locks this object for writing.
    413413 */
    414 HRESULT CaptureSettings::i_loadSettings(const settings::CaptureSettings &data)
     414HRESULT RecordSettings::i_loadSettings(const settings::RecordSettings &data)
    415415{
    416416    LogFlowThisFuncEnter();
    … …  
    427427    LogFlowThisFunc(("Data has %zu screens\n", data.mapScreens.size()));
    428428
    429     settings::CaptureScreenMap::const_iterator itScreen = data.mapScreens.begin();
     429    settings::RecordScreenMap::const_iterator itScreen = data.mapScreens.begin();
    430430    while (itScreen != data.mapScreens.end())
    431431    {
    … …  
    457457 * Resets the internal object state by destroying all screen settings objects.
    458458 */
    459 void CaptureSettings::i_reset(void)
     459void RecordSettings::i_reset(void)
    460460{
    461461    LogFlowThisFuncEnter();
    … …  
    472472 * @note Locks this object for reading.
    473473 */
    474 HRESULT CaptureSettings::i_saveSettings(settings::CaptureSettings &data)
     474HRESULT RecordSettings::i_saveSettings(settings::RecordSettings &data)
    475475{
    476476    LogFlowThisFuncEnter();
    … …  
    486486    data = *m->bd.data();
    487487
    488     settings::CaptureScreenMap::iterator itScreen = data.mapScreens.begin();
     488    settings::RecordScreenMap::iterator itScreen = data.mapScreens.begin();
    489489    while (itScreen != data.mapScreens.end())
    490490    {
    … …  
    499499}
    500500
    501 void CaptureSettings::i_rollback()
     501void RecordSettings::i_rollback()
    502502{
    503503    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    505505}
    506506
    507 void CaptureSettings::i_commit()
     507void RecordSettings::i_commit()
    508508{
    509509    /* sanity */
    … …  
    531531}
    532532
    533 void CaptureSettings::i_copyFrom(CaptureSettings *aThat)
     533void RecordSettings::i_copyFrom(RecordSettings *aThat)
    534534{
    535535    AssertReturnVoid(aThat != NULL);
    … …  
    552552}
    553553
    554 void CaptureSettings::i_applyDefaults(void)
     554void RecordSettings::i_applyDefaults(void)
    555555{
    556556    /* sanity */
    … …  
    566566 * Returns the full path to the default video capture file.
    567567 */
    568 int CaptureSettings::i_getDefaultFileName(Utf8Str &strFile)
     568int RecordSettings::i_getDefaultFileName(Utf8Str &strFile)
    569569{
    570570    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    582582 * @returns \c true if the settings can be changed, \c false if not.
    583583 */
    584 bool CaptureSettings::i_canChangeSettings(void)
     584bool RecordSettings::i_canChangeSettings(void)
    585585{
    586586    AutoAnyStateDependency adep(m->pMachine);
    … …  
    598598 * have been changed.
    599599 */
    600 void CaptureSettings::i_onSettingsChanged(void)
     600void RecordSettings::i_onSettingsChanged(void)
    601601{
    602602    LogFlowThisFuncEnter();
    603603
    604604    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
    605     m->pMachine->i_setModified(Machine::IsModified_Capture);
     605    m->pMachine->i_setModified(Machine::IsModified_Record);
    606606    mlock.release();
    607607
    … …  
    613613 * to the number of the machine's configured displays.
    614614 */
    615 int CaptureSettings::i_syncToMachineDisplays(void)
     615int RecordSettings::i_syncToMachineDisplays(void)
    616616{
    617617    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    632632        if (m->mapScreenObj.find(i) == m->mapScreenObj.end())
    633633        {
    634             settings::CaptureScreenMap::const_iterator itScreen = m->bd->mapScreens.find(i);
     634            settings::RecordScreenMap::const_iterator itScreen = m->bd->mapScreens.find(i);
    635635            if (itScreen == m->bd->mapScreens.end())
    636636            {
    637                 settings::CaptureScreenSettings defaultScreenSettings; /* Apply default settings. */
     637                settings::RecordScreenSettings defaultScreenSettings; /* Apply default settings. */
    638638                m->bd->mapScreens[i] = defaultScreenSettings;
    639639            }

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

    r75278 r75341  
    10821082    if (FAILED(rc)) return rc;
    10831083
    1084     unconst(mCaptureSettings).createObject();
    1085     rc = mCaptureSettings->initCopy(this, pMachine->mCaptureSettings);
     1084    unconst(mRecordSettings).createObject();
     1085    rc = mRecordSettings->initCopy(this, pMachine->mRecordSettings);
    10861086    if (FAILED(rc)) return rc;
    10871087
    … …  
    12081208    mBIOSSettings->init(this);
    12091209
    1210     unconst(mCaptureSettings).createObject();
    1211     mCaptureSettings->init(this);
     1210    unconst(mRecordSettings).createObject();
     1211    mRecordSettings->init(this);
    12121212
    12131213    unconst(mVRDEServer).createObject();

  • trunk/src/VBox/Main/xml/Settings.cpp

    r75324 r75341  
    23712371}
    23722372
    2373 CaptureScreenSettings::CaptureScreenSettings(void)
     2373RecordScreenSettings::RecordScreenSettings(void)
    23742374{
    23752375    applyDefaults();
    23762376}
    23772377
    2378 CaptureScreenSettings::~CaptureScreenSettings()
    2379 {
    2380 
    2381 }
    2382 
    2383 void CaptureScreenSettings::applyDefaults(void)
     2378RecordScreenSettings::~RecordScreenSettings()
     2379{
     2380
     2381}
     2382
     2383void RecordScreenSettings::applyDefaults(void)
    23842384{
    23852385    /*
    … …  
    23882388
    23892389    fEnabled            = false;
    2390     enmDest             = CaptureDestination_File;
     2390    enmDest             = RecordDestination_File;
    23912391    ulMaxTimeS          = 0;
    23922392    strOptions          = "";
    23932393    File.ulMaxSizeMB    = 0;
    23942394    File.strName        = "";
    2395     Video.enmCodec      = CaptureVideoCodec_VP8;
     2395    Video.enmCodec      = RecordVideoCodec_VP8;
    23962396    Video.ulWidth       = 1024;
    23972397    Video.ulHeight      = 768;
    23982398    Video.ulRate        = 512;
    23992399    Video.ulFPS         = 25;
    2400     Audio.enmAudioCodec = CaptureAudioCodec_Opus;
     2400    Audio.enmAudioCodec = RecordAudioCodec_Opus;
    24012401    Audio.cBits         = 16;
    24022402    Audio.cChannels     = 2;
    24032403    Audio.uHz           = 22050;
    24042404
    2405     featureMap[CaptureFeature_Video] = true;
    2406     featureMap[CaptureFeature_Audio] = false;
     2405    featureMap[RecordFeature_Video] = true;
     2406    featureMap[RecordFeature_Audio] = false;
    24072407}
    24082408
    … …  
    24102410 * Check if all settings have default values.
    24112411 */
    2412 bool CaptureScreenSettings::areDefaultSettings(void) const
     2412bool RecordScreenSettings::areDefaultSettings(void) const
    24132413{
    24142414    return    fEnabled            == false
    2415            && enmDest             == CaptureDestination_File
     2415           && enmDest             == RecordDestination_File
    24162416           && ulMaxTimeS          == 0
    24172417           && strOptions          == ""
    24182418           && File.ulMaxSizeMB    == 0
    24192419           && File.strName        == ""
    2420            && Video.enmCodec      == CaptureVideoCodec_VP8
     2420           && Video.enmCodec      == RecordVideoCodec_VP8
    24212421           && Video.ulWidth       == 1024
    24222422           && Video.ulHeight      == 768
    24232423           && Video.ulRate        == 512
    24242424           && Video.ulFPS         == 25
    2425            && Audio.enmAudioCodec == CaptureAudioCodec_Opus
     2425           && Audio.enmAudioCodec == RecordAudioCodec_Opus
    24262426           && Audio.cBits         == 16
    24272427           && Audio.cChannels     == 2
    … …  
    24292429}
    24302430
    2431 bool CaptureScreenSettings::isFeatureEnabled(CaptureFeature_T enmFeature) const
    2432 {
    2433     CaptureFeatureMap::const_iterator itFeature = featureMap.find(enmFeature);
     2431bool RecordScreenSettings::isFeatureEnabled(RecordFeature_T enmFeature) const
     2432{
     2433    RecordFeatureMap::const_iterator itFeature = featureMap.find(enmFeature);
    24342434    if (itFeature != featureMap.end())
    24352435        return itFeature->second;
    … …  
    24432443 * machine settings have really changed and thus need to be written out to disk.
    24442444 */
    2445 bool CaptureScreenSettings::operator==(const CaptureScreenSettings &d) const
     2445bool RecordScreenSettings::operator==(const RecordScreenSettings &d) const
    24462446{
    24472447    return    fEnabled            == d.fEnabled
    … …  
    24652465 * Constructor. Needs to set sane defaults which stand the test of time.
    24662466 */
    2467 CaptureSettings::CaptureSettings()
     2467RecordSettings::RecordSettings()
    24682468{
    24692469    applyDefaults();
    … …  
    24732473 * Applies the default settings.
    24742474 */
    2475 void CaptureSettings::applyDefaults(void)
     2475void RecordSettings::applyDefaults(void)
    24762476{
    24772477    fEnabled = false;
    … …  
    24822482    {
    24832483        /* Always add screen 0 to the default configuration. */
    2484         CaptureScreenSettings screenSettings; /* Apply default settings for screen 0. */
     2484        RecordScreenSettings screenSettings; /* Apply default settings for screen 0. */
    24852485        screenSettings.fEnabled = true;       /* Enabled by default. */
    24862486        mapScreens[0] = screenSettings;
    … …  
    24952495 * Check if all settings have default values.
    24962496 */
    2497 bool CaptureSettings::areDefaultSettings() const
     2497bool RecordSettings::areDefaultSettings() const
    24982498{
    24992499    const bool fDefault =    fEnabled          == false
    … …  
    25022502        return false;
    25032503
    2504     CaptureScreenMap::const_iterator itScreen = mapScreens.begin();
     2504    RecordScreenMap::const_iterator itScreen = mapScreens.begin();
    25052505    return    itScreen->first == 0
    25062506           && itScreen->second.areDefaultSettings();
    … …  
    25122512 * machine settings have really changed and thus need to be written out to disk.
    25132513 */
    2514 bool CaptureSettings::operator==(const CaptureSettings &d) const
     2514bool RecordSettings::operator==(const RecordSettings &d) const
    25152515{
    25162516    if (this == &d)
    … …  
    25212521        return false;
    25222522
    2523     CaptureScreenMap::const_iterator itScreen = mapScreens.begin();
     2523    RecordScreenMap::const_iterator itScreen = mapScreens.begin();
    25242524    uint32_t i = 0;
    25252525    while (itScreen != mapScreens.end())
    25262526    {
    2527         CaptureScreenMap::const_iterator itScreenThat = d.mapScreens.find(i);
     2527        RecordScreenMap::const_iterator itScreenThat = d.mapScreens.find(i);
    25282528        if (itScreen->second == itScreenThat->second)
    25292529        {
    … …  
    44094409        else if (pelmHwChild->nameEquals("VideoCapture"))
    44104410        {
    4411             pelmHwChild->getAttributeValue("enabled",   hw.captureSettings.fEnabled);
     4411            pelmHwChild->getAttributeValue("enabled",   hw.recordSettings.fEnabled);
    44124412
    44134413            /* Right now I don't want to bump the settings version, so just convert the enabled
    … …  
    44184418            /* At the moment we only support one capturing configuration, that is, all screens
    44194419             * have the same configuration. So load/save to/from screen 0. */
    4420             Assert(hw.captureSettings.mapScreens.size()); /* At least screen must be present. */
    4421             CaptureScreenSettings &screen0Settings = hw.captureSettings.mapScreens[0];
     4420            Assert(hw.recordSettings.mapScreens.size()); /* At least screen must be present. */
     4421            RecordScreenSettings &screen0Settings = hw.recordSettings.mapScreens[0];
    44224422
    44234423            pelmHwChild->getAttributeValue("maxTime",   screen0Settings.ulMaxTimeS);
    … …  
    44334433            {
    44344434                /* Add screen i to config in any case. */
    4435                 hw.captureSettings.mapScreens[i] = screen0Settings;
     4435                hw.recordSettings.mapScreens[i] = screen0Settings;
    44364436
    44374437                if (u64VideoCaptureScreens & RT_BIT_64(i)) /* Screen i enabled? */
    4438                     hw.captureSettings.mapScreens[i].fEnabled = true;
     4438                    hw.recordSettings.mapScreens[i].fEnabled = true;
    44394439            }
    44404440        }
    … …  
    58205820    }
    58215821
    5822     if (m->sv >= SettingsVersion_v1_14 && !hw.captureSettings.areDefaultSettings())
     5822    if (m->sv >= SettingsVersion_v1_14 && !hw.recordSettings.areDefaultSettings())
    58235823    {
    58245824        xml::ElementNode *pelmVideoCapture = pelmHardware->createChild("VideoCapture");
    58255825
    5826         if (hw.captureSettings.fEnabled)
    5827             pelmVideoCapture->setAttribute("enabled", hw.captureSettings.fEnabled);
     5826        if (hw.recordSettings.fEnabled)
     5827            pelmVideoCapture->setAttribute("enabled", hw.recordSettings.fEnabled);
    58285828
    58295829        /* Right now I don't want to bump the settings version, so just convert the enabled
    58305830         * screens to the former uint64t_t bit array and vice versa. */
    58315831        uint64_t u64VideoCaptureScreens = 0;
    5832         CaptureScreenMap::const_iterator itScreen = hw.captureSettings.mapScreens.begin();
    5833         while (itScreen != hw.captureSettings.mapScreens.end())
     5832        RecordScreenMap::const_iterator itScreen = hw.recordSettings.mapScreens.begin();
     5833        while (itScreen != hw.recordSettings.mapScreens.end())
    58345834        {
    58355835            if (itScreen->second.fEnabled)
    … …  
    58435843        /* At the moment we only support one capturing configuration, that is, all screens
    58445844         * have the same configuration. So load/save to/from screen 0. */
    5845         Assert(hw.captureSettings.mapScreens.size());
    5846         const CaptureScreenMap::const_iterator itScreen0Settings = hw.captureSettings.mapScreens.find(0);
    5847         Assert(itScreen0Settings != hw.captureSettings.mapScreens.end());
     5845        Assert(hw.recordSettings.mapScreens.size());
     5846        const RecordScreenMap::const_iterator itScreen0Settings = hw.recordSettings.mapScreens.find(0);
     5847        Assert(itScreen0Settings != hw.recordSettings.mapScreens.end());
    58485848
    58495849        if (itScreen0Settings->second.ulMaxTimeS)
    … …  
    74427442            || hardwareMachine.enmLongMode != Hardware::LongMode_Legacy
    74437443            || machineUserData.ovIcon.size() > 0
    7444             || hardwareMachine.captureSettings.fEnabled)
     7444            || hardwareMachine.recordSettings.fEnabled)
    74457445        {
    74467446            m->sv = SettingsVersion_v1_14;
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