Index: /trunk/src/VBox/Main/include/Recording.h =================================================================== --- /trunk/src/VBox/Main/include/Recording.h (revision 75440) +++ /trunk/src/VBox/Main/include/Recording.h (revision 75441) @@ -118,4 +118,6 @@ * Per VM screen (display) one recording stream is being used. */ RecordingStreams vecStreams; + /** Number of streams in vecStreams which currently are enabled for recording. */ + uint16_t cStreamsEnabled; /** Timestamp (in ms) of when recording has been started. */ uint64_t tsStartMs; Index: /trunk/src/VBox/Main/include/RecordingInternals.h =================================================================== --- /trunk/src/VBox/Main/include/RecordingInternals.h (revision 75440) +++ /trunk/src/VBox/Main/include/RecordingInternals.h (revision 75441) @@ -19,4 +19,5 @@ #define ____H_RECORDING_INTERNALS +#include #include /* drag in stdint.h before vpx does it. */ #include @@ -115,9 +116,52 @@ } RECORDINGBLOCKTYPE; +#ifdef VBOX_WITH_AUDIO_RECORDING +void RecordingAudioFrameFree(PRECORDINGAUDIOFRAME pFrame); +#endif +void RecordingVideoFrameFree(PRECORDINGVIDEOFRAME pFrame); + /** * Generic structure for keeping a single video recording (data) block. */ -typedef struct RECORDINGBLOCK +struct RecordingBlock { + RecordingBlock() + : enmType(RECORDINGBLOCKTYPE_UNKNOWN) + , cRefs(0) + , pvData(NULL) + , cbData(0) { } + + virtual ~RecordingBlock() + { + Reset(); + } + + void Reset(void) + { + switch (enmType) + { + case RECORDINGBLOCKTYPE_UNKNOWN: + break; + + case RECORDINGBLOCKTYPE_VIDEO: + RecordingVideoFrameFree((PRECORDINGVIDEOFRAME)pvData); + break; + +#ifdef VBOX_WITH_AUDIO_RECORDING + case RECORDINGBLOCKTYPE_AUDIO: + RecordingAudioFrameFree((PRECORDINGAUDIOFRAME)pvData); + break; +#endif + default: + AssertFailed(); + break; + } + + enmType = RECORDINGBLOCKTYPE_UNKNOWN; + cRefs = 0; + pvData = NULL; + cbData = 0; + } + /** The block's type. */ RECORDINGBLOCKTYPE enmType; @@ -130,14 +174,8 @@ /** Size (in bytes) of the (opaque) data block. */ size_t cbData; -} RECORDINGBLOCK, *PRECORDINGBLOCK; +}; /** List for keeping video recording (data) blocks. */ -typedef std::list RECORDINGBLOCKList; - -void RecordingBlockFree(PRECORDINGBLOCK pBlock); -#ifdef VBOX_WITH_AUDIO_RECORDING -void RecordingAudioFrameFree(PRECORDINGAUDIOFRAME pFrame); -#endif -void RecordingVideoFrameFree(PRECORDINGVIDEOFRAME pFrame); +typedef std::list RecordingBlockList; #endif /* ____H_RECORDING_INTERNALS */ Index: /trunk/src/VBox/Main/include/RecordingStream.h =================================================================== --- /trunk/src/VBox/Main/include/RecordingStream.h (revision 75440) +++ /trunk/src/VBox/Main/include/RecordingStream.h (revision 75441) @@ -51,7 +51,7 @@ while (!List.empty()) { - PRECORDINGBLOCK pBlock = List.front(); - RecordingBlockFree(pBlock); + RecordingBlock *pBlock = List.front(); List.pop_front(); + delete pBlock; } @@ -60,5 +60,5 @@ /** The actual block list for this timecode. */ - RECORDINGBLOCKList List; + RecordingBlockList List; }; @@ -125,4 +125,5 @@ const settings::RecordingScreenSettings &GetConfig(void) const; + uint16_t GetID(void) const { return this->uScreenID; }; bool IsLimitReached(uint64_t tsNowMs) const; bool IsReady(void) const; @@ -167,5 +168,5 @@ /** Recording context this stream is associated to. */ - RecordingContext *pCtx; + RecordingContext *pCtx; /** The current state. */ RECORDINGSTREAMSTATE enmState; @@ -206,5 +207,5 @@ /** Common set of recording (data) blocks, needed for * multiplexing to all recording streams. */ - RecordingBlockSet Blocks; + RecordingBlockSet Blocks; }; Index: /trunk/src/VBox/Main/src-client/Recording.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/Recording.cpp (revision 75440) +++ /trunk/src/VBox/Main/src-client/Recording.cpp (revision 75441) @@ -92,9 +92,11 @@ RecordingContext::RecordingContext(Console *a_pConsole) : pConsole(a_pConsole) - , enmState(RECORDINGSTS_UNINITIALIZED) { } + , enmState(RECORDINGSTS_UNINITIALIZED) + , cStreamsEnabled(0) { } RecordingContext::RecordingContext(Console *a_pConsole, const settings::RecordingSettings &a_Settings) : pConsole(a_pConsole) , enmState(RECORDINGSTS_UNINITIALIZED) + , cStreamsEnabled(0) { int rc = RecordingContext::createInternal(a_Settings); @@ -139,5 +141,8 @@ rc = pStream->Process(pThis->mapBlocksCommon); if (RT_FAILURE(rc)) + { + LogRel(("Recording: Processing stream #%RU16 failed (%Rrc)\n", pStream->GetID(), rc)); break; + } ++itStream; @@ -191,4 +196,6 @@ pStream = new RecordingStream(this, itScreen->first /* Screen ID */, itScreen->second); this->vecStreams.push_back(pStream); + if (itScreen->second.fEnabled) + this->cStreamsEnabled++; } catch (std::bad_alloc &) @@ -533,6 +540,5 @@ * audio data at the same given point in time. */ - PRECORDINGBLOCK pBlock = (PRECORDINGBLOCK)RTMemAlloc(sizeof(RECORDINGBLOCK)); - AssertPtrReturn(pBlock, VERR_NO_MEMORY); + RecordingBlock *pBlock = new RecordingBlock(); pBlock->enmType = RECORDINGBLOCKTYPE_AUDIO; @@ -548,5 +554,5 @@ pBlock->pvData = pFrame; pBlock->cbData = sizeof(RECORDINGAUDIOFRAME) + cbData; - pBlock->cRefs = (uint16_t)this->vecStreams.size(); /* All streams need the same audio data. */ + pBlock->cRefs = this->cStreamsEnabled; pBlock->uTimeStampMs = uTimeStampMs; Index: /trunk/src/VBox/Main/src-client/RecordingInternals.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/RecordingInternals.cpp (revision 75440) +++ /trunk/src/VBox/Main/src-client/RecordingInternals.cpp (revision 75441) @@ -61,33 +61,2 @@ } -/** - * Frees a recording (data) block. - * - * @returns IPRT status code. - * @param pBlock Recording (data) block to free. The pointer will be invalid after return. - */ -void RecordingBlockFree(PRECORDINGBLOCK pBlock) -{ - if (!pBlock) - return; - - switch (pBlock->enmType) - { - case RECORDINGBLOCKTYPE_VIDEO: - RecordingVideoFrameFree((PRECORDINGVIDEOFRAME)pBlock->pvData); - break; - -#ifdef VBOX_WITH_AUDIO_RECORDING - case RECORDINGBLOCKTYPE_AUDIO: - RecordingAudioFrameFree((PRECORDINGAUDIOFRAME)pBlock->pvData); - break; -#endif - default: - AssertFailed(); - break; - } - - RTMemFree(pBlock); - pBlock = NULL; -} - Index: /trunk/src/VBox/Main/src-client/RecordingStream.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/RecordingStream.cpp (revision 75440) +++ /trunk/src/VBox/Main/src-client/RecordingStream.cpp (revision 75441) @@ -276,4 +276,6 @@ && tsNowMs >= this->tsStartMs + (this->ScreenSettings.ulMaxTimeS * RT_MS_1SEC)) { + LogRel(("Recording: Time limit for stream #%RU16 has been reached (%RU32s)\n", + this->uScreenID, this->ScreenSettings.ulMaxTimeS)); return true; } @@ -281,10 +283,13 @@ if (this->ScreenSettings.enmDest == RecordingDestination_File) { - if (this->ScreenSettings.File.ulMaxSizeMB) { uint64_t sizeInMB = this->File.pWEBM->GetFileSize() / _1M; if(sizeInMB >= this->ScreenSettings.File.ulMaxSizeMB) + { + LogRel(("Recording: File size limit for stream #%RU16 has been reached (%RU64MB)\n", + this->uScreenID, this->ScreenSettings.File.ulMaxSizeMB)); return true; + } } @@ -293,5 +298,5 @@ && this->File.pWEBM->GetAvailableSpace() < 0x100000) /** @todo r=andy WTF? Fix this. */ { - LogRel(("Recording: Not enough free storage space available, stopping video capture\n")); + LogRel(("Recording: Not enough free storage space available, stopping recording\n")); return true; } @@ -321,4 +326,6 @@ int RecordingStream::Process(RecordingBlockMap &mapBlocksCommon) { + LogFlowFuncEnter(); + lock(); @@ -341,5 +348,5 @@ while (!pBlocks->List.empty()) { - PRECORDINGBLOCK pBlock = pBlocks->List.front(); + RecordingBlock *pBlock = pBlocks->List.front(); AssertPtr(pBlock); @@ -349,24 +356,24 @@ PRECORDINGVIDEOFRAME pVideoFrame = (PRECORDINGVIDEOFRAME)pBlock->pvData; - rc = RecordingUtilsRGBToYUV(pVideoFrame->uPixelFormat, - /* Destination */ - this->Video.Codec.VPX.pu8YuvBuf, pVideoFrame->uWidth, pVideoFrame->uHeight, - /* Source */ - pVideoFrame->pu8RGBBuf, this->ScreenSettings.Video.ulWidth, this->ScreenSettings.Video.ulHeight); - if (RT_SUCCESS(rc)) + int rc2 = RecordingUtilsRGBToYUV(pVideoFrame->uPixelFormat, + /* Destination */ + this->Video.Codec.VPX.pu8YuvBuf, pVideoFrame->uWidth, pVideoFrame->uHeight, + /* Source */ + pVideoFrame->pu8RGBBuf, this->ScreenSettings.Video.ulWidth, this->ScreenSettings.Video.ulHeight); + if (RT_SUCCESS(rc2)) { - rc = writeVideoVPX(uTimeStampMs, pVideoFrame); + rc2 = writeVideoVPX(uTimeStampMs, pVideoFrame); + AssertRC(rc2); + if (RT_SUCCESS(rc)) + rc = rc2; } - else - break; - } -#endif - RecordingBlockFree(pBlock); - pBlock = NULL; - + } +#endif pBlocks->List.pop_front(); - } - - ++itStreamBlocks; + delete pBlock; + } + + Blocks.Map.erase(itStreamBlocks); + itStreamBlocks = Blocks.Map.begin(); } @@ -379,8 +386,8 @@ while (itCommonBlocks != mapBlocksCommon.end()) { - RECORDINGBLOCKList::iterator itBlock = itCommonBlocks->second->List.begin(); + RecordingBlockList::iterator itBlock = itCommonBlocks->second->List.begin(); while (itBlock != itCommonBlocks->second->List.end()) { - PRECORDINGBLOCK pBlockCommon = (PRECORDINGBLOCK)(*itBlock); + RecordingBlock *pBlockCommon = (RecordingBlock *)(*itBlock); switch (pBlockCommon->enmType) { @@ -395,5 +402,8 @@ pBlockCommon->uTimeStampMs }; AssertPtr(this->File.pWEBM); - rc = this->File.pWEBM->WriteBlock(this->uTrackAudio, &blockData, sizeof(blockData)); + int rc2 = this->File.pWEBM->WriteBlock(this->uTrackAudio, &blockData, sizeof(blockData)); + AssertRC(rc2); + if (RT_SUCCESS(rc)) + rc = rc2; break; } @@ -404,13 +414,10 @@ } - if (RT_FAILURE(rc)) - break; - Assert(pBlockCommon->cRefs); pBlockCommon->cRefs--; if (pBlockCommon->cRefs == 0) { - RecordingBlockFree(pBlockCommon); itCommonBlocks->second->List.erase(itBlock); + delete pBlockCommon; itBlock = itCommonBlocks->second->List.begin(); } @@ -430,7 +437,4 @@ LogFunc(("Common blocks: %zu\n", mapBlocksCommon.size())); - - if (RT_FAILURE(rc)) - break; } #endif @@ -438,4 +442,5 @@ unlock(); + LogFlowFuncLeaveRC(rc); return rc; } @@ -637,5 +642,5 @@ if (rc == VINF_SUCCESS) /* Note: Also could be VINF_TRY_AGAIN. */ { - PRECORDINGBLOCK pBlock = (PRECORDINGBLOCK)RTMemAlloc(sizeof(RECORDINGBLOCK)); + RecordingBlock *pBlock = new RecordingBlock(); if (pBlock) { @@ -680,5 +685,5 @@ * @param a_pCtx Pointer to recording context. * @param uScreen Screen number to use for this recording stream. - * @param Settings Capturing configuration to use for initialization. + * @param Settings Recording screen configuration to use for initialization. */ int RecordingStream::Init(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings) @@ -693,5 +698,5 @@ * @param a_pCtx Pointer to recording context. * @param uScreen Screen number to use for this recording stream. - * @param Settings Capturing configuration to use for initialization. + * @param Settings Recording screen configuration to use for initialization. */ int RecordingStream::initInternal(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings) @@ -701,7 +706,9 @@ this->ScreenSettings = Settings; - int rc = parseOptionsString(Settings.strOptions); + int rc = parseOptionsString(this->ScreenSettings.strOptions); if (RT_FAILURE(rc)) return rc; + + const settings::RecordingScreenSettings *pSettings = &this->ScreenSettings; rc = RTCritSectInit(&this->CritSect); @@ -709,10 +716,10 @@ return rc; - rc = open(Settings); + rc = open(this->ScreenSettings); if (RT_FAILURE(rc)) return rc; - const bool fVideoEnabled = Settings.isFeatureEnabled(RecordingFeature_Video); - const bool fAudioEnabled = Settings.isFeatureEnabled(RecordingFeature_Audio); + const bool fVideoEnabled = pSettings->isFeatureEnabled(RecordingFeature_Video); + const bool fAudioEnabled = pSettings->isFeatureEnabled(RecordingFeature_Audio); if (fVideoEnabled) @@ -734,17 +741,15 @@ case RecordingDestination_File: { - Assert(this->ScreenSettings.File.strName.isNotEmpty()); - const char *pszFile = this->ScreenSettings.File.strName.c_str(); + Assert(pSettings->File.strName.isNotEmpty()); + const char *pszFile = pSettings->File.strName.c_str(); AssertPtr(File.pWEBM); rc = File.pWEBM->OpenEx(pszFile, &this->File.hFile, #ifdef VBOX_WITH_AUDIO_RECORDING - Settings.isFeatureEnabled(RecordingFeature_Audio) - ? WebMWriter::AudioCodec_Opus : WebMWriter::AudioCodec_None, + fAudioEnabled ? WebMWriter::AudioCodec_Opus : WebMWriter::AudioCodec_None, #else - WebMWriter::AudioCodec_None, -#endif - Settings.isFeatureEnabled(RecordingFeature_Video) - ? WebMWriter::VideoCodec_VP8 : WebMWriter::VideoCodec_None); + WebMWriter::AudioCodec_None, +#endif + fVideoEnabled ? WebMWriter::VideoCodec_VP8 : WebMWriter::VideoCodec_None); if (RT_FAILURE(rc)) { @@ -755,6 +760,6 @@ if (fVideoEnabled) { - rc = this->File.pWEBM->AddVideoTrack(Settings.Video.ulWidth, Settings.Video.ulHeight, - Settings.Video.ulFPS, &this->uTrackVideo); + rc = this->File.pWEBM->AddVideoTrack(pSettings->Video.ulWidth, pSettings->Video.ulHeight, pSettings->Video.ulFPS, + &this->uTrackVideo); if (RT_FAILURE(rc)) { @@ -764,6 +769,6 @@ LogRel(("Recording: Recording video of screen #%u with %RU32x%RU32 @ %RU32 kbps, %RU32 FPS (track #%RU8)\n", - this->uScreenID, Settings.Video.ulWidth, Settings.Video.ulHeight, Settings.Video.ulRate, - Settings.Video.ulFPS, this->uTrackVideo)); + this->uScreenID, pSettings->Video.ulWidth, pSettings->Video.ulHeight, + pSettings->Video.ulRate, pSettings->Video.ulFPS, this->uTrackVideo)); } @@ -771,5 +776,5 @@ if (fAudioEnabled) { - rc = this->File.pWEBM->AddAudioTrack(Settings.Audio.uHz, Settings.Audio.cChannels, Settings.Audio.cBits, + rc = this->File.pWEBM->AddAudioTrack(pSettings->Audio.uHz, pSettings->Audio.cChannels, pSettings->Audio.cBits, &this->uTrackAudio); if (RT_FAILURE(rc)) @@ -780,6 +785,6 @@ LogRel(("Recording: Recording audio of screen #%u in %RU16Hz, %RU8 bit, %RU8 %s (track #%RU8)\n", - this->uScreenID, Settings.Audio.uHz, Settings.Audio.cBits, Settings.Audio.cChannels, - Settings.Audio.cChannels ? "channels" : "channel", this->uTrackAudio)); + this->uScreenID, pSettings->Audio.uHz, pSettings->Audio.cBits, pSettings->Audio.cChannels, + pSettings->Audio.cChannels ? "channels" : "channel", this->uTrackAudio)); } #endif @@ -990,5 +995,6 @@ this->Video.cFailedEncodingFrames = 0; - this->Video.uDelayMs = RT_MS_1SEC / this->ScreenSettings.Video.ulFPS; + this->Video.uLastTimeStampMs = 0; + this->Video.uDelayMs = RT_MS_1SEC / this->ScreenSettings.Video.ulFPS; int rc; @@ -998,5 +1004,5 @@ rc = initVideoVPX(); #else - rc = VINF_SUCCESS; + rc = VERR_NOT_SUPPORTED; #endif Index: /trunk/src/VBox/Main/src-server/RecordingScreenSettingsImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-server/RecordingScreenSettingsImpl.cpp (revision 75440) +++ /trunk/src/VBox/Main/src-server/RecordingScreenSettingsImpl.cpp (revision 75441) @@ -810,5 +810,7 @@ Assert(m); - int rc = VINF_SUCCESS; + int rc = i_parseOptionsString(m->bd->strOptions, *m->bd.data()); + if (RT_FAILURE(rc)) + return rc; switch (m->bd->enmDest)