Changeset 75254 in vbox for trunk/src

Timestamp:

Nov 5, 2018 6:35:21 PM (6 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

126356

Message:

Capturing: Build fix.

Location:

trunk/src/VBox/Main

Files:

• include/DrvAudioVideoRec.h (modified) (1 diff)
• include/VideoRecStream.h (modified) (6 diffs)
• src-client/DrvAudioVideoRec.cpp (modified) (1 diff)
• src-client/VideoRec.cpp (modified) (1 diff)
• src-client/VideoRecStream.cpp (modified) (37 diffs)

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

@@ -45 +45 @@
 public:
 
-    int applyConfiguration(const settings::CaptureSettings &a_Settings);
+    int applyConfiguration(const settings::CaptureSettings &Settings);
 
 public:

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

@@ -32 +32 @@
 
 class WebMWriter;
-
-struct CaptureContext;
-typedef struct CaptureContext *PVIDEORECCONTEXT;
-
+class CaptureContext;
 
 /** Structure for queuing all blocks bound to a single timecode.
@@ -114 +111 @@
     CaptureStream(void);
 
-    CaptureStream(uint32_t a_uScreen, const settings::CaptureScreenSettings &a_Settings);
+    CaptureStream(uint32_t uScreen, const settings::CaptureScreenSettings &Settings);
 
     virtual ~CaptureStream(void);
@@ -120 +117 @@
 public:
 
-    int Init(uint32_t a_uScreen, const settings::CaptureScreenSettings &a_Settings);
+    int Init(uint32_t uScreen, const settings::CaptureScreenSettings &Settings);
     int Uninit(void);
 
@@ -136 +133 @@
     int close(void);
 
-    int initInternal(uint32_t a_uScreen, const settings::CaptureScreenSettings &a_Settings);
+    int initInternal(uint32_t uScreen, const settings::CaptureScreenSettings &Settings);
     int uninitInternal(void);
 
@@ -158 +155 @@
     /** Recording context this stream is associated to. */
     CaptureContext             *pCtx;
-    union
-    {
-        struct
-        {
-            /** File handle to use for writing. */
-            RTFILE              hFile;
-            /** File name being used for this stream. */
-            Utf8Str             strName;
-            /** Pointer to WebM writer instance being used. */
-            WebMWriter         *pWEBM;
-        } File;
-    };
+    struct
+    {
+        /** File handle to use for writing. */
+        RTFILE              hFile;
+        /** File name being used for this stream. */
+        Utf8Str             strName;
+        /** Pointer to WebM writer instance being used. */
+        WebMWriter         *pWEBM;
+    } File;
     bool                fEnabled;
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
@@ -196 +190 @@
     } Video;
 
-    settings::CaptureScreenSettings Settings;
+    settings::CaptureScreenSettings ScreenSettings;
     /** Common set of video recording (data) blocks, needed for
      *  multiplexing to all recording streams. */

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

@@ -1088 +1088 @@
  * @param   Settings        Capturing configuration to apply.
  */
-int AudioVideoRec::applyConfiguration(const settings::CaptureSettings &a_Settings)
+int AudioVideoRec::applyConfiguration(const settings::CaptureSettings &Settings)
 {
     /** @todo Do some validation here. */
-    mVideoRecCfg = a_Settings; /* Note: Does have an own copy operator. */
+    mVideoRecCfg = Settings; /* Note: Does have an own copy operator. */
     return VINF_SUCCESS;
 }

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

@@ -187 +187 @@
  *
  * @returns IPRT status code.
- * @param   cScreens            Number of screens to create context for.
- * @param   pVideoRecCfg        Pointer to video recording configuration to use.
+ * @param   a_Settings          Capture settings to use for context creation.
  */
 int CaptureContext::createInternal(const settings::CaptureSettings &a_Settings)

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

@@ -47 +47 @@
 }
 
-CaptureStream::CaptureStream(uint32_t a_uScreen, const settings::CaptureScreenSettings &a_Settings)
+CaptureStream::CaptureStream(uint32_t uScreen, const settings::CaptureScreenSettings &Settings)
     : tsStartMs(0)
 {
-    int rc2 = initInternal(a_uScreen, a_Settings);
+    int rc2 = initInternal(uScreen, Settings);
     if (RT_FAILURE(rc2))
         throw rc2;
@@ -68 +68 @@
 int CaptureStream::open(void)
 {
-    Assert(Settings.enmDest == CaptureDestination_None);
+    Assert(ScreenSettings.enmDest == CaptureDestination_None);
 
     int rc;
 
-    switch (Settings.enmDest)
+    switch (ScreenSettings.enmDest)
     {
         case CaptureDestination_File:
         {
-            Assert(Settings.File.strName.isNotEmpty());
-
-            char *pszAbsPath = RTPathAbsDup(Settings.File.strName.c_str());
+            Assert(ScreenSettings.File.strName.isNotEmpty());
+
+            char *pszAbsPath = RTPathAbsDup(ScreenSettings.File.strName.c_str());
             AssertPtrReturn(pszAbsPath, VERR_NO_MEMORY);
 
@@ -172 +172 @@
         {
 #ifdef VBOX_WITH_LIBVPX
-            Assert(this->Settings.Video.ulFPS);
+            Assert(this->ScreenSettings.Video.ulFPS);
             if (value.compare("realtime", Utf8Str::CaseInsensitive) == 0)
                 this->Video.Codec.VPX.uEncoderDeadline = VPX_DL_REALTIME;
             else if (value.compare("good", Utf8Str::CaseInsensitive) == 0)
-                this->Video.Codec.VPX.uEncoderDeadline = 1000000 / this->Settings.Video.ulFPS;
+                this->Video.Codec.VPX.uEncoderDeadline = 1000000 / this->ScreenSettings.Video.ulFPS;
             else if (value.compare("best", Utf8Str::CaseInsensitive) == 0)
                 this->Video.Codec.VPX.uEncoderDeadline = VPX_DL_BEST_QUALITY;
@@ -190 +190 @@
             if (value.compare("false", Utf8Str::CaseInsensitive) == 0)
             {
-                this->Settings.featureMap[CaptureFeature_Video] = false;
+                this->ScreenSettings.featureMap[CaptureFeature_Video] = false;
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
                 LogRel(("VideoRec: Only audio will be recorded\n"));
@@ -201 +201 @@
             if (value.compare("true", Utf8Str::CaseInsensitive) == 0)
             {
-                this->Settings.featureMap[CaptureFeature_Audio] = true;
+                this->ScreenSettings.featureMap[CaptureFeature_Audio] = true;
             }
             else
@@ -212 +212 @@
             if (value.compare("low", Utf8Str::CaseInsensitive) == 0)
             {
-                this->Settings.Audio.uHz       = 8000;
-                this->Settings.Audio.cBits     = 16;
-                this->Settings.Audio.cChannels = 1;
+                this->ScreenSettings.Audio.uHz       = 8000;
+                this->ScreenSettings.Audio.cBits     = 16;
+                this->ScreenSettings.Audio.cChannels = 1;
             }
             else if (value.startsWith("med" /* "med[ium]" */, Utf8Str::CaseInsensitive) == 0)
@@ -222 +222 @@
             else if (value.compare("high", Utf8Str::CaseInsensitive) == 0)
             {
-                this->Settings.Audio.uHz       = 48000;
-                this->Settings.Audio.cBits     = 16;
-                this->Settings.Audio.cChannels = 2;
+                this->ScreenSettings.Audio.uHz       = 48000;
+                this->ScreenSettings.Audio.cBits     = 16;
+                this->ScreenSettings.Audio.cChannels = 2;
             }
 #endif
@@ -238 +238 @@
 const settings::CaptureScreenSettings &CaptureStream::GetConfig(void) const
 {
-    return this->Settings;
+    return this->ScreenSettings;
 }
 
@@ -252 +252 @@
         return true;
 
-    if (   Settings.ulMaxTimeS
-        && tsNowMs >= this->tsStartMs + (Settings.ulMaxTimeS * RT_MS_1SEC))
+    if (   this->ScreenSettings.ulMaxTimeS
+        && tsNowMs >= this->tsStartMs + (this->ScreenSettings.ulMaxTimeS * RT_MS_1SEC))
     {
         return true;
     }
 
-    if (Settings.enmDest == CaptureDestination_File)
-    {
-
-        if (Settings.File.ulMaxSizeMB)
+    if (this->ScreenSettings.enmDest == CaptureDestination_File)
+    {
+
+        if (this->ScreenSettings.File.ulMaxSizeMB)
         {
             uint64_t sizeInMB = this->File.pWEBM->GetFileSize() / _1M;
-            if(sizeInMB >= Settings.File.ulMaxSizeMB)
+            if(sizeInMB >= this->ScreenSettings.File.ulMaxSizeMB)
                 return true;
         }
@@ -297 +297 @@
     lock();
 
-    if (!Settings.fEnabled)
+    if (!this->ScreenSettings.fEnabled)
     {
         unlock();
@@ -327 +327 @@
                                       this->Video.Codec.VPX.pu8YuvBuf, pVideoFrame->uWidth, pVideoFrame->uHeight,
                                       /* Source */
-                                      pVideoFrame->pu8RGBBuf, this->Settings.Video.ulWidth, this->Settings.Video.ulHeight);
+                                      pVideoFrame->pu8RGBBuf, this->ScreenSettings.Video.ulWidth, this->ScreenSettings.Video.ulHeight);
                 if (RT_SUCCESS(rc))
                 {
@@ -440 +440 @@
         this->Video.uLastTimeStampMs = uTimeStampMs;
 
-        int xDiff = ((int)this->Settings.Video.ulWidth - (int)uSrcWidth) / 2;
+        int xDiff = ((int)this->ScreenSettings.Video.ulWidth - (int)uSrcWidth) / 2;
         uint32_t w = uSrcWidth;
         if ((int)w + xDiff + (int)x <= 0)  /* Nothing visible. */
@@ -459 +459 @@
 
         uint32_t h = uSrcHeight;
-        int yDiff = ((int)this->Settings.Video.ulHeight - (int)uSrcHeight) / 2;
+        int yDiff = ((int)this->ScreenSettings.Video.ulHeight - (int)uSrcHeight) / 2;
         if ((int)h + yDiff + (int)y <= 0)  /* Nothing visible. */
         {
@@ -476 +476 @@
             destY = y + yDiff;
 
-        if (   destX > this->Settings.Video.ulWidth
-            || destY > this->Settings.Video.ulHeight)
+        if (   destX > this->ScreenSettings.Video.ulWidth
+            || destY > this->ScreenSettings.Video.ulHeight)
         {
             rc = VERR_INVALID_PARAMETER;  /* Nothing visible. */
@@ -483 +483 @@
         }
 
-        if (destX + w > this->Settings.Video.ulWidth)
-            w = this->Settings.Video.ulWidth - destX;
-
-        if (destY + h > this->Settings.Video.ulHeight)
-            h = this->Settings.Video.ulHeight - destY;
+        if (destX + w > this->ScreenSettings.Video.ulWidth)
+            w = this->ScreenSettings.Video.ulWidth - destX;
+
+        if (destY + h > this->ScreenSettings.Video.ulHeight)
+            h = this->ScreenSettings.Video.ulHeight - destY;
 
         pFrame = (PVIDEORECVIDEOFRAME)RTMemAllocZ(sizeof(VIDEORECVIDEOFRAME));
@@ -515 +515 @@
             AssertMsgFailedBreakStmt(("Unknown pixel format (%RU32)\n", uPixelFormat), rc = VERR_NOT_SUPPORTED);
 
-        const size_t cbRGBBuf =   this->Settings.Video.ulWidth
-                                * this->Settings.Video.ulHeight
+        const size_t cbRGBBuf =   this->ScreenSettings.Video.ulWidth
+                                * this->ScreenSettings.Video.ulHeight
                                 * uBytesPerPixel;
         AssertBreakStmt(cbRGBBuf, rc = VERR_INVALID_PARAMETER);
@@ -528 +528 @@
         /* If the current video frame is smaller than video resolution we're going to encode,
          * clear the frame beforehand to prevent artifacts. */
-        if (   uSrcWidth  < this->Settings.Video.ulWidth
-            || uSrcHeight < this->Settings.Video.ulHeight)
+        if (   uSrcWidth  < this->ScreenSettings.Video.ulWidth
+            || uSrcHeight < this->ScreenSettings.Video.ulHeight)
         {
             RT_BZERO(pFrame->pu8RGBBuf, pFrame->cbRGBBuf);
@@ -536 +536 @@
         /* Calculate start offset in source and destination buffers. */
         uint32_t offSrc = y * uBytesPerLine + x * uBytesPerPixel;
-        uint32_t offDst = (destY * this->Settings.Video.ulWidth + destX) * uBytesPerPixel;
+        uint32_t offDst = (destY * this->ScreenSettings.Video.ulWidth + destX) * uBytesPerPixel;
 
 #ifdef VBOX_VIDEOREC_DUMP
@@ -576 +576 @@
             /* Overflow check. */
             Assert(offSrc + w * uBytesPerPixel <= uSrcHeight * uBytesPerLine);
-            Assert(offDst + w * uBytesPerPixel <= this->Settings.Video.ulHeight * this->Settings.Video.ulWidth * uBytesPerPixel);
+            Assert(offDst + w * uBytesPerPixel <= this->ScreenSettings.Video.ulHeight * this->ScreenSettings.Video.ulWidth * uBytesPerPixel);
 
             memcpy(pFrame->pu8RGBBuf + offDst, puSrcData + offSrc, w * uBytesPerPixel);
@@ -585 +585 @@
 #endif
             offSrc += uBytesPerLine;
-            offDst += this->Settings.Video.ulWidth * uBytesPerPixel;
+            offDst += this->ScreenSettings.Video.ulWidth * uBytesPerPixel;
         }
 
@@ -634 +634 @@
 }
 
-int CaptureStream::Init(uint32_t a_uScreen, const settings::CaptureScreenSettings &a_Settings)
-{
-    return initInternal(a_uScreen, a_Settings);
+int CaptureStream::Init(uint32_t uScreen, const settings::CaptureScreenSettings &Settings)
+{
+    return initInternal(uScreen, Settings);
 }
 
@@ -644 +644 @@
  * @returns IPRT status code.
  * @param   uScreen             Screen number to use for this recording stream.
- * @param   Cfg                 Recording screen configuration to use for initialization.
- */
-int CaptureStream::initInternal(uint32_t a_uScreen, const settings::CaptureScreenSettings &a_Settings)
-{
-    int rc = parseOptionsString(a_Settings.strOptions);
+ * @param   Settings            Capturing configuration to use for initialization.
+ */
+int CaptureStream::initInternal(uint32_t uScreen, const settings::CaptureScreenSettings &Settings)
+{
+    int rc = parseOptionsString(Settings.strOptions);
     if (RT_FAILURE(rc))
         return rc;
@@ -660 +660 @@
         return rc;
 
-    const bool fVideoEnabled = a_Settings.isFeatureEnabled(CaptureFeature_Video);
-    const bool fAudioEnabled = a_Settings.isFeatureEnabled(CaptureFeature_Audio);
+    const bool fVideoEnabled = Settings.isFeatureEnabled(CaptureFeature_Video);
+    const bool fAudioEnabled = Settings.isFeatureEnabled(CaptureFeature_Audio);
 
     if (fVideoEnabled)
@@ -669 +669 @@
         rc = initAudio();
 
-    switch (this->Settings.enmDest)
+    switch (this->ScreenSettings.enmDest)
     {
         case CaptureDestination_File:
         {
-            const char *pszFile = this->Settings.File.strName.c_str();
+            const char *pszFile = this->ScreenSettings.File.strName.c_str();
 
             rc = File.pWEBM->OpenEx(pszFile, &this->File.hFile,
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
-                                      a_Settings.isFeatureEnabled(CaptureFeature_Audio)
+                                      Settings.isFeatureEnabled(CaptureFeature_Audio)
                                     ? WebMWriter::AudioCodec_Opus : WebMWriter::AudioCodec_None,
 #else
                                       WebMWriter::AudioCodec_None,
 #endif
-                                      a_Settings.isFeatureEnabled(CaptureFeature_Video)
+                                      Settings.isFeatureEnabled(CaptureFeature_Video)
                                     ? WebMWriter::VideoCodec_VP8 : WebMWriter::VideoCodec_None);
             if (RT_FAILURE(rc))
@@ -692 +692 @@
             if (fVideoEnabled)
             {
-                rc = this->File.pWEBM->AddVideoTrack(a_Settings.Video.ulWidth, a_Settings.Video.ulHeight,
-                                                     a_Settings.Video.ulFPS, &this->uTrackVideo);
+                rc = this->File.pWEBM->AddVideoTrack(Settings.Video.ulWidth, Settings.Video.ulHeight,
+                                                     Settings.Video.ulFPS, &this->uTrackVideo);
                 if (RT_FAILURE(rc))
                 {
@@ -701 +701 @@
 
                 LogRel(("VideoRec: Recording video of screen #%u with %RU32x%RU32 @ %RU32 kbps, %RU32 FPS (track #%RU8)\n",
-                        this->uScreenID, a_Settings.Video.ulWidth, a_Settings.Video.ulHeight, a_Settings.Video.ulRate,
-                        a_Settings.Video.ulFPS, this->uTrackVideo));
+                        this->uScreenID, Settings.Video.ulWidth, Settings.Video.ulHeight, Settings.Video.ulRate,
+                        Settings.Video.ulFPS, this->uTrackVideo));
             }
 
@@ -708 +708 @@
             if (fAudioEnabled)
             {
-                rc = this->File.pWEBM->AddAudioTrack(a_Settings.Audio.uHz, a_Settings.Audio.cChannels, a_Settings.Audio.cBits,
+                rc = this->File.pWEBM->AddAudioTrack(Settings.Audio.uHz, Settings.Audio.cChannels, Settings.Audio.cBits,
                                                      &this->uTrackAudio);
                 if (RT_FAILURE(rc))
@@ -717 +717 @@
 
                 LogRel(("VideoRec: Recording audio in %RU16Hz, %RU8 bit, %RU8 %s (track #%RU8)\n",
-                        a_Settings.Audio.uHz, a_Settings.Audio.cBits, a_Settings.Audio.cChannels,
-                        a_Settings.Audio.cChannels ? "channels" : "channel", this->uTrackAudio));
+                        Settings.Audio.uHz, Settings.Audio.cBits, Settings.Audio.cChannels,
+                        Settings.Audio.cChannels ? "channels" : "channel", this->uTrackAudio));
             }
 #endif
@@ -755 +755 @@
         this->pCtx      = pCtx;
         this->fEnabled  = true;
-        this->uScreenID = a_uScreen;
+        this->uScreenID = uScreen;
         this->tsStartMs = RTTimeMilliTS();
-        this->Settings  = a_Settings;
+        this->ScreenSettings  = Settings;
     }
     else
@@ -782 +782 @@
     if (this->fEnabled)
     {
-        switch (this->Settings.enmDest)
+        switch (this->ScreenSettings.enmDest)
         {
             case CaptureDestination_File:
@@ -807 +807 @@
     }
 
-    switch (this->Settings.enmDest)
+    switch (this->ScreenSettings.enmDest)
     {
         case CaptureDestination_File:
@@ -816 +816 @@
                 if (RT_SUCCESS(rc))
                 {
-                    LogRel(("VideoRec: Closed file '%s'\n", this->Settings.File.strName.c_str()));
+                    LogRel(("VideoRec: Closed file '%s'\n", this->ScreenSettings.File.strName.c_str()));
                 }
                 else
                 {
-                    LogRel(("VideoRec: Error closing file '%s', rc=%Rrc\n", this->Settings.File.strName.c_str(), rc));
+                    LogRel(("VideoRec: Error closing file '%s', rc=%Rrc\n", this->ScreenSettings.File.strName.c_str(), rc));
                     break;
                 }
@@ -858 +858 @@
         return rc;
 
-    if (this->Settings.isFeatureEnabled(CaptureFeature_Video))
+    if (this->ScreenSettings.isFeatureEnabled(CaptureFeature_Video))
     {
         int rc2 = unitVideo();
@@ -911 +911 @@
 {
     /* Sanity. */
-    AssertReturn(this->Settings.Video.ulRate,   VERR_INVALID_PARAMETER);
-    AssertReturn(this->Settings.Video.ulWidth,  VERR_INVALID_PARAMETER);
-    AssertReturn(this->Settings.Video.ulHeight, VERR_INVALID_PARAMETER);
-    AssertReturn(this->Settings.Video.ulFPS,    VERR_INVALID_PARAMETER);
+    AssertReturn(this->ScreenSettings.Video.ulRate,   VERR_INVALID_PARAMETER);
+    AssertReturn(this->ScreenSettings.Video.ulWidth,  VERR_INVALID_PARAMETER);
+    AssertReturn(this->ScreenSettings.Video.ulHeight, VERR_INVALID_PARAMETER);
+    AssertReturn(this->ScreenSettings.Video.ulFPS,    VERR_INVALID_PARAMETER);
 
     this->Video.cFailedEncodingFrames = 0;
-    this->Video.uDelayMs = RT_MS_1SEC / this->Settings.Video.ulFPS;
+    this->Video.uDelayMs = RT_MS_1SEC / this->ScreenSettings.Video.ulFPS;
 
 #ifdef VBOX_WITH_LIBVPX
@@ -951 +951 @@
 
     /* Target bitrate in kilobits per second. */
-    pCodec->VPX.Cfg.rc_target_bitrate = this->Settings.Video.ulRate;
+    pCodec->VPX.Cfg.rc_target_bitrate = this->ScreenSettings.Video.ulRate;
     /* Frame width. */
-    pCodec->VPX.Cfg.g_w = this->Settings.Video.ulWidth;
+    pCodec->VPX.Cfg.g_w = this->ScreenSettings.Video.ulWidth;
     /* Frame height. */
-    pCodec->VPX.Cfg.g_h = this->Settings.Video.ulHeight;
+    pCodec->VPX.Cfg.g_h = this->ScreenSettings.Video.ulHeight;
     /* 1ms per frame. */
     pCodec->VPX.Cfg.g_timebase.num = 1;
@@ -971 +971 @@
 
     if (!vpx_img_alloc(&pCodec->VPX.RawImage, VPX_IMG_FMT_I420,
-                       this->Settings.Video.ulWidth, this->Settings.Video.ulHeight, 1))
+                       this->ScreenSettings.Video.ulWidth, this->ScreenSettings.Video.ulHeight, 1))
     {
         LogRel(("VideoRec: Failed to allocate image %RU32x%RU32\n",
-                this->Settings.Video.ulWidth, this->Settings.Video.ulHeight));
+                this->ScreenSettings.Video.ulWidth, this->ScreenSettings.Video.ulHeight));
         return VERR_NO_MEMORY;
     }
@@ -988 +988 @@
 {
 #ifdef VBOX_WITH_AUDIO_VIDEOREC
-    if (this->Settings.isFeatureEnabled(CaptureFeature_Audio))
+    if (this->ScreenSettings.isFeatureEnabled(CaptureFeature_Audio))
     {
         /* Sanity. */
-        AssertReturn(this->Settings.Audio.uHz,       VERR_INVALID_PARAMETER);
-        AssertReturn(this->Settings.Audio.cBits,     VERR_INVALID_PARAMETER);
-        AssertReturn(this->Settings.Audio.cChannels, VERR_INVALID_PARAMETER);
+        AssertReturn(this->ScreenSettings.Audio.uHz,       VERR_INVALID_PARAMETER);
+        AssertReturn(this->ScreenSettings.Audio.cBits,     VERR_INVALID_PARAMETER);
+        AssertReturn(this->ScreenSettings.Audio.cChannels, VERR_INVALID_PARAMETER);
     }
 #endif