Changeset 96229 in vbox for trunk/src/VBox/Main

Timestamp:

Aug 16, 2022 3:41:39 PM (2 years ago)

Author:

vboxsync

Message:

Recording/Main: Decoupled the WebM writer class from codec dependencies. Various bugfixes. bugref:10275

Location:

trunk/src/VBox/Main

Files:

• include/Recording.h (modified) (8 diffs)
• include/RecordingInternals.h (modified) (12 diffs)
• include/RecordingStream.h (modified) (4 diffs)
• include/WebMWriter.h (modified) (2 diffs)
• src-client/DrvAudioRec.cpp (modified) (7 diffs)
• src-client/Recording.cpp (modified) (11 diffs)
• src-client/RecordingCodec.cpp (modified) (23 diffs)
• src-client/RecordingStream.cpp (modified) (25 diffs)
• src-client/WebMWriter.cpp (modified) (4 diffs)

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

@@ -38 +38 @@
     RecordingContext();
 
-    RecordingContext(Console *ptrConsole, const settings::RecordingSettings &settings);
+    RecordingContext(Console *ptrConsole, const settings::RecordingSettings &Settings);
 
     virtual ~RecordingContext(void);
@@ -47 +47 @@
     RecordingStream *GetStream(unsigned uScreen) const;
     size_t GetStreamCount(void) const;
+#ifdef VBOX_WITH_AUDIO_RECORDING
+    PRECORDINGCODEC GetCodecAudio(void) { return &this->CodecAudio; }
+#endif
 
-    int Create(Console *pConsole, const settings::RecordingSettings &settings);
+    int Create(Console *pConsole, const settings::RecordingSettings &Settings);
     void Destroy(void);
 
@@ -72 +75 @@
 protected:
 
-    int createInternal(Console *ptrConsole, const settings::RecordingSettings &settings);
+    int createInternal(Console *ptrConsole, const settings::RecordingSettings &Settings);
     int startInternal(void);
     int stopInternal(void);
@@ -80 +83 @@
     RecordingStream *getStreamInternal(unsigned uScreen) const;
 
+    int writeCommonData(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags);
+
     int lock(void);
     int unlock(void);
@@ -86 +91 @@
 
     int threadNotify(void);
+
+protected:
+
+    int audioInit(const settings::RecordingScreenSettings &screenSettings);
+
+    static DECLCALLBACK(int) audioCodecWriteDataCallback(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags, void *pvUser);
 
 protected:
@@ -107 +118 @@
     Console                     *pConsole;
     /** Used recording configuration. */
-    settings::RecordingSettings  Settings;
+    settings::RecordingSettings  m_Settings;
     /** The current state. */
     RECORDINGSTS                 enmState;
@@ -116 +127 @@
     /** Shutdown indicator. */
     bool                         fShutdown;
-    /** Worker thread. */
+    /** Encoding worker thread. */
     RTTHREAD                     Thread;
     /** Vector of current recording streams.
@@ -125 +136 @@
     /** Timestamp (in ms) of when recording has been started. */
     uint64_t                     tsStartMs;
+#ifdef VBOX_WITH_AUDIO_RECORDING
+    /** Audio codec to use.
+     *
+     *  We multiplex audio data from this recording context to all streams,
+     *  to avoid encoding the same audio data for each stream. We ASSUME that
+     *  all audio data of a VM will be the same for each stream at a given
+     *  point in time. */
+    RECORDINGCODEC               CodecAudio;
+#endif /* VBOX_WITH_AUDIO_RECORDING */
     /** Block map of common blocks which need to get multiplexed
      *  to all recording streams. This common block maps should help

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

@@ -122 +122 @@
      * @param   pCodec              Codec instance to use.
      * @param   pFrame              Pointer to frame data to encode.
-     * @param   pvDst               Where to store the encoded data on success.
-     * @param   cbDst               Size (in bytes) of \a pvDst.
      * @param   pcEncoded           Where to return the number of encoded blocks in \a pvDst on success. Optional.
      * @param   pcbEncoded          Where to return the number of encoded bytes in \a pvDst on success. Optional.
      */
-    DECLCALLBACKMEMBER(int, pfnEncode,       (PRECORDINGCODEC pCodec, const PRECORDINGFRAME pFrame, void *pvDst, size_t cbDst, size_t *pcEncoded, size_t *pcbEncoded));
+    DECLCALLBACKMEMBER(int, pfnEncode,       (PRECORDINGCODEC pCodec, const PRECORDINGFRAME pFrame, size_t *pcEncoded, size_t *pcbEncoded));
 
     /**
@@ -138 +136 @@
 } RECORDINGCODECOPS, *PRECORDINGCODECOPS;
 
+/** No encoding flags set. */
+#define RECORDINGCODEC_ENC_F_NONE               UINT32_C(0)
+/** Data block is a key block. */
+#define RECORDINGCODEC_ENC_F_BLOCK_IS_KEY       RT_BIT_32(0)
+/** Data block is invisible. */
+#define RECORDINGCODEC_ENC_F_BLOCK_IS_INVISIBLE RT_BIT_32(1)
+/** Encoding flags valid mask. */
+#define RECORDINGCODEC_ENC_F_VALID_MASK         0x1
+
 /**
  * Structure for keeping a codec callback table.
@@ -143 +150 @@
 typedef struct RECORDINGCODECCALLBACKS
 {
-    DECLCALLBACKMEMBER(int, pfnWriteData, (PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, void *pvUser));
+    /**
+     * Callback for notifying that encoded data has been written.
+     *
+     * @returns VBox status code.
+     * @param   pCodec          Pointer to codec instance which has written the data.
+     * @param   pvData          Pointer to written data (encoded).
+     * @param   cbData          Size (in bytes) of \a pvData.
+     * @param   msAbsPTS        Absolute PTS (in ms) of the written data.
+     * @param   uFlags          Encoding flags of type RECORDINGCODEC_ENC_F_XXX.
+     * @param   pvUser          User-supplied pointer.
+     */
+    DECLCALLBACKMEMBER(int, pfnWriteData, (PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags, void *pvUser));
     /** User-supplied data pointer. */
-    void                       *pvUser;
+    void                   *pvUser;
 } RECORDINGCODECCALLBACKS, *PRECORDINGCODECCALLBACKS;
 
@@ -186 +204 @@
      *  Set to 0 to use a variable bit rate (VBR) (if available, otherwise fall back to CBR). */
     uint32_t                    uBitrate;
-    /** Time (in ms) an (encoded) frame takes.
+    /** Time (in ms) the encoder expects us to send data to encode.
      *
      *  For Opus, valid frame sizes are:
@@ -196 +214 @@
      *  40           1920
      *  60           2880
+     *
+     *  For Vorbis, valid frame sizes are powers of two from 64 to 8192 bytes.
      */
     uint32_t                    msFrame;
-    /** The frame size in bytes (based on msFrame). */
+    /** The frame size in bytes (based on \a msFrame). */
     uint32_t                    cbFrame;
-    /** The frame size in samples per frame (based on msFrame). */
+    /** The frame size in samples per frame (based on \a msFrame). */
     uint32_t                    csFrame;
 } RECORDINGCODECPARMS, *PRECORDINGCODECPARMS;
@@ -258 +278 @@
 
 /**
+ * Structure for keeping a codec's internal state.
+ */
+typedef struct RECORDINGCODECSTATE
+{
+    /** Timestamp (in ms, absolute) of the last frame was encoded. */
+    uint64_t            tsLastWrittenMs;
+    /** Number of encoding errors. */
+    uint64_t            cEncErrors;
+} RECORDINGCODECSTATE;
+/** Pointer to an internal encoder state. */
+typedef RECORDINGCODECSTATE *PRECORDINGCODECSTATE;
+
+/**
  * Structure for keeping codec-specific data.
  */
@@ -268 +301 @@
     /** Generic codec parameters. */
     RECORDINGCODECPARMS         Parms;
+    /** Generic codec parameters. */
+    RECORDINGCODECSTATE         State;
 
 #ifdef VBOX_WITH_LIBVPX
@@ -288 +323 @@
 #endif /* VBOX_WITH_AUDIO_RECORDING */
 
-    /** Timestamp (in ms) of the last frame was encoded. */
-    uint64_t            uLastTimeStampMs;
-    /** Number of encoding errors. */
-    uint64_t            cEncErrors;
+    /** Internal scratch buffer for en-/decoding steps. */
+    void               *pvScratch;
+    /** Size (in bytes) of \a pvScratch. */
+    uint32_t            cbScratch;
 
 #ifdef VBOX_WITH_STATISTICS /** @todo Register these values with STAM. */
@@ -300 +335 @@
         /** Total time (in ms) of already encoded audio data. */
         uint64_t        msEncTotal;
-    } Stats;
+    } STAM;
 #endif
 } RECORDINGCODEC, *PRECORDINGCODEC;
@@ -395 +430 @@
         : enmType(RECORDINGBLOCKTYPE_UNKNOWN)
         , cRefs(0)
+        , uFlags(RECORDINGCODEC_ENC_F_NONE)
         , pvData(NULL)
         , cbData(0) { }
@@ -434 +470 @@
     /** Number of references held of this block. */
     uint16_t           cRefs;
+    /** Block flags of type RECORDINGCODEC_ENC_F_XXX. */
+    uint64_t           uFlags;
     /** The (absolute) timestamp (in ms, PTS) of this block. */
     uint64_t           msTimestamp;
@@ -449 +487 @@
 int recordingCodecInit(const PRECORDINGCODEC pCodec, const PRECORDINGCODECCALLBACKS pCallbacks, const settings::RecordingScreenSettings &Settings);
 int recordingCodecDestroy(PRECORDINGCODEC pCodec);
-int recordingCodecEncode(PRECORDINGCODEC pCodec, const PRECORDINGFRAME pFrame, void *pvDst, size_t cbDst, size_t *pcEncoded, size_t *pcbEncoded);
+int recordingCodecEncode(PRECORDINGCODEC pCodec, const PRECORDINGFRAME pFrame, size_t *pcEncoded, size_t *pcbEncoded);
 int recordingCodecFinalize(PRECORDINGCODEC pCodec);
 #endif /* !MAIN_INCLUDED_RecordingInternals_h */

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

@@ -126 +126 @@
     uint16_t GetID(void) const { return this->uScreenID; };
 #ifdef VBOX_WITH_AUDIO_RECORDING
-    PRECORDINGCODEC GetAudioCodec(void) { return &this->CodecAudio; };
+    PRECORDINGCODEC GetAudioCodec(void) { return this->pCodecAudio; };
 #endif
     PRECORDINGCODEC GetVideoCodec(void) { return &this->CodecVideo; };
@@ -132 +132 @@
     bool IsReady(void) const;
 
+public:
+
+    static DECLCALLBACK(int) codecWriteDataCallback(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags, void *pvUser);
+
 protected:
 
-    static DECLCALLBACK(int) codecWriteDataCallback(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, void *pvUser);
-
-protected:
-
-    int open(const settings::RecordingScreenSettings &Settings);
+    int open(const settings::RecordingScreenSettings &screenSettings);
     int close(void);
 
-    int initInternal(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings);
+    int initInternal(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &screenSettings);
     int uninitInternal(void);
 
-    int initVideo(const settings::RecordingScreenSettings &Settings);
+    int initVideo(const settings::RecordingScreenSettings &screenSettings);
     int unitVideo(void);
-
-    int initAudio(const settings::RecordingScreenSettings &Settings);
 
     bool isLimitReachedInternal(uint64_t msTimestamp) const;
     int iterateInternal(uint64_t msTimestamp);
+
+    int codecWriteToWebM(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags);
 
     void lock(void);
@@ -171 +171 @@
 
     /** Recording context this stream is associated to. */
-    RecordingContext       *pCtx;
+    RecordingContext       *m_pCtx;
     /** The current state. */
     RECORDINGSTREAMSTATE    enmState;
@@ -192 +192 @@
     /** Critical section to serialize access. */
     RTCRITSECT          CritSect;
-    /** Timestamp (in ms) of when recording has been start. */
+    /** Timestamp (in ms) of when recording has been started. */
     uint64_t            tsStartMs;
-
-    /** Audio codec instance data to use. */
-    RECORDINGCODEC                    CodecAudio;
+#ifdef VBOX_WITH_AUDIO_RECORDING
+    /** Pointer to audio codec instance data to use.
+     *
+     *  We multiplex audio data from the recording context to all streams,
+     *  to avoid encoding the same audio data for each stream. We ASSUME that
+     *  all audio data of a VM will be the same for each stream at a given
+     *  point in time.
+     *
+     *  Might be NULL if not being used. */
+    PRECORDINGCODEC     pCodecAudio;
+#endif /* VBOX_WITH_AUDIO_RECORDING */
     /** Video codec instance data to use. */
-    RECORDINGCODEC                    CodecVideo;
+    RECORDINGCODEC      CodecVideo;
     /** Screen settings to use. */
-    settings::RecordingScreenSettings ScreenSettings;
+    settings::RecordingScreenSettings
+                        ScreenSettings;
     /** Common set of recording (data) blocks, needed for
      *  multiplexing to all recording streams. */
-    RecordingBlockSet                 Blocks;
+    RecordingBlockSet   Blocks;
 };
 

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

@@ -563 +563 @@
     int AddVideoTrack(PRECORDINGCODEC pCodec, uint16_t uWidth, uint16_t uHeight, uint32_t uFPS, uint8_t *puTrack);
 
-    int WriteBlock(uint8_t uTrack, const void *pvData, size_t cbData);
+    int WriteBlock(uint8_t uTrack, const void *pvData, size_t cbData, WebMTimecodeAbs tcAbsPTSMs, WebMBlockFlags uFlags);
 
     const com::Utf8Str& GetFileName(void);
@@ -594 +594 @@
     int writeSimpleBlockQueued(WebMTrack *a_pTrack, WebMSimpleBlock *a_pBlock);
 
-#ifdef VBOX_WITH_LIBVPX
-    int writeSimpleBlockVP8(WebMTrack *a_pTrack, const vpx_codec_enc_cfg_t *a_pCfg, const vpx_codec_cx_pkt_t *a_pPkt);
-#endif
-
-    int writeSimpleBlockAudio(WebMTrack *pTrack, const void *pvData, size_t cbData, WebMTimecodeAbs tcAbsPTSMs);
-
     int processQueue(WebMQueue *pQueue, bool fForce);
 

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

@@ -171 +171 @@
 typedef struct AVRECSINK
 {
-    /** Pointer to audio codec to use. */
+    /** Pointer (weak) to audio codec to use. */
     PRECORDINGCODEC      pCodec;
     /** Container data to use for data processing. */
@@ -198 +198 @@
     /** Size (in bytes) of the temporary buffer holding the input (source) data to encode. */
     size_t                  cbSrcBuf;
-    /** Temporary buffer for the encoded output (destination) data. */
-    void                   *pvDstBuf;
-    /** Size (in bytes) of the temporary buffer holding the encoded output (destination) data. */
-    size_t                  cbDstBuf;
 } AVRECSTREAM, *PAVRECSTREAM;
 
@@ -355 +351 @@
         {
             pStreamAV->cbSrcBuf = cbScratchBuf;
-            pStreamAV->pvDstBuf = RTMemAlloc(cbScratchBuf);
-            if (pStreamAV->pvDstBuf)
-            {
-                pStreamAV->cbDstBuf = cbScratchBuf;
-
-                pStreamAV->pSink      = pSink; /* Assign sink to stream. */
-                pStreamAV->uLastPTSMs = 0;
-
-                /* Make sure to let the driver backend know that we need the audio data in
-                 * a specific sampling rate the codec is optimized for. */
+
+            pStreamAV->pSink      = pSink; /* Assign sink to stream. */
+            pStreamAV->uLastPTSMs = 0;
+
+            /* Make sure to let the driver backend know that we need the audio data in
+             * a specific sampling rate the codec is optimized for. */
 /** @todo r=bird: pCfgAcq->Props isn't initialized at all, except for uHz... */
-                pCfgAcq->Props.uHz         = pCodec->Parms.Audio.PCMProps.uHz;
+            pCfgAcq->Props.uHz         = pCodec->Parms.Audio.PCMProps.uHz;
 //                pCfgAcq->Props.cShift      = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfgAcq->Props.cbSample, pCfgAcq->Props.cChannels);
 
-                /* Every Opus frame marks a period for now. Optimize this later. */
-                pCfgAcq->Backend.cFramesPeriod       = PDMAudioPropsMilliToFrames(&pCfgAcq->Props, pCodec->Parms.msFrame);
-                pCfgAcq->Backend.cFramesBufferSize   = PDMAudioPropsMilliToFrames(&pCfgAcq->Props, 100 /*ms*/); /** @todo Make this configurable. */
-                pCfgAcq->Backend.cFramesPreBuffering = pCfgAcq->Backend.cFramesPeriod * 2;
-            }
-            else
-                vrc = VERR_NO_MEMORY;
+            /* Every Opus frame marks a period for now. Optimize this later. */
+            pCfgAcq->Backend.cFramesPeriod       = PDMAudioPropsMilliToFrames(&pCfgAcq->Props, pCodec->Parms.msFrame);
+            pCfgAcq->Backend.cFramesBufferSize   = PDMAudioPropsMilliToFrames(&pCfgAcq->Props, 100 /*ms*/); /** @todo Make this configurable. */
+            pCfgAcq->Backend.cFramesPreBuffering = pCfgAcq->Backend.cFramesPeriod * 2;
         }
         else
@@ -435 +424 @@
         pStreamAV->pvSrcBuf = NULL;
         pStreamAV->cbSrcBuf = 0;
-    }
-
-    if (pStreamAV->pvDstBuf)
-    {
-        Assert(pStreamAV->cbDstBuf);
-        RTMemFree(pStreamAV->pvDstBuf);
-        pStreamAV->pvDstBuf = NULL;
-        pStreamAV->cbDstBuf = 0;
     }
 
@@ -629 +610 @@
         vrc = recordingCodecEncode(pSink->pCodec,
                                    /* Source */
-                                   &Frame,
-                                   /* Dest */
-                                   pStreamAV->pvDstBuf, pStreamAV->cbDstBuf, &cEncoded, &cbEncoded);
+                                   &Frame, &cEncoded, &cbEncoded);
         if (   RT_SUCCESS(vrc)
             && cEncoded)
         {
             Assert(cbEncoded);
-
-            if (pStreamAV->uLastPTSMs == 0)
-                pStreamAV->uLastPTSMs = RTTimeProgramMilliTS(); /* We want the absolute time (in ms) since program start. */
-
-            const uint64_t uDurationMs = pSink->pCodec->Parms.msFrame * cEncoded;
-            const uint64_t uPTSMs      = pStreamAV->uLastPTSMs;
-
-            pStreamAV->uLastPTSMs += uDurationMs;
-
-            switch (pSink->Con.Parms.enmType)
-            {
-                case AVRECCONTAINERTYPE_MAIN_CONSOLE:
-                {
-                    HRESULT hrc = pSink->Con.Main.pConsole->i_recordingSendAudio(pStreamAV->pvDstBuf, cbEncoded, uPTSMs);
-                    Assert(hrc == S_OK);
-                    RT_NOREF(hrc);
-                    break;
-                }
-
-                case AVRECCONTAINERTYPE_WEBM:
-                {
-                    WebMWriter::BlockData_Audio blockData = { pStreamAV->pvDstBuf, cbEncoded, uPTSMs };
-                    vrc = pSink->Con.WebM.pWebM->WriteBlock(pSink->Con.WebM.uTrack, &blockData, sizeof(blockData));
-                    AssertRC(vrc);
-                    break;
-                }
-
-                default:
-                    AssertFailedStmt(vrc = VERR_NOT_IMPLEMENTED);
-                    break;
-            }
         }
         else if (RT_FAILURE(vrc)) /* Something went wrong -- report all bytes as being processed, to not hold up others. */
@@ -737 +685 @@
     AssertPtrReturnVoid(pSink);
 
-    recordingCodecFinalize(pSink->pCodec);
-    recordingCodecDestroy(pSink->pCodec);
     pSink->pCodec = NULL;
 
@@ -901 +847 @@
         return VINF_SUCCESS;
     }
-
-    recordingCodecDestroy(pSink->pCodec);
-    pSink->pCodec = NULL;
 
     LogRel(("Recording: Error creating sink (%Rrc)\n", vrc));

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

@@ -61 +61 @@
  * Recording context constructor.
  *
- * @note    Will throw when unable to create.
+ * @note    Will throw rc when unable to create.
  */
 RecordingContext::RecordingContext(void)
@@ -77 +77 @@
  *
  * @param   ptrConsole          Pointer to console object this context is bound to (weak pointer).
- * @param   settings            Reference to recording settings to use for creation.
- *
- * @note    Will throw when unable to create.
- */
-RecordingContext::RecordingContext(Console *ptrConsole, const settings::RecordingSettings &settings)
+ * @param   Settings            Reference to recording settings to use for creation.
+ *
+ * @note    Will throw rc when unable to create.
+ */
+RecordingContext::RecordingContext(Console *ptrConsole, const settings::RecordingSettings &Settings)
     : pConsole(NULL)
     , enmState(RECORDINGSTS_UNINITIALIZED)
@@ -90 +90 @@
         throw vrc;
 
-    vrc = RecordingContext::createInternal(ptrConsole, settings);
+    vrc = RecordingContext::createInternal(ptrConsole, Settings);
     if (RT_FAILURE(vrc))
         throw vrc;
@@ -170 +170 @@
 
 /**
+ * Writes block data which are common (shared) between all streams.
+ *
+ * To save time spent in EMT or other important threads (such as audio async I/O),
+ * do the required audio multiplexing in the encoding thread.
+ *
+ * The multiplexing is needed to supply all recorded (enabled) screens with the same
+ * data at the same given point in time.
+ *
+ * Currently this only is being used for audio data.
+ */
+int RecordingContext::writeCommonData(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData,
+                                      uint64_t msAbsPTS, uint32_t uFlags)
+{
+    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
+    AssertReturn(cbData, VERR_INVALID_PARAMETER);
+
+    LogFlowFunc(("pCodec=%p, cbData=%zu, msAbsPTS=%zu, uFlags=%#x\n",
+                 pCodec, cbData, msAbsPTS, uFlags));
+
+    /** @todo Optimize this! Three allocations in here! */
+
+    RECORDINGBLOCKTYPE const enmType = pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO
+                                     ? RECORDINGBLOCKTYPE_AUDIO : RECORDINGBLOCKTYPE_UNKNOWN;
+
+    AssertReturn(enmType != RECORDINGBLOCKTYPE_UNKNOWN, VERR_NOT_SUPPORTED);
+
+    RecordingBlock *pBlock = new RecordingBlock();
+
+    switch (enmType)
+    {
+        case RECORDINGBLOCKTYPE_AUDIO:
+        {
+            PRECORDINGAUDIOFRAME pFrame = (PRECORDINGAUDIOFRAME)RTMemAlloc(sizeof(RECORDINGAUDIOFRAME));
+            AssertPtrReturn(pFrame, VERR_NO_MEMORY);
+
+            pFrame->pvBuf = (uint8_t *)RTMemAlloc(cbData);
+            AssertPtrReturn(pFrame->pvBuf, VERR_NO_MEMORY);
+            pFrame->cbBuf = cbData;
+
+            memcpy(pFrame->pvBuf, pvData, cbData);
+
+            pBlock->enmType     = enmType;
+            pBlock->pvData      = pFrame;
+            pBlock->cbData      = sizeof(RECORDINGAUDIOFRAME) + cbData;
+            pBlock->cRefs       = this->cStreamsEnabled;
+            pBlock->msTimestamp = msAbsPTS;
+            pBlock->uFlags      = uFlags;
+
+            break;
+        }
+
+        default:
+            AssertFailed();
+            break;
+    }
+
+    lock();
+
+    int vrc;
+
+    try
+    {
+        RecordingBlockMap::iterator itBlocks = this->mapBlocksCommon.find(msAbsPTS);
+        if (itBlocks == this->mapBlocksCommon.end())
+        {
+            RecordingBlocks *pRecordingBlocks = new RecordingBlocks();
+            pRecordingBlocks->List.push_back(pBlock);
+
+            this->mapBlocksCommon.insert(std::make_pair(msAbsPTS, pRecordingBlocks));
+        }
+        else
+            itBlocks->second->List.push_back(pBlock);
+
+        vrc = VINF_SUCCESS;
+    }
+    catch (const std::exception &ex)
+    {
+        RT_NOREF(ex);
+        vrc = VERR_NO_MEMORY;
+    }
+
+    unlock();
+
+    if (RT_SUCCESS(vrc))
+        vrc = threadNotify();
+
+    return vrc;
+}
+
+#ifdef VBOX_WITH_AUDIO_RECORDING
+/**
+ * Callback function for taking care of multiplexing the encoded audio data to all connected streams.
+ *
+ * @copydoc RECORDINGCODECCALLBACKS::pfnWriteData
+ */
+/* static */
+DECLCALLBACK(int) RecordingContext::audioCodecWriteDataCallback(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData,
+                                                                uint64_t msAbsPTS, uint32_t uFlags, void *pvUser)
+{
+#if 0
+    RecordingContext *pThis = (RecordingContext *)pvUser;
+
+    int vrc = VINF_SUCCESS;
+
+    RecordingStreams::iterator itStream = pThis->vecStreams.begin();
+    while (itStream != pThis->vecStreams.end())
+    {
+        RecordingStream *pStream = (*itStream);
+
+        LogFlowFunc(("pStream=%p\n", pStream));
+
+        if (pStream->GetConfig().isFeatureEnabled(RecordingFeature_Audio)) /** @todo Optimize this! Use a dedicated stream group for video-only / audio-only streams. */
+        {
+            vrc = RecordingStream::codecWriteDataCallback(pCodec, pvData, cbData, msAbsPTS, uFlags, pStream);
+            if (RT_FAILURE(vrc))
+            {
+                LogRel(("Recording: Calling audio write callback for stream #%RU16 failed (%Rrc)\n", pStream->GetID(), vrc));
+                break;
+            }
+        }
+
+        ++itStream;
+    }
+
+    return vrc;
+#else
+    RecordingContext *pThis = (RecordingContext *)pvUser;
+
+    return pThis->writeCommonData(pCodec, pvData, cbData, msAbsPTS, uFlags);
+#endif
+}
+
+/**
+ * Initializes the audio codec for a (multiplexing) recording context.
+ *
+ * @returns VBox status code.
+ * @param   screenSettings      Reference to recording screen settings to use for initialization.
+ */
+int RecordingContext::audioInit(const settings::RecordingScreenSettings &screenSettings)
+{
+    RecordingAudioCodec_T const enmCodec = screenSettings.Audio.enmCodec;
+
+    if (enmCodec == RecordingAudioCodec_None)
+    {
+        LogRel2(("Recording: No audio codec configured, skipping audio init\n"));
+        return VINF_SUCCESS;
+    }
+
+    RECORDINGCODECCALLBACKS Callbacks;
+    Callbacks.pvUser       = this;
+    Callbacks.pfnWriteData = RecordingContext::audioCodecWriteDataCallback;
+
+    int vrc = recordingCodecCreateAudio(&this->CodecAudio, enmCodec);
+    if (RT_SUCCESS(vrc))
+        vrc = recordingCodecInit(&this->CodecAudio, &Callbacks, screenSettings);
+
+    return vrc;
+}
+#endif /* VBOX_WITH_AUDIO_RECORDING */
+
+/**
  * Creates a recording context.
  *
  * @returns IPRT status code.
  * @param   ptrConsole          Pointer to console object this context is bound to (weak pointer).
- * @param   settings            Reference to recording settings to use for creation.
- */
-int RecordingContext::createInternal(Console *ptrConsole, const settings::RecordingSettings &settings)
+ * @param   Settings            Reference to recording settings to use for creation.
+ */
+int RecordingContext::createInternal(Console *ptrConsole, const settings::RecordingSettings &Settings)
 {
     int vrc = VINF_SUCCESS;
 
+    /* Copy the settings to our context. */
+    m_Settings = Settings;
+
+#ifdef VBOX_WITH_AUDIO_RECORDING
+    settings::RecordingScreenSettingsMap::const_iterator itScreen0 = m_Settings.mapScreens.begin();
+    AssertReturn(itScreen0 != m_Settings.mapScreens.end(), VERR_WRONG_ORDER);
+
+    /* We always use the audio settings from screen 0, as we multiplex the audio data anyway. */
+    settings::RecordingScreenSettings const &screen0Settings = itScreen0->second;
+
+    vrc = this->audioInit(screen0Settings);
+    if (RT_FAILURE(vrc))
+        return vrc;
+#endif
+
     this->pConsole = ptrConsole;
 
-    settings::RecordingScreenSettingsMap::const_iterator itScreen = settings.mapScreens.begin();
-    while (itScreen != settings.mapScreens.end())
+    settings::RecordingScreenSettingsMap::const_iterator itScreen = m_Settings.mapScreens.begin();
+    while (itScreen != m_Settings.mapScreens.end())
     {
         RecordingStream *pStream = NULL;
@@ -192 +368 @@
             if (itScreen->second.fEnabled)
                 this->cStreamsEnabled++;
+            LogFlowFunc(("pStream=%p\n", pStream));
         }
         catch (std::bad_alloc &)
@@ -213 +390 @@
         this->fShutdown = false;
 
-        /* Copy the settings to our context. */
-        this->Settings  = settings;
-
         vrc = RTSemEventCreate(&this->WaitEvent);
         AssertRCReturn(vrc, vrc);
@@ -343 +517 @@
 const settings::RecordingSettings &RecordingContext::GetConfig(void) const
 {
-    return this->Settings;
+    return this->m_Settings;
 }
 
@@ -368 +542 @@
 }
 
+/**
+ * Locks the recording context for serializing access.
+ *
+ * @returns VBox status code.
+ */
 int RecordingContext::lock(void)
 {
@@ -375 +554 @@
 }
 
+/**
+ * Unlocks the recording context for serializing access.
+ *
+ * @returns VBox status code.
+ */
 int RecordingContext::unlock(void)
 {
@@ -408 +592 @@
  * @returns IPRT status code.
  * @param   ptrConsole          Pointer to console object this context is bound to (weak pointer).
- * @param   settings            Reference to recording settings to use for creation.
- */
-int RecordingContext::Create(Console *ptrConsole, const settings::RecordingSettings &settings)
-{
-    return createInternal(ptrConsole, settings);
+ * @param   Settings            Reference to recording settings to use for creation.
+ */
+int RecordingContext::Create(Console *ptrConsole, const settings::RecordingSettings &Settings)
+{
+    return createInternal(ptrConsole, Settings);
 }
 
@@ -605 +789 @@
 {
 #ifdef VBOX_WITH_AUDIO_RECORDING
-    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
-    AssertReturn(cbData, VERR_INVALID_PARAMETER);
-
-    /* To save time spent in EMT, do the required audio multiplexing in the encoding thread.
-     *
-     * The multiplexing is needed to supply all recorded (enabled) screens with the same
-     * audio data at the same given point in time.
-     */
-    RecordingBlock *pBlock = new RecordingBlock();
-    pBlock->enmType = RECORDINGBLOCKTYPE_AUDIO;
-
-    PRECORDINGAUDIOFRAME pFrame = (PRECORDINGAUDIOFRAME)RTMemAlloc(sizeof(RECORDINGAUDIOFRAME));
-    AssertPtrReturn(pFrame, VERR_NO_MEMORY);
-
-    pFrame->pvBuf = (uint8_t *)RTMemAlloc(cbData);
-    AssertPtrReturn(pFrame->pvBuf, VERR_NO_MEMORY);
-    pFrame->cbBuf = cbData;
-
-    memcpy(pFrame->pvBuf, pvData, cbData);
-
-    pBlock->pvData      = pFrame;
-    pBlock->cbData      = sizeof(RECORDINGAUDIOFRAME) + cbData;
-    pBlock->cRefs       = this->cStreamsEnabled;
-    pBlock->msTimestamp = msTimestamp;
-
-    lock();
-
-    int vrc;
-
-    try
-    {
-        RecordingBlockMap::iterator itBlocks = this->mapBlocksCommon.find(msTimestamp);
-        if (itBlocks == this->mapBlocksCommon.end())
-        {
-            RecordingBlocks *pRecordingBlocks = new RecordingBlocks();
-            pRecordingBlocks->List.push_back(pBlock);
-
-            this->mapBlocksCommon.insert(std::make_pair(msTimestamp, pRecordingBlocks));
-        }
-        else
-            itBlocks->second->List.push_back(pBlock);
-
-        vrc = VINF_SUCCESS;
-    }
-    catch (const std::exception &ex)
-    {
-        RT_NOREF(ex);
-        vrc = VERR_NO_MEMORY;
-    }
-
-    unlock();
-
-    if (RT_SUCCESS(vrc))
-        vrc = threadNotify();
-
-    return vrc;
+    return writeCommonData(&this->CodecAudio, pvData, cbData, msTimestamp, RECORDINGCODEC_ENC_F_BLOCK_IS_KEY);
 #else
     RT_NOREF(pvData, cbData, msTimestamp);

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

@@ -39 +39 @@
 static DECLCALLBACK(int) recordingCodecVPXInit(PRECORDINGCODEC pCodec)
 {
+    pCodec->cbScratch = _4K;
+    pCodec->pvScratch = RTMemAlloc(pCodec->cbScratch);
+    AssertPtrReturn(pCodec->pvScratch, VERR_NO_MEMORY);
+
 # ifdef VBOX_WITH_LIBVPX_VP9
     vpx_codec_iface_t *pCodecIface = vpx_codec_vp9_cx();
@@ -132 +136 @@
 /** @copydoc RECORDINGCODECOPS::pfnEncode */
 static DECLCALLBACK(int) recordingCodecVPXEncode(PRECORDINGCODEC pCodec, PRECORDINGFRAME pFrame,
-                                                 void *pvDst, size_t cbDst, size_t *pcEncoded, size_t *pcbEncoded)
-{
-    RT_NOREF(pvDst, cbDst, pcEncoded, pcbEncoded);
+                                                 size_t *pcEncoded, size_t *pcbEncoded)
+{
+    RT_NOREF(pcEncoded, pcbEncoded);
 
     AssertPtrReturn(pFrame, VERR_INVALID_POINTER);
@@ -158 +162 @@
     if (rcv != VPX_CODEC_OK)
     {
-        if (pCodec->cEncErrors++ < 64) /** @todo Make this configurable. */
+        if (pCodec->State.cEncErrors++ < 64) /** @todo Make this configurable. */
             LogRel(("Recording: Failed to encode video frame: %s\n", vpx_codec_err_to_string(rcv)));
         return VERR_RECORDING_ENCODING_FAILED;
     }
 
-    pCodec->cEncErrors = 0;
+    pCodec->State.cEncErrors = 0;
 
     vpx_codec_iter_t iter = NULL;
@@ -169 +173 @@
     for (;;)
     {
-        const vpx_codec_cx_pkt_t *pPacket = vpx_codec_get_cx_data(&pVPX->Ctx, &iter);
-        if (!pPacket)
+        const vpx_codec_cx_pkt_t *pPkt = vpx_codec_get_cx_data(&pVPX->Ctx, &iter);
+        if (!pPkt)
             break;
 
-        switch (pPacket->kind)
+        switch (pPkt->kind)
         {
             case VPX_CODEC_CX_FRAME_PKT:
             {
-                WebMWriter::BlockData_VP8 blockData = { &pCodec->Video.VPX.Cfg, pPacket };
-                AssertPtr(pCodec->Callbacks.pfnWriteData);
-
-                vrc = pCodec->Callbacks.pfnWriteData(pCodec, &blockData, sizeof(blockData), pCodec->Callbacks.pvUser);
+                /* Calculate the absolute PTS of this frame (in ms). */
+                uint64_t tsAbsPTSMs =   pPkt->data.frame.pts * 1000
+                                      * (uint64_t)pCodec->Video.VPX.Cfg.g_timebase.num / pCodec->Video.VPX.Cfg.g_timebase.den;
+
+                pCodec->State.tsLastWrittenMs += pCodec->Parms.msFrame;
+
+                const bool fKeyframe = RT_BOOL(pPkt->data.frame.flags & VPX_FRAME_IS_KEY);
+
+                uint32_t fFlags = RECORDINGCODEC_ENC_F_NONE;
+                if (fKeyframe)
+                    fFlags |= RECORDINGCODEC_ENC_F_BLOCK_IS_KEY;
+                if (pPkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE)
+                    fFlags |= RECORDINGCODEC_ENC_F_BLOCK_IS_INVISIBLE;
+
+                vrc = pCodec->Callbacks.pfnWriteData(pCodec, pPkt->data.frame.buf, pPkt->data.frame.sz,
+                                                     tsAbsPTSMs, fFlags, pCodec->Callbacks.pvUser);
                 break;
             }
@@ -186 +202 @@
             default:
                 AssertFailed();
-                LogFunc(("Unexpected video packet type %ld\n", pPacket->kind));
+                LogFunc(("Unexpected video packet type %ld\n", pPkt->kind));
                 break;
         }
@@ -204 +220 @@
 static DECLCALLBACK(int) recordingCodecOpusInit(PRECORDINGCODEC pCodec)
 {
+    pCodec->cbScratch = _4K;
+    pCodec->pvScratch = RTMemAlloc(pCodec->cbScratch);
+    AssertPtrReturn(pCodec->pvScratch, VERR_NO_MEMORY);
+
     const PPDMAUDIOPCMPROPS pProps = &pCodec->Parms.Audio.PCMProps;
 
@@ -275 +295 @@
 /** @copydoc RECORDINGCODECOPS::pfnEncode */
 static DECLCALLBACK(int) recordingCodecOpusEncode(PRECORDINGCODEC pCodec,
-                                                  const PRECORDINGFRAME pFrame, void *pvDst, size_t cbDst,
-                                                  size_t *pcEncoded, size_t *pcbEncoded)
+                                                  const PRECORDINGFRAME pFrame, size_t *pcEncoded, size_t *pcbEncoded)
 {
     const PPDMAUDIOPCMPROPS pPCMProps = &pCodec->Parms.Audio.PCMProps;
@@ -284 +303 @@
     Assert         (pFrame->Audio.cbBuf);
     AssertReturn   (pFrame->Audio.cbBuf % pPCMProps->cbFrame == 0, VERR_INVALID_PARAMETER);
+    AssertReturn(pCodec->cbScratch >= pFrame->Audio.cbBuf, VERR_INVALID_PARAMETER);
     AssertPtrReturn(pcEncoded,  VERR_INVALID_POINTER);
     AssertPtrReturn(pcbEncoded, VERR_INVALID_POINTER);
 
     int vrc = VINF_SUCCESS;
+
+    size_t cBlocksEncoded = 0;
+    size_t cBytesEncoded  = 0;
 
     /*
@@ -298 +321 @@
     opus_int32 cbWritten = opus_encode(pCodec->Audio.Opus.pEnc,
                                        (opus_int16 *)pFrame->Audio.pvBuf, (int)(pFrame->Audio.cbBuf / pPCMProps->cbFrame /* Number of audio frames */),
-                                       (uint8_t *)pvDst, (opus_int32)cbDst);
+                                       (uint8_t *)pCodec->pvScratch, (opus_int32)pCodec->cbScratch);
     if (cbWritten < 0)
     {
@@ -305 +328 @@
     }
 
-    /* Get overall frames encoded. */
-    *pcEncoded  = opus_packet_get_nb_frames((uint8_t *)pvDst, cbWritten);
-    *pcbEncoded = cbWritten;
+    if (cbWritten)
+    {
+        vrc = pCodec->Callbacks.pfnWriteData(pCodec, pCodec->pvScratch, (size_t)cbWritten, pCodec->State.tsLastWrittenMs,
+                                             RECORDINGCODEC_ENC_F_BLOCK_IS_KEY /* Every Opus frame is a key frame */,
+                                             pCodec->Callbacks.pvUser);
+        if (RT_SUCCESS(vrc))
+            pCodec->State.tsLastWrittenMs += pCodec->Parms.msFrame;
+    }
+
+    if (RT_SUCCESS(vrc))
+    {
+        /* Get overall frames encoded. */
+        cBlocksEncoded = opus_packet_get_nb_frames((uint8_t *)pCodec->pvScratch, cbWritten);
+        cBytesEncoded  = cbWritten;
+
+        if (pcEncoded)
+            *pcEncoded  = cBlocksEncoded;
+        if (pcbEncoded)
+            *pcbEncoded = cBytesEncoded;
+    }
 
     if (RT_FAILURE(vrc))
         LogRel(("Recording: Encoding Opus data failed, rc=%Rrc\n", vrc));
 
-    Log3Func(("cbSrc=%zu, cbDst=%zu, cEncoded=%zu, cbEncoded=%zu, vrc=%Rrc\n", pFrame->Audio.cbBuf, cbDst,
-              RT_SUCCESS(vrc) ? *pcEncoded : 0, RT_SUCCESS(vrc) ? *pcbEncoded : 0, vrc));
+    Log3Func(("cbSrc=%zu, cbDst=%zu, cEncoded=%zu, cbEncoded=%zu, vrc=%Rrc\n",
+              pFrame->Audio.cbBuf, pCodec->cbScratch, cBlocksEncoded, cBytesEncoded, vrc));
 
     return vrc;
@@ -328 +368 @@
 static DECLCALLBACK(int) recordingCodecVorbisInit(PRECORDINGCODEC pCodec)
 {
+    pCodec->cbScratch = _4K;
+    pCodec->pvScratch = RTMemAlloc(pCodec->cbScratch);
+    AssertPtrReturn(pCodec->pvScratch, VERR_NO_MEMORY);
+
     const PPDMAUDIOPCMPROPS pPCMProps = &pCodec->Parms.Audio.PCMProps;
 
@@ -395 +439 @@
 /** @copydoc RECORDINGCODECOPS::pfnEncode */
 static DECLCALLBACK(int) recordingCodecVorbisEncode(PRECORDINGCODEC pCodec,
-                                                    const PRECORDINGFRAME pFrame, void *pvDst, size_t cbDst,
-                                                    size_t *pcEncoded, size_t *pcbEncoded)
+                                                    const PRECORDINGFRAME pFrame, size_t *pcEncoded, size_t *pcbEncoded)
 {
     const PPDMAUDIOPCMPROPS pPCMProps = &pCodec->Parms.Audio.PCMProps;
 
-    Assert         (pCodec->Parms.cbFrame);
-    AssertReturn   (pFrame->Audio.cbBuf % pCodec->Parms.cbFrame == 0, VERR_INVALID_PARAMETER);
-    Assert         (pFrame->Audio.cbBuf);
-    AssertReturn   (pFrame->Audio.cbBuf % PDMAudioPropsFrameSize(pPCMProps) == 0, VERR_INVALID_PARAMETER);
+    Assert      (pCodec->Parms.cbFrame);
+    AssertReturn(pFrame->Audio.cbBuf % pCodec->Parms.cbFrame == 0, VERR_INVALID_PARAMETER);
+    Assert      (pFrame->Audio.cbBuf);
+    AssertReturn(pFrame->Audio.cbBuf % PDMAudioPropsFrameSize(pPCMProps) == 0, VERR_INVALID_PARAMETER);
+    AssertReturn(pCodec->cbScratch >= pFrame->Audio.cbBuf, VERR_INVALID_PARAMETER);
 
     int vrc = VINF_SUCCESS;
@@ -443 +487 @@
     size_t cBytesEncoded  = 0;
 
-    uint8_t *puDst = (uint8_t *)pvDst;
+    uint8_t *puDst = (uint8_t *)pCodec->pvScratch;
 
     while (vorbis_analysis_blockout(&pCodec->Audio.Vorbis.dsp_state, &pCodec->Audio.Vorbis.block_cur) == 1 /* More available? */)
@@ -474 +518 @@
         {
             cBytesEncoded += op.bytes;
-            AssertBreakStmt(cBytesEncoded <= cbDst, vrc = VERR_BUFFER_OVERFLOW);
+            AssertBreakStmt(cBytesEncoded <= pCodec->cbScratch, vrc = VERR_BUFFER_OVERFLOW);
             cBlocksEncoded++;
 
-            if (pCodec->Callbacks.pfnWriteData)
-            {
-                WebMWriter::BlockData_Audio blockData = { op.packet, (size_t)op.bytes, pCodec->uLastTimeStampMs };
-                pCodec->Callbacks.pfnWriteData(pCodec, &blockData, sizeof(blockData), pCodec->Callbacks.pvUser);
-            }
-
-            pCodec->uLastTimeStampMs += uDurationMs;
+            vrc = pCodec->Callbacks.pfnWriteData(pCodec, op.packet, (size_t)op.bytes, pCodec->State.tsLastWrittenMs,
+                                                 RECORDINGCODEC_ENC_F_BLOCK_IS_KEY /* Every Vorbis frame is a key frame */,
+                                                 pCodec->Callbacks.pvUser);
+            if (RT_SUCCESS(vrc))
+                pCodec->State.tsLastWrittenMs += uDurationMs;
         }
 
@@ -513 +555 @@
 
     Log3Func(("cbSrc=%zu, cbDst=%zu, cEncoded=%zu, cbEncoded=%zu, vrc=%Rrc\n",
-              pFrame->Audio.cbBuf, cbDst, cBlocksEncoded, cBytesEncoded, vrc));
+              pFrame->Audio.cbBuf, pCodec->cbScratch, cBlocksEncoded, cBytesEncoded, vrc));
 
     return vrc;
@@ -687 +729 @@
 #endif
 
+static void recordingCodecReset(PRECORDINGCODEC pCodec)
+{
+    pCodec->State.tsLastWrittenMs = 0;
+
+    pCodec->State.cEncErrors = 0;
+#ifdef VBOX_WITH_STATISTICS
+    pCodec->STAM.cEncBlocks  = 0;
+    pCodec->STAM.msEncTotal  = 0;
+#endif
+}
+
+/**
+ * Common code for codec creation.
+ *
+ * @param   pCodec              Codec instance to create.
+ */
+static void recordingCodecCreateCommon(PRECORDINGCODEC pCodec)
+{
+    RT_ZERO(pCodec->Ops);
+    RT_ZERO(pCodec->Callbacks);
+}
+
 /**
  * Creates an audio codec.
@@ -697 +761 @@
 {
     int vrc;
+
+    recordingCodecCreateCommon(pCodec);
 
     switch (enmAudioCodec)
@@ -728 +794 @@
 
         default:
+            LogRel(("Recording: Selected codec is not supported!\n"));
             vrc = VERR_RECORDING_CODEC_NOT_SUPPORTED;
             break;
@@ -751 +818 @@
 {
     int vrc;
+
+    recordingCodecCreateCommon(pCodec);
 
     switch (enmVideoCodec)
@@ -791 +860 @@
 int recordingCodecInit(const PRECORDINGCODEC pCodec, const PRECORDINGCODECCALLBACKS pCallbacks, const settings::RecordingScreenSettings &Settings)
 {
+    recordingCodecReset(pCodec);
+
     int vrc;
     if (pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO)
@@ -799 +870 @@
         AssertFailedStmt(vrc = VERR_NOT_SUPPORTED);
 
-    if (RT_SUCCESS(vrc))
-    {
-        pCodec->cEncErrors       = 0;
-#ifdef VBOX_WITH_STATISTICS
-        pCodec->Stats.cEncBlocks = 0;
-        pCodec->Stats.msEncTotal = 0;
-#endif
-    }
-
     return vrc;
 }
@@ -859 +921 @@
     if (RT_SUCCESS(vrc))
     {
+        if (pCodec->pvScratch)
+        {
+            Assert(pCodec->cbScratch);
+            RTMemFree(pCodec->pvScratch);
+            pCodec->pvScratch = NULL;
+            pCodec->cbScratch = 0;
+        }
+
         pCodec->Parms.enmType       = RECORDINGCODECTYPE_INVALID;
         pCodec->Parms.enmVideoCodec = RecordingVideoCodec_None;
@@ -872 +942 @@
  * @param   pCodec              Codec to use.
  * @param   pFrame              Pointer to frame data to encode.
- * @param   pvDst               Where to store the encoded data on success.
- * @param   cbDst               Size (in bytes) of \a pvDst.
  * @param   pcEncoded           Where to return the number of encoded blocks in \a pvDst on success. Optional.
  * @param   pcbEncoded          Where to return the number of encoded bytes in \a pvDst on success. Optional.
  */
 int recordingCodecEncode(PRECORDINGCODEC pCodec,
-                         const PRECORDINGFRAME pFrame, void *pvDst, size_t cbDst,
-                         size_t *pcEncoded, size_t *pcbEncoded)
+                         const PRECORDINGFRAME pFrame, size_t *pcEncoded, size_t *pcbEncoded)
 {
     AssertPtrReturn(pCodec->Ops.pfnEncode, VERR_NOT_SUPPORTED);
 
     size_t cEncoded, cbEncoded;
-    int vrc = pCodec->Ops.pfnEncode(pCodec, pFrame, pvDst, cbDst, &cEncoded, &cbEncoded);
+    int vrc = pCodec->Ops.pfnEncode(pCodec, pFrame, &cEncoded, &cbEncoded);
     if (RT_SUCCESS(vrc))
     {
 #ifdef VBOX_WITH_STATISTICS
-        pCodec->Stats.cEncBlocks += cEncoded;
-        pCodec->Stats.msEncTotal += pCodec->Parms.msFrame * cEncoded;
+        pCodec->STAM.cEncBlocks += cEncoded;
+        pCodec->STAM.msEncTotal += pCodec->Parms.msFrame * cEncoded;
 #endif
         if (pcEncoded)

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

@@ -42 +42 @@
     int vrc2 = initInternal(a_pCtx, uScreen, Settings);
     if (RT_FAILURE(vrc2))
-    {
-        LogRel(("Recording: Initialization failed with %Rrc\n", vrc2));
         throw vrc2;
-    }
 }
 
@@ -58 +55 @@
  *
  * @returns IPRT status code.
- */
-int RecordingStream::open(const settings::RecordingScreenSettings &Settings)
+ * @param   screenSettings      Recording settings to use.
+ */
+int RecordingStream::open(const settings::RecordingScreenSettings &screenSettings)
 {
     /* Sanity. */
-    Assert(Settings.enmDest != RecordingDestination_None);
+    Assert(screenSettings.enmDest != RecordingDestination_None);
 
     int vrc;
 
-    switch (Settings.enmDest)
+    switch (screenSettings.enmDest)
     {
         case RecordingDestination_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);
 
@@ -87 +85 @@
             char *pszFile = NULL;
 
-            if (this->uScreenID > 0)
-                vrc = RTStrAPrintf(&pszFile, "%s-%u%s", pszAbsPath, this->uScreenID + 1, pszSuff);
-            else
-                vrc = RTStrAPrintf(&pszFile, "%s%s", pszAbsPath, pszSuff);
-
+            vrc = RTStrAPrintf(&pszFile, "%s-%u%s", pszAbsPath, this->uScreenID, pszSuff);
             if (RT_SUCCESS(vrc))
             {
+#ifdef DEBUG_andy
+                uint64_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE;
+#else
                 uint64_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_WRITE;
 
@@ -100 +97 @@
                  * other important file, causing unintentional data loss. */
                 fOpen |= RTFILE_O_CREATE;
-
+#endif
                 RTFILE hFile;
                 vrc = RTFileOpen(&hFile, pszFile, fOpen);
@@ -113 +110 @@
                     RTTimeExplode(&time, &ts);
 
-                    if (this->uScreenID > 0)
-                        vrc = RTStrAPrintf(&pszFile, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ-%u%s",
-                                           pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
-                                           time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
-                                           this->uScreenID + 1, pszSuff);
-                    else
-                        vrc = RTStrAPrintf(&pszFile, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ%s",
-                                           pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
-                                           time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
-                                           pszSuff);
-
+                    vrc = RTStrAPrintf(&pszFile, "%s-%04d-%02u-%02uT%02u-%02u-%02u-%09uZ-%u%s",
+                                       pszAbsPath, time.i32Year, time.u8Month, time.u8MonthDay,
+                                       time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond,
+                                       this->uScreenID, pszSuff);
                     if (RT_SUCCESS(vrc))
                         vrc = RTFileOpen(&hFile, pszFile, fOpen);
                 }
 
+                if (RT_FAILURE(vrc))
+                    break;
+
+                LogRel2(("Recording: Opened file '%s'\n", pszFile));
+
                 try
                 {
@@ -134 +129 @@
                 }
                 catch (std::bad_alloc &)
-               {
+                {
                     vrc = VERR_NO_MEMORY;
                 }
@@ -242 +237 @@
         vrc = VINF_SUCCESS;
 
-    AssertPtr(this->pCtx);
+    AssertPtr(this->m_pCtx);
 
     switch (vrc)
@@ -250 +245 @@
             this->fEnabled = false;
 
-            int vrc2 = this->pCtx->OnLimitReached(this->uScreenID, VINF_SUCCESS /* rc */);
+            int vrc2 = this->m_pCtx->OnLimitReached(this->uScreenID, VINF_SUCCESS /* rc */);
             AssertRC(vrc2);
             break;
@@ -294 +289 @@
  * @returns IPRT status code.
  * @param   mapBlocksCommon     Map of common block to process for this stream.
+ *
+ * @note    Runs in recording thread.
  */
 int RecordingStream::Process(RecordingBlockMap &mapBlocksCommon)
@@ -328 +325 @@
                 Frame.msTimestamp = msTimestamp;
 
-                int vrc2 = recordingCodecEncode(&this->CodecVideo, &Frame, NULL, 0, NULL, NULL);
+                int vrc2 = recordingCodecEncode(&this->CodecVideo, &Frame, NULL, NULL);
                 AssertRC(vrc2);
                 if (RT_SUCCESS(vrc))
@@ -346 +343 @@
 
 #ifdef VBOX_WITH_AUDIO_RECORDING
-    AssertPtr(pCtx);
-
-    /* As each (enabled) screen has to get the same audio data, look for common (audio) data which needs to be
-     * written to the screen's assigned recording stream. */
-    RecordingBlockMap::iterator itCommonBlocks = mapBlocksCommon.begin();
-    while (itCommonBlocks != mapBlocksCommon.end())
-    {
-        RecordingBlockList::iterator itBlock = itCommonBlocks->second->List.begin();
-        while (itBlock != itCommonBlocks->second->List.end())
-        {
-            RecordingBlock *pBlockCommon = (RecordingBlock *)(*itBlock);
-            switch (pBlockCommon->enmType)
-            {
-                case RECORDINGBLOCKTYPE_AUDIO:
-                {
-                    PRECORDINGAUDIOFRAME pAudioFrame = (PRECORDINGAUDIOFRAME)pBlockCommon->pvData;
-                    AssertPtr(pAudioFrame);
-                    AssertPtr(pAudioFrame->pvBuf);
-                    Assert(pAudioFrame->cbBuf);
-
-                    WebMWriter::BlockData_Audio blockData = { pAudioFrame->pvBuf, pAudioFrame->cbBuf,
-                                                              pBlockCommon->msTimestamp };
-                    AssertPtr(this->File.pWEBM);
-                    int vrc2 = this->File.pWEBM->WriteBlock(this->uTrackAudio, &blockData, sizeof(blockData));
-                    AssertRC(vrc2);
-                    if (RT_SUCCESS(vrc))
-                        vrc = vrc2;
-                    break;
-                }
-
-                default:
-                    AssertFailed();
-                    break;
-            }
-
-            Assert(pBlockCommon->cRefs);
-            pBlockCommon->cRefs--;
-            if (pBlockCommon->cRefs == 0)
-            {
-                itCommonBlocks->second->List.erase(itBlock);
-                delete pBlockCommon;
-                itBlock = itCommonBlocks->second->List.begin();
+    /* Do we need to multiplex the common audio data to this stream? */
+    if (this->ScreenSettings.isFeatureEnabled(RecordingFeature_Audio))
+    {
+        /* As each (enabled) screen has to get the same audio data, look for common (audio) data which needs to be
+         * written to the screen's assigned recording stream. */
+        RecordingBlockMap::iterator itCommonBlocks = mapBlocksCommon.begin();
+        while (itCommonBlocks != mapBlocksCommon.end())
+        {
+            RecordingBlockList::iterator itBlock = itCommonBlocks->second->List.begin();
+            while (itBlock != itCommonBlocks->second->List.end())
+            {
+                RecordingBlock *pBlockCommon = (RecordingBlock *)(*itBlock);
+                switch (pBlockCommon->enmType)
+                {
+                    case RECORDINGBLOCKTYPE_AUDIO:
+                    {
+                        PRECORDINGAUDIOFRAME pAudioFrame = (PRECORDINGAUDIOFRAME)pBlockCommon->pvData;
+                        AssertPtr(pAudioFrame);
+                        AssertPtr(pAudioFrame->pvBuf);
+                        Assert(pAudioFrame->cbBuf);
+
+                        AssertPtr(this->File.pWEBM);
+                        int vrc2 = this->File.pWEBM->WriteBlock(this->uTrackAudio, pAudioFrame->pvBuf, pAudioFrame->cbBuf, pBlockCommon->msTimestamp, pBlockCommon->uFlags);
+                        AssertRC(vrc2);
+                        if (RT_SUCCESS(vrc))
+                            vrc = vrc2;
+                        break;
+                    }
+
+                    default:
+                        AssertFailed();
+                        break;
+                }
+
+                Assert(pBlockCommon->cRefs);
+                pBlockCommon->cRefs--;
+                if (pBlockCommon->cRefs == 0)
+                {
+                    itCommonBlocks->second->List.erase(itBlock);
+                    delete pBlockCommon;
+                    itBlock = itCommonBlocks->second->List.begin();
+                }
+                else
+                    ++itBlock;
+            }
+
+            /* If no entries are left over in the block map, remove it altogether. */
+            if (itCommonBlocks->second->List.empty())
+            {
+                delete itCommonBlocks->second;
+                mapBlocksCommon.erase(itCommonBlocks);
+                itCommonBlocks = mapBlocksCommon.begin();
             }
             else
-                ++itBlock;
-        }
-
-        /* If no entries are left over in the block map, remove it altogether. */
-        if (itCommonBlocks->second->List.empty())
-        {
-            delete itCommonBlocks->second;
-            mapBlocksCommon.erase(itCommonBlocks);
-            itCommonBlocks = mapBlocksCommon.begin();
-        }
-        else
-            ++itCommonBlocks;
-
-        LogFunc(("Common blocks: %zu\n", mapBlocksCommon.size()));
+                ++itCommonBlocks;
+
+            LogFunc(("Common blocks: %zu\n", mapBlocksCommon.size()));
+        }
     }
 #else
@@ -429 +426 @@
  * @param   uSrcHeight          Height (in pixels) of the video frame.
  * @param   puSrcData           Actual pixel data of the video frame.
- * @param   msTimestamp         Timestamp (in ms) as PTS.
+ * @param   msTimestamp         Absolute PTS timestamp (in ms).
  */
 int RecordingStream::SendVideoFrame(uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine,
@@ -436 +433 @@
     lock();
 
-    LogFlowFunc(("msTimestamp=%RU64\n", msTimestamp));
+    LogFlowFunc(("tsAbsPTSMs=%RU64\n", msTimestamp));
 
     PRECORDINGCODEC pCodec = &this->CodecVideo;
@@ -451 +448 @@
     do
     {
-        if (msTimestamp < pCodec->uLastTimeStampMs + pCodec->Parms.Video.uDelayMs)
+        if (msTimestamp < pCodec->State.tsLastWrittenMs + pCodec->Parms.Video.uDelayMs)
         {
             vrc = VINF_RECORDING_THROTTLED; /* Respect maximum frames per second. */
@@ -457 +454 @@
         }
 
-        pCodec->uLastTimeStampMs = msTimestamp;
+        pCodec->State.tsLastWrittenMs = msTimestamp;
 
         int xDiff = ((int)this->ScreenSettings.Video.ulWidth - (int)uSrcWidth) / 2;
@@ -657 +654 @@
  *
  * @returns IPRT status code.
- * @param   a_pCtx              Pointer to recording context.
+ * @param   pCtx                Pointer to recording context.
  * @param   uScreen             Screen number to use for this recording stream.
  * @param   Settings            Recording screen configuration to use for initialization.
  */
-int RecordingStream::Init(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings)
-{
-    return initInternal(a_pCtx, uScreen, Settings);
+int RecordingStream::Init(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings)
+{
+    return initInternal(pCtx, uScreen, Settings);
 }
 
@@ -670 +667 @@
  *
  * @returns IPRT status code.
- * @param   a_pCtx              Pointer to recording context.
+ * @param   pCtx                Pointer to recording context.
  * @param   uScreen             Screen number to use for this recording stream.
- * @param   Settings            Recording screen configuration to use for initialization.
- */
-int RecordingStream::initInternal(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings)
+ * @param   screenSettings      Recording screen configuration to use for initialization.
+ */
+int RecordingStream::initInternal(RecordingContext *pCtx, uint32_t uScreen,
+                                  const settings::RecordingScreenSettings &screenSettings)
 {
     AssertReturn(enmState == RECORDINGSTREAMSTATE_UNINITIALIZED, VERR_WRONG_ORDER);
 
-    this->pCtx           = a_pCtx;
+    this->m_pCtx         = pCtx;
     this->uTrackAudio    = UINT8_MAX;
     this->uTrackVideo    = UINT8_MAX;
     this->tsStartMs      = 0;
     this->uScreenID      = uScreen;
-    this->ScreenSettings = Settings;
+#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;
@@ -704 +706 @@
     {
         vrc = initVideo(*pSettings);
-        if (RT_FAILURE(vrc))
-            return vrc;
-    }
-
-    if (fAudioEnabled)
-    {
-        vrc = initAudio(*pSettings);
         if (RT_FAILURE(vrc))
             return vrc;
@@ -755 +750 @@
             if (fAudioEnabled)
             {
-                vrc = this->File.pWEBM->AddAudioTrack(&this->CodecAudio, pSettings->Audio.uHz, pSettings->Audio.cChannels, pSettings->Audio.cBits,
+                AssertPtr(this->pCodecAudio);
+                vrc = this->File.pWEBM->AddAudioTrack(this->pCodecAudio,
+                                                      pSettings->Audio.uHz, pSettings->Audio.cChannels, pSettings->Audio.cBits,
                                                       &this->uTrackAudio);
                 if (RT_FAILURE(vrc))
@@ -803 +800 @@
         this->fEnabled  = true;
         this->tsStartMs = RTTimeProgramMilliTS();
-    }
-    else
-    {
-        int vrc2 = uninitInternal();
-        AssertRC(vrc2);
-        return vrc;
-    }
-
-    return VINF_SUCCESS;
+
+        return VINF_SUCCESS;
+    }
+
+    int vrc2 = uninitInternal();
+    AssertRC(vrc2);
+
+    LogRel(("Recording: Stream #%RU32 initialization failed with %Rrc\n", uScreen, vrc));
+    return vrc;
 }
 
@@ -920 +917 @@
         return vrc;
 
+#ifdef VBOX_WITH_AUDIO_RECORDING
+    this->pCodecAudio = NULL;
+#endif
+
     if (this->ScreenSettings.isFeatureEnabled(RecordingFeature_Video))
-        vrc = recordingCodecDestroy(&this->CodecVideo);
+    {
+        vrc = recordingCodecFinalize(&this->CodecVideo);
+        if (RT_SUCCESS(vrc))
+            vrc = recordingCodecDestroy(&this->CodecVideo);
+    }
 
     if (RT_SUCCESS(vrc))
@@ -934 +939 @@
 }
 
+/**
+ * Writes encoded data to a WebM file instance.
+ *
+ * @returns VBox status code.
+ * @param   pCodec              Codec which has encoded the data.
+ * @param   pvData              Encoded data to write.
+ * @param   cbData              Size (in bytes) of \a pvData.
+ * @param   msAbsPTS            Absolute PTS (in ms) of written data.
+ * @param   uFlags              Encoding flags of type RECORDINGCODEC_ENC_F_XXX.
+ */
+int RecordingStream::codecWriteToWebM(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData,
+                                      uint64_t msAbsPTS, uint32_t uFlags)
+{
+    AssertPtr(this->File.pWEBM);
+    AssertPtr(pvData);
+    Assert   (cbData);
+
+    WebMWriter::WebMBlockFlags blockFlags = VBOX_WEBM_BLOCK_FLAG_NONE;
+    if (RT_LIKELY(uFlags != RECORDINGCODEC_ENC_F_NONE))
+    {
+        /* All set. */
+    }
+    else
+    {
+        if (uFlags & RECORDINGCODEC_ENC_F_BLOCK_IS_KEY)
+            blockFlags |= VBOX_WEBM_BLOCK_FLAG_KEY_FRAME;
+        if (uFlags & RECORDINGCODEC_ENC_F_BLOCK_IS_INVISIBLE)
+            blockFlags |= VBOX_WEBM_BLOCK_FLAG_INVISIBLE;
+    }
+
+    return this->File.pWEBM->WriteBlock(  pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO
+                                        ? this->uTrackAudio : this->uTrackVideo,
+                                        pvData, cbData, msAbsPTS, blockFlags);
+}
+
+/**
+ * Codec callback for writing encoded data to a recording stream.
+ *
+ * @returns VBox status code.
+ * @param   pCodec              Codec which has encoded the data.
+ * @param   pvData              Encoded data to write.
+ * @param   cbData              Size (in bytes) of \a pvData.
+ * @param   msAbsPTS            Absolute PTS (in ms) of written data.
+ * @param   uFlags              Encoding flags of type RECORDINGCODEC_ENC_F_XXX.
+ */
 /* static */
-DECLCALLBACK(int) RecordingStream::codecWriteDataCallback(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData, void *pvUser)
-{
-    RT_NOREF(pCodec);
-
+DECLCALLBACK(int) RecordingStream::codecWriteDataCallback(PRECORDINGCODEC pCodec, const void *pvData, size_t cbData,
+                                                          uint64_t msAbsPTS, uint32_t uFlags, void *pvUser)
+{
     RecordingStream *pThis = (RecordingStream *)pvUser;
     AssertPtr(pThis);
 
-    AssertPtr(pThis->File.pWEBM);
-    return pThis->File.pWEBM->WriteBlock(pCodec->Parms.enmType == RECORDINGCODECTYPE_AUDIO
-                                         ? pThis->uTrackAudio : pThis->uTrackVideo, pvData, cbData);
+    /** @todo For now this is hardcoded to always write to a WebM file. Add other stuff later. */
+    return pThis->codecWriteToWebM(pCodec, pvData, cbData, msAbsPTS, uFlags);
 }
 
@@ -951 +999 @@
  *
  * @returns VBox status code.
- * @param   Settings            Settings to use.
- */
-int RecordingStream::initVideo(const settings::RecordingScreenSettings &Settings)
+ * @param   screenSettings      Screen settings to use.
+ */
+int RecordingStream::initVideo(const settings::RecordingScreenSettings &screenSettings)
 {
     /* Sanity. */
-    AssertReturn(Settings.Video.ulRate,   VERR_INVALID_PARAMETER);
-    AssertReturn(Settings.Video.ulWidth,  VERR_INVALID_PARAMETER);
-    AssertReturn(Settings.Video.ulHeight, VERR_INVALID_PARAMETER);
-    AssertReturn(Settings.Video.ulFPS,    VERR_INVALID_PARAMETER);
+    AssertReturn(screenSettings.Video.ulRate,   VERR_INVALID_PARAMETER);
+    AssertReturn(screenSettings.Video.ulWidth,  VERR_INVALID_PARAMETER);
+    AssertReturn(screenSettings.Video.ulHeight, VERR_INVALID_PARAMETER);
+    AssertReturn(screenSettings.Video.ulFPS,    VERR_INVALID_PARAMETER);
 
     PRECORDINGCODEC pCodec = &this->CodecVideo;
@@ -967 +1015 @@
     Callbacks.pfnWriteData = RecordingStream::codecWriteDataCallback;
 
-    int vrc = recordingCodecCreateVideo(pCodec, Settings.Video.enmCodec);
+    int vrc = recordingCodecCreateVideo(pCodec, screenSettings.Video.enmCodec);
     if (RT_SUCCESS(vrc))
-        vrc = recordingCodecInit(pCodec, &Callbacks, Settings);
+        vrc = recordingCodecInit(pCodec, &Callbacks, screenSettings);
 
     if (RT_FAILURE(vrc))
@@ -978 +1026 @@
 
 /**
- * Initializes the audio part of a recording stream,
- *
- * @returns VBox status code.
- * @retval  VERR_NOT_SUPPORTED if the selected codec is not supported / available.
- * @param   Settings            Settings to use.
- */
-int RecordingStream::initAudio(const settings::RecordingScreenSettings &Settings)
-{
-    if (Settings.Audio.enmCodec == RecordingAudioCodec_None)
-        return VINF_SUCCESS;
-
-    if (Settings.isFeatureEnabled(RecordingFeature_Audio))
-    {
-        /* Sanity. */
-        AssertReturn(Settings.Audio.uHz,       VERR_INVALID_PARAMETER);
-        AssertReturn(Settings.Audio.cBits,     VERR_INVALID_PARAMETER);
-        AssertReturn(Settings.Audio.cChannels, VERR_INVALID_PARAMETER);
-    }
-
-    PRECORDINGCODEC pCodec = &this->CodecAudio;
-
-    RECORDINGCODECCALLBACKS Callbacks;
-    Callbacks.pvUser       = this;
-    Callbacks.pfnWriteData = RecordingStream::codecWriteDataCallback;
-
-    int vrc = recordingCodecCreateAudio(pCodec, Settings.Audio.enmCodec);
-    if (RT_SUCCESS(vrc))
-        vrc = recordingCodecInit(pCodec, &Callbacks, Settings);
-
-    if (RT_FAILURE(vrc))
-        LogRel(("Recording: Initializing audio codec failed with %Rrc\n", vrc));
-
-    return vrc;
-}
-
-/**
  * Locks a recording stream.
  */

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

@@ -566 +566 @@
 }
 
-#ifdef VBOX_WITH_LIBVPX
-/**
- * Writes VPX (VP8 video) simple data block.
- *
- * @returns IPRT status code.
- * @param   a_pTrack        Track ID to write data to.
- * @param   a_pCfg          VPX encoder configuration to use.
- * @param   a_pPkt          VPX packet video data packet to write.
- */
-int WebMWriter::writeSimpleBlockVP8(WebMTrack *a_pTrack, const vpx_codec_enc_cfg_t *a_pCfg, const vpx_codec_cx_pkt_t *a_pPkt)
-{
-    RT_NOREF(a_pTrack);
-
-    /* Calculate the absolute PTS of this frame (in ms). */
-    WebMTimecodeAbs tcAbsPTSMs =   a_pPkt->data.frame.pts * 1000
-                                 * (uint64_t) a_pCfg->g_timebase.num / a_pCfg->g_timebase.den;
-    if (   tcAbsPTSMs
-        && tcAbsPTSMs <= a_pTrack->tcAbsLastWrittenMs)
-    {
-        AssertFailed(); /* Should never happen. */
-        tcAbsPTSMs = a_pTrack->tcAbsLastWrittenMs + 1;
-    }
-
-    const bool fKeyframe = RT_BOOL(a_pPkt->data.frame.flags & VPX_FRAME_IS_KEY);
-
-    uint8_t fFlags = VBOX_WEBM_BLOCK_FLAG_NONE;
-    if (fKeyframe)
-        fFlags |= VBOX_WEBM_BLOCK_FLAG_KEY_FRAME;
-    if (a_pPkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE)
-        fFlags |= VBOX_WEBM_BLOCK_FLAG_INVISIBLE;
-
-    return writeSimpleBlockQueued(a_pTrack,
-                                  new WebMSimpleBlock(a_pTrack,
-                                                      tcAbsPTSMs, a_pPkt->data.frame.buf, a_pPkt->data.frame.sz, fFlags));
-}
-#endif /* VBOX_WITH_LIBVPX */
-
-/**
- * Writes an Opus (audio) simple data block.
- *
- * @returns IPRT status code.
- * @param   pTrack          Track ID to write data to.
- * @param   pvData          Pointer to simple data block to write.
- * @param   cbData          Size (in bytes) of simple data block to write.
- * @param   tcAbsPTSMs      Absolute PTS of simple data block.
- *
- * @remarks Audio blocks that have same absolute timecode as video blocks SHOULD be written before the video blocks.
- */
-int WebMWriter::writeSimpleBlockAudio(WebMTrack *pTrack, const void *pvData, size_t cbData, WebMTimecodeAbs tcAbsPTSMs)
-{
-    AssertPtrReturn(pTrack, VERR_INVALID_POINTER);
-    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
-    AssertReturn(cbData,    VERR_INVALID_PARAMETER);
-
-    /* Every Opus frame is a key frame. */
-    const uint8_t fFlags = VBOX_WEBM_BLOCK_FLAG_KEY_FRAME;
-
-    return writeSimpleBlockQueued(pTrack,
-                                  new WebMSimpleBlock(pTrack, tcAbsPTSMs, pvData, cbData, fFlags));
-}
-
 /**
  * Writes a data block to the specified track.
@@ -634 +573 @@
  * @param   pvData          Pointer to data block to write.
  * @param   cbData          Size (in bytes) of data block to write.
- */
-int WebMWriter::WriteBlock(uint8_t uTrack, const void *pvData, size_t cbData)
-{
-    RT_NOREF(cbData); /* Only needed for assertions for now. */
-
+ * @param   tcAbsPTSMs      Absolute PTS of simple data block.
+ * @param   uFlags          WebM block flags to use for this block.
+ */
+int WebMWriter::WriteBlock(uint8_t uTrack, const void *pvData, size_t cbData, WebMTimecodeAbs tcAbsPTSMs, WebMBlockFlags uFlags)
+{
     int vrc = RTCritSectEnter(&CurSeg.CritSect);
     AssertRC(vrc);
 
+#ifdef DEBUG /* Only validate in debug builds, to speed things up in release builds. */
     WebMTracks::iterator itTrack = CurSeg.mapTracks.find(uTrack);
     if (itTrack == CurSeg.mapTracks.end())
@@ -648 +588 @@
         return VERR_NOT_FOUND;
     }
+#endif
 
     WebMTrack *pTrack = itTrack->second;
@@ -658 +599 @@
     }
 
-    switch (pTrack->enmType)
-    {
-
-        case WebMTrackType_Audio:
-        {
-            if (   m_enmAudioCodec == RecordingAudioCodec_Opus
-                || m_enmAudioCodec == RecordingAudioCodec_OggVorbis)
-            {
-                Assert(cbData == sizeof(WebMWriter::BlockData_Audio));
-                WebMWriter::BlockData_Audio *pData = (WebMWriter::BlockData_Audio *)pvData;
-                vrc = writeSimpleBlockAudio(pTrack, pData->pvData, pData->cbData, pData->uPTSMs);
-            }
-            /* else nothing to do here; WebM only supports Opus or Ogg Vorbis. */
-            break;
-        }
-
-        case WebMTrackType_Video:
-        {
-#ifdef VBOX_WITH_LIBVPX
-            if (m_enmVideoCodec == RecordingVideoCodec_VP8)
-            {
-                Assert(cbData == sizeof(WebMWriter::BlockData_VP8));
-                WebMWriter::BlockData_VP8 *pData = (WebMWriter::BlockData_VP8 *)pvData;
-                vrc = writeSimpleBlockVP8(pTrack, pData->pCfg, pData->pPkt);
-            }
-            else
-#endif /* VBOX_WITH_LIBVPX */
-                vrc = VERR_NOT_SUPPORTED;
-            break;
-        }
-
-        default:
-            vrc = VERR_NOT_SUPPORTED;
-            break;
+    try
+    {
+        vrc = writeSimpleBlockQueued(pTrack,
+                                     new WebMSimpleBlock(pTrack,
+                                                         tcAbsPTSMs, pvData, cbData, uFlags));
+    }
+    catch (std::bad_alloc &)
+    {
+        vrc = VERR_NO_MEMORY;
     }