Changeset 75499 in vbox for trunk/src/VBox/Main/src-client

Timestamp:

Nov 16, 2018 1:23:14 AM (6 years ago)

Author:

vboxsync

Message:

Main/Recording: build fix. Time Stamp -> Timestamp; while at it also changing variables and members to use the 'ms' prefix to indicate milliseconds.

Location:

trunk/src/VBox/Main/src-client

Files:

• Recording.cpp (modified) (11 diffs)
• RecordingStream.cpp (modified) (13 diffs)

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

@@ -484 +484 @@
  * @returns @c true if the specified screen is ready, @c false if not.
  * @param   uScreen             Screen ID.
- * @param   uTimeStampMs        Current time stamp (in ms). Currently not being used.
- */
-bool RecordingContext::IsReady(uint32_t uScreen, uint64_t uTimeStampMs)
-{
-    RT_NOREF(uTimeStampMs);
+ * @param   msTimestamp         Current timestamp (in ms). Currently not being used.
+ */
+bool RecordingContext::IsReady(uint32_t uScreen, uint64_t msTimestamp)
+{
+    RT_NOREF(msTimestamp);
 
     lock();
@@ -549 +549 @@
  * @returns true if any limit has been reached.
  * @param   uScreen             Screen ID.
- * @param   uTimeStampMs        Timestamp (in ms) to check for.
- */
-bool RecordingContext::IsLimitReached(uint32_t uScreen, uint64_t uTimeStampMs)
+ * @param   msTimestamp         Timestamp (in ms) to check for.
+ */
+bool RecordingContext::IsLimitReached(uint32_t uScreen, uint64_t msTimestamp)
 {
     lock();
@@ -559 +559 @@
     const RecordingStream *pStream = getStreamInternal(uScreen);
     if (   !pStream
-        || pStream->IsLimitReached(uTimeStampMs))
+        || pStream->IsLimitReached(msTimestamp))
     {
         fLimitReached = true;
@@ -571 +571 @@
 DECLCALLBACK(int) RecordingContext::OnLimitReached(uint32_t uScreen, int rc)
 {
-    RT_NOREF(uScreen);
+    RT_NOREF(uScreen, rc);
     LogFlowThisFunc(("Stream %RU32 has reached its limit (%Rrc)\n", uScreen, rc));
 
@@ -594 +594 @@
  * @param   pvData              Audio frame data to send.
  * @param   cbData              Size (in bytes) of (encoded) audio frame data.
- * @param   uTimeStampMs        Time stamp (in ms) of audio playback.
- */
-int RecordingContext::SendAudioFrame(const void *pvData, size_t cbData, uint64_t uTimeStampMs)
+ * @param   msTimestamp         Timestamp (in ms) of audio playback.
+ */
+int RecordingContext::SendAudioFrame(const void *pvData, size_t cbData, uint64_t msTimestamp)
 {
 #ifdef VBOX_WITH_AUDIO_RECORDING
@@ -619 +619 @@
     memcpy(pFrame->pvBuf, pvData, cbData);
 
-    pBlock->pvData       = pFrame;
-    pBlock->cbData       = sizeof(RECORDINGAUDIOFRAME) + cbData;
-    pBlock->cRefs        = this->cStreamsEnabled;
-    pBlock->uTimeStampMs = uTimeStampMs;
+    pBlock->pvData      = pFrame;
+    pBlock->cbData      = sizeof(RECORDINGAUDIOFRAME) + cbData;
+    pBlock->cRefs       = this->cStreamsEnabled;
+    pBlock->msTimestamp = msTimestamp;
 
     int rc = RTCritSectEnter(&this->CritSect);
@@ -630 +630 @@
     try
     {
-        RecordingBlockMap::iterator itBlocks = this->mapBlocksCommon.find(uTimeStampMs);
+        RecordingBlockMap::iterator itBlocks = this->mapBlocksCommon.find(msTimestamp);
         if (itBlocks == this->mapBlocksCommon.end())
         {
@@ -636 +636 @@
             pRecordingBlocks->List.push_back(pBlock);
 
-            this->mapBlocksCommon.insert(std::make_pair(uTimeStampMs, pRecordingBlocks));
+            this->mapBlocksCommon.insert(std::make_pair(msTimestamp, pRecordingBlocks));
         }
         else
@@ -655 +655 @@
     return rc;
 #else
-    RT_NOREF(pCtx, pvData, cbData, uTimeStampMs);
+    RT_NOREF(pCtx, pvData, cbData, msTimestamp);
     return VINF_SUCCESS;
 #endif
@@ -676 +676 @@
  * @param   uSrcHeight         Height of the video frame.
  * @param   puSrcData          Pointer to video frame data.
- * @param   uTimeStampMs       Time stamp (in ms).
+ * @param   msTimestamp        Timestamp (in ms).
  */
 int RecordingContext::SendVideoFrame(uint32_t uScreen, uint32_t x, uint32_t y,
                                      uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine,
                                      uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData,
-                                     uint64_t uTimeStampMs)
+                                     uint64_t msTimestamp)
 {
     AssertReturn(uSrcWidth,  VERR_INVALID_PARAMETER);
@@ -700 +700 @@
     }
 
-    rc = pStream->SendVideoFrame(x, y, uPixelFormat, uBPP, uBytesPerLine, uSrcWidth, uSrcHeight, puSrcData, uTimeStampMs);
+    rc = pStream->SendVideoFrame(x, y, uPixelFormat, uBPP, uBytesPerLine, uSrcWidth, uSrcHeight, puSrcData, msTimestamp);
 
     int rc2 = RTCritSectLeave(&this->CritSect);

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

@@ -266 +266 @@
  *
  * @returns true if any limit has been reached.
- * @param   uTimeStampMs        Timestamp (in ms) to check for.
- */
-bool RecordingStream::isLimitReachedInternal(uint64_t uTimeStampMs) const
-{
-    LogFlowThisFunc(("uTimeStampMs=%RU64, ulMaxTimeS=%RU32, tsStartMs=%RU64\n",
-                     uTimeStampMs, this->ScreenSettings.ulMaxTimeS, this->tsStartMs));
+ * @param   msTimestamp     Timestamp (in ms) to check for.
+ */
+bool RecordingStream::isLimitReachedInternal(uint64_t msTimestamp) const
+{
+    LogFlowThisFunc(("msTimestamp=%RU64, ulMaxTimeS=%RU32, tsStartMs=%RU64\n",
+                     msTimestamp, this->ScreenSettings.ulMaxTimeS, this->tsStartMs));
 
     if (   this->ScreenSettings.ulMaxTimeS
-        && uTimeStampMs >= this->tsStartMs + (this->ScreenSettings.ulMaxTimeS * RT_MS_1SEC))
+        && msTimestamp >= this->tsStartMs + (this->ScreenSettings.ulMaxTimeS * RT_MS_1SEC))
     {
         LogRel(("Recording: Time limit for stream #%RU16 has been reached (%RU32s)\n",
@@ -311 +311 @@
  *
  * @returns IPRT status code.
- * @param   uTimeStampMs        Current timestamp (in ms).
- */
-int RecordingStream::iterateInternal(uint64_t uTimeStampMs)
+ * @param   msTimestamp         Current timestamp (in ms).
+ */
+int RecordingStream::iterateInternal(uint64_t msTimestamp)
 {
     if (!this->fEnabled)
@@ -320 +320 @@
     int rc;
 
-    if (isLimitReachedInternal(uTimeStampMs))
+    if (isLimitReachedInternal(msTimestamp))
     {
         rc = VINF_RECORDING_LIMIT_REACHED;
@@ -352 +352 @@
  *
  * @returns true if any limit has been reached.
- * @param   uTimeStampMs        Timestamp (in ms) to check for.
- */
-bool RecordingStream::IsLimitReached(uint64_t uTimeStampMs) const
+ * @param   msTimestamp         Timestamp (in ms) to check for.
+ */
+bool RecordingStream::IsLimitReached(uint64_t msTimestamp) const
 {
     if (!IsReady())
         return true;
 
-    return isLimitReachedInternal(uTimeStampMs);
+    return isLimitReachedInternal(msTimestamp);
 }
 
@@ -397 +397 @@
     while (itStreamBlocks != Blocks.Map.end())
     {
-        const uint64_t         uTimeStampMs = itStreamBlocks->first;
-              RecordingBlocks *pBlocks      = itStreamBlocks->second;
+        uint64_t const   msTimestamp = itStreamBlocks->first;
+        RecordingBlocks *pBlocks     = itStreamBlocks->second;
 
         AssertPtr(pBlocks);
@@ -419 +419 @@
                 if (RT_SUCCESS(rc2))
                 {
-                    rc2 = writeVideoVPX(uTimeStampMs, pVideoFrame);
+                    rc2 = writeVideoVPX(msTimestamp, pVideoFrame);
                     AssertRC(rc2);
                     if (RT_SUCCESS(rc))
@@ -459 +459 @@
 
                     WebMWriter::BlockData_Opus blockData = { pAudioFrame->pvBuf, pAudioFrame->cbBuf,
-                                                             pBlockCommon->uTimeStampMs };
+                                                             pBlockCommon->msTimestamp };
                     AssertPtr(this->File.pWEBM);
                     int rc2 = this->File.pWEBM->WriteBlock(this->uTrackAudio, &blockData, sizeof(blockData));
@@ -519 +519 @@
  * @param   uSrcHeight          Height (in pixels) of the video frame.
  * @param   puSrcData           Actual pixel data of the video frame.
- * @param   uTimeStampMs        Timestamp (in ms) as PTS.
+ * @param   msTimestamp         Timestamp (in ms) as PTS.
  */
 int RecordingStream::SendVideoFrame(uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine,
-                                    uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, uint64_t uTimeStampMs)
+                                    uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, uint64_t msTimestamp)
 {
     lock();
 
-    LogFlowFunc(("uTimeStampMs=%RU64\n", uTimeStampMs));
+    LogFlowFunc(("msTimestamp=%RU64\n", msTimestamp));
 
     PRECORDINGVIDEOFRAME pFrame = NULL;
 
-    int rc = iterateInternal(uTimeStampMs);
+    int rc = iterateInternal(msTimestamp);
     if (rc != VINF_SUCCESS) /* Can return VINF_RECORDING_LIMIT_REACHED. */
     {
@@ -539 +539 @@
     do
     {
-        if (uTimeStampMs < this->Video.uLastTimeStampMs + this->Video.uDelayMs)
+        if (msTimestamp < this->Video.uLastTimeStampMs + this->Video.uDelayMs)
         {
             rc = VINF_RECORDING_THROTTLED; /* Respect maximum frames per second. */
@@ -545 +545 @@
         }
 
-        this->Video.uLastTimeStampMs = uTimeStampMs;
+        this->Video.uLastTimeStampMs = msTimestamp;
 
         int xDiff = ((int)this->ScreenSettings.Video.ulWidth - (int)uSrcWidth) / 2;
@@ -718 +718 @@
                 pRecordingBlocks->List.push_back(pBlock);
 
-                Assert(this->Blocks.Map.find(uTimeStampMs) == this->Blocks.Map.end());
-                this->Blocks.Map.insert(std::make_pair(uTimeStampMs, pRecordingBlocks));
+                Assert(this->Blocks.Map.find(msTimestamp) == this->Blocks.Map.end());
+                this->Blocks.Map.insert(std::make_pair(msTimestamp, pRecordingBlocks));
             }
             catch (const std::exception &ex)
@@ -1155 +1155 @@
  *
  * @returns IPRT status code.
- * @param   uTimeStampMs        Absolute timestamp (PTS) of frame (in ms) to encode.
+ * @param   msTimestamp         Absolute timestamp (PTS) of frame (in ms) to encode.
  * @param   pFrame              Frame to encode and submit.
  */
-int RecordingStream::writeVideoVPX(uint64_t uTimeStampMs, PRECORDINGVIDEOFRAME pFrame)
+int RecordingStream::writeVideoVPX(uint64_t msTimestamp, PRECORDINGVIDEOFRAME pFrame)
 {
     AssertPtrReturn(pFrame, VERR_INVALID_POINTER);
@@ -1166 +1166 @@
     PRECORDINGVIDEOCODEC pCodec = &this->Video.Codec;
 
-    /* Presentation Time Stamp (PTS). */
-    vpx_codec_pts_t pts = uTimeStampMs;
+    /* Presentation TimeStamp (PTS). */
+    vpx_codec_pts_t pts = msTimestamp;
     vpx_codec_err_t rcv = vpx_codec_encode(&pCodec->VPX.Ctx,
                                            &pCodec->VPX.RawImage,
-                                           pts                          /* Time stamp */,
+                                           pts                          /* Timestamp */,
                                            this->Video.uDelayMs         /* How long to show this frame */,
                                            0                            /* Flags */,