Changeset 96324 in vbox

Timestamp:

Aug 19, 2022 8:15:55 AM (2 years ago)

Author:

vboxsync

Message:

Recording/Main: Renaming (use m_ prefixes for class variables).

Location:

trunk/src/VBox/Main

Files:

• include/Recording.h (modified) (4 diffs)
• include/RecordingStream.h (modified) (3 diffs)
• include/WebMWriter.h (modified) (7 diffs)
• src-client/Recording.cpp (modified) (33 diffs)
• src-client/RecordingStream.cpp (modified) (49 diffs)
• src-client/WebMWriter.cpp (modified) (32 diffs)

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

@@ -48 +48 @@
     size_t GetStreamCount(void) const;
 #ifdef VBOX_WITH_AUDIO_RECORDING
-    PRECORDINGCODEC GetCodecAudio(void) { return &this->CodecAudio; }
+    PRECORDINGCODEC GetCodecAudio(void) { return &this->m_CodecAudio; }
 #endif
 
@@ -118 +118 @@
 
     /** Pointer to the console object. */
-    Console                     *pConsole;
+    Console                     *m_pConsole;
     /** Used recording configuration. */
     settings::RecordingSettings  m_Settings;
     /** The current state. */
-    RECORDINGSTS                 enmState;
+    RECORDINGSTS                 m_enmState;
     /** Critical section to serialize access. */
-    RTCRITSECT                   CritSect;
+    RTCRITSECT                   m_CritSect;
     /** Semaphore to signal the encoding worker thread. */
-    RTSEMEVENT                   WaitEvent;
+    RTSEMEVENT                   m_WaitEvent;
     /** Shutdown indicator. */
-    bool                         fShutdown;
+    bool                         m_fShutdown;
     /** Encoding worker thread. */
-    RTTHREAD                     Thread;
+    RTTHREAD                     m_Thread;
     /** Vector of current recording streams.
      *  Per VM screen (display) one recording stream is being used. */
-    RecordingStreams             vecStreams;
+    RecordingStreams             m_vecStreams;
     /** Number of streams in vecStreams which currently are enabled for recording. */
-    uint16_t                     cStreamsEnabled;
+    uint16_t                     m_cStreamsEnabled;
     /** Timestamp (in ms) of when recording has been started. */
-    uint64_t                     tsStartMs;
+    uint64_t                     m_tsStartMs;
 #ifdef VBOX_WITH_AUDIO_RECORDING
     /** Audio codec to use.
@@ -145 +145 @@
      *  all audio data of a VM will be the same for each stream at a given
      *  point in time. */
-    RECORDINGCODEC               CodecAudio;
+    RECORDINGCODEC               m_CodecAudio;
 #endif /* VBOX_WITH_AUDIO_RECORDING */
     /** Block map of raw common data blocks which need to get encoded first. */
-    RecordingBlockMap            mapBlocksRaw;
+    RecordingBlockMap            m_mapBlocksRaw;
     /** Block map of encoded common blocks.
      *
@@ -159 +159 @@
      *  For now this only affects audio, e.g. all recording streams
      *  need to have the same audio data at a specific point in time. */
-    RecordingBlockMap            mapBlocksEncoded;
+    RecordingBlockMap            m_mapBlocksEncoded;
 };
 #endif /* !MAIN_INCLUDED_Recording_h */

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

@@ -125 +125 @@
 
     const settings::RecordingScreenSettings &GetConfig(void) const;
-    uint16_t GetID(void) const { return this->uScreenID; };
+    uint16_t GetID(void) const { return this->m_uScreenID; };
 #ifdef VBOX_WITH_AUDIO_RECORDING
-    PRECORDINGCODEC GetAudioCodec(void) { return this->pCodecAudio; };
+    PRECORDINGCODEC GetAudioCodec(void) { return this->m_pCodecAudio; };
 #endif
-    PRECORDINGCODEC GetVideoCodec(void) { return &this->CodecVideo; };
+    PRECORDINGCODEC GetVideoCodec(void) { return &this->m_CodecVideo; };
 
     bool IsLimitReached(uint64_t msTimestamp) const;
@@ -176 +176 @@
     RecordingContext       *m_pCtx;
     /** The current state. */
-    RECORDINGSTREAMSTATE    enmState;
+    RECORDINGSTREAMSTATE    m_enmState;
     struct
     {
         /** File handle to use for writing. */
-        RTFILE              hFile;
+        RTFILE              m_hFile;
         /** Pointer to WebM writer instance being used. */
-        WebMWriter         *pWEBM;
+        WebMWriter         *m_pWEBM;
     } File;
-    bool                fEnabled;
+    bool                m_fEnabled;
     /** Track number of audio stream.
      *  Set to UINT8_MAX if not being used. */
-    uint8_t             uTrackAudio;
+    uint8_t             m_uTrackAudio;
     /** Track number of video stream.
      *  Set to UINT8_MAX if not being used. */
-    uint8_t             uTrackVideo;
+    uint8_t             m_uTrackVideo;
     /** Screen ID. */
-    uint16_t            uScreenID;
+    uint16_t            m_uScreenID;
     /** Critical section to serialize access. */
-    RTCRITSECT          CritSect;
+    RTCRITSECT          m_CritSect;
     /** Timestamp (in ms) of when recording has been started. */
-    uint64_t            tsStartMs;
+    uint64_t            m_tsStartMs;
 #ifdef VBOX_WITH_AUDIO_RECORDING
     /** Pointer to audio codec instance data to use.
@@ -206 +206 @@
      *
      *  Might be NULL if not being used. */
-    PRECORDINGCODEC     pCodecAudio;
+    PRECORDINGCODEC     m_pCodecAudio;
 #endif /* VBOX_WITH_AUDIO_RECORDING */
     /** Video codec instance data to use. */
-    RECORDINGCODEC      CodecVideo;
+    RECORDINGCODEC      m_CodecVideo;
     /** Screen settings to use. */
     settings::RecordingScreenSettings
-                        ScreenSettings;
+                        m_ScreenSettings;
     /** Common set of recording (data) blocks, needed for
      *  multiplexing to all recording streams. */
-    RecordingBlockSet   Blocks;
+    RecordingBlockSet   m_Blocks;
 };
 

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

@@ -373 +373 @@
     {
         WebMSegment(void)
-            : tcAbsStartMs(0)
-            , tcAbsLastWrittenMs(0)
-            , offStart(0)
-            , offInfo(0)
-            , offSeekInfo(0)
-            , offTracks(0)
-            , offCues(0)
-            , cClusters(0)
-        {
-            uTimecodeScaleFactor = VBOX_WEBM_TIMECODESCALE_FACTOR_MS;
-
-            LogFunc(("Default timecode scale is: %RU64ns\n", uTimecodeScaleFactor));
+            : m_tcAbsStartMs(0)
+            , m_tcAbsLastWrittenMs(0)
+            , m_offStart(0)
+            , m_offInfo(0)
+            , m_offSeekInfo(0)
+            , m_offTracks(0)
+            , m_offCues(0)
+            , m_cClusters(0)
+        {
+            m_uTimecodeScaleFactor = VBOX_WEBM_TIMECODESCALE_FACTOR_MS;
+
+            LogFunc(("Default timecode scale is: %RU64ns\n", m_uTimecodeScaleFactor));
         }
 
@@ -399 +399 @@
         int init(void)
         {
-            return RTCritSectInit(&CritSect);
+            return RTCritSectInit(&m_CritSect);
         }
 
@@ -409 +409 @@
             clear();
 
-            RTCritSectDelete(&CritSect);
+            RTCritSectDelete(&m_CritSect);
         }
 
@@ -417 +417 @@
         void clear(void)
         {
-            WebMCuePointList::iterator itCuePoint = lstCuePoints.begin();
-            while (itCuePoint != lstCuePoints.end())
+            WebMCuePointList::iterator itCuePoint = m_lstCuePoints.begin();
+            while (itCuePoint != m_lstCuePoints.end())
             {
                 WebMCuePoint *pCuePoint = (*itCuePoint);
@@ -424 +424 @@
                 delete pCuePoint;
 
-                lstCuePoints.erase(itCuePoint);
-                itCuePoint = lstCuePoints.begin();
+                m_lstCuePoints.erase(itCuePoint);
+                itCuePoint = m_lstCuePoints.begin();
             }
 
-            Assert(lstCuePoints.empty());
+            Assert(m_lstCuePoints.empty());
         }
 
         /** Critical section for serializing access to this segment. */
-        RTCRITSECT                      CritSect;
+        RTCRITSECT                      m_CritSect;
 
         /** The timecode scale factor of this segment. */
-        uint64_t                        uTimecodeScaleFactor;
+        uint64_t                        m_uTimecodeScaleFactor;
 
         /** Absolute timecode (in ms) when starting this segment. */
-        WebMTimecodeAbs                 tcAbsStartMs;
+        WebMTimecodeAbs                 m_tcAbsStartMs;
         /** Absolute timecode (in ms) of last write. */
-        WebMTimecodeAbs                 tcAbsLastWrittenMs;
+        WebMTimecodeAbs                 m_tcAbsLastWrittenMs;
 
         /** Absolute offset (in bytes) of CurSeg. */
-        uint64_t                        offStart;
+        uint64_t                        m_offStart;
         /** Absolute offset (in bytes) of general info. */
-        uint64_t                        offInfo;
+        uint64_t                        m_offInfo;
         /** Absolute offset (in bytes) of seeking info. */
-        uint64_t                        offSeekInfo;
+        uint64_t                        m_offSeekInfo;
         /** Absolute offset (in bytes) of tracks. */
-        uint64_t                        offTracks;
+        uint64_t                        m_offTracks;
         /** Absolute offset (in bytes) of cues table. */
-        uint64_t                        offCues;
+        uint64_t                        m_offCues;
         /** List of cue points. Needed for seeking table. */
-        WebMCuePointList                lstCuePoints;
+        WebMCuePointList                m_lstCuePoints;
 
         /** Total number of clusters. */
-        uint64_t                        cClusters;
+        uint64_t                        m_cClusters;
 
         /** Map of tracks.
          *  The key marks the track number (*not* the UUID!). */
-        std::map <uint8_t, WebMTrack *> mapTracks;
+        std::map <uint8_t, WebMTrack *> m_mapTracks;
 
         /** Current cluster which is being handled.
@@ -466 +466 @@
          *  Note that we don't need (and shouldn't need, as this can be a *lot* of data!) a
          *  list of all clusters. */
-        WebMCluster                     CurCluster;
-
-        WebMQueue                       queueBlocks;
-
-    } CurSeg;
+        WebMCluster                     m_CurCluster;
+
+        WebMQueue                       m_queueBlocks;
+
+    } m_CurSeg;
 
     /** Audio codec to use. */
@@ -542 +542 @@
      * @returns Number of written WebM clusters; 0 when no clusters written (empty file).
      */
-    uint64_t GetClusters(void) const { return CurSeg.cClusters; }
+    uint64_t GetClusters(void) const { return m_CurSeg.m_cClusters; }
 
 protected:

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

@@ -64 +64 @@
  */
 RecordingContext::RecordingContext(void)
-    : pConsole(NULL)
-    , enmState(RECORDINGSTS_UNINITIALIZED)
-    , cStreamsEnabled(0)
-{
-    int vrc = RTCritSectInit(&this->CritSect);
+    : m_pConsole(NULL)
+    , m_enmState(RECORDINGSTS_UNINITIALIZED)
+    , m_cStreamsEnabled(0)
+{
+    int vrc = RTCritSectInit(&m_CritSect);
     if (RT_FAILURE(vrc))
         throw vrc;
@@ -82 +82 @@
  */
 RecordingContext::RecordingContext(Console *ptrConsole, const settings::RecordingSettings &Settings)
-    : pConsole(NULL)
-    , enmState(RECORDINGSTS_UNINITIALIZED)
-    , cStreamsEnabled(0)
-{
-    int vrc = RTCritSectInit(&this->CritSect);
+    : m_pConsole(NULL)
+    , m_enmState(RECORDINGSTS_UNINITIALIZED)
+    , m_cStreamsEnabled(0)
+{
+    int vrc = RTCritSectInit(&m_CritSect);
     if (RT_FAILURE(vrc))
         throw vrc;
@@ -99 +99 @@
     destroyInternal();
 
-    if (RTCritSectIsInitialized(&this->CritSect))
-        RTCritSectDelete(&this->CritSect);
+    if (RTCritSectIsInitialized(&m_CritSect))
+        RTCritSectDelete(&m_CritSect);
 }
 
@@ -119 +119 @@
     for (;;)
     {
-        int vrc = RTSemEventWait(pThis->WaitEvent, RT_INDEFINITE_WAIT);
+        int vrc = RTSemEventWait(pThis->m_WaitEvent, RT_INDEFINITE_WAIT);
         AssertRCBreak(vrc);
 
-        Log2Func(("Processing %zu streams\n", pThis->vecStreams.size()));
+        Log2Func(("Processing %zu streams\n", pThis->m_vecStreams.size()));
 
         /* Process common raw blocks (data which not has been encoded yet). */
-        vrc = pThis->processCommonData(pThis->mapBlocksRaw, 100 /* ms timeout */);
+        vrc = pThis->processCommonData(pThis->m_mapBlocksRaw, 100 /* ms timeout */);
 
         /** @todo r=andy This is inefficient -- as we already wake up this thread
          *               for every screen from Main, we here go again (on every wake up) through
          *               all screens.  */
-        RecordingStreams::iterator itStream = pThis->vecStreams.begin();
-        while (itStream != pThis->vecStreams.end())
+        RecordingStreams::iterator itStream = pThis->m_vecStreams.begin();
+        while (itStream != pThis->m_vecStreams.end())
         {
             RecordingStream *pStream = (*itStream);
 
             /* Hand-in common encoded blocks. */
-            vrc = pStream->Process(pThis->mapBlocksEncoded);
+            vrc = pStream->Process(pThis->m_mapBlocksEncoded);
             if (RT_FAILURE(vrc))
             {
@@ -151 +151 @@
         /* Keep going in case of errors. */
 
-        if (ASMAtomicReadBool(&pThis->fShutdown))
+        if (ASMAtomicReadBool(&pThis->m_fShutdown))
         {
             LogFunc(("Thread is shutting down ...\n"));
@@ -170 +170 @@
 int RecordingContext::threadNotify(void)
 {
-    return RTSemEventSignal(this->WaitEvent);
+    return RTSemEventSignal(m_WaitEvent);
 }
 
@@ -209 +209 @@
                     Frame.Audio.cbBuf = pAudioFrame->cbBuf;
 
-                    vrc = recordingCodecEncode(&this->CodecAudio, &Frame, NULL, NULL);
+                    vrc = recordingCodecEncode(&m_CodecAudio, &Frame, NULL, NULL);
                     break;
                 }
@@ -293 +293 @@
             pBlock->pvData      = pFrame;
             pBlock->cbData      = sizeof(RECORDINGAUDIOFRAME) + cbData;
-            pBlock->cRefs       = this->cStreamsEnabled;
+            pBlock->cRefs       = m_cStreamsEnabled;
             pBlock->msTimestamp = msTimestamp;
             pBlock->uFlags      = uFlags;
@@ -351 +351 @@
 {
     RecordingContext *pThis = (RecordingContext *)pvUser;
-    return pThis->writeCommonData(pThis->mapBlocksEncoded, pCodec, pvData, cbData, msAbsPTS, uFlags);
+    return pThis->writeCommonData(pThis->m_mapBlocksEncoded, pCodec, pvData, cbData, msAbsPTS, uFlags);
 }
 
@@ -374 +374 @@
     Callbacks.pfnWriteData = RecordingContext::audioCodecWriteDataCallback;
 
-    int vrc = recordingCodecCreateAudio(&this->CodecAudio, enmCodec);
+    int vrc = recordingCodecCreateAudio(&m_CodecAudio, enmCodec);
     if (RT_SUCCESS(vrc))
-        vrc = recordingCodecInit(&this->CodecAudio, &Callbacks, screenSettings);
+        vrc = recordingCodecInit(&m_CodecAudio, &Callbacks, screenSettings);
 
     return vrc;
@@ -408 +408 @@
 #endif
 
-    this->pConsole = ptrConsole;
+    m_pConsole = ptrConsole;
 
     settings::RecordingScreenSettingsMap::const_iterator itScreen = m_Settings.mapScreens.begin();
@@ -417 +417 @@
         {
             pStream = new RecordingStream(this, itScreen->first /* Screen ID */, itScreen->second);
-            this->vecStreams.push_back(pStream);
+            m_vecStreams.push_back(pStream);
             if (itScreen->second.fEnabled)
-                this->cStreamsEnabled++;
+                m_cStreamsEnabled++;
             LogFlowFunc(("pStream=%p\n", pStream));
         }
@@ -438 +438 @@
     if (RT_SUCCESS(vrc))
     {
-        this->tsStartMs = RTTimeMilliTS();
-        this->enmState  = RECORDINGSTS_CREATED;
-        this->fShutdown = false;
-
-        vrc = RTSemEventCreate(&this->WaitEvent);
+        m_tsStartMs = RTTimeMilliTS();
+        m_enmState  = RECORDINGSTS_CREATED;
+        m_fShutdown = false;
+
+        vrc = RTSemEventCreate(&m_WaitEvent);
         AssertRCReturn(vrc, vrc);
     }
@@ -459 +459 @@
 int RecordingContext::startInternal(void)
 {
-    if (this->enmState == RECORDINGSTS_STARTED)
+    if (m_enmState == RECORDINGSTS_STARTED)
         return VINF_SUCCESS;
 
-    Assert(this->enmState == RECORDINGSTS_CREATED);
-
-    int vrc = RTThreadCreate(&this->Thread, RecordingContext::threadMain, (void *)this, 0,
+    Assert(m_enmState == RECORDINGSTS_CREATED);
+
+    int vrc = RTThreadCreate(&m_Thread, RecordingContext::threadMain, (void *)this, 0,
                              RTTHREADTYPE_MAIN_WORKER, RTTHREADFLAGS_WAITABLE, "Record");
 
     if (RT_SUCCESS(vrc)) /* Wait for the thread to start. */
-        vrc = RTThreadUserWait(this->Thread, RT_MS_30SEC /* 30s timeout */);
+        vrc = RTThreadUserWait(m_Thread, RT_MS_30SEC /* 30s timeout */);
 
     if (RT_SUCCESS(vrc))
     {
         LogRel(("Recording: Started\n"));
-        this->enmState = RECORDINGSTS_STARTED;
+        m_enmState = RECORDINGSTS_STARTED;
     }
     else
@@ -488 +488 @@
 int RecordingContext::stopInternal(void)
 {
-    if (this->enmState != RECORDINGSTS_STARTED)
+    if (m_enmState != RECORDINGSTS_STARTED)
         return VINF_SUCCESS;
 
@@ -494 +494 @@
 
     /* Set shutdown indicator. */
-    ASMAtomicWriteBool(&this->fShutdown, true);
+    ASMAtomicWriteBool(&m_fShutdown, true);
 
     /* Signal the thread and wait for it to shut down. */
     int vrc = threadNotify();
     if (RT_SUCCESS(vrc))
-        vrc = RTThreadWait(this->Thread, RT_MS_30SEC /* 30s timeout */, NULL);
+        vrc = RTThreadWait(m_Thread, RT_MS_30SEC /* 30s timeout */, NULL);
 
     lock();
@@ -506 +506 @@
     {
         LogRel(("Recording: Stopped\n"));
-        this->enmState = RECORDINGSTS_CREATED;
+        m_enmState = RECORDINGSTS_CREATED;
     }
     else
@@ -524 +524 @@
     lock();
 
-    if (this->enmState == RECORDINGSTS_UNINITIALIZED)
+    if (m_enmState == RECORDINGSTS_UNINITIALIZED)
     {
         unlock();
@@ -533 +533 @@
     AssertRCReturnVoid(vrc);
 
-    vrc = RTSemEventDestroy(this->WaitEvent);
+    vrc = RTSemEventDestroy(m_WaitEvent);
     AssertRCReturnVoid(vrc);
 
-    this->WaitEvent = NIL_RTSEMEVENT;
-
-    RecordingStreams::iterator it = this->vecStreams.begin();
-    while (it != this->vecStreams.end())
+    m_WaitEvent = NIL_RTSEMEVENT;
+
+    RecordingStreams::iterator it = m_vecStreams.begin();
+    while (it != m_vecStreams.end())
     {
         RecordingStream *pStream = (*it);
@@ -549 +549 @@
         pStream = NULL;
 
-        this->vecStreams.erase(it);
-        it = this->vecStreams.begin();
+        m_vecStreams.erase(it);
+        it = m_vecStreams.begin();
     }
 
     /* Sanity. */
-    Assert(this->vecStreams.empty());
-    Assert(this->mapBlocksRaw.size() == 0);
-    Assert(this->mapBlocksEncoded.size() == 0);
-
-    this->enmState = RECORDINGSTS_UNINITIALIZED;
+    Assert(m_vecStreams.empty());
+    Assert(m_mapBlocksRaw.size() == 0);
+    Assert(m_mapBlocksEncoded.size() == 0);
+
+    m_enmState = RECORDINGSTS_UNINITIALIZED;
 
     unlock();
@@ -570 +570 @@
 const settings::RecordingSettings &RecordingContext::GetConfig(void) const
 {
-    return this->m_Settings;
+    return m_Settings;
 }
 
@@ -585 +585 @@
     try
     {
-        pStream = this->vecStreams.at(uScreen);
+        pStream = m_vecStreams.at(uScreen);
     }
     catch (std::out_of_range &)
@@ -602 +602 @@
 int RecordingContext::lock(void)
 {
-    int vrc = RTCritSectEnter(&this->CritSect);
+    int vrc = RTCritSectEnter(&m_CritSect);
     AssertRC(vrc);
     return vrc;
@@ -614 +614 @@
 int RecordingContext::unlock(void)
 {
-    int vrc = RTCritSectLeave(&this->CritSect);
+    int vrc = RTCritSectLeave(&m_CritSect);
     AssertRC(vrc);
     return vrc;
@@ -637 +637 @@
 size_t RecordingContext::GetStreamCount(void) const
 {
-    return this->vecStreams.size();
+    return m_vecStreams.size();
 }
 
@@ -690 +690 @@
     lock();
 
-    RecordingStreams::const_iterator itStream = this->vecStreams.begin();
-    while (itStream != this->vecStreams.end())
+    RecordingStreams::const_iterator itStream = m_vecStreams.begin();
+    while (itStream != m_vecStreams.end())
     {
         if ((*itStream)->GetConfig().isFeatureEnabled(enmFeature))
@@ -715 +715 @@
     lock();
 
-    const bool fIsReady = this->enmState >= RECORDINGSTS_CREATED;
+    const bool fIsReady = m_enmState >= RECORDINGSTS_CREATED;
 
     unlock();
@@ -737 +737 @@
     bool fIsReady = false;
 
-    if (this->enmState != RECORDINGSTS_STARTED)
+    if (m_enmState != RECORDINGSTS_STARTED)
     {
         const RecordingStream *pStream = getStreamInternal(uScreen);
@@ -762 +762 @@
     lock();
 
-    const bool fIsStarted = this->enmState == RECORDINGSTS_STARTED;
+    const bool fIsStarted = m_enmState == RECORDINGSTS_STARTED;
 
     unlock();
@@ -778 +778 @@
     lock();
 
-    LogFlowThisFunc(("cStreamsEnabled=%RU16\n", this->cStreamsEnabled));
-
-    const bool fLimitReached = this->cStreamsEnabled == 0;
+    LogFlowThisFunc(("cStreamsEnabled=%RU16\n", m_cStreamsEnabled));
+
+    const bool fLimitReached = m_cStreamsEnabled == 0;
 
     unlock();
@@ -825 +825 @@
     bool fNeedsUpdate = false;
 
-    if (this->enmState == RECORDINGSTS_STARTED)
-    {
-        if (   recordingCodecIsInitialized(&CodecAudio)
-            && recordingCodecGetWritable(&CodecAudio, msTimestamp) > 0)
+    if (m_enmState == RECORDINGSTS_STARTED)
+    {
+        if (   recordingCodecIsInitialized(&m_CodecAudio)
+            && recordingCodecGetWritable(&m_CodecAudio, msTimestamp) > 0)
         {
             fNeedsUpdate = true;
@@ -853 +853 @@
     lock();
 
-    Assert(this->cStreamsEnabled);
-    this->cStreamsEnabled--;
-
-    LogFlowThisFunc(("cStreamsEnabled=%RU16\n", cStreamsEnabled));
+    Assert(m_cStreamsEnabled);
+    m_cStreamsEnabled--;
+
+    LogFlowThisFunc(("cStreamsEnabled=%RU16\n", m_cStreamsEnabled));
 
     unlock();
@@ -874 +874 @@
 {
 #ifdef VBOX_WITH_AUDIO_RECORDING
-    return writeCommonData(this->mapBlocksRaw, &this->CodecAudio,
+    return writeCommonData(m_mapBlocksRaw, &m_CodecAudio,
                            pvData, cbData, msTimestamp, RECORDINGCODEC_ENC_F_BLOCK_IS_KEY);
 #else

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

@@ -38 +38 @@
 
 RecordingStream::RecordingStream(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings)
-    : enmState(RECORDINGSTREAMSTATE_UNINITIALIZED)
+    : m_enmState(RECORDINGSTREAMSTATE_UNINITIALIZED)
 {
     int vrc2 = initInternal(a_pCtx, uScreen, Settings);
@@ -85 +85 @@
             char *pszFile = NULL;
 
-            vrc = RTStrAPrintf(&pszFile, "%s-%u%s", pszAbsPath, this->uScreenID, pszSuff);
+            vrc = RTStrAPrintf(&pszFile, "%s-%u%s", pszAbsPath, m_uScreenID, pszSuff);
             if (RT_SUCCESS(vrc))
             {
@@ -113 +113 @@
                                        pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
                                        time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
-                                       this->uScreenID, pszSuff);
+                                       m_uScreenID, pszSuff);
                     if (RT_SUCCESS(vrc))
                         vrc = RTFileOpen(&hFile, pszFile, fOpen);
@@ -125 +125 @@
                 try
                 {
-                    Assert(File.pWEBM == NULL);
-                    File.pWEBM = new WebMWriter();
+                    Assert(File.m_pWEBM == NULL);
+                    File.m_pWEBM = new WebMWriter();
                 }
                 catch (std::bad_alloc &)
@@ -135 +135 @@
                 if (RT_SUCCESS(vrc))
                 {
-                    this->File.hFile = hFile;
-                    this->ScreenSettings.File.strName = pszFile;
+                    this->File.m_hFile = hFile;
+                    m_ScreenSettings.File.strName = pszFile;
                 }
             }
@@ -146 +146 @@
             {
                 LogRel(("Recording: Failed to open file '%s' for screen %RU32, vrc=%Rrc\n",
-                        pszFile ? pszFile : "<Unnamed>", this->uScreenID, vrc));
+                        pszFile ? pszFile : "<Unnamed>", m_uScreenID, vrc));
             }
 
@@ -169 +169 @@
 const settings::RecordingScreenSettings &RecordingStream::GetConfig(void) const
 {
-    return this->ScreenSettings;
+    return m_ScreenSettings;
 }
 
@@ -181 +181 @@
 {
     LogFlowThisFunc(("msTimestamp=%RU64, ulMaxTimeS=%RU32, tsStartMs=%RU64\n",
-                     msTimestamp, this->ScreenSettings.ulMaxTimeS, this->tsStartMs));
-
-    if (   this->ScreenSettings.ulMaxTimeS
-        && msTimestamp >= this->tsStartMs + (this->ScreenSettings.ulMaxTimeS * RT_MS_1SEC))
+                     msTimestamp, m_ScreenSettings.ulMaxTimeS, m_tsStartMs));
+
+    if (   m_ScreenSettings.ulMaxTimeS
+        && msTimestamp >= m_tsStartMs + (m_ScreenSettings.ulMaxTimeS * RT_MS_1SEC))
     {
         LogRel(("Recording: Time limit for stream #%RU16 has been reached (%RU32s)\n",
-                this->uScreenID, this->ScreenSettings.ulMaxTimeS));
+                m_uScreenID, m_ScreenSettings.ulMaxTimeS));
         return true;
     }
 
-    if (this->ScreenSettings.enmDest == RecordingDestination_File)
-    {
-        if (this->ScreenSettings.File.ulMaxSizeMB)
-        {
-            uint64_t sizeInMB = this->File.pWEBM->GetFileSize() / _1M;
-            if(sizeInMB >= this->ScreenSettings.File.ulMaxSizeMB)
+    if (m_ScreenSettings.enmDest == RecordingDestination_File)
+    {
+        if (m_ScreenSettings.File.ulMaxSizeMB)
+        {
+            uint64_t sizeInMB = this->File.m_pWEBM->GetFileSize() / _1M;
+            if(sizeInMB >= m_ScreenSettings.File.ulMaxSizeMB)
             {
                 LogRel(("Recording: File size limit for stream #%RU16 has been reached (%RU64MB)\n",
-                        this->uScreenID, this->ScreenSettings.File.ulMaxSizeMB));
+                        m_uScreenID, m_ScreenSettings.File.ulMaxSizeMB));
                 return true;
             }
@@ -205 +205 @@
 
         /* Check for available free disk space */
-        if (   this->File.pWEBM
-            && this->File.pWEBM->GetAvailableSpace() < 0x100000) /** @todo r=andy WTF? Fix this. */
+        if (   this->File.m_pWEBM
+            && this->File.m_pWEBM->GetAvailableSpace() < 0x100000) /** @todo r=andy WTF? Fix this. */
         {
             LogRel(("Recording: Not enough free storage space available, stopping recording\n"));
@@ -225 +225 @@
 int RecordingStream::iterateInternal(uint64_t msTimestamp)
 {
-    if (!this->fEnabled)
+    if (!m_fEnabled)
         return VINF_SUCCESS;
 
@@ -237 +237 @@
         vrc = VINF_SUCCESS;
 
-    AssertPtr(this->m_pCtx);
+    AssertPtr(m_pCtx);
 
     switch (vrc)
@@ -243 +243 @@
         case VINF_RECORDING_LIMIT_REACHED:
         {
-            this->fEnabled = false;
-
-            int vrc2 = this->m_pCtx->OnLimitReached(this->uScreenID, VINF_SUCCESS /* rc */);
+            m_fEnabled = false;
+
+            int vrc2 = m_pCtx->OnLimitReached(m_uScreenID, VINF_SUCCESS /* rc */);
             AssertRC(vrc2);
             break;
@@ -279 +279 @@
 bool RecordingStream::IsReady(void) const
 {
-    return this->fEnabled;
+    return m_fEnabled;
 }
 
@@ -290 +290 @@
 bool RecordingStream::NeedsUpdate(uint64_t msTimestamp) const
 {
-    return recordingCodecGetWritable((const PRECORDINGCODEC)&CodecVideo, msTimestamp) > 0;
+    return recordingCodecGetWritable((const PRECORDINGCODEC)&m_CodecVideo, msTimestamp) > 0;
 }
 
@@ -309 +309 @@
     lock();
 
-    if (!this->ScreenSettings.fEnabled)
+    if (!m_ScreenSettings.fEnabled)
     {
         unlock();
@@ -317 +317 @@
     int vrc = VINF_SUCCESS;
 
-    RecordingBlockMap::iterator itStreamBlocks = Blocks.Map.begin();
-    while (itStreamBlocks != Blocks.Map.end())
+    RecordingBlockMap::iterator itStreamBlocks = m_Blocks.Map.begin();
+    while (itStreamBlocks != m_Blocks.Map.end())
     {
         uint64_t const   msTimestamp = itStreamBlocks->first;
@@ -338 +338 @@
                     Frame.msTimestamp = msTimestamp;
 
-                    int vrc2 = recordingCodecEncode(&this->CodecVideo, &Frame, NULL, NULL);
+                    int vrc2 = recordingCodecEncode(&m_CodecVideo, &Frame, NULL, NULL);
                     AssertRC(vrc2);
                     if (RT_SUCCESS(vrc))
@@ -358 +358 @@
         delete pBlocks;
 
-        Blocks.Map.erase(itStreamBlocks);
-        itStreamBlocks = Blocks.Map.begin();
+        m_Blocks.Map.erase(itStreamBlocks);
+        itStreamBlocks = m_Blocks.Map.begin();
     }
 
 #ifdef VBOX_WITH_AUDIO_RECORDING
     /* Do we need to multiplex the common audio data to this stream? */
-    if (this->ScreenSettings.isFeatureEnabled(RecordingFeature_Audio))
+    if (m_ScreenSettings.isFeatureEnabled(RecordingFeature_Audio))
     {
         /* As each (enabled) screen has to get the same audio data, look for common (audio) data which needs to be
@@ -384 +384 @@
                         Assert(pAudioFrame->cbBuf);
 
-                        AssertPtr(this->File.pWEBM);
-                        int vrc2 = this->File.pWEBM->WriteBlock(this->uTrackAudio, pAudioFrame->pvBuf, pAudioFrame->cbBuf, pBlockCommon->msTimestamp, pBlockCommon->uFlags);
+                        AssertPtr(this->File.m_pWEBM);
+                        int vrc2 = this->File.m_pWEBM->WriteBlock(m_uTrackAudio, pAudioFrame->pvBuf, pAudioFrame->cbBuf, pBlockCommon->msTimestamp, pBlockCommon->uFlags);
                         AssertRC(vrc2);
                         if (RT_SUCCESS(vrc))
@@ -489 +489 @@
     do
     {
-        int xDiff = ((int)this->ScreenSettings.Video.ulWidth - (int)uSrcWidth) / 2;
+        int xDiff = ((int)m_ScreenSettings.Video.ulWidth - (int)uSrcWidth) / 2;
         uint32_t w = uSrcWidth;
         if ((int)w + xDiff + (int)x <= 0)  /* Nothing visible. */
@@ -508 +508 @@
 
         uint32_t h = uSrcHeight;
-        int yDiff = ((int)this->ScreenSettings.Video.ulHeight - (int)uSrcHeight) / 2;
+        int yDiff = ((int)m_ScreenSettings.Video.ulHeight - (int)uSrcHeight) / 2;
         if ((int)h + yDiff + (int)y <= 0)  /* Nothing visible. */
         {
@@ -525 +525 @@
             destY = y + yDiff;
 
-        if (   destX > this->ScreenSettings.Video.ulWidth
-            || destY > this->ScreenSettings.Video.ulHeight)
+        if (   destX > m_ScreenSettings.Video.ulWidth
+            || destY > m_ScreenSettings.Video.ulHeight)
         {
             vrc = VERR_INVALID_PARAMETER;  /* Nothing visible. */
@@ -532 +532 @@
         }
 
-        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;
+        if (destX + w > m_ScreenSettings.Video.ulWidth)
+            w = m_ScreenSettings.Video.ulWidth - destX;
+
+        if (destY + h > m_ScreenSettings.Video.ulHeight)
+            h = m_ScreenSettings.Video.ulHeight - destY;
 
         pFrame = (PRECORDINGVIDEOFRAME)RTMemAllocZ(sizeof(RECORDINGVIDEOFRAME));
@@ -564 +564 @@
             AssertMsgFailedBreakStmt(("Unknown pixel format (%RU32)\n", uPixelFormat), vrc = VERR_NOT_SUPPORTED);
 
-        const size_t cbRGBBuf =   this->ScreenSettings.Video.ulWidth
-                                * this->ScreenSettings.Video.ulHeight
+        const size_t cbRGBBuf =   m_ScreenSettings.Video.ulWidth
+                                * m_ScreenSettings.Video.ulHeight
                                 * uBytesPerPixel;
         AssertBreakStmt(cbRGBBuf, vrc = VERR_INVALID_PARAMETER);
@@ -577 +577 @@
         /* 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->ScreenSettings.Video.ulWidth
-            || uSrcHeight < this->ScreenSettings.Video.ulHeight)
+        if (   uSrcWidth  < m_ScreenSettings.Video.ulWidth
+            || uSrcHeight < m_ScreenSettings.Video.ulHeight)
         {
             RT_BZERO(pFrame->pu8RGBBuf, pFrame->cbRGBBuf);
@@ -585 +585 @@
         /* Calculate start offset in source and destination buffers. */
         uint32_t offSrc = y * uBytesPerLine + x * uBytesPerPixel;
-        uint32_t offDst = (destY * this->ScreenSettings.Video.ulWidth + destX) * uBytesPerPixel;
+        uint32_t offDst = (destY * m_ScreenSettings.Video.ulWidth + destX) * uBytesPerPixel;
 
 #ifdef VBOX_RECORDING_DUMP
@@ -607 +607 @@
 
         char szFileName[RTPATH_MAX];
-        RTStrPrintf2(szFileName, sizeof(szFileName), "/tmp/VideoRecFrame-%RU32.bmp", this->uScreenID);
+        RTStrPrintf2(szFileName, sizeof(szFileName), "/tmp/VideoRecFrame-%RU32.bmp", m_uScreenID);
 
         RTFILE fh;
@@ -625 +625 @@
             /* Overflow check. */
             Assert(offSrc + w * uBytesPerPixel <= uSrcHeight * uBytesPerLine);
-            Assert(offDst + w * uBytesPerPixel <= this->ScreenSettings.Video.ulHeight * this->ScreenSettings.Video.ulWidth * uBytesPerPixel);
+            Assert(offDst + w * uBytesPerPixel <= m_ScreenSettings.Video.ulHeight * m_ScreenSettings.Video.ulWidth * uBytesPerPixel);
 
             memcpy(pFrame->pu8RGBBuf + offDst, puSrcData + offSrc, w * uBytesPerPixel);
@@ -634 +634 @@
 #endif
             offSrc += uBytesPerLine;
-            offDst += this->ScreenSettings.Video.ulWidth * uBytesPerPixel;
+            offDst += m_ScreenSettings.Video.ulWidth * uBytesPerPixel;
         }
 
@@ -660 +660 @@
                 pRecordingBlocks->List.push_back(pBlock);
 
-                Assert(this->Blocks.Map.find(msTimestamp) == this->Blocks.Map.end());
-                this->Blocks.Map.insert(std::make_pair(msTimestamp, pRecordingBlocks));
+                Assert(m_Blocks.Map.find(msTimestamp) == m_Blocks.Map.end());
+                m_Blocks.Map.insert(std::make_pair(msTimestamp, pRecordingBlocks));
             }
             catch (const std::exception &ex)
@@ -708 +708 @@
                                   const settings::RecordingScreenSettings &screenSettings)
 {
-    AssertReturn(enmState == RECORDINGSTREAMSTATE_UNINITIALIZED, VERR_WRONG_ORDER);
-
-    this->m_pCtx         = pCtx;
-    this->uTrackAudio    = UINT8_MAX;
-    this->uTrackVideo    = UINT8_MAX;
-    this->tsStartMs      = 0;
-    this->uScreenID      = uScreen;
+    AssertReturn(m_enmState == RECORDINGSTREAMSTATE_UNINITIALIZED, VERR_WRONG_ORDER);
+
+    m_pCtx         = pCtx;
+    m_uTrackAudio    = UINT8_MAX;
+    m_uTrackVideo    = UINT8_MAX;
+    m_tsStartMs      = 0;
+    m_uScreenID      = uScreen;
 #ifdef VBOX_WITH_AUDIO_RECORDING
     /* We use the codec from the recording context, as this stream only receives multiplexed data (same audio for all streams). */
-    this->pCodecAudio    = m_pCtx->GetCodecAudio();
-#endif
-    this->ScreenSettings = screenSettings;
-
-    settings::RecordingScreenSettings *pSettings = &this->ScreenSettings;
-
-    int vrc = RTCritSectInit(&this->CritSect);
+    m_pCodecAudio    = m_pCtx->GetCodecAudio();
+#endif
+    m_ScreenSettings = screenSettings;
+
+    settings::RecordingScreenSettings *pSettings = &m_ScreenSettings;
+
+    int vrc = RTCritSectInit(&m_CritSect);
     if (RT_FAILURE(vrc))
         return vrc;
 
-    this->File.pWEBM = NULL;
-    this->File.hFile = NIL_RTFILE;
+    this->File.m_pWEBM = NULL;
+    this->File.m_hFile = NIL_RTFILE;
 
     vrc = open(*pSettings);
@@ -751 +751 @@
             const char *pszFile = pSettings->File.strName.c_str();
 
-            AssertPtr(File.pWEBM);
-            vrc = File.pWEBM->OpenEx(pszFile, &this->File.hFile,
+            AssertPtr(File.m_pWEBM);
+            vrc = File.m_pWEBM->OpenEx(pszFile, &this->File.m_hFile,
                                      fAudioEnabled ? pSettings->Audio.enmCodec : RecordingAudioCodec_None,
                                      fVideoEnabled ? pSettings->Video.enmCodec : RecordingVideoCodec_None);
@@ -763 +763 @@
             if (fVideoEnabled)
             {
-                vrc = this->File.pWEBM->AddVideoTrack(&this->CodecVideo,
+                vrc = this->File.m_pWEBM->AddVideoTrack(&m_CodecVideo,
                                                       pSettings->Video.ulWidth, pSettings->Video.ulHeight, pSettings->Video.ulFPS,
-                                                      &this->uTrackVideo);
+                                                      &m_uTrackVideo);
                 if (RT_FAILURE(vrc))
                 {
@@ -773 +773 @@
 
                 LogRel(("Recording: Recording video of screen #%u with %RU32x%RU32 @ %RU32 kbps, %RU32 FPS (track #%RU8)\n",
-                        this->uScreenID, pSettings->Video.ulWidth, pSettings->Video.ulHeight,
-                        pSettings->Video.ulRate, pSettings->Video.ulFPS, this->uTrackVideo));
+                        m_uScreenID, pSettings->Video.ulWidth, pSettings->Video.ulHeight,
+                        pSettings->Video.ulRate, pSettings->Video.ulFPS, m_uTrackVideo));
             }
 
@@ -780 +780 @@
             if (fAudioEnabled)
             {
-                AssertPtr(this->pCodecAudio);
-                vrc = this->File.pWEBM->AddAudioTrack(this->pCodecAudio,
+                AssertPtr(m_pCodecAudio);
+                vrc = this->File.m_pWEBM->AddAudioTrack(m_pCodecAudio,
                                                       pSettings->Audio.uHz, pSettings->Audio.cChannels, pSettings->Audio.cBits,
-                                                      &this->uTrackAudio);
+                                                      &m_uTrackAudio);
                 if (RT_FAILURE(vrc))
                 {
@@ -791 +791 @@
 
                 LogRel(("Recording: Recording audio of screen #%u in %RU16Hz, %RU8 bit, %RU8 %s (track #%RU8)\n",
-                        this->uScreenID, pSettings->Audio.uHz, pSettings->Audio.cBits, pSettings->Audio.cChannels,
-                        pSettings->Audio.cChannels ? "channels" : "channel", this->uTrackAudio));
+                        m_uScreenID, pSettings->Audio.uHz, pSettings->Audio.cBits, pSettings->Audio.cChannels,
+                        pSettings->Audio.cChannels ? "channels" : "channel", m_uTrackAudio));
             }
 #endif
@@ -813 +813 @@
                 }
 #endif
-                LogRel(("Recording: Recording %s of screen #%u to '%s'\n", szWhat, this->uScreenID, pszFile));
+                LogRel(("Recording: Recording %s of screen #%u to '%s'\n", szWhat, m_uScreenID, pszFile));
             }
 
@@ -827 +827 @@
     if (RT_SUCCESS(vrc))
     {
-        this->enmState  = RECORDINGSTREAMSTATE_INITIALIZED;
-        this->fEnabled  = true;
-        this->tsStartMs = RTTimeProgramMilliTS();
+        m_enmState  = RECORDINGSTREAMSTATE_INITIALIZED;
+        m_fEnabled  = true;
+        m_tsStartMs = RTTimeProgramMilliTS();
 
         return VINF_SUCCESS;
@@ -852 +852 @@
     int vrc = VINF_SUCCESS;
 
-    switch (this->ScreenSettings.enmDest)
+    switch (m_ScreenSettings.enmDest)
     {
         case RecordingDestination_File:
         {
-            if (this->File.pWEBM)
-                vrc = this->File.pWEBM->Close();
+            if (this->File.m_pWEBM)
+                vrc = this->File.m_pWEBM->Close();
             break;
         }
@@ -866 +866 @@
     }
 
-    this->Blocks.Clear();
-
-    LogRel(("Recording: Recording screen #%u stopped\n", this->uScreenID));
+    m_Blocks.Clear();
+
+    LogRel(("Recording: Recording screen #%u stopped\n", m_uScreenID));
 
     if (RT_FAILURE(vrc))
     {
-        LogRel(("Recording: Error stopping recording screen #%u, vrc=%Rrc\n", this->uScreenID, vrc));
+        LogRel(("Recording: Error stopping recording screen #%u, vrc=%Rrc\n", m_uScreenID, vrc));
         return vrc;
     }
 
-    switch (this->ScreenSettings.enmDest)
+    switch (m_ScreenSettings.enmDest)
     {
         case RecordingDestination_File:
         {
-            if (RTFileIsValid(this->File.hFile))
-            {
-                vrc = RTFileClose(this->File.hFile);
+            if (RTFileIsValid(this->File.m_hFile))
+            {
+                vrc = RTFileClose(this->File.m_hFile);
                 if (RT_SUCCESS(vrc))
                 {
-                    LogRel(("Recording: Closed file '%s'\n", this->ScreenSettings.File.strName.c_str()));
+                    LogRel(("Recording: Closed file '%s'\n", m_ScreenSettings.File.strName.c_str()));
                 }
                 else
                 {
-                    LogRel(("Recording: Error closing file '%s', rc=%Rrc\n", this->ScreenSettings.File.strName.c_str(), vrc));
+                    LogRel(("Recording: Error closing file '%s', rc=%Rrc\n", m_ScreenSettings.File.strName.c_str(), vrc));
                     break;
                 }
             }
 
-            WebMWriter *pWebMWriter = this->File.pWEBM;
+            WebMWriter *pWebMWriter = this->File.m_pWEBM;
             AssertPtr(pWebMWriter);
 
@@ -902 +902 @@
                 if (pWebMWriter->GetClusters() == 0)
                 {
-                    int vrc2 = RTFileDelete(this->ScreenSettings.File.strName.c_str());
+                    int vrc2 = RTFileDelete(m_ScreenSettings.File.strName.c_str());
                     AssertRC(vrc2); /* Ignore rc on non-debug builds. */
                 }
@@ -909 +909 @@
                 pWebMWriter = NULL;
 
-                this->File.pWEBM = NULL;
+                this->File.m_pWEBM = NULL;
             }
             break;
@@ -940 +940 @@
 int RecordingStream::uninitInternal(void)
 {
-    if (this->enmState != RECORDINGSTREAMSTATE_INITIALIZED)
+    if (m_enmState != RECORDINGSTREAMSTATE_INITIALIZED)
         return VINF_SUCCESS;
 
@@ -948 +948 @@
 
 #ifdef VBOX_WITH_AUDIO_RECORDING
-    this->pCodecAudio = NULL;
-#endif
-
-    if (this->ScreenSettings.isFeatureEnabled(RecordingFeature_Video))
-    {
-        vrc = recordingCodecFinalize(&this->CodecVideo);
+    m_pCodecAudio = NULL;
+#endif
+
+    if (m_ScreenSettings.isFeatureEnabled(RecordingFeature_Video))
+    {
+        vrc = recordingCodecFinalize(&m_CodecVideo);
         if (RT_SUCCESS(vrc))
-            vrc = recordingCodecDestroy(&this->CodecVideo);
+            vrc = recordingCodecDestroy(&m_CodecVideo);
     }
 
     if (RT_SUCCESS(vrc))
     {
-        RTCritSectDelete(&this->CritSect);
-
-        this->enmState = RECORDINGSTREAMSTATE_UNINITIALIZED;
-        this->fEnabled = false;
+        RTCritSectDelete(&m_CritSect);
+
+        m_enmState = RECORDINGSTREAMSTATE_UNINITIALIZED;
+        m_fEnabled = false;
     }
 
@@ -982 +982 @@
                                       uint64_t msAbsPTS, uint32_t uFlags)
 {
-    AssertPtr(this->File.pWEBM);
+    AssertPtr(this->File.m_pWEBM);
     AssertPtr(pvData);
     Assert   (cbData);
@@ -999 +999 @@
     }
 
-    return this->File.pWEBM->WriteBlock(  pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO
-                                        ? this->uTrackAudio : this->uTrackVideo,
+    return this->File.m_pWEBM->WriteBlock(  pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO
+                                        ? m_uTrackAudio : m_uTrackVideo,
                                         pvData, cbData, msAbsPTS, blockFlags);
 }
@@ -1040 +1040 @@
     AssertReturn(screenSettings.Video.ulFPS,    VERR_INVALID_PARAMETER);
 
-    PRECORDINGCODEC pCodec = &this->CodecVideo;
+    PRECORDINGCODEC pCodec = &m_CodecVideo;
 
     RECORDINGCODECCALLBACKS Callbacks;
@@ -1061 +1061 @@
 void RecordingStream::lock(void)
 {
-    int vrc = RTCritSectEnter(&CritSect);
+    int vrc = RTCritSectEnter(&m_CritSect);
     AssertRC(vrc);
 }
@@ -1070 +1070 @@
 void RecordingStream::unlock(void)
 {
-    int vrc = RTCritSectLeave(&CritSect);
+    int vrc = RTCritSectLeave(&m_CritSect);
     AssertRC(vrc);
 }

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

@@ -123 +123 @@
 
     /* Make sure to drain all queues. */
-    processQueue(&CurSeg.queueBlocks, true /* fForce */);
+    processQueue(&m_CurSeg.m_queueBlocks, true /* fForce */);
 
     writeFooter();
 
-    WebMTracks::iterator itTrack = CurSeg.mapTracks.begin();
-    while (itTrack != CurSeg.mapTracks.end())
+    WebMTracks::iterator itTrack = m_CurSeg.m_mapTracks.begin();
+    while (itTrack != m_CurSeg.m_mapTracks.end())
     {
         WebMTrack *pTrack = itTrack->second;
@@ -134 +134 @@
             delete pTrack;
 
-        CurSeg.mapTracks.erase(itTrack);
-
-        itTrack = CurSeg.mapTracks.begin();
-    }
-
-    Assert(CurSeg.queueBlocks.Map.size() == 0);
-    Assert(CurSeg.mapTracks.size() == 0);
+        m_CurSeg.m_mapTracks.erase(itTrack);
+
+        itTrack = m_CurSeg.m_mapTracks.begin();
+    }
+
+    Assert(m_CurSeg.m_queueBlocks.Map.size() == 0);
+    Assert(m_CurSeg.m_mapTracks.size() == 0);
 
     com::Utf8Str strFileName = getFileName().c_str();
@@ -169 +169 @@
     /* Some players (e.g. Firefox with Nestegg) rely on track numbers starting at 1.
      * Using a track number 0 will show those files as being corrupted. */
-    const uint8_t uTrack = (uint8_t)CurSeg.mapTracks.size() + 1;
+    const uint8_t uTrack = (uint8_t)m_CurSeg.m_mapTracks.size() + 1;
 
     subStart(MkvElem_TrackEntry);
@@ -287 +287 @@
                  pTrack->uTrack, pTrack->Audio.uHz, pTrack->Audio.msPerBlock, pTrack->Audio.framesPerBlock));
 
-        CurSeg.mapTracks[uTrack] = pTrack;
+        m_CurSeg.m_mapTracks[uTrack] = pTrack;
 
         if (puTrack)
@@ -319 +319 @@
     /* Some players (e.g. Firefox with Nestegg) rely on track numbers starting at 1.
      * Using a track number 0 will show those files as being corrupted. */
-    const uint8_t uTrack = (uint8_t)CurSeg.mapTracks.size() + 1;
+    const uint8_t uTrack = (uint8_t)m_CurSeg.m_mapTracks.size() + 1;
 
     subStart(MkvElem_TrackEntry);
@@ -345 +345 @@
     LogRel2(("Recording: WebM track #%RU8: Video\n", pTrack->uTrack));
 
-    CurSeg.mapTracks[uTrack] = pTrack;
+    m_CurSeg.m_mapTracks[uTrack] = pTrack;
 
     if (puTrack)
@@ -406 +406 @@
     m_enmVideoCodec = enmVideoCodec;
 
-    return CurSeg.init();
+    return m_CurSeg.init();
 }
 
@@ -414 +414 @@
 void WebMWriter::destroy(void)
 {
-    CurSeg.uninit();
+    m_CurSeg.uninit();
 }
 
@@ -439 +439 @@
 
     /* Save offset of current segment. */
-    CurSeg.offStart = RTFileTell(getFile());
+    m_CurSeg.m_offStart = RTFileTell(getFile());
 
     writeSeekHeader();
 
     /* Save offset of upcoming tracks segment. */
-    CurSeg.offTracks = RTFileTell(getFile());
+    m_CurSeg.m_offTracks = RTFileTell(getFile());
 
     /* The tracks segment starts right after this header. */
@@ -463 +463 @@
 {
 #ifdef LOG_ENABLED
-    WebMCluster &Cluster = CurSeg.CurCluster;
+    WebMCluster &Cluster = m_CurSeg.m_CurCluster;
 
     Log3Func(("[T%RU8C%RU64] Off=%RU64, AbsPTSMs=%RU64, RelToClusterMs=%RU16, %zu bytes\n",
@@ -508 +508 @@
 
         /* See if we already have an entry for the specified timecode in our queue. */
-        WebMBlockMap::iterator itQueue = CurSeg.queueBlocks.Map.find(tcAbsPTS);
-        if (itQueue != CurSeg.queueBlocks.Map.end()) /* Use existing queue. */
+        WebMBlockMap::iterator itQueue = m_CurSeg.m_queueBlocks.Map.find(tcAbsPTS);
+        if (itQueue != m_CurSeg.m_queueBlocks.Map.end()) /* Use existing queue. */
         {
             WebMTimecodeBlocks &Blocks = itQueue->second;
@@ -519 +519 @@
             Blocks.Enqueue(a_pBlock);
 
-            CurSeg.queueBlocks.Map[tcAbsPTS] = Blocks;
+            m_CurSeg.m_queueBlocks.Map[tcAbsPTS] = Blocks;
         }
 
-        vrc = processQueue(&CurSeg.queueBlocks, false /* fForce */);
+        vrc = processQueue(&m_CurSeg.m_queueBlocks, false /* fForce */);
     }
     catch(...)
@@ -547 +547 @@
 int WebMWriter::WriteBlock(uint8_t uTrack, const void *pvData, size_t cbData, WebMTimecodeAbs tcAbsPTSMs, WebMBlockFlags uFlags)
 {
-    int vrc = RTCritSectEnter(&CurSeg.CritSect);
+    int vrc = RTCritSectEnter(&m_CurSeg.m_CritSect);
     AssertRC(vrc);
 
-    WebMTracks::iterator itTrack = CurSeg.mapTracks.find(uTrack);
-    if (itTrack == CurSeg.mapTracks.end())
-    {
-        RTCritSectLeave(&CurSeg.CritSect);
+    WebMTracks::iterator itTrack = m_CurSeg.m_mapTracks.find(uTrack);
+    if (itTrack == m_CurSeg.m_mapTracks.end())
+    {
+        RTCritSectLeave(&m_CurSeg.m_CritSect);
         return VERR_NOT_FOUND;
     }
@@ -577 +577 @@
     }
 
-    int vrc2 = RTCritSectLeave(&CurSeg.CritSect);
+    int vrc2 = RTCritSectLeave(&m_CurSeg.m_CritSect);
     AssertRC(vrc2);
 
@@ -603 +603 @@
     }
 
-    WebMCluster &Cluster = CurSeg.CurCluster;
+    WebMCluster &Cluster = m_CurSeg.m_CurCluster;
 
     /* Iterate through the block map. */
     WebMBlockMap::iterator it = pQueue->Map.begin();
-    while (it != CurSeg.queueBlocks.Map.end())
+    while (it != m_CurSeg.m_queueBlocks.Map.end())
     {
         WebMTimecodeAbs    mapAbsPTSMs = it->first;
@@ -617 +617 @@
         /* If the current segment does not have any clusters (yet),
          * take the first absolute PTS as the starting point for that segment. */
-        if (CurSeg.cClusters == 0)
+        if (m_CurSeg.m_cClusters == 0)
         {
-            CurSeg.tcAbsStartMs = mapAbsPTSMs;
+            m_CurSeg.m_tcAbsStartMs = mapAbsPTSMs;
             fClusterStart = true;
         }
@@ -656 +656 @@
             }
             else /* First cluster ever? Use the segment's starting timecode. */
-                tcAbsClusterLastWrittenMs = CurSeg.tcAbsStartMs;
+                tcAbsClusterLastWrittenMs = m_CurSeg.m_tcAbsStartMs;
 
             Cluster.fOpen              = true;
-            Cluster.uID                = CurSeg.cClusters;
+            Cluster.uID                = m_CurSeg.m_cClusters;
             /* Use the block map's currently processed TC as the cluster's starting TC. */
             Cluster.tcAbsStartMs       = mapAbsPTSMs;
@@ -676 +676 @@
             WebMCuePoint *pCuePoint = new WebMCuePoint(Cluster.tcAbsStartMs);
 
-            WebMTracks::iterator itTrack = CurSeg.mapTracks.begin();
-            while (itTrack != CurSeg.mapTracks.end())
+            WebMTracks::iterator itTrack = m_CurSeg.m_mapTracks.begin();
+            while (itTrack != m_CurSeg.m_mapTracks.end())
             {
                 pCuePoint->Pos[itTrack->first] = new WebMCueTrackPosEntry(Cluster.offStart);
@@ -683 +683 @@
             }
 
-            CurSeg.lstCuePoints.push_back(pCuePoint);
+            m_CurSeg.m_lstCuePoints.push_back(pCuePoint);
 
             subStart(MkvElem_Cluster)
-                .serializeUnsignedInteger(MkvElem_Timecode, Cluster.tcAbsStartMs - CurSeg.tcAbsStartMs);
-
-            CurSeg.cClusters++;
+                .serializeUnsignedInteger(MkvElem_Timecode, Cluster.tcAbsStartMs - m_CurSeg.m_tcAbsStartMs);
+
+            m_CurSeg.m_cClusters++;
 
             mapBlocks.fClusterStarted = true;
@@ -694 +694 @@
 
         Log2Func(("[C%RU64] SegTcAbsStartMs=%RU64, ClusterTcAbsStartMs=%RU64, ClusterTcAbsLastWrittenMs=%RU64, mapAbsPTSMs=%RU64\n",
-                   Cluster.uID, CurSeg.tcAbsStartMs, Cluster.tcAbsStartMs, Cluster.tcAbsLastWrittenMs, mapAbsPTSMs));
+                   Cluster.uID, m_CurSeg.m_tcAbsStartMs, Cluster.tcAbsStartMs, Cluster.tcAbsLastWrittenMs, mapAbsPTSMs));
 
         /* Iterate through all blocks related to the current timecode. */
@@ -718 +718 @@
             pTrack->tcAbsLastWrittenMs = Cluster.tcAbsLastWrittenMs;
 
-            if (CurSeg.tcAbsLastWrittenMs < pTrack->tcAbsLastWrittenMs)
-                CurSeg.tcAbsLastWrittenMs = pTrack->tcAbsLastWrittenMs;
+            if (m_CurSeg.m_tcAbsLastWrittenMs < pTrack->tcAbsLastWrittenMs)
+                m_CurSeg.m_tcAbsLastWrittenMs = pTrack->tcAbsLastWrittenMs;
 
             /* Save a cue point if this is a keyframe (if no new cluster has been started,
@@ -729 +729 @@
                 WebMCuePoint *pCuePoint = new WebMCuePoint(Cluster.tcAbsLastWrittenMs);
 
-                WebMTracks::iterator itTrack = CurSeg.mapTracks.begin();
-                while (itTrack != CurSeg.mapTracks.end())
+                WebMTracks::iterator itTrack = m_CurSeg.m_mapTracks.begin();
+                while (itTrack != m_CurSeg.m_mapTracks.end())
                 {
                     pCuePoint->Pos[itTrack->first] = new WebMCueTrackPosEntry(Cluster.offStart);
@@ -736 +736 @@
                 }
 
-                CurSeg.lstCuePoints.push_back(pCuePoint);
+                m_CurSeg.m_lstCuePoints.push_back(pCuePoint);
             }
 
@@ -747 +747 @@
         Assert(mapBlocks.Queue.empty());
 
-        CurSeg.queueBlocks.Map.erase(it);
-
-        it = CurSeg.queueBlocks.Map.begin();
-    }
-
-    Assert(CurSeg.queueBlocks.Map.empty());
+        m_CurSeg.m_queueBlocks.Map.erase(it);
+
+        it = m_CurSeg.m_queueBlocks.Map.begin();
+    }
+
+    Assert(m_CurSeg.m_queueBlocks.Map.empty());
 
     pQueue->tsLastProcessedMs = RTTimeMilliTS();
@@ -774 +774 @@
     }
 
-    if (CurSeg.CurCluster.fOpen)
+    if (m_CurSeg.m_CurCluster.fOpen)
     {
         subEnd(MkvElem_Cluster);
-        CurSeg.CurCluster.fOpen = false;
+        m_CurSeg.m_CurCluster.fOpen = false;
     }
 
@@ -783 +783 @@
      * Write Cues element.
      */
-    CurSeg.offCues = RTFileTell(getFile());
-    LogFunc(("Cues @ %RU64\n", CurSeg.offCues));
+    m_CurSeg.m_offCues = RTFileTell(getFile());
+    LogFunc(("Cues @ %RU64\n", m_CurSeg.m_offCues));
 
     subStart(MkvElem_Cues);
 
-    WebMCuePointList::iterator itCuePoint = CurSeg.lstCuePoints.begin();
-    while (itCuePoint != CurSeg.lstCuePoints.end())
+    WebMCuePointList::iterator itCuePoint = m_CurSeg.m_lstCuePoints.begin();
+    while (itCuePoint != m_CurSeg.m_lstCuePoints.end())
     {
         WebMCuePoint *pCuePoint = (*itCuePoint);
@@ -811 +811 @@
                 subStart(MkvElem_CueTrackPositions)
                     .serializeUnsignedInteger(MkvElem_CueTrack,           itTrackPos->first)
-                    .serializeUnsignedInteger(MkvElem_CueClusterPosition, pTrackPos->offCluster - CurSeg.offStart, 8)
+                    .serializeUnsignedInteger(MkvElem_CueClusterPosition, pTrackPos->offCluster - m_CurSeg.m_offStart, 8)
                     .subEnd(MkvElem_CueTrackPositions);
 
@@ -839 +839 @@
 void WebMWriter::writeSeekHeader(void)
 {
-    if (CurSeg.offSeekInfo)
-        RTFileSeek(getFile(), CurSeg.offSeekInfo, RTFILE_SEEK_BEGIN, NULL);
+    if (m_CurSeg.m_offSeekInfo)
+        RTFileSeek(getFile(), m_CurSeg.m_offSeekInfo, RTFILE_SEEK_BEGIN, NULL);
     else
-        CurSeg.offSeekInfo = RTFileTell(getFile());
-
-    LogFunc(("Seek Header @ %RU64\n", CurSeg.offSeekInfo));
+        m_CurSeg.m_offSeekInfo = RTFileTell(getFile());
+
+    LogFunc(("Seek Header @ %RU64\n", m_CurSeg.m_offSeekInfo));
 
     subStart(MkvElem_SeekHead);
@@ -850 +850 @@
     subStart(MkvElem_Seek)
           .serializeUnsignedInteger(MkvElem_SeekID, MkvElem_Tracks)
-          .serializeUnsignedInteger(MkvElem_SeekPosition, CurSeg.offTracks - CurSeg.offStart, 8)
+          .serializeUnsignedInteger(MkvElem_SeekPosition, m_CurSeg.m_offTracks - m_CurSeg.m_offStart, 8)
           .subEnd(MkvElem_Seek);
 
-    if (CurSeg.offCues)
-        LogFunc(("Updating Cues @ %RU64\n", CurSeg.offCues));
+    if (m_CurSeg.m_offCues)
+        LogFunc(("Updating Cues @ %RU64\n", m_CurSeg.m_offCues));
 
     subStart(MkvElem_Seek)
           .serializeUnsignedInteger(MkvElem_SeekID, MkvElem_Cues)
-          .serializeUnsignedInteger(MkvElem_SeekPosition, CurSeg.offCues - CurSeg.offStart, 8)
+          .serializeUnsignedInteger(MkvElem_SeekPosition, m_CurSeg.m_offCues - m_CurSeg.m_offStart, 8)
           .subEnd(MkvElem_Seek);
 
     subStart(MkvElem_Seek)
           .serializeUnsignedInteger(MkvElem_SeekID, MkvElem_Info)
-          .serializeUnsignedInteger(MkvElem_SeekPosition, CurSeg.offInfo - CurSeg.offStart, 8)
+          .serializeUnsignedInteger(MkvElem_SeekPosition, m_CurSeg.m_offInfo - m_CurSeg.m_offStart, 8)
           .subEnd(MkvElem_Seek);
 
@@ -873 +873 @@
 
     /* Save offset of the segment's info element. */
-    CurSeg.offInfo = RTFileTell(getFile());
-
-    LogFunc(("Info @ %RU64\n", CurSeg.offInfo));
+    m_CurSeg.m_offInfo = RTFileTell(getFile());
+
+    LogFunc(("Info @ %RU64\n", m_CurSeg.m_offInfo));
 
     char szMux[64];
@@ -888 +888 @@
     RTStrPrintf(szApp, sizeof(szApp), VBOX_PRODUCT " %sr%u", VBOX_VERSION_STRING, RTBldCfgRevision());
 
-    const WebMTimecodeAbs tcAbsDurationMs = CurSeg.tcAbsLastWrittenMs - CurSeg.tcAbsStartMs;
-
-    if (!CurSeg.lstCuePoints.empty())
+    const WebMTimecodeAbs tcAbsDurationMs = m_CurSeg.m_tcAbsLastWrittenMs - m_CurSeg.m_tcAbsStartMs;
+
+    if (!m_CurSeg.m_lstCuePoints.empty())
     {
         LogFunc(("tcAbsDurationMs=%RU64\n", tcAbsDurationMs));
@@ -897 +897 @@
 
     subStart(MkvElem_Info)
-        .serializeUnsignedInteger(MkvElem_TimecodeScale, CurSeg.uTimecodeScaleFactor)
+        .serializeUnsignedInteger(MkvElem_TimecodeScale, m_CurSeg.m_uTimecodeScaleFactor)
         .serializeFloat(MkvElem_Segment_Duration, tcAbsDurationMs)
         .serializeString(MkvElem_MuxingApp, szMux)