Index: /trunk/src/VBox/Main/src-client/DrvAudioVideoRec.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/DrvAudioVideoRec.cpp (revision 65329) +++ /trunk/src/VBox/Main/src-client/DrvAudioVideoRec.cpp (revision 65330) @@ -96,4 +96,5 @@ AVRECCODEC Codec; /** (Audio) frame buffer. */ + PRTCIRCBUF pCircBuf; uint8_t *pvFrameBuf; size_t cbFrameBufSize; @@ -121,4 +122,6 @@ * See the AVRECMODE enumeration for more information. */ WebMWriter *pEBML; + /** Track number for audio data. */ + uint8_t uTrack; } DRVAUDIOVIDEOREC, *PDRVAUDIOVIDEOREC; @@ -141,8 +144,10 @@ #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,5 +240,5 @@ 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,8 +290,8 @@ */ 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,5 +324,5 @@ pStreamOut->Props.cBits, pStreamOut->Props.fSigned, cSamplesToSend)); - uint32_t csRead = 0; + uint32_t csReadTotal = 0; int rc; @@ -329,42 +334,89 @@ /** @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,7 +424,4 @@ rc = VERR_NOT_SUPPORTED; #endif /* VBOX_WITH_LIBOPUS */ - - if (csRead) - AudioMixBufFinish(&pStream->MixBuf, csRead); /* @@ -381,7 +430,7 @@ */ 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,4 +442,10 @@ RT_NOREF(pThis); PAVRECSTREAMOUT pStreamOut = (PAVRECSTREAMOUT)pStream; + + if (pStreamOut->pCircBuf) + { + RTCircBufDestroy(pStreamOut->pCircBuf); + pStreamOut->pCircBuf = NULL; + } if (pStreamOut->pvFrameBuf) Index: /trunk/src/VBox/Main/src-client/EbmlWriter.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/EbmlWriter.cpp (revision 65329) +++ /trunk/src/VBox/Main/src-client/EbmlWriter.cpp (revision 65330) @@ -18,4 +18,5 @@ #include +#include #include #include @@ -295,15 +296,32 @@ 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,6 +385,8 @@ std::list m_lstCue; - /** List of tracks. */ - std::list m_lstTracks; + /** Map of tracks. + * The key marks the track number (*not* the UID!). */ + std::map m_mapTracks; + /** Whether we're currently in an opened tracks segment. */ bool m_fTracksOpen; @@ -380,4 +400,8 @@ Ebml m_Ebml; + +public: + + typedef std::map WebMTracks; public: @@ -397,21 +421,36 @@ , 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,9 +459,14 @@ .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,15 +477,15 @@ } - 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,4 +496,9 @@ .subEnd(Video) .subEnd(TrackEntry); + + m_mapTracks[uTrack] = pTrack; + + if (puTrack) + *puTrack = uTrack; return VINF_SUCCESS; @@ -510,6 +559,8 @@ } - 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,11 +621,14 @@ 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,11 +640,24 @@ } - 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,8 +669,8 @@ } - switch (blockType) - { - - case WebMWriter::BlockType_Audio: + switch (pTrack->enmType) + { + + case WebMTrackType_Audio: { #ifdef VBOX_WITH_LIBOPUS @@ -612,5 +679,5 @@ 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,5 +687,5 @@ } - case WebMWriter::BlockType_Video: + case WebMTrackType_Video: { if (m_enmVideoCodec == WebMWriter::VideoCodec_VP8) @@ -626,5 +693,5 @@ 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,4 +754,20 @@ } + 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,22 +861,21 @@ 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,5 +883,5 @@ try { - rc = m_pImpl->WriteBlock(blockType, pvData, cbData); + rc = m_pImpl->WriteBlock(uTrack, pvData, cbData); } catch(int rc2) Index: /trunk/src/VBox/Main/src-client/EbmlWriter.h =================================================================== --- /trunk/src/VBox/Main/src-client/EbmlWriter.h (revision 65329) +++ /trunk/src/VBox/Main/src-client/EbmlWriter.h (revision 65330) @@ -79,15 +79,4 @@ }; - /** - * Block type to write. - */ - enum BlockType - { - BlockType_Invalid = 0, - BlockType_Audio = 1, - BlockType_Video = 2, - BlockType_Raw = 3 - }; - public: @@ -110,12 +99,12 @@ 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,5 +112,5 @@ * @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); /** Index: /trunk/src/VBox/Main/src-client/VideoRec.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/VideoRec.cpp (revision 65329) +++ /trunk/src/VBox/Main/src-client/VideoRec.cpp (revision 65330) @@ -109,4 +109,6 @@ /** Container context. */ WebMWriter *pEBML; + /** Track number of video stream. */ + uint8_t uTrackVideo; /** Codec data. */ VIDEORECCODEC Codec; @@ -754,5 +756,5 @@ if (fHasVideoTrack) { - rc = pStream->pEBML->AddVideoTrack(uWidth, uHeight, uFps); + rc = pStream->pEBML->AddVideoTrack(uWidth, uHeight, uFps, &pStream->uTrackVideo); if (RT_FAILURE(rc)) { @@ -914,5 +916,5 @@ { 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; }