Changeset 65389 in vbox

Timestamp:

Jan 20, 2017 2:03:51 PM (8 years ago)

Author:

vboxsync

Message:

VideoRec: Update.

Location:

trunk/src/VBox/Main/src-client

Files:

• DrvAudioVideoRec.cpp (modified) (12 diffs)
• EbmlWriter.cpp (modified) (21 diffs)

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

@@ -75 +75 @@
         {
             /** Encoder we're going to use. */
-            OpusEncoder *pEnc;
+            OpusEncoder    *pEnc;
+            /** The encoding rate to use. */
+            uint16_t        uHz;
+            /** Duration of the frame in samples (per channel).
+             *  Valid frame size are:
+             *
+             *  ms           Frame size
+             *  2.5          120
+             *  5            240
+             *  10           480
+             *  20 (Default) 960
+             *  40           1920
+             *  60           2880
+             */
+            uint32_t        csFrame;
+            /** The maximum frame size (in samples) we can handle. */
+            uint32_t        csFrameMax;
+# ifdef DEBUG /** @todo Make these a STAM value? */
+            /** Number of frames encoded. */
+            uint64_t        cEncFrames;
+            /** Total time (in ms) of already encoded audio data. */
+            uint64_t        msEncTotal;
+# endif
         } Opus;
 #endif /* VBOX_WITH_LIBOPUS */
@@ -90 +112 @@
     /** The PCM properties of this stream. */
     PDMAUDIOPCMPROPS     Props;
-    uint64_t             old_ticks;
-    uint64_t             cSamplesSentPerSec;
     /** Codec-specific data.
      *  As every stream can be different, one codec per stream is needed. */
@@ -136 +156 @@
     PAVRECSTREAMOUT pStreamOut = (PAVRECSTREAMOUT)pStream;
 
-    int rc;
+    int rc = DrvAudioHlpStreamCfgToProps(pCfgReq, &pStreamOut->Props);
+    if (RT_FAILURE(rc))
+        return rc;
 
 #ifdef VBOX_WITH_LIBOPUS
     PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
 
+    uint16_t uHz = pStreamOut->Props.uHz;
+
+    /* Opus only supports certain input sample rates in an efficient manner.
+     * So make sure that we use those by resampling the data to the requested rate. */
+    if      (uHz > 24000) uHz = 48000;
+    else if (uHz > 16000) uHz = 24000;
+    else if (uHz > 12000) uHz = 16000;
+    else if (uHz > 8000 ) uHz = 12000;
+    else     uHz = 8000;
+
+    LogFunc(("%RU16Hz -> %RU16Hz\n", pStreamOut->Props.uHz, uHz));
+
+    pStreamOut->Codec.Opus.uHz        = uHz;
+    pStreamOut->Codec.Opus.csFrame    = uHz / 50;
+#ifdef DEBUG
+    pStreamOut->Codec.Opus.cEncFrames = 0;
+    pStreamOut->Codec.Opus.msEncTotal = 0;
+#endif
+
+    /* Calculate the maximum frame size. */
+    pStreamOut->Codec.Opus.csFrameMax = 48000                        /* Maximum sample rate Opus can handle */
+                                      * pStreamOut->Props.cChannels; /* Number of channels */
+
+    /* If we only record audio, create our own WebM writer instance here. */
     if (pThis->enmMode == AVRECMODE_AUDIO)
     {
@@ -147 +193 @@
                                        WebMWriter::AudioCodec_Opus, WebMWriter::VideoCodec_None);
         if (RT_SUCCESS(rc))
-            rc = pStreamOut->pWebM->AddAudioTrack(44100, 2, 16, &pStreamOut->uTrack);
+            rc = pStreamOut->pWebM->AddAudioTrack(pStreamOut->Codec.Opus.uHz, pStreamOut->Props.cChannels, pStreamOut->Props.cBits,
+                                                  &pStreamOut->uTrack);
     }
 
@@ -153 +200 @@
         return rc;
 
-    rc = RTCircBufCreate(&pStreamOut->pCircBuf, _4K);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    rc = DrvAudioHlpStreamCfgToProps(pCfgReq, &pStreamOut->Props);
+    rc = RTCircBufCreate(&pStreamOut->pCircBuf, (pStreamOut->Codec.Opus.csFrame * pStreamOut->Props.cChannels) * sizeof(uint16_t));
     if (RT_SUCCESS(rc))
     {
@@ -163 +206 @@
 
         int orc;
-        pEnc = opus_encoder_create(48000 /* Hz */, 2 /* Stereo */, OPUS_APPLICATION_AUDIO, &orc);
+        pEnc = opus_encoder_create(pStreamOut->Codec.Opus.uHz, pStreamOut->Props.cChannels, OPUS_APPLICATION_AUDIO, &orc);
         if (orc != OPUS_OK)
         {
@@ -172 +215 @@
         AssertPtr(pEnc);
 
-#if 0
-        orc = opus_encoder_ctl(pEnc, OPUS_SET_BITRATE(DrvAudioHlpCalcBitrate()));
+        opus_encoder_ctl(pEnc, OPUS_SET_BITRATE(196000)); /** @todo Make this configurable. */
         if (orc != OPUS_OK)
         {
@@ -181 +223 @@
         else
         {
-#endif
-        pStreamOut->Codec.Opus.pEnc = pEnc;
-
-        if (pCfgAcq)
-            pCfgAcq->cSampleBufferSize = _4K; /** @todo Make this configurable. */
+            pStreamOut->Codec.Opus.pEnc = pEnc;
+
+            if (pCfgAcq)
+            {
+                /* Make sure to let the driver backend know that we need the audio data in
+                 * a specific sampling rate Opus is optimized for. */
+                pCfgAcq->uHz               = pStreamOut->Codec.Opus.uHz;
+                pCfgAcq->cSampleBufferSize = _4K; /** @todo Make this configurable. */
+            }
+
+            LogRel(("VideoRec: Recording audio in %RU16Hz, %RU8 channels, %RU16 bpS\n",
+                    uHz, pStreamOut->Props.cChannels, pStreamOut->Props.cBits));
+        }
     }
 #else
@@ -315 +365 @@
 
     PDRVAUDIOVIDEOREC pThis      = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
+    RT_NOREF(pThis);
     PAVRECSTREAMOUT   pStreamOut = (PAVRECSTREAMOUT)pStream;
 
-    uint32_t cLive = AudioMixBufLive(&pStream->MixBuf);
-
-    uint64_t now = PDMDrvHlpTMGetVirtualTime(pThis->pDrvIns);
-    uint64_t ticks = now  - pStreamOut->old_ticks;
-    uint64_t ticks_per_second = PDMDrvHlpTMGetVirtualFreq(pThis->pDrvIns);
-
-    /* Minimize the rounding error: samples = int((ticks * freq) / ticks_per_second + 0.5). */
-    uint32_t cSamplesPlayed = (int)((2 * ticks * pStreamOut->Props.uHz + ticks_per_second) / ticks_per_second / 2);
-
-    /* Don't play more than available. */
-    if (cSamplesPlayed > cLive)
-        cSamplesPlayed = cLive;
-
-    /* Remember when samples were consumed. */
-    pStreamOut->old_ticks = now;
-
-    int cSamplesToSend = cSamplesPlayed;
-
-    LogFlowFunc(("uFreq=%RU32, cChan=%RU8, cBits=%RU8, fSigned=%RTbool, cSamplesToSend=%RU32\n",
-                 pStreamOut->Props.uHz,   pStreamOut->Props.cChannels,
-                 pStreamOut->Props.cBits, pStreamOut->Props.fSigned, cSamplesToSend));
+    uint32_t csLive = AudioMixBufUsed(&pStream->MixBuf);
+    if (!csLive)
+    {
+        Log3Func(("No live samples, skipping\n"));
+        if (pcbWritten)
+            *pcbWritten = 0;
+        return VINF_SUCCESS;
+    }
+
+    int rc;
 
     uint32_t csReadTotal = 0;
-
-    int rc;
 
     /*
@@ -347 +385 @@
      */
 #ifdef VBOX_WITH_LIBOPUS
-
-    uint16_t cbFrameSize = 960; /** @todo 20ms worth of audio data. */
-
     PRTCIRCBUF pCircBuf = pStreamOut->pCircBuf;
 
-    while (RTCircBufUsed(pCircBuf) < cbFrameSize)
-    {
-        void  *pvBuf;
-        size_t cbBuf;
+    void  *pvBuf;
+    size_t cbBuf;
+
+    /*
+     * Fetch as much as we can into our internal ring buffer.
+     */
+    while (RTCircBufFree(pCircBuf))
+    {
         RTCircBufAcquireWriteBlock(pCircBuf, RTCircBufFree(pCircBuf), &pvBuf, &cbBuf);
 
@@ -364 +403 @@
             uint32_t csRead = 0;
             rc = AudioMixBufReadCirc(&pStream->MixBuf, pvBuf, cbBuf, &csRead);
-            if (RT_SUCCESS(rc))
+            if (   RT_SUCCESS(rc)
+                && csRead)
             {
-                AudioMixBufFinish(&pStream->MixBuf, csRead);
-
-                cbRead = AUDIOMIXBUF_S2B(&pStream->MixBuf, csRead);
+                cbRead       = AUDIOMIXBUF_S2B(&pStream->MixBuf, csRead);
                 csReadTotal += csRead;
             }
@@ -380 +418 @@
             break;
         }
-
-        if (RTCircBufUsed(pCircBuf) >= cbFrameSize)
-        {
-            uint8_t abSrc[_4K];
-            size_t  cbSrc = 0;
-
-            while (cbSrc < cbFrameSize)
+    }
+
+    if (csReadTotal)
+        AudioMixBufFinish(&pStream->MixBuf, csReadTotal);
+
+    /*
+     * Process our internal ring buffer and encode the data.
+     */
+
+    uint8_t abSrc[_64K]; /** @todo Fix! */
+    size_t  cbSrc;
+
+    const uint32_t csFrame = pStreamOut->Codec.Opus.csFrame;
+    const uint32_t cbFrame = AUDIOMIXBUF_S2B(&pStream->MixBuf, csFrame);
+
+    while (RTCircBufUsed(pCircBuf) >= cbFrame)
+    {
+        cbSrc = 0;
+
+        while (cbSrc < cbFrame)
+        {
+            RTCircBufAcquireReadBlock(pCircBuf, cbFrame - cbSrc, &pvBuf, &cbBuf);
+
+            if (cbBuf)
             {
-                RTCircBufAcquireReadBlock(pCircBuf, cbFrameSize - cbSrc, &pvBuf, &cbBuf);
-
-                if (cbBuf)
-                {
-                    memcpy(&abSrc[cbSrc], pvBuf, cbBuf);
-
-                    cbSrc += cbBuf;
-                    Assert(cbSrc <= sizeof(abSrc));
-                }
-
-                RTCircBufReleaseReadBlock(pCircBuf, cbBuf);
-
-                if (!cbBuf)
-                    break;
+                memcpy(&abSrc[cbSrc], pvBuf, cbBuf);
+
+                cbSrc += cbBuf;
+                Assert(cbSrc <= sizeof(abSrc));
             }
 
-            /*
-             * Opus always encodes PER FRAME, that is, 2.5, 5, 10, 20, 40 or 60 ms of audio data.
-             *
-             * A packet can have up to 120ms worth of audio data.
-             * Anything > 120ms of data will result in a "corrupted package" error message by
-             * by decoding application.
-             */
-            uint8_t abDst[_4K];
-            size_t  cbDst = sizeof(abDst);
-
-            /* Call the encoder to encode one frame per iteration. */
-            opus_encoder_ctl(pStreamOut->Codec.Opus.pEnc, OPUS_SET_BITRATE(196000)); /** @todo Only needed for VBR encoding. */
-            opus_int32 cbWritten = opus_encode(pStreamOut->Codec.Opus.pEnc,
-                                               (opus_int16 *)abSrc, cbSrc, abDst, cbDst);
-            if (cbWritten > 0)
-            {
-                cbDst = cbWritten;
-                Assert(cbDst <= sizeof(abDst));
-
-                /* Call the WebM writer to actually write the encoded audio data. */
-                WebMWriter::BlockData_Opus blockData = { abDst, cbDst };
-                rc = pStreamOut->pWebM->WriteBlock(pStreamOut->uTrack, &blockData, sizeof(blockData));
-                AssertRC(rc);
-            }
-            else if (cbWritten < 0)
-            {
-                AssertMsgFailed(("Encoding failed: %s\n", opus_strerror(cbWritten)));
-                rc = VERR_INVALID_PARAMETER;
-            }
-
-            if (RT_FAILURE(rc))
+            RTCircBufReleaseReadBlock(pCircBuf, cbBuf);
+
+            if (!cbBuf)
                 break;
         }
+
+#ifdef DEBUG_andy
+        RTFILE fh;
+        RTFileOpen(&fh, "/tmp/acap.pcm", RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
+        RTFileWrite(fh, abSrc, cbSrc, NULL);
+        RTFileClose(fh);
+#endif
+
+        Assert(cbSrc == cbFrame);
+
+        /*
+         * Opus always encodes PER FRAME, that is, exactly 2.5, 5, 10, 20, 40 or 60 ms of audio data.
+         *
+         * A packet can have up to 120ms worth of audio data.
+         * Anything > 120ms of data will result in a "corrupted package" error message by
+         * by decoding application.
+         */
+        uint8_t abDst[_64K]; /** @todo Fix! */
+        size_t  cbDst = sizeof(abDst);
+
+        /* Call the encoder to encode one frame per iteration. */
+        opus_int32 cbWritten = opus_encode(pStreamOut->Codec.Opus.pEnc,
+                                           (opus_int16 *)abSrc, csFrame, abDst, cbDst);
+        if (cbWritten > 0)
+        {
+#ifdef DEBUG
+            /* Get overall frames encoded. */
+            uint32_t cEncFrames          = opus_packet_get_nb_frames(abDst, cbDst);
+            uint32_t cEncSamplesPerFrame = opus_packet_get_samples_per_frame(abDst, pStreamOut->Codec.Opus.uHz);
+            uint32_t csEnc               = cEncFrames * cEncSamplesPerFrame;
+
+            pStreamOut->Codec.Opus.cEncFrames += cEncFrames;
+            pStreamOut->Codec.Opus.msEncTotal += 20 /* Default 20 ms */ * cEncFrames;
+
+            LogFunc(("%RU64ms [%RU64 frames]: cbSrc=%zu, cbDst=%zu, cEncFrames=%RU32, cEncSamplesPerFrame=%RU32, csEnc=%RU32\n",
+                     pStreamOut->Codec.Opus.msEncTotal, pStreamOut->Codec.Opus.cEncFrames,
+                     cbSrc, cbDst, cEncFrames, cEncSamplesPerFrame, csEnc));
+#endif
+            Assert((uint32_t)cbWritten <= cbDst);
+            cbDst = RT_MIN((uint32_t)cbWritten, cbDst); /* Update cbDst to actual bytes encoded (written). */
+
+            /* Call the WebM writer to actually write the encoded audio data. */
+            WebMWriter::BlockData_Opus blockData = { abDst, cbDst };
+            rc = pStreamOut->pWebM->WriteBlock(pStreamOut->uTrack, &blockData, sizeof(blockData));
+            AssertRC(rc);
+        }
+        else if (cbWritten < 0)
+        {
+            AssertMsgFailed(("Encoding failed: %s\n", opus_strerror(cbWritten)));
+            rc = VERR_INVALID_PARAMETER;
+        }
+
+        if (RT_FAILURE(rc))
+            break;
     }
 #else

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

@@ -20 +20 @@
 #include <map>
 #include <stack>
+
+#include <math.h> /* For lround.h. */
+
 #include <iprt/asm.h>
 #include <iprt/buildconfig.h>
@@ -176 +179 @@
      * by this function.
      */
-    inline Ebml &serializeFloat(EbmlClassId classId, double value)
+    inline Ebml &serializeFloat(EbmlClassId classId, float value)
     {
         writeClassId(classId);
-        writeSize(sizeof(double));
-        writeUnsignedInteger(*reinterpret_cast<uint64_t*>(&value));
+        Assert(sizeof(uint32_t) == sizeof(float));
+        writeSize(sizeof(float));
+
+        union
+        {
+            float   f;
+            uint8_t u8[4];
+        } u;
+
+        u.f = value;
+
+        for (int8_t i = 3; i >= 0; i--) /* Converts values to big endian. */
+            write(&u.u8[i], 1);
+
         return *this;
     }
@@ -314 +329 @@
             {
                 /** Sample rate of input data. */
-                uint16_t uHzIn;
-                /** Sample rate the codec is using. */
-                uint16_t uHzCodec;
-                /** Frame size (in bytes), based on the codec sample rate.
-                 *  Note: For now this does *not* change dynamically, in other words,
-                 *        we do CBR (and not VBR) here! */
-                size_t   cbFrameSize;
+                uint16_t uHz;
+                /** Duration of the frame in samples (per channel).
+                 *  Valid frame size are:
+                 *
+                 *  ms           Frame size
+                 *  2.5          120
+                 *  5            240
+                 *  10           480
+                 *  20 (Default) 960
+                 *  40           1920
+                 *  60           2880
+                 */
+                uint16_t csFrame;
             } Audio;
         };
@@ -346 +367 @@
             , offCluster(0)
             , fOpen(false)
-            , tsStartMs(0)
-            , tsEndMs(0) { }
+            , tcStart(0)
+            , tcLast(0)
+            , cBlocks(0)
+            , cbData(0) { }
 
         /** This cluster's ID. */
@@ -356 +379 @@
         /** Whether this cluster element is opened currently. */
         bool          fOpen;
-        /** Timestamp (in ms) when starting this  cluster. */
-        uint64_t      tsStartMs;
-        /** Timestamp (in ms) when this cluster ended. */
-        uint64_t      tsEndMs;
+        /** Timecode when starting this cluster. */
+        uint64_t      tcStart;
+        /** Timecode when this cluster was last touched. */
+        uint64_t      tcLast;
+        /** Number of (simple) blocks in this cluster. */
+        uint64_t      cBlocks;
+        /** Size (in bytes) of data already written. */
+        uint64_t      cbData;
     };
 
@@ -370 +397 @@
     {
         WebMSegment(void)
-            : offStart(0)
+            : tcStart(UINT64_MAX)
+            , tcEnd(UINT64_MAX)
+            , offStart(0)
             , offInfo(0)
             , offSeekInfo(0)
             , offTracks(0)
-            , offCues(0) { }
+            , offCues(0)
+        {
+            /* This is the default for WebM -- all timecodes in the segments are expressed in ms.
+             * This allows every cluster to have blocks with positive values up to 32.767 seconds. */
+            uTimecodeScaleFactor = 1000000;
+            //m_uTimecodeScaleFactor = lround(1000000000 /* ns */ / 48000);
+
+            LogFunc(("Default timecode scale is: %RU64ns\n", uTimecodeScaleFactor));
+        }
+
+        /** The timecode scale factor of this segment.
+         *  By default this is 1000000, which is 1ms per timecode unit. */
+        uint64_t                        uTimecodeScaleFactor;
+
+        /** Timecode when starting this segment. */
+        uint64_t                        tcStart;
+        /** Timecode when this segment ended. */
+        uint64_t                        tcEnd;
 
         /** Absolute offset (in bytes) of CurSeg. */
@@ -434 +480 @@
     WebMWriter::VideoCodec      m_enmVideoCodec;
 
-    /** This PTS (Presentation Time Stamp) acts as our master clock for synchronizing streams. */
-    uint64_t                    m_uPts;
-    /** Timestamp (in ms) of initial PTS. */
-    int64_t                     m_tsInitialPtsMs;
-    /** Timestamp (in ms) of last written PTS. */
-    int64_t                     m_tsLastPtsMs;
-
     /** Whether we're currently in the tracks section. */
     bool                        m_fInTracksSection;
@@ -448 +487 @@
     /** Maximum value a timecode can have. */
     uint32_t                    m_uTimecodeMax;
-    /** The timecode scale factor. */
-    uint64_t                    m_uTimecodeScaleNs;
 
     Ebml                        m_Ebml;
@@ -460 +497 @@
 
     WebMWriter_Impl() :
-          m_uPts(0)
-        , m_tsInitialPtsMs(-1)
-        , m_tsLastPtsMs(-1)
-        , m_fInTracksSection(false)
+        m_fInTracksSection(false)
     {
         /* Size (in bytes) of time code to write. We use 2 bytes (16 bit) by default. */
         m_cbTimecode   = 2;
         m_uTimecodeMax = UINT16_MAX;
-
-        /* This is the default for WebM -- all timecodes in the segments are expressed in ms.
-         * This allows every cluster to have blocks with positive values up to 32.767 seconds. */
-        m_uTimecodeScaleNs = 1000000;
     }
 
@@ -479 +509 @@
     }
 
+    /**
+     * Adds an audio track.
+     *
+     * @returns IPRT status code.
+     * @param   uHz             Input sampling rate.
+     * @param   cChannels       Number of input audio channels.
+     * @param   cBits           Number of input bits per channel.
+     * @param   puTrack         Track number on successful creation. Optional.
+     */
     int AddAudioTrack(uint16_t uHz, uint8_t cChannels, uint8_t cBits, uint8_t *puTrack)
     {
 #ifdef VBOX_WITH_LIBOPUS
+        int rc;
+
+        /*
+         * Check if the requested codec rate is supported.
+         *
+         * Only the following values are supported by an Opus standard build
+         * -- every other rate only is supported by a custom build.
+         */
+        switch (uHz)
+        {
+            case 48000:
+            case 24000:
+            case 16000:
+            case 12000:
+            case  8000:
+                rc = VINF_SUCCESS;
+                break;
+
+            default:
+                rc = VERR_NOT_SUPPORTED;
+                break;
+        }
+
+        if (RT_FAILURE(rc))
+            return rc;
+
         m_Ebml.subStart(MkvElem_TrackEntry);
         m_Ebml.serializeUnsignedInteger(MkvElem_TrackNumber, (uint8_t)CurSeg.mapTracks.size());
@@ -490 +555 @@
         WebMTrack *pTrack = new WebMTrack(WebMTrackType_Audio, uTrack, RTFileTell(m_Ebml.getFile()));
 
-        /* Clamp the codec rate (Hz) value if it reaches a certain threshold. */
-        if      (uHz > 24000) pTrack->Audio.uHzCodec = 48000;
-        else if (uHz > 16000) pTrack->Audio.uHzCodec = 24000;
-        else if (uHz > 12000) pTrack->Audio.uHzCodec = 16000;
-        else if (uHz > 8000 ) pTrack->Audio.uHzCodec = 12000;
-        else                  pTrack->Audio.uHzCodec = 8000;
-
-        pTrack->Audio.uHzIn = uHz;
-
-        /** @todo 960 bytes is 20ms worth of audio data. Make this configurable. */
-        pTrack->Audio.cbFrameSize = 960 /* Bytes */ / (48000 /* Hz */ / pTrack->Audio.uHzCodec);
-
-        /** @todo Resolve codec type. */
+        pTrack->Audio.uHz     = uHz;
+        pTrack->Audio.csFrame = pTrack->Audio.uHz / 50; /** @todo 20 ms of audio data. Make this configurable? */
+
         OpusPrivData opusPrivData(uHz, cChannels);
 
-        m_Ebml.serializeUnsignedInteger(MkvElem_TrackUID, pTrack->uUUID, 4)
-              .serializeUnsignedInteger(MkvElem_TrackType, 2 /* Audio */)
-              .serializeString(MkvElem_CodecID, "A_OPUS")
-              .serializeData(MkvElem_CodecPrivate, &opusPrivData, sizeof(opusPrivData))
-              .serializeUnsignedInteger(MkvElem_CodecDelay,  0)
-              .serializeUnsignedInteger(MkvElem_SeekPreRoll, 80000000) /* 80.000ms */
+        LogFunc(("Opus @ %RU16Hz (Frame size is %RU16 samples / channel))\n", pTrack->Audio.uHz, pTrack->Audio.csFrame));
+
+        m_Ebml.serializeUnsignedInteger(MkvElem_TrackUID,     pTrack->uUUID, 4)
+              .serializeUnsignedInteger(MkvElem_TrackType,    2 /* Audio */)
+              .serializeString(MkvElem_CodecID,               "A_OPUS")
+              .serializeData(MkvElem_CodecPrivate,            &opusPrivData, sizeof(opusPrivData))
+              .serializeUnsignedInteger(MkvElem_CodecDelay,   0)
+              .serializeUnsignedInteger(MkvElem_SeekPreRoll,  80000000) /* 80ms in ns. */
               .subStart(MkvElem_Audio)
-                  .serializeFloat(MkvElem_SamplingFrequency,  (float)pTrack->Audio.uHzCodec)
+                  .serializeFloat(MkvElem_SamplingFrequency,  (float)uHz)
                   .serializeUnsignedInteger(MkvElem_Channels, cChannels)
                   .serializeUnsignedInteger(MkvElem_BitDepth, cBits)
@@ -519 +576 @@
 
         CurSeg.mapTracks[uTrack] = pTrack;
+
+        Assert(uTrack == 0);
 
         if (puTrack)
@@ -541 +600 @@
 
         /** @todo Resolve codec type. */
-        m_Ebml.serializeUnsignedInteger(MkvElem_TrackUID, pTrack->uUUID /* UID */, 4)
-              .serializeUnsignedInteger(MkvElem_TrackType, 1 /* Video */)
-              .serializeString(MkvElem_CodecID, "V_VP8")
+        m_Ebml.serializeUnsignedInteger(MkvElem_TrackUID,    pTrack->uUUID /* UID */, 4)
+              .serializeUnsignedInteger(MkvElem_TrackType,   1 /* Video */)
+              .serializeString(MkvElem_CodecID,              "V_VP8")
               .subStart(MkvElem_Video)
-              .serializeUnsignedInteger(MkvElem_PixelWidth, uWidth)
+              .serializeUnsignedInteger(MkvElem_PixelWidth,  uWidth)
               .serializeUnsignedInteger(MkvElem_PixelHeight, uHeight)
-              .serializeFloat(MkvElem_FrameRate, dbFPS)
+              .serializeFloat(MkvElem_FrameRate,             dbFPS)
               .subEnd(MkvElem_Video)
               .subEnd(MkvElem_TrackEntry);
@@ -630 +689 @@
 
         /* Calculate the PTS of this frame in milliseconds. */
-        int64_t tsPtsMs = a_pPkt->data.frame.pts * 1000
-                        * (uint64_t) a_pCfg->g_timebase.num / a_pCfg->g_timebase.den;
-
-        if (tsPtsMs <= m_tsLastPtsMs)
-            tsPtsMs = m_tsLastPtsMs + 1;
-
-        m_tsLastPtsMs = tsPtsMs;
-
-        if (m_tsInitialPtsMs < 0)
-            m_tsInitialPtsMs = m_tsLastPtsMs;
+        uint64_t tcPTS = a_pPkt->data.frame.pts * 1000
+                         * (uint64_t) a_pCfg->g_timebase.num / a_pCfg->g_timebase.den;
+
+        if (tcPTS <= CurSeg.CurCluster.tcLast)
+            tcPTS = CurSeg.CurCluster.tcLast + 1;
+
+        CurSeg.CurCluster.tcLast = tcPTS;
+
+        if (CurSeg.CurCluster.tcStart == UINT64_MAX)
+            CurSeg.CurCluster.tcStart = CurSeg.CurCluster.tcLast;
 
         /* Calculate the relative time of this block. */
-        uint16_t tsBlockMs     = 0;
+        uint16_t tcBlock       = 0;
         bool     fClusterStart = false;
 
         /* Did we reach the maximum our timecode can hold? Use a new cluster then. */
-        if (tsPtsMs - CurSeg.CurCluster.tsStartMs > m_uTimecodeMax)
+        if (tcPTS - CurSeg.CurCluster.tcStart > m_uTimecodeMax)
             fClusterStart = true;
         else
         {
             /* Calculate the block's timecode, which is relative to the current cluster's starting timecode. */
-            tsBlockMs = static_cast<uint16_t>(tsPtsMs - CurSeg.CurCluster.tsStartMs);
+            tcBlock = static_cast<uint16_t>(tcPTS - CurSeg.CurCluster.tcStart);
         }
 
@@ -669 +728 @@
             }
 
-            tsBlockMs = 0;
+            tcBlock = 0;
 
             /* Open a new cluster. */
             Cluster.fOpen      = true;
-            Cluster.tsStartMs    = tsPtsMs;
+            Cluster.tcStart    = tcPTS;
             Cluster.offCluster = RTFileTell(m_Ebml.getFile());
-
-            LogFunc(("Cluster @ %RU64\n", Cluster.offCluster));
+            Cluster.cBlocks    = 0;
+            Cluster.cbData     = 0;
+
+            LogFunc(("[C%RU64] Start @ tc=%RU64 off=%RU64\n", a_pTrack->cTotalClusters, Cluster.tcStart, Cluster.offCluster));
 
             m_Ebml.subStart(MkvElem_Cluster)
-                  .serializeUnsignedInteger(MkvElem_Timecode, Cluster.tsStartMs);
+                  .serializeUnsignedInteger(MkvElem_Timecode, Cluster.tcStart);
 
             /* Save a cue point if this is a keyframe. */
             if (fKeyframe)
             {
-                WebMCueEntry cue(Cluster.tsStartMs, Cluster.offCluster);
+                WebMCueEntry cue(Cluster.tcStart, Cluster.offCluster);
                 CurSeg.lstCues.push_back(cue);
             }
         }
+
+        LogFunc(("tcPTS=%RU64, s=%RU64, e=%RU64\n", tcPTS, CurSeg.CurCluster.tcStart, CurSeg.CurCluster.tcLast));
 
         uint8_t fFlags = 0;
@@ -695 +758 @@
             fFlags |= 0x08; /* Invisible frame. */
 
-        return writeSimpleBlockInternal(a_pTrack, tsBlockMs, a_pPkt->data.frame.buf, a_pPkt->data.frame.sz, fFlags);
+        return writeSimpleBlockInternal(a_pTrack, tcBlock, a_pPkt->data.frame.buf, a_pPkt->data.frame.sz, fFlags);
     }
 #endif /* VBOX_WITH_LIBVPX */
@@ -707 +770 @@
         AssertReturn(cbData, VERR_INVALID_PARAMETER);
 
-        //static uint64_t s_uTimecode = 0;
-        /* For now this is constant while encoding (CBR), but might change to VBR later. */
-        //s_uTimecode += a_pTrack->Audio.cbFrameSize * 48000 / a_pTrack->Audio.uHzCodec;
-
-        //static uint64_t s_uPts = 0;
-
-        int64_t tsPtsMs = 1000000000 * a_pTrack->cTotalBlocks / 48000;
-
-        m_tsLastPtsMs = tsPtsMs;
-
-        if (m_tsInitialPtsMs < 0)
-            m_tsInitialPtsMs = m_tsLastPtsMs;
-
         WebMCluster &Cluster = CurSeg.CurCluster;
 
-        /* Calculate the relative time of this block. */
-        uint16_t tsBlockMs     = 0;
+        /* Calculate the PTS. */
+        /* Make sure to round the result. This is very important! */
+        uint64_t tcPTSRaw = lround((CurSeg.uTimecodeScaleFactor * 1000 * Cluster.cbData) / a_pTrack->Audio.uHz);
+
+        uint64_t tcPTS = /*Cluster.tcStart +*/ lround(tcPTSRaw / CurSeg.uTimecodeScaleFactor);
+
+        if (Cluster.tcStart == UINT64_MAX)
+            Cluster.tcStart = tcPTS;
+
+        LogFunc(("tcPTSRaw=%RU64, tcPTS=%RU64, cbData=%RU64\n", tcPTSRaw, tcPTS, Cluster.cbData));
+
+        Cluster.tcLast = tcPTS;
+
+        uint16_t tcBlock;
         bool     fClusterStart = false;
 
@@ -730 +792 @@
 
         /* Did we reach the maximum our timecode can hold? Use a new cluster then. */
-        if (tsPtsMs - Cluster.tsStartMs > m_uTimecodeMax)
+        if (tcPTS - Cluster.tcStart > m_uTimecodeMax)
+        {
+            tcBlock = 0;
+
             fClusterStart = true;
+        }
         else
         {
             /* Calculate the block's timecode, which is relative to the Cluster timecode. */
-            tsBlockMs = static_cast<uint16_t>(tsPtsMs - Cluster.tsStartMs);
+            tcBlock = static_cast<uint16_t>(tcPTS - Cluster.tcStart);
         }
 
         if (fClusterStart)
         {
-            a_pTrack->cTotalClusters++;
-
             if (Cluster.fOpen) /* Close current cluster first. */
             {
@@ -748 +812 @@
             }
 
-            tsBlockMs = 0;
+            tcBlock = 0;
 
             Cluster.fOpen      = true;
-            Cluster.tsStartMs    = tsPtsMs;
+            Cluster.tcStart    = tcPTS;
             Cluster.offCluster = RTFileTell(m_Ebml.getFile());
-
-            LogFunc(("Cluster @ %RU64\n", Cluster.offCluster));
+            Cluster.cBlocks    = 0;
+            Cluster.cbData     = 0;
+
+            LogFunc(("[C%RU64] Start @ tc=%RU64 off=%RU64\n", a_pTrack->cTotalClusters, Cluster.tcStart, Cluster.offCluster));
 
             m_Ebml.subStart(MkvElem_Cluster)
-                  .serializeUnsignedInteger(MkvElem_Timecode, Cluster.tsStartMs);
-        }
-
-        LogFunc(("Cluster %RU64 - Block %RU64: -> %RU64ms\n",
-                 a_pTrack->cTotalClusters, a_pTrack->cTotalBlocks, a_pTrack->cTotalBlocks * 20));
-
-        return writeSimpleBlockInternal(a_pTrack, tsBlockMs, pvData, cbData, 0 /* Flags */);
+                  .serializeUnsignedInteger(MkvElem_Timecode, Cluster.tcStart);
+
+            a_pTrack->cTotalClusters++;
+        }
+
+        LogFunc(("tcPTS=%RU64, s=%RU64, e=%RU64\n", tcPTS, CurSeg.CurCluster.tcStart, CurSeg.CurCluster.tcLast));
+
+        Cluster.cBlocks += 1;
+        Cluster.cbData  += cbData;
+
+        return writeSimpleBlockInternal(a_pTrack, tcBlock, pvData, cbData, 0x80 /* Flags */);
     }
 #endif /* VBOX_WITH_LIBOPUS */
@@ -930 +1000 @@
         .subEnd(MkvElem_SeekHead);
 
-        int64_t iFrameTime = (int64_t)1000 * 1 / 25; //m_Framerate.den / m_Framerate.num; /** @todo Fix this! */
+        //int64_t iFrameTime = (int64_t)1000 * 1 / 25; //m_Framerate.den / m_Framerate.num; /** @todo Fix this! */
         CurSeg.offInfo = RTFileTell(m_Ebml.getFile());
 
@@ -945 +1015 @@
         RTStrPrintf(szApp, sizeof(szApp), VBOX_PRODUCT " %sr%u", VBOX_VERSION_STRING, RTBldCfgRevision());
 
+        LogFunc(("Duration=%RU64\n", CurSeg.tcEnd - CurSeg.tcStart));
+
         m_Ebml.subStart(MkvElem_Info)
-              .serializeUnsignedInteger(MkvElem_TimecodeScale, m_uTimecodeScaleNs)
-              .serializeFloat(MkvElem_Segment_Duration, m_tsLastPtsMs + iFrameTime - m_tsInitialPtsMs)
+              .serializeUnsignedInteger(MkvElem_TimecodeScale, CurSeg.uTimecodeScaleFactor)
+              .serializeFloat(MkvElem_Segment_Duration, CurSeg.tcEnd /*+ iFrameTime*/ - CurSeg.tcStart)
               .serializeString(MkvElem_MuxingApp, szMux)
               .serializeString(MkvElem_WritingApp, szApp)