Changeset 95639 in vbox for trunk/src/VBox/Main/xml

Timestamp:

Jul 14, 2022 8:30:45 AM (3 years ago)

Author:

vboxsync

Message:

Recording: Settings handling fixes / overhaul. This adds the ability to handle per-screen settings, which can be different from the first screen (screen 0). Also fixed a couple of bugs regarding snapshot handling and persistence (committing, rolling back, ++) in that area. FE/VBoxManage now can also list the per-screen settings. Added some further @todos. bugref:9286

File:

• trunk/src/VBox/Main/xml/Settings.cpp (modified) (23 diffs)

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

@@ -2779 +2779 @@
 
 /**
+ * Returns the default options string for screen recording settings.
+ */
+/* static */
+const char *RecordingScreenSettings::getDefaultOptions(void)
+{
+    /* Note: Needs to be kept in sync with FE/Qt's UIMachineSettingsDisplay::putToCache()! */
+    return "vc_enabled=true,ac_enabled=false,ac_profile=med";
+}
+
+/**
  * Applies the default settings.
  */
@@ -2787 +2797 @@
      */
 
-    fEnabled            = false;
-    enmDest             = RecordingDestination_File;
-    ulMaxTimeS          = 0;
-    strOptions          = "";
-    File.ulMaxSizeMB    = 0;
-    File.strName        = "";
-    Video.enmCodec      = RecordingVideoCodec_VP8;
-    Video.ulWidth       = 1024;
-    Video.ulHeight      = 768;
-    Video.ulRate        = 512;
-    Video.ulFPS         = 25;
-    Audio.enmAudioCodec = RecordingAudioCodec_Opus;
-    Audio.cBits         = 16;
-    Audio.cChannels     = 2;
-    Audio.uHz           = 22050;
+    fEnabled             = false;
+    enmDest              = RecordingDestination_File;
+    ulMaxTimeS           = 0;
+    strOptions           = RecordingScreenSettings::getDefaultOptions();
+    File.ulMaxSizeMB     = 0;
+    File.strName         = "";
+    Video.enmCodec       = RecordingVideoCodec_VP8;
+    Video.ulWidth        = 1024;
+    Video.ulHeight       = 768;
+    Video.ulRate         = 512;
+    Video.ulFPS          = 25;
+    Audio.enmAudioCodec  = RecordingAudioCodec_Opus;
+    Audio.cBits          = 16;
+    Audio.cChannels      = 2;
+    Audio.uHz            = 22050;
 
     featureMap[RecordingFeature_Video] = true;
@@ -2812 +2822 @@
 bool RecordingScreenSettings::areDefaultSettings(void) const
 {
-    return    fEnabled            == false
-           && enmDest             == RecordingDestination_File
-           && ulMaxTimeS          == 0
-           && strOptions          == ""
-           && File.ulMaxSizeMB    == 0
-           && File.strName        == ""
-           && Video.enmCodec      == RecordingVideoCodec_VP8
-           && Video.ulWidth       == 1024
-           && Video.ulHeight      == 768
-           && Video.ulRate        == 512
-           && Video.ulFPS         == 25
-           && Audio.enmAudioCodec == RecordingAudioCodec_Opus
-           && Audio.cBits         == 16
-           && Audio.cChannels     == 2
-           && Audio.uHz           == 22050;
+    return    fEnabled                                        == false
+           && enmDest                                         == RecordingDestination_File
+           && ulMaxTimeS                                      == 0
+           && strOptions                                      == RecordingScreenSettings::getDefaultOptions()
+           && File.ulMaxSizeMB                                == 0
+           && File.strName                                    == ""
+           && Video.enmCodec                                  == RecordingVideoCodec_VP8
+           && Video.ulWidth                                   == 1024
+           && Video.ulHeight                                  == 768
+           && Video.ulRate                                    == 512
+           && Video.ulFPS                                     == 25
+           && Audio.enmAudioCodec                             == RecordingAudioCodec_Opus
+           && Audio.cBits                                     == 16
+           && Audio.cChannels                                 == 2
+           && Audio.uHz                                       == 22050
+           && featureMap.find(RecordingFeature_Video)->second == true
+           && featureMap.find(RecordingFeature_Audio)->second == false;
 }
 
@@ -2856 +2868 @@
            && ulMaxTimeS          == d.ulMaxTimeS
            && strOptions          == d.strOptions
+           && File.strName        == d.File.strName
            && File.ulMaxSizeMB    == d.File.ulMaxSizeMB
            && Video.enmCodec      == d.Video.enmCodec
@@ -2865 +2878 @@
            && Audio.cBits         == d.Audio.cBits
            && Audio.cChannels     == d.Audio.cChannels
-           && Audio.uHz           == d.Audio.uHz;
+           && Audio.uHz           == d.Audio.uHz
+           && featureMap          == d.featureMap;
 }
 
@@ -2871 +2885 @@
  * Constructor. Needs to set sane defaults which stand the test of time.
  */
-RecordingSettings::RecordingSettings()
+RecordingCommonSettings::RecordingCommonSettings()
 {
     applyDefaults();
@@ -2879 +2893 @@
  * Applies the default settings.
  */
-void RecordingSettings::applyDefaults(void)
+void RecordingCommonSettings::applyDefaults(void)
 {
     fEnabled = false;
-
-    mapScreens.clear();
-
-    try
-    {
-        /* Always add screen 0 to the default configuration. */
-        RecordingScreenSettings screenSettings; /* Apply default settings for screen 0. */
-        screenSettings.fEnabled = true;       /* Enabled by default. */
-        mapScreens[0] = screenSettings;
-    }
-    catch (std::bad_alloc &)
-    {
-        AssertFailed();
-    }
 }
 
@@ -2901 +2901 @@
  * Check if all settings have default values.
  */
-bool RecordingSettings::areDefaultSettings() const
-{
-    const bool fDefault =    fEnabled          == false
-                          && mapScreens.size() == 1;
-    if (!fDefault)
-        return false;
-
-    RecordingScreenMap::const_iterator itScreen = mapScreens.begin();
-    return    itScreen->first == 0
-           && itScreen->second.areDefaultSettings();
+bool RecordingCommonSettings::areDefaultSettings(void) const
+{
+    return fEnabled == false;
 }
 
@@ -2918 +2911 @@
  * machine settings have really changed and thus need to be written out to disk.
  */
-bool RecordingSettings::operator==(const RecordingSettings &d) const
+bool RecordingCommonSettings::operator==(const RecordingCommonSettings &d) const
 {
     if (this == &d)
         return true;
 
-    if (   fEnabled          != d.fEnabled
-        || mapScreens.size() != d.mapScreens.size())
+    return fEnabled == d.fEnabled;
+}
+
+/**
+ * Constructor. Needs to set sane defaults which stand the test of time.
+ */
+RecordingSettings::RecordingSettings()
+{
+    applyDefaults();
+}
+
+/**
+ * Applies the default settings.
+ */
+void RecordingSettings::applyDefaults(void)
+{
+    common.applyDefaults();
+
+    mapScreens.clear();
+
+    try
+    {
+        /* Always add screen 0 to the default configuration. */
+        RecordingScreenSettings screenSettings;
+        mapScreens[0] = screenSettings;
+    }
+    catch (std::bad_alloc &)
+    {
+        AssertFailed();
+    }
+}
+
+/**
+ * Check if all settings have default values.
+ */
+bool RecordingSettings::areDefaultSettings(void) const
+{
+    AssertReturn(mapScreens.size() >= 1, false); /* The first screen always must be present. */
+
+    if (!common.areDefaultSettings())
         return false;
 
-    RecordingScreenMap::const_iterator itScreen = mapScreens.begin();
-    uint32_t i = 0;
+    RecordingScreenSettingsMap::const_iterator itScreen = mapScreens.begin();
     while (itScreen != mapScreens.end())
     {
-        RecordingScreenMap::const_iterator itScreenThat = d.mapScreens.find(i);
+        if (!itScreen->second.areDefaultSettings())
+            return false;
+        ++itScreen;
+    }
+
+    return true;
+}
+
+/**
+ * Comparison operator. This gets called from MachineConfigFile::operator==,
+ * which in turn gets called from Machine::saveSettings to figure out whether
+ * machine settings have really changed and thus need to be written out to disk.
+ */
+bool RecordingSettings::operator==(const RecordingSettings &that) const
+{
+    if (this == &that) /* If pointers match, take a shortcut. */
+        return true;
+
+    if (common == that.common)
+    {
+        /* Too lazy for a != operator. */
+    }
+    else
+        return false;
+
+    if (mapScreens.size() != that.mapScreens.size())
+        return false;
+
+    RecordingScreenSettingsMap::const_iterator itScreen     = mapScreens.begin();
+    RecordingScreenSettingsMap::const_iterator itScreenThat = that.mapScreens.begin();
+    while (   itScreen     != mapScreens.end()
+           && itScreenThat != that.mapScreens.end())
+    {
         if (itScreen->second == itScreenThat->second)
         {
@@ -2940 +3002 @@
 
         ++itScreen;
-        ++i;
+        ++itScreenThat;
     }
 
@@ -3934 +3996 @@
             && strStateFile          == s.strStateFile
             && hardware              == s.hardware                  // deep compare
+            && recordingSettings     == s.recordingSettings         // deep compare
             && llChildSnapshots      == s.llChildSnapshots          // deep compare
             && debugging             == s.debugging
@@ -4114 +4177 @@
             // skip mapExtraDataItems! there is no old state available as it's always forced
             && llFirstSnapshot            == c.llFirstSnapshot     // this one's deep
+            && recordingSettings          == c.recordingSettings   // this one's deep
             && strKeyId                   == c.strKeyId
             && strKeyStore                == c.strKeyStore
@@ -4714 +4778 @@
  * the IDE and SATA controllers used to be defined under \<Hardware\>.
  *
- * @param elmHardware
- * @param hw
+ * @param elmHardware           Hardware node to read from.
+ * @param hw                    Where to store the hardware settings.
  */
 void MachineConfigFile::readHardware(const xml::ElementNode &elmHardware,
@@ -5078 +5142 @@
                 pelmHwChild->getAttributeValue("Accelerate3D", hw.graphicsAdapter.fAccelerate3D);   // pre-v1.5 variant
             pelmHwChild->getAttributeValue("accelerate2DVideo", hw.graphicsAdapter.fAccelerate2DVideo);
-        }
-        else if (pelmHwChild->nameEquals("VideoCapture"))
-        {
-            pelmHwChild->getAttributeValue("enabled",   hw.recordingSettings.fEnabled);
-
-            /* Right now I don't want to bump the settings version, so just convert the enabled
-             * screens to the former uint64t_t bit array and vice versa. */
-            uint64_t u64VideoCaptureScreens;
-            pelmHwChild->getAttributeValue("screens",   u64VideoCaptureScreens);
-
-            /* At the moment we only support one capturing configuration, that is, all screens
-             * have the same configuration. So load/save to/from screen 0. */
-            Assert(hw.recordingSettings.mapScreens.size()); /* At least screen must be present. */
-            RecordingScreenSettings &screen0Settings = hw.recordingSettings.mapScreens[0];
-
-            pelmHwChild->getAttributeValue("maxTime",   screen0Settings.ulMaxTimeS);
-            pelmHwChild->getAttributeValue("options",   screen0Settings.strOptions);
-            pelmHwChild->getAttributeValuePath("file",  screen0Settings.File.strName);
-            pelmHwChild->getAttributeValue("maxSize",   screen0Settings.File.ulMaxSizeMB);
-            pelmHwChild->getAttributeValue("horzRes",   screen0Settings.Video.ulWidth);
-            pelmHwChild->getAttributeValue("vertRes",   screen0Settings.Video.ulHeight);
-            pelmHwChild->getAttributeValue("rate",      screen0Settings.Video.ulRate);
-            pelmHwChild->getAttributeValue("fps",       screen0Settings.Video.ulFPS);
-
-            for (unsigned i = 0; i < hw.graphicsAdapter.cMonitors; i++) /* Don't add more settings than we have monitors configured. */
-            {
-                /* Add screen i to config in any case. */
-                hw.recordingSettings.mapScreens[i] = screen0Settings;
-
-                if (u64VideoCaptureScreens & RT_BIT_64(i)) /* Screen i enabled? */
-                    hw.recordingSettings.mapScreens[i].fEnabled = true;
-            }
         }
         else if (pelmHwChild->nameEquals("RemoteDisplay"))
@@ -5949 +5981 @@
 
 /**
+ * Called for reading the \<VideoCapture\> element under \<Machine|Hardware\>,
+ * or \<Recording\> under \<Machine\>,
+ */
+void MachineConfigFile::readRecordingSettings(const xml::ElementNode &elmRecording, RecordingSettings &recording)
+{
+    elmRecording.getAttributeValue("enabled", recording.common.fEnabled);
+
+    /* Note: Since settings 1.19 the recording settings have a dedicated XML branch "Recording" outside of "Hardware". */
+    if (m->sv >= SettingsVersion_v1_19 /* VBox >= 7.0 */)
+    {
+        uint32_t cScreens = 0;
+        elmRecording.getAttributeValue("screens",   cScreens);
+
+        xml::ElementNodesList plstScreens;
+        elmRecording.getChildElements(plstScreens, "Screen");
+
+        /* Sanity checks. */
+        if (cScreens != plstScreens.size())
+            throw ConfigFileError(this, &elmRecording, N_("Recording/@screens attribute does not match stored screen objects"));
+
+        for (xml::ElementNodesList::iterator itScreen  = plstScreens.begin();
+                                             itScreen != plstScreens.end();
+                                           ++itScreen)
+        {
+            /* The screen's stored ID is the monitor ID and also the key for the map. */
+            uint32_t idxScreen;
+            (*itScreen)->getAttributeValue("id",        idxScreen);
+
+            RecordingScreenSettings &screenSettings = recording.mapScreens[idxScreen];
+
+            (*itScreen)->getAttributeValue("enabled",   screenSettings.fEnabled);
+            (*itScreen)->getAttributeValue("maxTimeS",  screenSettings.ulMaxTimeS);
+            (*itScreen)->getAttributeValue("options",   screenSettings.strOptions);
+            (*itScreen)->getAttributeValue("dest",      (uint32_t &)screenSettings.enmDest);
+            if (screenSettings.enmDest == RecordingDestination_File)
+                (*itScreen)->getAttributeValuePath("file",  screenSettings.File.strName);
+            else
+                throw ConfigFileError(this, (*itScreen),
+                                      N_("Not supported Recording/@dest attribute '%#x'"), screenSettings.enmDest);
+            (*itScreen)->getAttributeValue("maxSizeMB", screenSettings.File.ulMaxSizeMB);
+            (*itScreen)->getAttributeValue("horzRes",   screenSettings.Video.ulWidth);
+            (*itScreen)->getAttributeValue("vertRes",   screenSettings.Video.ulHeight);
+            (*itScreen)->getAttributeValue("rateKbps",  screenSettings.Video.ulRate);
+            (*itScreen)->getAttributeValue("fps",       screenSettings.Video.ulFPS);
+        }
+    }
+    else if (   m->sv >= SettingsVersion_v1_14
+             && m->sv <  SettingsVersion_v1_19 /* VBox < 7.0 */)
+    {
+        /* For settings < 1.19 (< VBox 7.0) we only support one recording configuration, that is,
+         * all screens have the same configuration. So load/save to/from screen 0. */
+        RecordingScreenSettings &screen0 = recording.mapScreens[0];
+
+        elmRecording.getAttributeValue("maxTime",   screen0.ulMaxTimeS);
+        elmRecording.getAttributeValue("options",   screen0.strOptions);
+        elmRecording.getAttributeValuePath("file",  screen0.File.strName);
+        elmRecording.getAttributeValue("maxSize",   screen0.File.ulMaxSizeMB);
+        elmRecording.getAttributeValue("horzRes",   screen0.Video.ulWidth);
+        elmRecording.getAttributeValue("vertRes",   screen0.Video.ulHeight);
+        elmRecording.getAttributeValue("rate",      screen0.Video.ulRate);
+        elmRecording.getAttributeValue("fps",       screen0.Video.ulFPS);
+
+        /* Convert the enabled screens to the former uint64_t bit array and vice versa. */
+        uint64_t cScreens = 0;
+        elmRecording.getAttributeValue("screens",   cScreens);
+
+        /* Propagate the settings from screen 0 to all other screens (= monitors). */
+        for (unsigned i = 0; i <  cScreens; i++)
+        {
+            /* Add screen i to config in any case. */
+            recording.mapScreens[i] = screen0;
+
+            if (cScreens & RT_BIT_64(i)) /* Screen i enabled? */
+                recording.mapScreens[i].fEnabled = true;
+        }
+    }
+}
+
+/**
  * Called for reading the \<Groups\> element under \<Machine\>.
  */
@@ -6064 +6175 @@
             readDVDAndFloppies_pre1_9(*pelmHardware, pSnap->hardware.storage);
 
-        const xml::ElementNode *pelmDebugging = elmSnapshot.findChildElement("Debugging");
+        const xml::ElementNode *pelmDebugging = elmSnapshot.findChildElement("Debugging"); /** @todo r=andy Shouldn't this be pElement instead of elmSnapshot? Re-visit this! */
         if (pelmDebugging)
             readDebugging(*pelmDebugging, pSnap->debugging);
-        const xml::ElementNode *pelmAutostart = elmSnapshot.findChildElement("Autostart");
+        const xml::ElementNode *pelmAutostart = elmSnapshot.findChildElement("Autostart"); /** @todo r=andy Ditto. */
         if (pelmAutostart)
             readAutostart(*pelmAutostart, pSnap->autostart);
+        if (m->sv < SettingsVersion_v1_19)
+        {
+            /* The recording settings were part of the Hardware branch, called "VideoCapture". */
+            const xml::ElementNode *pelmVideoCapture = pelmHardware->findChildElement("VideoCapture");
+            if (pelmVideoCapture)
+                readRecordingSettings(*pelmVideoCapture, pSnap->recordingSettings);
+        }
+        else /* >= VBox 7.0 */
+        {
+            const xml::ElementNode *pelmRecording = pElement->findChildElement("Recording");
+            if (pelmRecording)
+                readRecordingSettings(*pelmRecording, pSnap->recordingSettings);
+        }
         // note: Groups exist only for Machine, not for Snapshot
 
@@ -6257 +6381 @@
             else if (pelmMachineChild->nameEquals("Autostart"))
                 readAutostart(*pelmMachineChild, autostart);
+            else if (pelmMachineChild->nameEquals("Recording"))
+                readRecordingSettings(*pelmMachineChild, recordingSettings);
             else if (pelmMachineChild->nameEquals("Groups"))
                 readGroups(*pelmMachineChild, machineUserData.llGroups);
@@ -6683 +6809 @@
                 pelmDisplay->setAttribute("accelerate2DVideo", hw.graphicsAdapter.fAccelerate2DVideo);
         }
-    }
-
-    if (m->sv >= SettingsVersion_v1_14 && !hw.recordingSettings.areDefaultSettings())
-    {
-        xml::ElementNode *pelmVideoCapture = pelmHardware->createChild("VideoCapture");
-
-        if (hw.recordingSettings.fEnabled)
-            pelmVideoCapture->setAttribute("enabled", hw.recordingSettings.fEnabled);
-
-        /* Right now I don't want to bump the settings version, so just convert the enabled
-         * screens to the former uint64t_t bit array and vice versa. */
-        uint64_t u64VideoCaptureScreens = 0;
-        RecordingScreenMap::const_iterator itScreen = hw.recordingSettings.mapScreens.begin();
-        while (itScreen != hw.recordingSettings.mapScreens.end())
-        {
-            if (itScreen->second.fEnabled)
-               u64VideoCaptureScreens |= RT_BIT_64(itScreen->first);
-            ++itScreen;
-        }
-
-        if (u64VideoCaptureScreens)
-            pelmVideoCapture->setAttribute("screens",      u64VideoCaptureScreens);
-
-        /* At the moment we only support one capturing configuration, that is, all screens
-         * have the same configuration. So load/save to/from screen 0. */
-        Assert(hw.recordingSettings.mapScreens.size());
-        const RecordingScreenMap::const_iterator itScreen0Settings = hw.recordingSettings.mapScreens.find(0);
-        Assert(itScreen0Settings != hw.recordingSettings.mapScreens.end());
-
-        if (itScreen0Settings->second.ulMaxTimeS)
-            pelmVideoCapture->setAttribute("maxTime",      itScreen0Settings->second.ulMaxTimeS);
-        if (itScreen0Settings->second.strOptions.isNotEmpty())
-            pelmVideoCapture->setAttributePath("options",  itScreen0Settings->second.strOptions);
-
-        if (!itScreen0Settings->second.File.strName.isEmpty())
-            pelmVideoCapture->setAttributePath("file",     itScreen0Settings->second.File.strName);
-        if (itScreen0Settings->second.File.ulMaxSizeMB)
-            pelmVideoCapture->setAttribute("maxSize",      itScreen0Settings->second.File.ulMaxSizeMB);
-
-        if (   itScreen0Settings->second.Video.ulWidth  != 1024
-            || itScreen0Settings->second.Video.ulHeight != 768)
-        {
-            pelmVideoCapture->setAttribute("horzRes",      itScreen0Settings->second.Video.ulWidth);
-            pelmVideoCapture->setAttribute("vertRes",      itScreen0Settings->second.Video.ulHeight);
-        }
-        if (itScreen0Settings->second.Video.ulRate != 512)
-            pelmVideoCapture->setAttribute("rate",         itScreen0Settings->second.Video.ulRate);
-        if (itScreen0Settings->second.Video.ulFPS)
-            pelmVideoCapture->setAttribute("fps",          itScreen0Settings->second.Video.ulFPS);
     }
 
@@ -7919 +7996 @@
 }
 
+void MachineConfigFile::buildRecordingXML(xml::ElementNode &elmParent, const RecordingSettings &recording)
+{
+    /* Note: Since settings 1.19 the recording settings have a dedicated XML branch outside of Hardware. */
+    if (m->sv >= SettingsVersion_v1_19 /* VBox >= 7.0 */)
+    {
+        /* Note: elmParent is Machine or Snapshot. */
+        xml::ElementNode *pelmRecording = elmParent.createChild("Recording");
+
+        if (recordingSettings.common.fEnabled)
+            pelmRecording->setAttribute("enabled", recording.common.fEnabled);
+
+        /* Only serialize screens which have non-default settings. */
+        size_t cScreensToWrite = 0;
+
+        RecordingScreenSettingsMap::const_iterator itScreen = recording.mapScreens.begin();
+        while (itScreen != recording.mapScreens.end())
+        {
+            if (!itScreen->second.areDefaultSettings())
+                cScreensToWrite++;
+            ++itScreen;
+        }
+
+        if (cScreensToWrite)
+            pelmRecording->setAttribute("screens", cScreensToWrite);
+
+        itScreen = recording.mapScreens.begin();
+        while (itScreen != recording.mapScreens.end())
+        {
+            if (!itScreen->second.areDefaultSettings()) /* Skip serializing screen settings which have default settings. */
+            {
+                xml::ElementNode *pelmScreen = pelmRecording->createChild("Screen");
+
+                pelmScreen->setAttribute("id",                  itScreen->first); /* The key equals the monitor ID. */
+                pelmScreen->setAttribute("enabled",             itScreen->second.fEnabled);
+                if (itScreen->second.ulMaxTimeS)
+                    pelmScreen->setAttribute("maxTimeS",        itScreen->second.ulMaxTimeS);
+                if (itScreen->second.strOptions.isNotEmpty())
+                    pelmScreen->setAttributePath("options",     itScreen->second.strOptions);
+                pelmScreen->setAttribute("dest",                itScreen->second.enmDest);
+                if (!itScreen->second.File.strName.isEmpty())
+                    pelmScreen->setAttributePath("file",        itScreen->second.File.strName);
+                if (itScreen->second.File.ulMaxSizeMB)
+                    pelmScreen->setAttribute("maxSizeMB",       itScreen->second.File.ulMaxSizeMB);
+
+                if (   itScreen->second.Video.ulWidth  != 1024
+                    || itScreen->second.Video.ulHeight != 768)
+                {
+                    pelmScreen->setAttribute("horzRes",         itScreen->second.Video.ulWidth);
+                    pelmScreen->setAttribute("vertRes",         itScreen->second.Video.ulHeight);
+                }
+                if (itScreen->second.Video.ulRate != 512)
+                    pelmScreen->setAttribute("rateKbps",        itScreen->second.Video.ulRate);
+                if (itScreen->second.Video.ulFPS)
+                    pelmScreen->setAttribute("fps",             itScreen->second.Video.ulFPS);
+            }
+            ++itScreen;
+        }
+    }
+    else if (   m->sv >= SettingsVersion_v1_14
+             && m->sv <  SettingsVersion_v1_19 /* VBox < 7.0 */
+             && !recording.areDefaultSettings())
+    {
+        /* Note: elmParent is Hardware or Snapshot. */
+        xml::ElementNode *pelmVideoCapture = elmParent.createChild("VideoCapture");
+
+        if (recording.common.fEnabled)
+            pelmVideoCapture->setAttribute("enabled", recording.common.fEnabled);
+
+        /* Convert the enabled screens to the former uint64_t bit array and vice versa. */
+        uint64_t u64VideoCaptureScreens = 0;
+        RecordingScreenSettingsMap::const_iterator itScreen = recording.mapScreens.begin();
+        while (itScreen != recording.mapScreens.end())
+        {
+            if (itScreen->second.fEnabled)
+               u64VideoCaptureScreens |= RT_BIT_64(itScreen->first);
+            ++itScreen;
+        }
+
+        if (u64VideoCaptureScreens)
+            pelmVideoCapture->setAttribute("screens",      u64VideoCaptureScreens);
+
+        Assert(recording.mapScreens.size());
+        const RecordingScreenSettingsMap::const_iterator itScreen0Settings = recording.mapScreens.find(0);
+        Assert(itScreen0Settings != recording.mapScreens.end());
+
+        if (itScreen0Settings->second.ulMaxTimeS)
+            pelmVideoCapture->setAttribute("maxTime",      itScreen0Settings->second.ulMaxTimeS);
+        if (itScreen0Settings->second.strOptions.isNotEmpty())
+            pelmVideoCapture->setAttributePath("options",  itScreen0Settings->second.strOptions);
+
+        if (!itScreen0Settings->second.File.strName.isEmpty())
+            pelmVideoCapture->setAttributePath("file",     itScreen0Settings->second.File.strName);
+        if (itScreen0Settings->second.File.ulMaxSizeMB)
+            pelmVideoCapture->setAttribute("maxSize",      itScreen0Settings->second.File.ulMaxSizeMB);
+
+        if (   itScreen0Settings->second.Video.ulWidth  != 1024
+            || itScreen0Settings->second.Video.ulHeight != 768)
+        {
+            pelmVideoCapture->setAttribute("horzRes",      itScreen0Settings->second.Video.ulWidth);
+            pelmVideoCapture->setAttribute("vertRes",      itScreen0Settings->second.Video.ulHeight);
+        }
+        if (itScreen0Settings->second.Video.ulRate != 512)
+            pelmVideoCapture->setAttribute("rate",         itScreen0Settings->second.Video.ulRate);
+        if (itScreen0Settings->second.Video.ulFPS)
+            pelmVideoCapture->setAttribute("fps",          itScreen0Settings->second.Video.ulFPS);
+    }
+}
+
 /**
  * Creates a \<Groups\> node under elmParent and then writes out the XML
@@ -7991 +8176 @@
         buildDebuggingXML(*pelmSnapshot, pSnap->debugging);
         buildAutostartXML(*pelmSnapshot, pSnap->autostart);
+        buildRecordingXML(*pelmSnapshot, pSnap->recordingSettings);
         // note: Groups exist only for Machine, not for Snapshot
 
@@ -8157 +8343 @@
     buildDebuggingXML(elmMachine, debugging);
     buildAutostartXML(elmMachine, autostart);
+    buildRecordingXML(elmMachine, recordingSettings);
     buildGroupsXML(elmMachine, machineUserData.llGroups);
 }
@@ -8371 +8558 @@
             || hardwareMachine.nvramSettings.strKeyId.isNotEmpty()
             || hardwareMachine.nvramSettings.strKeyStore.isNotEmpty()
+            || recordingSettings.areDefaultSettings() == false
             || strLogKeyId.isNotEmpty()
             || strLogKeyStore.isEmpty())
@@ -8635 +8823 @@
             || hardwareMachine.enmLongMode != Hardware::LongMode_Legacy
             || machineUserData.ovIcon.size() > 0
-            || hardwareMachine.recordingSettings.fEnabled)
+            || recordingSettings.common.fEnabled)
         {
             m->sv = SettingsVersion_v1_14;