Changeset 65330 in vbox

Timestamp:

Jan 16, 2017 1:38:36 PM (8 years ago)

Author:

vboxsync

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

112908

Message:

VideoRec: Update.

Location:

trunk/src/VBox/Main/src-client

Files:

• DrvAudioVideoRec.cpp (modified) (10 diffs)
• EbmlWriter.cpp (modified) (18 diffs)
• EbmlWriter.h (modified) (3 diffs)
• VideoRec.cpp (modified) (3 diffs)

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

@@ -96 +96 @@
     AVRECCODEC           Codec;
     /** (Audio) frame buffer. */
+    PRTCIRCBUF           pCircBuf;
     uint8_t             *pvFrameBuf;
     size_t               cbFrameBufSize;
@@ -121 +122 @@
      *  See the AVRECMODE enumeration for more information. */
     WebMWriter          *pEBML;
+    /** Track number for audio data. */
+    uint8_t              uTrack;
 } DRVAUDIOVIDEOREC, *PDRVAUDIOVIDEOREC;
 
@@ -141 +144 @@
 
 #ifdef VBOX_WITH_LIBOPUS
+    RTCircBufCreate(&pStreamOut->pCircBuf, _4K);
+
     rc = DrvAudioHlpStreamCfgToProps(pCfgReq, &pStreamOut->Props);
     if (RT_SUCCESS(rc))
     {
-        size_t cbFrameBuf = sizeof(uint8_t) * _8K; /** @todo Make this configurable */
+        size_t cbFrameBuf = sizeof(uint8_t) * _4K; /** @todo Make this configurable */
 
         pStreamOut->pvFrameBuf = (uint8_t *)RTMemAlloc(cbFrameBuf);
@@ -235 +240 @@
                                           WebMWriter::AudioCodec_Opus, WebMWriter::VideoCodec_None);
                 if (RT_SUCCESS(rc))
-                    rc = pThis->pEBML->AddAudioTrack(44100, 2, 16);
+                    rc = pThis->pEBML->AddAudioTrack(44100, 2, 16, &pThis->uTrack);
                 break;
             }
@@ -285 +290 @@
  */
 static DECLCALLBACK(int) drvAudioVideoRecStreamPlay(PPDMIHOSTAUDIO pInterface,
-                                                    PPDMAUDIOSTREAM pStream, const void *pvBuf, uint32_t cbBuf,
+                                                    PPDMAUDIOSTREAM pStream, const void *pvBuf2, uint32_t cbBuf2,
                                                     uint32_t *pcbWritten)
 {
-    RT_NOREF2(pvBuf, cbBuf);
+    RT_NOREF2(pvBuf2, cbBuf2);
 
     AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
@@ -319 +324 @@
                  pStreamOut->Props.cBits, pStreamOut->Props.fSigned, cSamplesToSend));
 
-    uint32_t csRead = 0;
+    uint32_t csReadTotal = 0;
 
     int rc;
@@ -329 +334 @@
 
     /** @todo For now we ASSUME 25 FPS. */
-    uint16_t csFrameSize = /*pStreamOut->Props.uHz*/ 48000 / 25;
-    size_t   cbFrameSize = AUDIOMIXBUF_S2B(&pStream->MixBuf, csFrameSize);
-
-    rc = AudioMixBufReadCirc(&pStream->MixBuf, (uint8_t *)&pStreamOut->pvFrameBuf[pStreamOut->offFrameBufWrite],
-                             pStreamOut->cbFrameBufSize - pStreamOut->offFrameBufWrite, &csRead);
-    if (RT_SUCCESS(rc))
-    {
-        const uint32_t cbRead = AUDIOMIXBUF_S2B(&pStream->MixBuf, csRead);
-
-        pStreamOut->offFrameBufWrite =
-            (pStreamOut->offFrameBufWrite + cbRead) % pStreamOut->cbFrameBufSize;
-        Assert(pStreamOut->offFrameBufWrite <= pStreamOut->cbFrameBufSize);
-        pStreamOut->cbFrameBufUsed  += cbRead;
-        Assert(pStreamOut->cbFrameBufUsed  <= pStreamOut->cbFrameBufSize);
-
-        if (pStreamOut->cbFrameBufUsed >= cbFrameSize)
+    uint16_t cbFrameSize = (/*pStreamOut->Props.uHz*/ 48000 / 25 /* FPS */);
+
+    PRTCIRCBUF pCircBuf = pStreamOut->pCircBuf;
+
+    while (pStreamOut->cbFrameBufUsed < cbFrameSize)
+    {
+        void  *pvBuf;
+        size_t cbBuf;
+        RTCircBufAcquireWriteBlock(pCircBuf, RTCircBufFree(pCircBuf), &pvBuf, &cbBuf);
+
+        uint32_t cbRead = 0;
+
+        if (cbBuf)
         {
-            /* Opus always encodes PER FRAME, that is, 2.5, 5, 10, 20, 40 or 60 ms of audio data. */
+            uint32_t csRead = 0;
+            rc = AudioMixBufReadCirc(&pStream->MixBuf, pvBuf, cbBuf, &csRead);
+            if (RT_SUCCESS(rc))
+            {
+                AudioMixBufFinish(&pStream->MixBuf, csRead);
+
+                cbRead = AUDIOMIXBUF_S2B(&pStream->MixBuf, csRead);
+                csReadTotal += csRead;
+            }
+        }
+
+        RTCircBufReleaseWriteBlock(pCircBuf, cbRead);
+
+        if (   RT_FAILURE(rc)
+            || !cbRead)
+        {
+            break;
+        }
+
+        if (RTCircBufUsed(pCircBuf) >= cbFrameSize)
+        {
+            uint8_t abSrc[_4K];
+            size_t  cbSrc = 0;
+
+            while (cbSrc < cbFrameSize)
+            {
+                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;
+            }
+
+            /*
+             * 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 our input samples. */
+            opus_encoder_ctl(pStreamOut->Codec.Opus.pEnc, OPUS_SET_BITRATE(196000)); /** @todo */
             opus_int32 cbWritten = opus_encode(pStreamOut->Codec.Opus.pEnc,
-                                               (opus_int16 *)&pStreamOut->pvFrameBuf[pStreamOut->offFrameBufRead],
-                                               csFrameSize, abDst, cbDst);
+                                               (opus_int16 *)abSrc, cbSrc, abDst, cbDst);
             if (cbWritten > 0)
             {
-                pStreamOut->offFrameBufRead = (pStreamOut->offFrameBufRead + cbWritten) % pStreamOut->cbFrameBufSize;
-                Assert(pStreamOut->cbFrameBufUsed >= cbFrameSize);
-                pStreamOut->cbFrameBufUsed -= cbFrameSize;
-
                 /* Call the WebM writer to actually write the encoded audio data. */
                 WebMWriter::BlockData_Opus blockData = { abDst, cbDst };
-                rc = pThis->pEBML->WriteBlock(WebMWriter::BlockType_Audio, &blockData, sizeof(blockData));
+                rc = pThis->pEBML->WriteBlock(pThis->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;
         }
     }
@@ -372 +424 @@
     rc = VERR_NOT_SUPPORTED;
 #endif /* VBOX_WITH_LIBOPUS */
-
-    if (csRead)
-        AudioMixBufFinish(&pStream->MixBuf, csRead);
 
     /*
@@ -381 +430 @@
      */
     if (pcbWritten)
-        *pcbWritten = csRead;
-
-    LogFlowFunc(("csRead=%RU32, rc=%Rrc\n", csRead, rc));
+        *pcbWritten = csReadTotal;
+
+    LogFlowFunc(("csReadTotal=%RU32, rc=%Rrc\n", csReadTotal, rc));
     return rc;
 }
@@ -393 +442 @@
     RT_NOREF(pThis);
     PAVRECSTREAMOUT   pStreamOut = (PAVRECSTREAMOUT)pStream;
+
+    if (pStreamOut->pCircBuf)
+    {
+        RTCircBufDestroy(pStreamOut->pCircBuf);
+        pStreamOut->pCircBuf = NULL;
+    }
 
     if (pStreamOut->pvFrameBuf)

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

@@ -18 +18 @@
 
 #include <list>
+#include <map>
 #include <stack>
 #include <iprt/asm.h>
@@ -295 +296 @@
     struct WebMTrack
     {
-        WebMTrack(WebMTrackType a_enmType, uint64_t a_offID)
+        WebMTrack(WebMTrackType a_enmType, uint8_t a_uTrack, uint64_t a_offID)
             : enmType(a_enmType)
+            , uTrack(a_uTrack)
             , offID(a_offID)
         {
-            uID = RTRandU32();
+            uUUID = RTRandU32();
         }
 
         /** The type of this track. */
         WebMTrackType enmType;
-        /** The track's UUID. */
-        uint32_t      uID;
+        /** Track parameters. */
+        union
+        {
+            struct
+            {
+                /** 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. */
+                size_t   cbFrameSize;
+            } Audio;
+        };
+        /** This track's track number. Also used as key in track map. */
+        uint8_t       uTrack;
+        /** The track's "UUID".
+         *  Needed in case this track gets mux'ed with tracks from other files. Not really unique though. */
+        uint32_t      uUUID;
         /** Absolute offset in file of track ID.
          *  Needed to write the hash sum within the footer. */
@@ -367 +385 @@
     std::list<WebMCueEntry>     m_lstCue;
 
-    /** List of tracks. */
-    std::list<WebMTrack>        m_lstTracks;
+    /** Map of tracks.
+     *  The key marks the track number (*not* the UID!). */
+    std::map <uint8_t, WebMTrack *> m_mapTracks;
+    /** Whether we're currently in an opened tracks segment. */
     bool                        m_fTracksOpen;
 
@@ -380 +400 @@
 
     Ebml                        m_Ebml;
+
+public:
+
+    typedef std::map <uint8_t, WebMTrack *> WebMTracks;
 
 public:
@@ -397 +421 @@
         , m_offSegClusterStart(0) {}
 
-    int AddAudioTrack(uint16_t uHz, uint8_t cChannels, uint8_t cBits)
+    virtual ~WebMWriter_Impl()
+    {
+        close();
+    }
+
+    int AddAudioTrack(uint16_t uHz, uint8_t cChannels, uint8_t cBits, uint8_t *puTrack)
     {
 #ifdef VBOX_WITH_LIBOPUS
         m_Ebml.subStart(TrackEntry);
-        m_Ebml.serializeUnsignedInteger(TrackNumber, (uint8_t)m_lstTracks.size());
+        m_Ebml.serializeUnsignedInteger(TrackNumber, (uint8_t)m_mapTracks.size());
         /** @todo Implement track's "Language" property? Currently this defaults to English ("eng"). */
 
-        WebMTrack TrackAudio(WebMTrackType_Audio, RTFileTell(m_Ebml.getFile()));
-        m_lstTracks.push_back(TrackAudio);
-
-        if (uHz >= 44100)
-            uHz = 48000;
+        uint8_t uTrack = m_mapTracks.size();
+
+        WebMTrack *pTrack = new WebMTrack(WebMTrackType_Audio, uTrack, RTFileTell(m_Ebml.getFile()));
+
+        /* Clamp the codec rate 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 1920 bytes is 40ms worth of audio data. Make this configurable. */
+        pTrack->Audio.cbFrameSize =  1920 / (48000 / pTrack->Audio.uHzCodec);
 
         /** @todo Resolve codec type. */
         OpusPrivData opusPrivData(uHz, cChannels);
 
-        m_Ebml.serializeUnsignedInteger(TrackUID, TrackAudio.uID, 4)
+        m_Ebml.serializeUnsignedInteger(TrackUID, pTrack->uUUID, 4)
               .serializeUnsignedInteger(TrackType, 2 /* Audio */)
               .serializeString(CodecID, "A_OPUS")
@@ -420 +459 @@
               .serializeUnsignedInteger(SeekPreRoll, 80000000)
               .subStart(Audio)
-                  .serializeFloat(SamplingFrequency,       (float)uHz)
-                  .serializeUnsignedInteger(Channels,      cChannels)
-                  .serializeUnsignedInteger(BitDepth,      cBits)
+                  .serializeFloat(SamplingFrequency,  (float)pTrack->Audio.uHzCodec)
+                  .serializeUnsignedInteger(Channels, cChannels)
+                  .serializeUnsignedInteger(BitDepth, cBits)
               .subEnd(Audio)
               .subEnd(TrackEntry);
+
+        m_mapTracks[uTrack] = pTrack;
+
+        if (puTrack)
+            *puTrack = uTrack;
 
         return VINF_SUCCESS;
@@ -433 +477 @@
     }
 
-    int AddVideoTrack(uint16_t uWidth, uint16_t uHeight, double dbFPS)
+    int AddVideoTrack(uint16_t uWidth, uint16_t uHeight, double dbFPS, uint8_t *puTrack)
     {
         m_Ebml.subStart(TrackEntry);
-        m_Ebml.serializeUnsignedInteger(TrackNumber, (uint8_t)m_lstTracks.size());
-
-        WebMTrack TrackVideo(WebMTrackType_Video, RTFileTell(m_Ebml.getFile()));
-        m_lstTracks.push_back(TrackVideo);
+        m_Ebml.serializeUnsignedInteger(TrackNumber, (uint8_t)m_mapTracks.size());
+
+        uint8_t uTrack = m_mapTracks.size();
+
+        WebMTrack *pTrack = new WebMTrack(WebMTrackType_Video, uTrack, RTFileTell(m_Ebml.getFile()));
 
         /** @todo Resolve codec type. */
-
-        m_Ebml.serializeUnsignedInteger(TrackUID, TrackVideo.uID /* UID */, 4)
+        m_Ebml.serializeUnsignedInteger(TrackUID, pTrack->uUUID /* UID */, 4)
               .serializeUnsignedInteger(TrackType, 1 /* Video */)
               .serializeString(CodecID, "V_VP8")
@@ -452 +496 @@
               .subEnd(Video)
               .subEnd(TrackEntry);
+
+        m_mapTracks[uTrack] = pTrack;
+
+        if (puTrack)
+            *puTrack = uTrack;
 
         return VINF_SUCCESS;
@@ -510 +559 @@
     }
 
-    int writeBlockVP8(const vpx_codec_enc_cfg_t *a_pCfg, const vpx_codec_cx_pkt_t *a_pPkt)
-    {
+    int writeBlockVP8(const 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 PTS of this frame in milliseconds. */
         int64_t tsPtsMs = a_pPkt->data.frame.pts * 1000
@@ -570 +621 @@
             fFlags |= 0x08; /* Invisible frame. */
 
-        return writeSimpleBlockInternal(0 /** @todo FIX! */, tsBlockMs, a_pPkt->data.frame.buf, a_pPkt->data.frame.sz, fFlags);
+        return writeSimpleBlockInternal(a_pTrack->uTrack, tsBlockMs, a_pPkt->data.frame.buf, a_pPkt->data.frame.sz, fFlags);
     }
 
 #ifdef VBOX_WITH_LIBOPUS
     /* Audio blocks that have same absolute timecode as video blocks SHOULD be written before the video blocks. */
-    int writeBlockOpus(const void *pvData, size_t cbData)
-    {
+    int writeBlockOpus(const WebMTrack *a_pTrack, const void *pvData, size_t cbData)
+    {
+        AssertPtrReturn(a_pTrack, VERR_INVALID_POINTER);
+        AssertReturn(a_pTrack->Audio.cbFrameSize == cbData, VERR_INVALID_PARAMETER);
+
 static uint16_t s_uTimecode = 0;
 
@@ -586 +640 @@
         }
 
-        return writeSimpleBlockInternal(0 /** @todo FIX! */, s_uTimecode++, pvData, cbData, 0 /* Flags */);
+        uint64_t ts = (s_uTimecode * 1000 * 1000 * 1000) / 48000;
+
+        LogFunc(("ts=%RU64 (timecode %RU16)\n", ts, s_uTimecode));
+
+        s_uTimecode += a_pTrack->Audio.cbFrameSize;
+
+        return writeSimpleBlockInternal(a_pTrack->uTrack, ts, pvData, cbData, 0 /* Flags */);
     }
 #endif
 
-    int WriteBlock(WebMWriter::BlockType blockType, const void *pvData, size_t cbData)
+    int WriteBlock(uint8_t uTrack, const void *pvData, size_t cbData)
     {
         RT_NOREF(cbData); /* Only needed for assertions for now. */
+
+        WebMTracks::const_iterator itTrack = m_mapTracks.find(uTrack);
+        if (itTrack == m_mapTracks.end())
+            return VERR_NOT_FOUND;
+
+        const WebMTrack *pTrack = itTrack->second;
+        AssertPtr(pTrack);
 
         int rc;
@@ -602 +669 @@
         }
 
-        switch (blockType)
-        {
-
-            case WebMWriter::BlockType_Audio:
+        switch (pTrack->enmType)
+        {
+
+            case WebMTrackType_Audio:
             {
 #ifdef VBOX_WITH_LIBOPUS
@@ -612 +679 @@
                     Assert(cbData == sizeof(WebMWriter::BlockData_Opus));
                     WebMWriter::BlockData_Opus *pData = (WebMWriter::BlockData_Opus *)pvData;
-                    rc = writeBlockOpus(pData->pvData, pData->cbData);
+                    rc = writeBlockOpus(pTrack, pData->pvData, pData->cbData);
                 }
                 else
@@ -620 +687 @@
             }
 
-            case WebMWriter::BlockType_Video:
+            case WebMTrackType_Video:
             {
                 if (m_enmVideoCodec == WebMWriter::VideoCodec_VP8)
@@ -626 +693 @@
                     Assert(cbData == sizeof(WebMWriter::BlockData_VP8));
                     WebMWriter::BlockData_VP8 *pData = (WebMWriter::BlockData_VP8 *)pvData;
-                    rc = writeBlockVP8(pData->pCfg, pData->pPkt);
+                    rc = writeBlockVP8(pTrack, pData->pCfg, pData->pPkt);
                 }
                 else
@@ -687 +754 @@
     }
 
+    int close(void)
+    {
+        WebMTracks::iterator itTrack = m_mapTracks.begin();
+        for (; itTrack != m_mapTracks.end(); ++itTrack)
+        {
+            delete itTrack->second;
+            itTrack = m_mapTracks.erase(itTrack);
+        }
+
+        Assert(m_mapTracks.size() == 0);
+
+        m_Ebml.close();
+
+        return VINF_SUCCESS;
+    }
+
     friend class Ebml;
     friend class WebMWriter;
@@ -778 +861 @@
 
     int rc = m_pImpl->writeFooter();
-
-    /* Close the file in any case. */
-    m_pImpl->m_Ebml.close();
+    if (RT_SUCCESS(rc))
+        m_pImpl->close();
 
     return rc;
 }
 
-int WebMWriter::AddAudioTrack(uint16_t uHz, uint8_t cChannels, uint8_t cBitDepth)
+int WebMWriter::AddAudioTrack(uint16_t uHz, uint8_t cChannels, uint8_t cBitDepth, uint8_t *puTrack)
 {
-    return m_pImpl->AddAudioTrack(uHz, cChannels, cBitDepth);
+    return m_pImpl->AddAudioTrack(uHz, cChannels, cBitDepth, puTrack);
 }
 
-int WebMWriter::AddVideoTrack(uint16_t uWidth, uint16_t uHeight, double dbFPS)
+int WebMWriter::AddVideoTrack(uint16_t uWidth, uint16_t uHeight, double dbFPS, uint8_t *puTrack)
 {
-    return m_pImpl->AddVideoTrack(uWidth, uHeight, dbFPS);
+    return m_pImpl->AddVideoTrack(uWidth, uHeight, dbFPS, puTrack);
 }
 
-int WebMWriter::WriteBlock(WebMWriter::BlockType blockType, const void *pvData, size_t cbData)
+int WebMWriter::WriteBlock(uint8_t uTrack, const void *pvData, size_t cbData)
 {
     int rc;
@@ -801 +883 @@
     try
     {
-        rc = m_pImpl->WriteBlock(blockType, pvData, cbData);
+        rc = m_pImpl->WriteBlock(uTrack, pvData, cbData);
     }
     catch(int rc2)

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

@@ -79 +79 @@
     };
 
-    /**
-     * Block type to write.
-     */
-    enum BlockType
-    {
-        BlockType_Invalid = 0,
-        BlockType_Audio   = 1,
-        BlockType_Video   = 2,
-        BlockType_Raw     = 3
-    };
-
 public:
 
@@ -110 +99 @@
     int Close(void);
 
-    int AddAudioTrack(uint16_t uHz, uint8_t cChannels, uint8_t cBits);
+    int AddAudioTrack(uint16_t uHz, uint8_t cChannels, uint8_t cBits, uint8_t *puTrack);
 
-    int AddVideoTrack(uint16_t uWidth, uint16_t uHeight, double dbFPS);
+    int AddVideoTrack(uint16_t uWidth, uint16_t uHeight, double dbFPS, uint8_t *puTrack);
 
     /**
      * Writes a block of compressed data.
      *
-     * @param blockType         Block type to write.
+     * @param uTrack            Track number to write data to.
      * @param pvData            Pointer to block data to write.
      * @param cbData            Size (in bytes) of block data to write.
@@ -123 +112 @@
      * @returns VBox status code.
      */
-    int WriteBlock(WebMWriter::BlockType blockType, const void *pvData, size_t cbData);
+    int WriteBlock(uint8_t uTrack, const void *pvData, size_t cbData);
 
     /**

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

@@ -109 +109 @@
     /** Container context. */
     WebMWriter         *pEBML;
+    /** Track number of video stream. */
+    uint8_t             uTrackVideo;
     /** Codec data. */
     VIDEORECCODEC       Codec;
@@ -754 +756 @@
     if (fHasVideoTrack)
     {
-        rc = pStream->pEBML->AddVideoTrack(uWidth, uHeight, uFps);
+        rc = pStream->pEBML->AddVideoTrack(uWidth, uHeight, uFps, &pStream->uTrackVideo);
         if (RT_FAILURE(rc))
         {
@@ -914 +916 @@
             {
                 WebMWriter::BlockData_VP8 blockData = { &pStream->Codec.VPX.Config, pPacket };
-                rc = pStream->pEBML->WriteBlock(WebMWriter::BlockType_Video, &blockData, sizeof(blockData));
+                rc = pStream->pEBML->WriteBlock(pStream->uTrackVideo, &blockData, sizeof(blockData));
                 break;
             }