Index: /trunk/src/VBox/Main/include/ConsoleImpl.h =================================================================== --- /trunk/src/VBox/Main/include/ConsoleImpl.h (revision 75353) +++ /trunk/src/VBox/Main/include/ConsoleImpl.h (revision 75354) @@ -149,5 +149,5 @@ int i_recordingStop(void); AudioVideoRec *i_recordingGetAudioDrv(void) const { return Recording.mAudioRec; } - CaptureContext *i_recordingGetContext(void) const { return Recording.mpRecordCtx; } + RecordingContext *i_recordingGetContext(void) const { return Recording.mpCtx; } HRESULT i_recordingSendAudio(const void *pvData, size_t cbData, uint64_t uDurationMs); #endif @@ -1034,9 +1034,9 @@ { Recording() - : mpRecordCtx(NULL) + : mpCtx(NULL) , mAudioRec(NULL) { } /** The recording context. */ - CaptureContext *mpRecordCtx; + RecordingContext *mpCtx; # ifdef VBOX_WITH_AUDIO_RECORDING /** Pointer to capturing audio backend. */ Index: /trunk/src/VBox/Main/include/DrvAudioRec.h =================================================================== --- /trunk/src/VBox/Main/include/DrvAudioRec.h (revision 75353) +++ /trunk/src/VBox/Main/include/DrvAudioRec.h (revision 75354) @@ -16,6 +16,6 @@ */ -#ifndef ____H_DRVAUDIOVIDEOREC -#define ____H_DRVAUDIOVIDEOREC +#ifndef ____H_DRVAUDIORECORDING +#define ____H_DRVAUDIORECORDING #include @@ -59,9 +59,9 @@ /** Pointer to the associated video recording audio driver. */ - struct DRVAUDIOVIDEOREC *mpDrv; + struct DRVAUDIORECORDING *mpDrv; /** Capturing configuration used for configuring the driver. */ struct settings::RecordSettings mVideoRecCfg; }; -#endif /* !____H_DRVAUDIOVIDEOREC */ +#endif /* !____H_DRVAUDIORECORDING */ Index: /trunk/src/VBox/Main/include/Recording.h =================================================================== --- /trunk/src/VBox/Main/include/Recording.h (revision 75353) +++ /trunk/src/VBox/Main/include/Recording.h (revision 75354) @@ -16,6 +16,6 @@ */ -#ifndef ____H_VIDEOREC -#define ____H_VIDEOREC +#ifndef ____H_RECORDING +#define ____H_RECORDING #include @@ -35,18 +35,18 @@ * Class for managing a capturing context. */ -class CaptureContext +class RecordingContext { public: - CaptureContext(Console *pConsole); + RecordingContext(Console *pConsole); - CaptureContext(Console *pConsole, const settings::RecordSettings &a_Settings); + RecordingContext(Console *pConsole, const settings::RecordSettings &a_Settings); - virtual ~CaptureContext(void); + virtual ~RecordingContext(void); public: const settings::RecordSettings &GetConfig(void) const; - CaptureStream *GetStream(unsigned uScreen) const; + RecordingStream *GetStream(unsigned uScreen) const; size_t GetStreamCount(void) const; @@ -78,5 +78,5 @@ int destroyInternal(void); - CaptureStream *getStreamInternal(unsigned uScreen) const; + RecordingStream *getStreamInternal(unsigned uScreen) const; static DECLCALLBACK(int) threadMain(RTTHREAD hThreadSelf, void *pvUser); @@ -89,14 +89,14 @@ * Enumeration for a recording context state. */ - enum VIDEORECSTS + enum RECORDINGSTS { /** Context not initialized. */ - VIDEORECSTS_UNINITIALIZED = 0, + RECORDINGSTS_UNINITIALIZED = 0, /** Context was created. */ - VIDEORECSTS_CREATED = 1, + RECORDINGSTS_CREATED = 1, /** Context was started. */ - VIDEORECSTS_STARTED = 2, + RECORDINGSTS_STARTED = 2, /** The usual 32-bit hack. */ - VIDEORECSTS_32BIT_HACK = 0x7fffffff + RECORDINGSTS_32BIT_HACK = 0x7fffffff }; @@ -104,7 +104,7 @@ Console *pConsole; /** Used recording configuration. */ - settings::RecordSettings Settings; + settings::RecordSettings Settings; /** The current state. */ - VIDEORECSTS enmState; + RECORDINGSTS enmState; /** Critical section to serialize access. */ RTCRITSECT CritSect; @@ -117,5 +117,5 @@ /** Vector of current recording streams. * Per VM screen (display) one recording stream is being used. */ - VideoRecStreams vecStreams; + RecordingStreams vecStreams; /** Timestamp (in ms) of when recording has been started. */ uint64_t tsStartMs; @@ -127,6 +127,6 @@ * For now this only affects audio, e.g. all recording streams * need to have the same audio data at a specific point in time. */ - VideoRecBlockMap mapBlocksCommon; + RecordingBlockMap mapBlocksCommon; }; -#endif /* !____H_VIDEOREC */ +#endif /* !____H_RECORDING */ Index: /trunk/src/VBox/Main/include/RecordingInternals.h =================================================================== --- /trunk/src/VBox/Main/include/RecordingInternals.h (revision 75353) +++ /trunk/src/VBox/Main/include/RecordingInternals.h (revision 75354) @@ -16,6 +16,6 @@ */ -#ifndef ____H_VIDEOREC_INTERNALS -#define ____H_VIDEOREC_INTERNALS +#ifndef ____H_RECORDING_INTERNALS +#define ____H_RECORDING_INTERNALS #include /* drag in stdint.h before vpx does it. */ @@ -30,7 +30,7 @@ /** - * Structure for keeping specific video recording codec data. + * Structure for keeping specific recording video codec data. */ -typedef struct VIDEORECVIDEOCODEC +typedef struct RECORDINGVIDEOCODEC { #ifdef VBOX_WITH_LIBVPX @@ -51,27 +51,27 @@ }; #endif /* VBOX_WITH_LIBVPX */ -} VIDEORECVIDEOCODEC, *PVIDEORECVIDEOCODEC; +} RECORDINGVIDEOCODEC, *PRECORDINGVIDEOCODEC; /** * Enumeration for supported pixel formats. */ -enum VIDEORECPIXELFMT +enum RECORDINGPIXELFMT { /** Unknown pixel format. */ - VIDEORECPIXELFMT_UNKNOWN = 0, + RECORDINGPIXELFMT_UNKNOWN = 0, /** RGB 24. */ - VIDEORECPIXELFMT_RGB24 = 1, + RECORDINGPIXELFMT_RGB24 = 1, /** RGB 24. */ - VIDEORECPIXELFMT_RGB32 = 2, + RECORDINGPIXELFMT_RGB32 = 2, /** RGB 565. */ - VIDEORECPIXELFMT_RGB565 = 3, + RECORDINGPIXELFMT_RGB565 = 3, /** The usual 32-bit hack. */ - VIDEORECPIXELFMT_32BIT_HACK = 0x7fffffff + RECORDINGPIXELFMT_32BIT_HACK = 0x7fffffff }; /** - * Structure for keeping a single video recording video frame. + * Structure for keeping a single recording video frame. */ -typedef struct VIDEORECVIDEOFRAME +typedef struct RECORDINGVIDEOFRAME { /** X resolution of this frame. */ @@ -85,11 +85,11 @@ /** Size (in bytes) of the RGB buffer. */ size_t cbRGBBuf; -} VIDEORECVIDEOFRAME, *PVIDEORECVIDEOFRAME; +} RECORDINGVIDEOFRAME, *PRECORDINGVIDEOFRAME; #ifdef VBOX_WITH_AUDIO_RECORDING /** - * Structure for keeping a single video recording audio frame. + * Structure for keeping a single recording audio frame. */ -typedef struct VIDEORECAUDIOFRAME +typedef struct RECORDINGAUDIOFRAME { /** Pointer to audio data. */ @@ -97,5 +97,5 @@ /** Size (in bytes) of audio data. */ size_t cbBuf; -} VIDEORECAUDIOFRAME, *PVIDEORECAUDIOFRAME; +} RECORDINGAUDIOFRAME, *PRECORDINGAUDIOFRAME; #endif @@ -103,23 +103,23 @@ * Enumeration for specifying a video recording block type. */ -typedef enum VIDEORECBLOCKTYPE +typedef enum RECORDINGBLOCKTYPE { /** Uknown block type, do not use. */ - VIDEORECBLOCKTYPE_UNKNOWN = 0, + RECORDINGBLOCKTYPE_UNKNOWN = 0, /** The block is a video frame. */ - VIDEORECBLOCKTYPE_VIDEO, + RECORDINGBLOCKTYPE_VIDEO, #ifdef VBOX_WITH_AUDIO_RECORDING /** The block is an audio frame. */ - VIDEORECBLOCKTYPE_AUDIO + RECORDINGBLOCKTYPE_AUDIO #endif -} VIDEORECBLOCKTYPE; +} RECORDINGBLOCKTYPE; /** * Generic structure for keeping a single video recording (data) block. */ -typedef struct VIDEORECBLOCK +typedef struct RECORDINGBLOCK { /** The block's type. */ - VIDEORECBLOCKTYPE enmType; + RECORDINGBLOCKTYPE enmType; /** Number of references held of this block. */ uint16_t cRefs; @@ -130,14 +130,14 @@ /** Size (in bytes) of the (opaque) data block. */ size_t cbData; -} VIDEORECBLOCK, *PVIDEORECBLOCK; +} RECORDINGBLOCK, *PRECORDINGBLOCK; /** List for keeping video recording (data) blocks. */ -typedef std::list VideoRecBlockList; +typedef std::list RECORDINGBLOCKList; -void VideoRecBlockFree(PVIDEORECBLOCK pBlock); +void RecordingBlockFree(PRECORDINGBLOCK pBlock); #ifdef VBOX_WITH_AUDIO_RECORDING -void VideoRecAudioFrameFree(PVIDEORECAUDIOFRAME pFrame); +void RecordingAudioFrameFree(PRECORDINGAUDIOFRAME pFrame); #endif -void VideoRecVideoFrameFree(PVIDEORECVIDEOFRAME pFrame); +void RecordingVideoFrameFree(PRECORDINGVIDEOFRAME pFrame); -#endif /* ____H_VIDEOREC_INTERNALS */ +#endif /* ____H_RECORDING_INTERNALS */ Index: /trunk/src/VBox/Main/include/RecordingStream.h =================================================================== --- /trunk/src/VBox/Main/include/RecordingStream.h (revision 75353) +++ /trunk/src/VBox/Main/include/RecordingStream.h (revision 75354) @@ -16,6 +16,6 @@ */ -#ifndef ____H_VIDEOREC_STREAM -#define ____H_VIDEOREC_STREAM +#ifndef ____H_RECORDING_STREAM +#define ____H_RECORDING_STREAM #include @@ -32,11 +32,11 @@ class WebMWriter; -class CaptureContext; +class RecordingContext; /** Structure for queuing all blocks bound to a single timecode. * This can happen if multiple tracks are being involved. */ -struct CaptureBlocks +struct RecordingBlocks { - virtual ~CaptureBlocks() + virtual ~RecordingBlocks() { Clear(); @@ -44,5 +44,5 @@ /** - * Resets a video recording block list by removing (destroying) + * Resets a recording block list by removing (destroying) * all current elements. */ @@ -51,6 +51,6 @@ while (!List.empty()) { - PVIDEORECBLOCK pBlock = List.front(); - VideoRecBlockFree(pBlock); + PRECORDINGBLOCK pBlock = List.front(); + RecordingBlockFree(pBlock); List.pop_front(); } @@ -60,5 +60,5 @@ /** The actual block list for this timecode. */ - VideoRecBlockList List; + RECORDINGBLOCKList List; }; @@ -66,12 +66,12 @@ * The key specifies a unique timecode, whereas the value * is a list of blocks which all correlate to the same key (timecode). */ -typedef std::map VideoRecBlockMap; +typedef std::map RecordingBlockMap; /** * Structure for holding a set of recording (data) blocks. */ -struct CaptureBlockSet +struct RecordingBlockSet { - virtual ~CaptureBlockSet() + virtual ~RecordingBlockSet() { Clear(); @@ -84,5 +84,5 @@ void Clear(void) { - VideoRecBlockMap::iterator it = Map.begin(); + RecordingBlockMap::iterator it = Map.begin(); while (it != Map.end()) { @@ -99,5 +99,5 @@ uint64_t tsLastProcessedMs; /** All blocks related to this block set. */ - VideoRecBlockMap Map; + RecordingBlockMap Map; }; @@ -105,20 +105,20 @@ * Class for managing a recording stream. */ -class CaptureStream +class RecordingStream { public: - CaptureStream(CaptureContext *pCtx); - - CaptureStream(CaptureContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings); - - virtual ~CaptureStream(void); + RecordingStream(RecordingContext *pCtx); + + RecordingStream(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings); + + virtual ~RecordingStream(void); public: - int Init(CaptureContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings); + int Init(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings); int Uninit(void); - int Process(VideoRecBlockMap &mapBlocksCommon); + int Process(RecordingBlockMap &mapBlocksCommon); int SendVideoFrame(uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine, uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, uint64_t uTimeStampMs); @@ -133,5 +133,5 @@ int close(void); - int initInternal(CaptureContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings); + int initInternal(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings); int uninitInternal(void); @@ -144,5 +144,5 @@ int initVideoVPX(void); int uninitVideoVPX(void); - int writeVideoVPX(uint64_t uTimeStampMs, PVIDEORECVIDEOFRAME pFrame); + int writeVideoVPX(uint64_t uTimeStampMs, PRECORDINGVIDEOFRAME pFrame); #endif void lock(void); @@ -167,5 +167,5 @@ /** Recording context this stream is associated to. */ - CaptureContext *pCtx; + RecordingContext *pCtx; /** The current state. */ RECORDINGSTREAMSTATE enmState; @@ -202,5 +202,5 @@ /** Number of failed attempts to encode the current video frame in a row. */ uint16_t cFailedEncodingFrames; - VIDEORECVIDEOCODEC Codec; + RECORDINGVIDEOCODEC Codec; } Video; @@ -208,10 +208,10 @@ /** Common set of video recording (data) blocks, needed for * multiplexing to all recording streams. */ - CaptureBlockSet Blocks; + RecordingBlockSet Blocks; }; /** Vector of video recording streams. */ -typedef std::vector VideoRecStreams; - -#endif /* ____H_VIDEOREC_STREAM */ - +typedef std::vector RecordingStreams; + +#endif /* ____H_RECORDING_STREAM */ + Index: /trunk/src/VBox/Main/include/RecordingUtils.h =================================================================== --- /trunk/src/VBox/Main/include/RecordingUtils.h (revision 75353) +++ /trunk/src/VBox/Main/include/RecordingUtils.h (revision 75354) @@ -15,4 +15,7 @@ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. */ + +#ifndef ____H_RECORDING_UTILS +#define ____H_RECORDING_UTILS #include @@ -195,5 +198,8 @@ }; -int videoRecRGBToYUV(uint32_t uPixelFormat, - uint8_t *paDst, uint32_t uDstWidth, uint32_t uDstHeight, - uint8_t *paSrc, uint32_t uSrcWidth, uint32_t uSrcHeight); +int recordingRGBToYUV(uint32_t uPixelFormat, + uint8_t *paDst, uint32_t uDstWidth, uint32_t uDstHeight, + uint8_t *paSrc, uint32_t uSrcWidth, uint32_t uSrcHeight); + +#endif /* ____H_RECORDING_UTILS */ + Index: /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp (revision 75353) +++ /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp (revision 75354) @@ -5616,6 +5616,6 @@ if (pDisplay) { - const bool fIsEnabled = Recording.mpRecordCtx - && Recording.mpRecordCtx->IsStarted(); + const bool fIsEnabled = Recording.mpCtx + && Recording.mpCtx->IsStarted(); if (RT_BOOL(fEnable) != fIsEnabled) @@ -5632,8 +5632,8 @@ # ifdef VBOX_WITH_AUDIO_RECORDING /* Attach the video recording audio driver if required. */ - if ( Recording.mpRecordCtx->IsFeatureEnabled(RecordFeature_Audio) + if ( Recording.mpCtx->IsFeatureEnabled(RecordFeature_Audio) && Recording.mAudioRec) { - vrc = Recording.mAudioRec->applyConfiguration(Recording.mpRecordCtx->GetConfig()); + vrc = Recording.mAudioRec->applyConfiguration(Recording.mpCtx->GetConfig()); if (RT_SUCCESS(vrc)) vrc = Recording.mAudioRec->doAttachDriverViaEmt(mpUVM, pAutoLock); @@ -5641,5 +5641,5 @@ # endif if ( RT_SUCCESS(vrc) - && Recording.mpRecordCtx->IsReady()) /* Any video recording (audio and/or video) feature enabled? */ + && Recording.mpCtx->IsReady()) /* Any video recording (audio and/or video) feature enabled? */ { vrc = i_recordingStart(); @@ -6878,11 +6878,11 @@ HRESULT Console::i_recordingSendAudio(const void *pvData, size_t cbData, uint64_t uTimestampMs) { - if (!Recording.mpRecordCtx) + if (!Recording.mpCtx) return S_OK; - if ( Recording.mpRecordCtx->IsStarted() - && Recording.mpRecordCtx->IsFeatureEnabled(RecordFeature_Audio)) - { - return Recording.mpRecordCtx->SendAudioFrame(pvData, cbData, uTimestampMs); + if ( Recording.mpCtx->IsStarted() + && Recording.mpCtx->IsFeatureEnabled(RecordFeature_Audio)) + { + return Recording.mpCtx->SendAudioFrame(pvData, cbData, uTimestampMs); } @@ -6907,12 +6907,12 @@ Settings.fEnabled = RT_BOOL(fTemp); - SafeIfaceArray paCaptureScreens; - hrc = pRecordSettings->COMGETTER(Screens)(ComSafeArrayAsOutParam(paCaptureScreens)); + SafeIfaceArray paRecordingScreens; + hrc = pRecordSettings->COMGETTER(Screens)(ComSafeArrayAsOutParam(paRecordingScreens)); AssertComRCReturn(hrc, VERR_INVALID_PARAMETER); - for (unsigned long i = 0; i < (unsigned long)paCaptureScreens.size(); ++i) + for (unsigned long i = 0; i < (unsigned long)paRecordingScreens.size(); ++i) { settings::RecordScreenSettings RecordScreenSettings; - ComPtr pRecordScreenSettings = paCaptureScreens[i]; + ComPtr pRecordScreenSettings = paRecordingScreens[i]; hrc = pRecordScreenSettings->COMGETTER(Enabled)(&fTemp); @@ -6942,5 +6942,5 @@ } - Assert(Settings.mapScreens.size() == paCaptureScreens.size()); + Assert(Settings.mapScreens.size() == paRecordingScreens.size()); return VINF_SUCCESS; @@ -6954,5 +6954,5 @@ int Console::i_recordingCreate(void) { - AssertReturn(Recording.mpRecordCtx == NULL, VERR_WRONG_ORDER); + AssertReturn(Recording.mpCtx == NULL, VERR_WRONG_ORDER); int rc = VINF_SUCCESS; @@ -6960,5 +6960,5 @@ try { - Recording.mpRecordCtx = new CaptureContext(this); + Recording.mpCtx = new RecordingContext(this); } catch (std::bad_alloc &) @@ -6975,6 +6975,6 @@ if (RT_SUCCESS(rc)) { - AssertPtr(Recording.mpRecordCtx); - rc = Recording.mpRecordCtx->Create(Settings); + AssertPtr(Recording.mpCtx); + rc = Recording.mpCtx->Create(Settings); } @@ -6988,8 +6988,8 @@ void Console::i_recordingDestroy(void) { - if (Recording.mpRecordCtx) - { - delete Recording.mpRecordCtx; - Recording.mpRecordCtx = NULL; + if (Recording.mpCtx) + { + delete Recording.mpCtx; + Recording.mpCtx = NULL; } @@ -7004,15 +7004,15 @@ int Console::i_recordingStart(void) { - AssertPtrReturn(Recording.mpRecordCtx, VERR_WRONG_ORDER); - - if (Recording.mpRecordCtx->IsStarted()) + AssertPtrReturn(Recording.mpCtx, VERR_WRONG_ORDER); + + if (Recording.mpCtx->IsStarted()) return VINF_SUCCESS; LogRel(("Recording: Starting ...\n")); - int rc = Recording.mpRecordCtx->Start(); + int rc = Recording.mpCtx->Start(); if (RT_SUCCESS(rc)) { - for (unsigned uScreen = 0; uScreen < Recording.mpRecordCtx->GetStreamCount(); uScreen++) + for (unsigned uScreen = 0; uScreen < Recording.mpCtx->GetStreamCount(); uScreen++) mDisplay->i_recordingScreenChanged(uScreen); } @@ -7030,14 +7030,14 @@ int Console::i_recordingStop(void) { - if ( !Recording.mpRecordCtx - || !Recording.mpRecordCtx->IsStarted()) + if ( !Recording.mpCtx + || !Recording.mpCtx->IsStarted()) return VINF_SUCCESS; LogRel(("Recording: Stopping ...\n")); - int rc = Recording.mpRecordCtx->Stop(); + int rc = Recording.mpCtx->Stop(); if (RT_SUCCESS(rc)) { - const size_t cStreams = Recording.mpRecordCtx->GetStreamCount(); + const size_t cStreams = Recording.mpCtx->GetStreamCount(); for (unsigned uScreen = 0; uScreen < cStreams; ++uScreen) mDisplay->i_recordingScreenChanged(uScreen); Index: /trunk/src/VBox/Main/src-client/DisplayImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/DisplayImpl.cpp (revision 75353) +++ /trunk/src/VBox/Main/src-client/DisplayImpl.cpp (revision 75354) @@ -2413,5 +2413,5 @@ int Display::i_recordingInvalidate(void) { - CaptureContext *pCtx = mParent->i_recordingGetContext(); + RecordingContext *pCtx = mParent->i_recordingGetContext(); if (!pCtx || !pCtx->IsStarted()) return VINF_SUCCESS; @@ -2422,5 +2422,5 @@ for (unsigned uScreen = 0; uScreen < mcMonitors; uScreen++) { - CaptureStream *pRecordingStream = pCtx->GetStream(uScreen); + RecordingStream *pRecordingStream = pCtx->GetStream(uScreen); const bool fStreamEnabled = pRecordingStream->IsReady(); @@ -2438,5 +2438,5 @@ void Display::i_recordingScreenChanged(unsigned uScreenId) { - CaptureContext *pCtx = mParent->i_recordingGetContext(); + RecordingContext *pCtx = mParent->i_recordingGetContext(); if ( RT_LIKELY(!maRecordingEnabled[uScreenId]) @@ -3389,5 +3389,5 @@ #ifdef VBOX_WITH_RECORDING AssertPtr(pDisplay->mParent); - CaptureContext *pCtx = pDisplay->mParent->i_recordingGetContext(); + RecordingContext *pCtx = pDisplay->mParent->i_recordingGetContext(); if ( pCtx @@ -3833,5 +3833,5 @@ { # ifdef VBOX_WITH_RECORDING - CaptureContext *pCtx = mParent->i_recordingGetContext(); + RecordingContext *pCtx = mParent->i_recordingGetContext(); return ( pCtx && pCtx->IsReady(uScreen, uTimestampMs)); @@ -3855,5 +3855,5 @@ Assert(mfCrOglVideoRecState == CRVREC_STATE_SUBMITTED); # ifdef VBOX_WITH_RECORDING - CaptureContext *pCtx = mParent->i_recordingGetContext(); + RecordingContext *pCtx = mParent->i_recordingGetContext(); if ( pCtx Index: /trunk/src/VBox/Main/src-client/DrvAudioRec.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/DrvAudioRec.cpp (revision 75353) +++ /trunk/src/VBox/Main/src-client/DrvAudioRec.cpp (revision 75354) @@ -272,5 +272,5 @@ * Video recording audio driver instance data. */ -typedef struct DRVAUDIOVIDEOREC +typedef struct DRVAUDIORECORDING { /** Pointer to audio video recording object. */ @@ -290,9 +290,9 @@ /** The driver's sink for writing output to. */ AVRECSINK Sink; -} DRVAUDIOVIDEOREC, *PDRVAUDIOVIDEOREC; - -/** Makes DRVAUDIOVIDEOREC out of PDMIHOSTAUDIO. */ -#define PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface) /* (clang doesn't think it is a POD, thus _DYN.) */ \ - ( (PDRVAUDIOVIDEOREC)((uintptr_t)pInterface - RT_UOFFSETOF_DYN(DRVAUDIOVIDEOREC, IHostAudio)) ) +} DRVAUDIORECORDING, *PDRVAUDIORECORDING; + +/** Makes DRVAUDIORECORDING out of PDMIHOSTAUDIO. */ +#define PDMIHOSTAUDIO_2_DRVAUDIORECORDING(pInterface) /* (clang doesn't think it is a POD, thus _DYN.) */ \ + ( (PDRVAUDIORECORDING)((uintptr_t)pInterface - RT_UOFFSETOF_DYN(DRVAUDIORECORDING, IHostAudio)) ) /** @@ -305,5 +305,5 @@ * @param pCodecParms Codec parameters to set. */ -static int avRecSinkInit(PDRVAUDIOVIDEOREC pThis, PAVRECSINK pSink, PAVRECCONTAINERPARMS pConParms, PAVRECCODECPARMS pCodecParms) +static int avRecSinkInit(PDRVAUDIORECORDING pThis, PAVRECSINK pSink, PAVRECCONTAINERPARMS pConParms, PAVRECCODECPARMS pCodecParms) { uint32_t uHz = pCodecParms->PCMProps.uHz; @@ -513,5 +513,5 @@ * @param pCfgAcq Acquired configuration by the audio output stream. */ -static int avRecCreateStreamOut(PDRVAUDIOVIDEOREC pThis, PAVRECSTREAM pStreamAV, +static int avRecCreateStreamOut(PDRVAUDIORECORDING pThis, PAVRECSTREAM pStreamAV, PAVRECSINK pSink, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq) { @@ -585,5 +585,5 @@ * @param pStreamAV Audio output stream to destroy. */ -static int avRecDestroyStreamOut(PDRVAUDIOVIDEOREC pThis, PAVRECSTREAM pStreamAV) +static int avRecDestroyStreamOut(PDRVAUDIORECORDING pThis, PAVRECSTREAM pStreamAV) { RT_NOREF(pThis); @@ -621,5 +621,5 @@ * @param enmStreamCmd Stream command to issue. */ -static int avRecControlStreamOut(PDRVAUDIOVIDEOREC pThis, +static int avRecControlStreamOut(PDRVAUDIORECORDING pThis, PAVRECSTREAM pStreamAV, PDMAUDIOSTREAMCMD enmStreamCmd) { @@ -654,5 +654,5 @@ LogFlowFuncEnter(); - PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface); + PDRVAUDIORECORDING pThis = PDMIHOSTAUDIO_2_DRVAUDIORECORDING(pInterface); LogRel(("Recording: Audio driver is using %RU32Hz, %RU16bit, %RU8 %s\n", @@ -699,5 +699,5 @@ /* pcxWritten is optional. */ - PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface); + PDRVAUDIORECORDING pThis = PDMIHOSTAUDIO_2_DRVAUDIORECORDING(pInterface); RT_NOREF(pThis); PAVRECSTREAM pStreamAV = (PAVRECSTREAM)pStream; @@ -900,5 +900,5 @@ LogFlowFuncEnter(); - PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface); + PDRVAUDIORECORDING pThis = PDMIHOSTAUDIO_2_DRVAUDIORECORDING(pInterface); avRecSinkShutdown(&pThis->Sink); @@ -933,5 +933,5 @@ AssertPtrReturn(pStream, VERR_INVALID_POINTER); - PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface); + PDRVAUDIORECORDING pThis = PDMIHOSTAUDIO_2_DRVAUDIORECORDING(pInterface); PAVRECSTREAM pStreamAV = (PAVRECSTREAM)pStream; @@ -960,5 +960,5 @@ AssertPtrReturn(pStream, VERR_INVALID_POINTER); - PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface); + PDRVAUDIORECORDING pThis = PDMIHOSTAUDIO_2_DRVAUDIORECORDING(pInterface); PAVRECSTREAM pStreamAV = (PAVRECSTREAM)pStream; @@ -990,5 +990,5 @@ AssertPtrReturn(pStream, VERR_INVALID_POINTER); - PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface); + PDRVAUDIORECORDING pThis = PDMIHOSTAUDIO_2_DRVAUDIORECORDING(pInterface); PAVRECSTREAM pStreamAV = (PAVRECSTREAM)pStream; @@ -1057,5 +1057,5 @@ { PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface); - PDRVAUDIOVIDEOREC pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIOVIDEOREC); + PDRVAUDIORECORDING pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIORECORDING); PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase); @@ -1139,5 +1139,5 @@ { PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns); - PDRVAUDIOVIDEOREC pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIOVIDEOREC); + PDRVAUDIORECORDING pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIORECORDING); RT_NOREF(fFlags); @@ -1247,5 +1247,5 @@ { PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns); - PDRVAUDIOVIDEOREC pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIOVIDEOREC); + PDRVAUDIORECORDING pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIORECORDING); LogFlowFuncEnter(); @@ -1323,5 +1323,5 @@ ~0U, /* cbInstance */ - sizeof(DRVAUDIOVIDEOREC), + sizeof(DRVAUDIORECORDING), /* pfnConstruct */ AudioVideoRec::drvConstruct, Index: /trunk/src/VBox/Main/src-client/Recording.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/Recording.cpp (revision 75353) +++ /trunk/src/VBox/Main/src-client/Recording.cpp (revision 75354) @@ -54,8 +54,8 @@ #ifdef DEBUG_andy /** Enables dumping audio / video data for debugging reasons. */ -//# define VBOX_VIDEOREC_DUMP +//# define VBOX_RECORDING_DUMP #endif -#ifdef VBOX_VIDEOREC_DUMP +#ifdef VBOX_RECORDING_DUMP #pragma pack(push) #pragma pack(1) @@ -67,6 +67,6 @@ uint16_t u16Reserved2; uint32_t u32OffBits; -} VIDEORECBMPHDR, *PVIDEORECBMPHDR; -AssertCompileSize(VIDEORECBMPHDR, 14); +} RECORDINGBMPHDR, *PRECORDINGBMPHDR; +AssertCompileSize(RECORDINGBMPHDR, 14); typedef struct @@ -83,25 +83,25 @@ uint32_t u32ClrUsed; uint32_t u32ClrImportant; -} VIDEORECBMPDIBHDR, *PVIDEORECBMPDIBHDR; -AssertCompileSize(VIDEORECBMPDIBHDR, 40); +} RECORDINGBMPDIBHDR, *PRECORDINGBMPDIBHDR; +AssertCompileSize(RECORDINGBMPDIBHDR, 40); #pragma pack(pop) -#endif /* VBOX_VIDEOREC_DUMP */ - - -CaptureContext::CaptureContext(Console *a_pConsole) +#endif /* VBOX_RECORDING_DUMP */ + + +RecordingContext::RecordingContext(Console *a_pConsole) : pConsole(a_pConsole) - , enmState(VIDEORECSTS_UNINITIALIZED) { } - -CaptureContext::CaptureContext(Console *a_pConsole, const settings::RecordSettings &a_Settings) + , enmState(RECORDINGSTS_UNINITIALIZED) { } + +RecordingContext::RecordingContext(Console *a_pConsole, const settings::RecordSettings &a_Settings) : pConsole(a_pConsole) - , enmState(VIDEORECSTS_UNINITIALIZED) -{ - int rc = CaptureContext::createInternal(a_Settings); + , enmState(RECORDINGSTS_UNINITIALIZED) +{ + int rc = RecordingContext::createInternal(a_Settings); if (RT_FAILURE(rc)) throw rc; } -CaptureContext::~CaptureContext(void) +RecordingContext::~RecordingContext(void) { destroyInternal(); @@ -109,11 +109,11 @@ /** - * Worker thread for all streams of a video recording context. + * Worker thread for all streams of a recording context. * * For video frames, this also does the RGB/YUV conversion and encoding. */ -DECLCALLBACK(int) CaptureContext::threadMain(RTTHREAD hThreadSelf, void *pvUser) -{ - CaptureContext *pThis = (CaptureContext *)pvUser; +DECLCALLBACK(int) RecordingContext::threadMain(RTTHREAD hThreadSelf, void *pvUser) +{ + RecordingContext *pThis = (RecordingContext *)pvUser; /* Signal that we're up and rockin'. */ @@ -132,8 +132,8 @@ * for every screen from Main, we here go again (on every wake up) through * all screens. */ - VideoRecStreams::iterator itStream = pThis->vecStreams.begin(); + RecordingStreams::iterator itStream = pThis->vecStreams.begin(); while (itStream != pThis->vecStreams.end()) { - CaptureStream *pStream = (*itStream); + RecordingStream *pStream = (*itStream); rc = pStream->Process(pThis->mapBlocksCommon); @@ -166,5 +166,5 @@ * @returns IPRT status code. */ -int CaptureContext::threadNotify(void) +int RecordingContext::threadNotify(void) { return RTSemEventSignal(this->WaitEvent); @@ -177,5 +177,5 @@ * @param a_Settings Capture settings to use for context creation. */ -int CaptureContext::createInternal(const settings::RecordSettings &a_Settings) +int RecordingContext::createInternal(const settings::RecordSettings &a_Settings) { int rc = RTCritSectInit(&this->CritSect); @@ -186,8 +186,8 @@ while (itScreen != a_Settings.mapScreens.end()) { - CaptureStream *pStream = NULL; + RecordingStream *pStream = NULL; try { - pStream = new CaptureStream(this, itScreen->first /* Screen ID */, itScreen->second); + pStream = new RecordingStream(this, itScreen->first /* Screen ID */, itScreen->second); this->vecStreams.push_back(pStream); } @@ -204,5 +204,5 @@ { this->tsStartMs = RTTimeMilliTS(); - this->enmState = VIDEORECSTS_CREATED; + this->enmState = RECORDINGSTS_CREATED; this->fShutdown = false; @@ -223,12 +223,12 @@ } -int CaptureContext::startInternal(void) -{ - if (this->enmState == VIDEORECSTS_STARTED) +int RecordingContext::startInternal(void) +{ + if (this->enmState == RECORDINGSTS_STARTED) return VINF_SUCCESS; - Assert(this->enmState == VIDEORECSTS_CREATED); - - int rc = RTThreadCreate(&this->Thread, CaptureContext::threadMain, (void *)this, 0, + Assert(this->enmState == RECORDINGSTS_CREATED); + + int rc = RTThreadCreate(&this->Thread, RecordingContext::threadMain, (void *)this, 0, RTTHREADTYPE_MAIN_WORKER, RTTHREADFLAGS_WAITABLE, "Record"); @@ -238,5 +238,5 @@ if (RT_SUCCESS(rc)) { - this->enmState = VIDEORECSTS_STARTED; + this->enmState = RECORDINGSTS_STARTED; } @@ -244,7 +244,7 @@ } -int CaptureContext::stopInternal(void) -{ - if (this->enmState != VIDEORECSTS_STARTED) +int RecordingContext::stopInternal(void) +{ + if (this->enmState != RECORDINGSTS_STARTED) return VINF_SUCCESS; @@ -261,5 +261,5 @@ if (RT_SUCCESS(rc)) { - this->enmState = VIDEORECSTS_CREATED; + this->enmState = RECORDINGSTS_CREATED; } @@ -271,5 +271,5 @@ * Destroys a video recording context. */ -int CaptureContext::destroyInternal(void) +int RecordingContext::destroyInternal(void) { int rc = stopInternal(); @@ -285,8 +285,8 @@ if (RT_SUCCESS(rc)) { - VideoRecStreams::iterator it = this->vecStreams.begin(); + RecordingStreams::iterator it = this->vecStreams.begin(); while (it != this->vecStreams.end()) { - CaptureStream *pStream = (*it); + RecordingStream *pStream = (*it); int rc2 = pStream->Uninit(); @@ -318,12 +318,12 @@ } -const settings::RecordSettings &CaptureContext::GetConfig(void) const +const settings::RecordSettings &RecordingContext::GetConfig(void) const { return this->Settings; } -CaptureStream *CaptureContext::getStreamInternal(unsigned uScreen) const -{ - CaptureStream *pStream; +RecordingStream *RecordingContext::getStreamInternal(unsigned uScreen) const +{ + RecordingStream *pStream; try @@ -345,37 +345,37 @@ * @param uScreen Screen number of recording stream to look up. */ -CaptureStream *CaptureContext::GetStream(unsigned uScreen) const +RecordingStream *RecordingContext::GetStream(unsigned uScreen) const { return getStreamInternal(uScreen); } -size_t CaptureContext::GetStreamCount(void) const +size_t RecordingContext::GetStreamCount(void) const { return this->vecStreams.size(); } -int CaptureContext::Create(const settings::RecordSettings &a_Settings) +int RecordingContext::Create(const settings::RecordSettings &a_Settings) { return createInternal(a_Settings); } -int CaptureContext::Destroy(void) +int RecordingContext::Destroy(void) { return destroyInternal(); } -int CaptureContext::Start(void) +int RecordingContext::Start(void) { return startInternal(); } -int CaptureContext::Stop(void) +int RecordingContext::Stop(void) { return stopInternal(); } -bool CaptureContext::IsFeatureEnabled(RecordFeature_T enmFeature) const -{ - VideoRecStreams::const_iterator itStream = this->vecStreams.begin(); +bool RecordingContext::IsFeatureEnabled(RecordFeature_T enmFeature) const +{ + RecordingStreams::const_iterator itStream = this->vecStreams.begin(); while (itStream != this->vecStreams.end()) { @@ -393,7 +393,7 @@ * @returns @c true if recording context is ready, @c false if not. */ -bool CaptureContext::IsReady(void) const -{ - return (this->enmState >= VIDEORECSTS_CREATED); +bool RecordingContext::IsReady(void) const +{ + return (this->enmState >= RECORDINGSTS_CREATED); } @@ -405,14 +405,14 @@ * @param uTimeStampMs Current time stamp (in ms). Currently not being used. */ -bool CaptureContext::IsReady(uint32_t uScreen, uint64_t uTimeStampMs) const +bool RecordingContext::IsReady(uint32_t uScreen, uint64_t uTimeStampMs) const { RT_NOREF(uTimeStampMs); - if (this->enmState != VIDEORECSTS_STARTED) + if (this->enmState != RECORDINGSTS_STARTED) return false; bool fIsReady = false; - const CaptureStream *pStream = GetStream(uScreen); + const RecordingStream *pStream = GetStream(uScreen); if (pStream) fIsReady = pStream->IsReady(); @@ -430,7 +430,7 @@ * @returns true if active, false if not. */ -bool CaptureContext::IsStarted(void) const -{ - return (this->enmState == VIDEORECSTS_STARTED); +bool RecordingContext::IsStarted(void) const +{ + return (this->enmState == RECORDINGSTS_STARTED); } @@ -442,7 +442,7 @@ * @param tsNowMs Current time stamp (in ms). */ -bool CaptureContext::IsLimitReached(uint32_t uScreen, uint64_t tsNowMs) const -{ - const CaptureStream *pStream = GetStream(uScreen); +bool RecordingContext::IsLimitReached(uint32_t uScreen, uint64_t tsNowMs) const +{ + const RecordingStream *pStream = GetStream(uScreen); if ( !pStream || pStream->IsLimitReached(tsNowMs)) @@ -464,5 +464,5 @@ * @param uTimeStampMs Time stamp (in ms) of audio playback. */ -int CaptureContext::SendAudioFrame(const void *pvData, size_t cbData, uint64_t uTimeStampMs) +int RecordingContext::SendAudioFrame(const void *pvData, size_t cbData, uint64_t uTimeStampMs) { #ifdef VBOX_WITH_AUDIO_RECORDING @@ -475,9 +475,9 @@ * audio data at the same given point in time. */ - PVIDEORECBLOCK pBlock = (PVIDEORECBLOCK)RTMemAlloc(sizeof(VIDEORECBLOCK)); + PRECORDINGBLOCK pBlock = (PRECORDINGBLOCK)RTMemAlloc(sizeof(RECORDINGBLOCK)); AssertPtrReturn(pBlock, VERR_NO_MEMORY); - pBlock->enmType = VIDEORECBLOCKTYPE_AUDIO; - - PVIDEORECAUDIOFRAME pFrame = (PVIDEORECAUDIOFRAME)RTMemAlloc(sizeof(VIDEORECAUDIOFRAME)); + pBlock->enmType = RECORDINGBLOCKTYPE_AUDIO; + + PRECORDINGAUDIOFRAME pFrame = (PRECORDINGAUDIOFRAME)RTMemAlloc(sizeof(RECORDINGAUDIOFRAME)); AssertPtrReturn(pFrame, VERR_NO_MEMORY); @@ -489,5 +489,5 @@ pBlock->pvData = pFrame; - pBlock->cbData = sizeof(VIDEORECAUDIOFRAME) + cbData; + pBlock->cbData = sizeof(RECORDINGAUDIOFRAME) + cbData; pBlock->cRefs = (uint16_t)this->vecStreams.size(); /* All streams need the same audio data. */ pBlock->uTimeStampMs = uTimeStampMs; @@ -499,11 +499,11 @@ try { - VideoRecBlockMap::iterator itBlocks = this->mapBlocksCommon.find(uTimeStampMs); + RecordingBlockMap::iterator itBlocks = this->mapBlocksCommon.find(uTimeStampMs); if (itBlocks == this->mapBlocksCommon.end()) { - CaptureBlocks *pVideoRecBlocks = new CaptureBlocks(); - pVideoRecBlocks->List.push_back(pBlock); - - this->mapBlocksCommon.insert(std::make_pair(uTimeStampMs, pVideoRecBlocks)); + RecordingBlocks *pRecordingBlocks = new RecordingBlocks(); + pRecordingBlocks->List.push_back(pBlock); + + this->mapBlocksCommon.insert(std::make_pair(uTimeStampMs, pRecordingBlocks)); } else @@ -547,5 +547,5 @@ * @param uTimeStampMs Time stamp (in ms). */ -int CaptureContext::SendVideoFrame(uint32_t uScreen, uint32_t x, uint32_t y, +int RecordingContext::SendVideoFrame(uint32_t uScreen, uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine, uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, @@ -559,5 +559,5 @@ AssertRC(rc); - CaptureStream *pStream = GetStream(uScreen); + RecordingStream *pStream = GetStream(uScreen); if (!pStream) { Index: /trunk/src/VBox/Main/src-client/RecordingInternals.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/RecordingInternals.cpp (revision 75353) +++ /trunk/src/VBox/Main/src-client/RecordingInternals.cpp (revision 75354) @@ -27,5 +27,5 @@ * @param pFrame Audio frame to free. The pointer will be invalid after return. */ -void VideoRecAudioFrameFree(PVIDEORECAUDIOFRAME pFrame) +void RecordingAudioFrameFree(PRECORDINGAUDIOFRAME pFrame) { if (!pFrame) @@ -48,5 +48,5 @@ * @param pFrame Pointer to video frame to free. The pointer will be invalid after return. */ -void VideoRecVideoFrameFree(PVIDEORECVIDEOFRAME pFrame) +void RecordingVideoFrameFree(PRECORDINGVIDEOFRAME pFrame) { if (!pFrame) @@ -67,5 +67,5 @@ * @param pBlock Video recording (data) block to free. The pointer will be invalid after return. */ -void VideoRecBlockFree(PVIDEORECBLOCK pBlock) +void RECORDINGBLOCKFree(PRECORDINGBLOCK pBlock) { if (!pBlock) @@ -74,11 +74,11 @@ switch (pBlock->enmType) { - case VIDEORECBLOCKTYPE_VIDEO: - VideoRecVideoFrameFree((PVIDEORECVIDEOFRAME)pBlock->pvData); + case RECORDINGBLOCKTYPE_VIDEO: + RecordingVideoFrameFree((PRECORDINGVIDEOFRAME)pBlock->pvData); break; #ifdef VBOX_WITH_AUDIO_RECORDING - case VIDEORECBLOCKTYPE_AUDIO: - VideoRecAudioFrameFree((PVIDEORECAUDIOFRAME)pBlock->pvData); + case RECORDINGBLOCKTYPE_AUDIO: + RecordingAudioFrameFree((PRECORDINGAUDIOFRAME)pBlock->pvData); break; #endif Index: /trunk/src/VBox/Main/src-client/RecordingStream.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/RecordingStream.cpp (revision 75353) +++ /trunk/src/VBox/Main/src-client/RecordingStream.cpp (revision 75354) @@ -42,5 +42,5 @@ -CaptureStream::CaptureStream(CaptureContext *a_pCtx) +RecordingStream::RecordingStream(RecordingContext *a_pCtx) : pCtx(a_pCtx) , enmState(RECORDINGSTREAMSTATE_UNINITIALIZED) @@ -51,5 +51,5 @@ } -CaptureStream::CaptureStream(CaptureContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings) +RecordingStream::RecordingStream(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings) : enmState(RECORDINGSTREAMSTATE_UNINITIALIZED) , tsStartMs(0) @@ -63,5 +63,5 @@ } -CaptureStream::~CaptureStream(void) +RecordingStream::~RecordingStream(void) { int rc2 = uninitInternal(); @@ -74,5 +74,5 @@ * @returns IPRT status code. */ -int CaptureStream::open(const settings::RecordScreenSettings &Settings) +int RecordingStream::open(const settings::RecordScreenSettings &Settings) { /* Sanity. */ @@ -182,5 +182,5 @@ } -int CaptureStream::parseOptionsString(const com::Utf8Str &strOptions) +int RecordingStream::parseOptionsString(const com::Utf8Str &strOptions) { size_t pos = 0; @@ -255,5 +255,5 @@ } -const settings::RecordScreenSettings &CaptureStream::GetConfig(void) const +const settings::RecordScreenSettings &RecordingStream::GetConfig(void) const { return this->ScreenSettings; @@ -266,5 +266,5 @@ * @param tsNowMs Current time stamp (in ms). */ -bool CaptureStream::IsLimitReached(uint64_t tsNowMs) const +bool RecordingStream::IsLimitReached(uint64_t tsNowMs) const { if (!IsReady()) @@ -299,5 +299,5 @@ } -bool CaptureStream::IsReady(void) const +bool RecordingStream::IsReady(void) const { return this->fEnabled; @@ -312,5 +312,5 @@ * @param mapBlocksCommon Map of common block to process for this stream. */ -int CaptureStream::Process(VideoRecBlockMap &mapBlocksCommon) +int RecordingStream::Process(RecordingBlockMap &mapBlocksCommon) { lock(); @@ -324,9 +324,9 @@ int rc = VINF_SUCCESS; - VideoRecBlockMap::iterator itStreamBlocks = Blocks.Map.begin(); + RecordingBlockMap::iterator itStreamBlocks = Blocks.Map.begin(); while (itStreamBlocks != Blocks.Map.end()) { - const uint64_t uTimeStampMs = itStreamBlocks->first; - CaptureBlocks *pBlocks = itStreamBlocks->second; + const uint64_t uTimeStampMs = itStreamBlocks->first; + RecordingBlocks *pBlocks = itStreamBlocks->second; AssertPtr(pBlocks); @@ -334,17 +334,17 @@ while (!pBlocks->List.empty()) { - PVIDEORECBLOCK pBlock = pBlocks->List.front(); + PRECORDINGBLOCK pBlock = pBlocks->List.front(); AssertPtr(pBlock); #ifdef VBOX_WITH_LIBVPX - if (pBlock->enmType == VIDEORECBLOCKTYPE_VIDEO) - { - PVIDEORECVIDEOFRAME pVideoFrame = (PVIDEORECVIDEOFRAME)pBlock->pvData; - - rc = videoRecRGBToYUV(pVideoFrame->uPixelFormat, - /* Destination */ - this->Video.Codec.VPX.pu8YuvBuf, pVideoFrame->uWidth, pVideoFrame->uHeight, - /* Source */ - pVideoFrame->pu8RGBBuf, this->ScreenSettings.Video.ulWidth, this->ScreenSettings.Video.ulHeight); + if (pBlock->enmType == RECORDINGBLOCKTYPE_VIDEO) + { + PRECORDINGVIDEOFRAME pVideoFrame = (PRECORDINGVIDEOFRAME)pBlock->pvData; + + rc = recordingRGBToYUV(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)) { @@ -355,5 +355,5 @@ } #endif - VideoRecBlockFree(pBlock); + RecordingBlockFree(pBlock); pBlock = NULL; @@ -369,16 +369,16 @@ /* 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. */ - VideoRecBlockMap::iterator itCommonBlocks = mapBlocksCommon.begin(); + RecordingBlockMap::iterator itCommonBlocks = mapBlocksCommon.begin(); while (itCommonBlocks != mapBlocksCommon.end()) { - VideoRecBlockList::iterator itBlock = itCommonBlocks->second->List.begin(); + RECORDINGBLOCKList::iterator itBlock = itCommonBlocks->second->List.begin(); while (itBlock != itCommonBlocks->second->List.end()) { - PVIDEORECBLOCK pBlockCommon = (PVIDEORECBLOCK)(*itBlock); + PRECORDINGBLOCK pBlockCommon = (PRECORDINGBLOCK)(*itBlock); switch (pBlockCommon->enmType) { - case VIDEORECBLOCKTYPE_AUDIO: + case RECORDINGBLOCKTYPE_AUDIO: { - PVIDEORECAUDIOFRAME pAudioFrame = (PVIDEORECAUDIOFRAME)pBlockCommon->pvData; + PRECORDINGAUDIOFRAME pAudioFrame = (PRECORDINGAUDIOFRAME)pBlockCommon->pvData; AssertPtr(pAudioFrame); AssertPtr(pAudioFrame->pvBuf); @@ -404,5 +404,5 @@ if (pBlockCommon->cRefs == 0) { - VideoRecBlockFree(pBlockCommon); + RecordingBlockFree(pBlockCommon); itCommonBlocks->second->List.erase(itBlock); itBlock = itCommonBlocks->second->List.begin(); @@ -434,10 +434,10 @@ } -int CaptureStream::SendVideoFrame(uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine, +int RecordingStream::SendVideoFrame(uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBPP, uint32_t uBytesPerLine, uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, uint64_t uTimeStampMs) { lock(); - PVIDEORECVIDEOFRAME pFrame = NULL; + PRECORDINGVIDEOFRAME pFrame = NULL; int rc = VINF_SUCCESS; @@ -508,5 +508,5 @@ h = this->ScreenSettings.Video.ulHeight - destY; - pFrame = (PVIDEORECVIDEOFRAME)RTMemAllocZ(sizeof(VIDEORECVIDEOFRAME)); + pFrame = (PRECORDINGVIDEOFRAME)RTMemAllocZ(sizeof(RECORDINGVIDEOFRAME)); AssertBreakStmt(pFrame, rc = VERR_NO_MEMORY); @@ -518,11 +518,11 @@ { case 32: - pFrame->uPixelFormat = VIDEORECPIXELFMT_RGB32; + pFrame->uPixelFormat = RECORDINGPIXELFMT_RGB32; break; case 24: - pFrame->uPixelFormat = VIDEORECPIXELFMT_RGB24; + pFrame->uPixelFormat = RECORDINGPIXELFMT_RGB24; break; case 16: - pFrame->uPixelFormat = VIDEORECPIXELFMT_RGB565; + pFrame->uPixelFormat = RECORDINGPIXELFMT_RGB565; break; default: @@ -557,16 +557,16 @@ uint32_t offDst = (destY * this->ScreenSettings.Video.ulWidth + destX) * uBytesPerPixel; -#ifdef VBOX_VIDEOREC_DUMP - VIDEORECBMPHDR bmpHdr; +#ifdef VBOX_RECORDING_DUMP + RECORDINGBMPHDR bmpHdr; RT_ZERO(bmpHdr); - VIDEORECBMPDIBHDR bmpDIBHdr; + RECORDINGBMPDIBHDR bmpDIBHdr; RT_ZERO(bmpDIBHdr); bmpHdr.u16Magic = 0x4d42; /* Magic */ - bmpHdr.u32Size = (uint32_t)(sizeof(VIDEORECBMPHDR) + sizeof(VIDEORECBMPDIBHDR) + (w * h * uBytesPerPixel)); - bmpHdr.u32OffBits = (uint32_t)(sizeof(VIDEORECBMPHDR) + sizeof(VIDEORECBMPDIBHDR)); - - bmpDIBHdr.u32Size = sizeof(VIDEORECBMPDIBHDR); + bmpHdr.u32Size = (uint32_t)(sizeof(RECORDINGBMPHDR) + sizeof(RECORDINGBMPDIBHDR) + (w * h * uBytesPerPixel)); + bmpHdr.u32OffBits = (uint32_t)(sizeof(RECORDINGBMPHDR) + sizeof(RECORDINGBMPDIBHDR)); + + bmpDIBHdr.u32Size = sizeof(RECORDINGBMPDIBHDR); bmpDIBHdr.u32Width = w; bmpDIBHdr.u32Height = h; @@ -599,5 +599,5 @@ memcpy(pFrame->pu8RGBBuf + offDst, puSrcData + offSrc, w * uBytesPerPixel); -#ifdef VBOX_VIDEOREC_DUMP +#ifdef VBOX_RECORDING_DUMP if (RT_SUCCESS(rc2)) RTFileWrite(fh, pFrame->pu8RGBBuf + offDst, w * uBytesPerPixel, NULL); @@ -607,5 +607,5 @@ } -#ifdef VBOX_VIDEOREC_DUMP +#ifdef VBOX_RECORDING_DUMP if (RT_SUCCESS(rc2)) RTFileClose(fh); @@ -616,20 +616,20 @@ if (rc == VINF_SUCCESS) /* Note: Also could be VINF_TRY_AGAIN. */ { - PVIDEORECBLOCK pBlock = (PVIDEORECBLOCK)RTMemAlloc(sizeof(VIDEORECBLOCK)); + PRECORDINGBLOCK pBlock = (PRECORDINGBLOCK)RTMemAlloc(sizeof(RECORDINGBLOCK)); if (pBlock) { AssertPtr(pFrame); - pBlock->enmType = VIDEORECBLOCKTYPE_VIDEO; + pBlock->enmType = RECORDINGBLOCKTYPE_VIDEO; pBlock->pvData = pFrame; - pBlock->cbData = sizeof(VIDEORECVIDEOFRAME) + pFrame->cbRGBBuf; + pBlock->cbData = sizeof(RECORDINGVIDEOFRAME) + pFrame->cbRGBBuf; try { - CaptureBlocks *pVideoRecBlocks = new CaptureBlocks(); - pVideoRecBlocks->List.push_back(pBlock); + RecordingBlocks *pRECORDINGBLOCKs = new RecordingBlocks(); + pRECORDINGBLOCKs->List.push_back(pBlock); Assert(this->Blocks.Map.find(uTimeStampMs) == this->Blocks.Map.end()); - this->Blocks.Map.insert(std::make_pair(uTimeStampMs, pVideoRecBlocks)); + this->Blocks.Map.insert(std::make_pair(uTimeStampMs, pRECORDINGBLOCKs)); } catch (const std::exception &ex) @@ -646,5 +646,5 @@ if (RT_FAILURE(rc)) - VideoRecVideoFrameFree(pFrame); + RecordingVideoFrameFree(pFrame); unlock(); @@ -661,5 +661,5 @@ * @param Settings Capturing configuration to use for initialization. */ -int CaptureStream::Init(CaptureContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings) +int RecordingStream::Init(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings) { return initInternal(a_pCtx, uScreen, Settings); @@ -674,5 +674,5 @@ * @param Settings Capturing configuration to use for initialization. */ -int CaptureStream::initInternal(CaptureContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings) +int RecordingStream::initInternal(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings) { int rc = parseOptionsString(Settings.strOptions); @@ -806,5 +806,5 @@ * @returns IPRT status code. */ -int CaptureStream::close(void) +int RecordingStream::close(void) { int rc = VINF_SUCCESS; @@ -877,10 +877,10 @@ * @returns IPRT status code. */ -int CaptureStream::Uninit(void) +int RecordingStream::Uninit(void) { return uninitInternal(); } -int CaptureStream::uninitInternal(void) +int RecordingStream::uninitInternal(void) { if (this->enmState != RECORDINGSTREAMSTATE_INITIALIZED) @@ -911,5 +911,5 @@ * @returns IPRT status code. */ -int CaptureStream::unitVideo(void) +int RecordingStream::unitVideo(void) { #ifdef VBOX_WITH_LIBVPX @@ -927,7 +927,7 @@ * @returns IPRT status code. */ -int CaptureStream::uninitVideoVPX(void) -{ - PVIDEORECVIDEOCODEC pCodec = &this->Video.Codec; +int RecordingStream::uninitVideoVPX(void) +{ + PRECORDINGVIDEOCODEC pCodec = &this->Video.Codec; vpx_img_free(&pCodec->VPX.RawImage); pCodec->VPX.pu8YuvBuf = NULL; /* Was pointing to VPX.RawImage. */ @@ -945,5 +945,5 @@ * @returns IPRT status code. */ -int CaptureStream::initVideo(void) +int RecordingStream::initVideo(void) { /* Sanity. */ @@ -970,5 +970,5 @@ * @returns IPRT status code. */ -int CaptureStream::initVideoVPX(void) +int RecordingStream::initVideoVPX(void) { # ifdef VBOX_WITH_LIBVPX_VP9 @@ -978,5 +978,5 @@ # endif - PVIDEORECVIDEOCODEC pCodec = &this->Video.Codec; + PRECORDINGVIDEOCODEC pCodec = &this->Video.Codec; vpx_codec_err_t rcv = vpx_codec_enc_config_default(pCodecIface, &pCodec->VPX.Cfg, 0 /* Reserved */); @@ -1022,5 +1022,5 @@ #endif -int CaptureStream::initAudio(void) +int RecordingStream::initAudio(void) { #ifdef VBOX_WITH_AUDIO_RECORDING @@ -1045,5 +1045,5 @@ * @param pFrame Frame to encode and submit. */ -int CaptureStream::writeVideoVPX(uint64_t uTimeStampMs, PVIDEORECVIDEOFRAME pFrame) +int RecordingStream::writeVideoVPX(uint64_t uTimeStampMs, PRECORDINGVIDEOFRAME pFrame) { AssertPtrReturn(pFrame, VERR_INVALID_POINTER); @@ -1051,5 +1051,5 @@ int rc; - PVIDEORECVIDEOCODEC pCodec = &this->Video.Codec; + PRECORDINGVIDEOCODEC pCodec = &this->Video.Codec; /* Presentation Time Stamp (PTS). */ @@ -1103,5 +1103,5 @@ * Locks a recording stream. */ -void CaptureStream::lock(void) +void RecordingStream::lock(void) { int rc = RTCritSectEnter(&CritSect); @@ -1112,5 +1112,5 @@ * Unlocks a locked recording stream. */ -void CaptureStream::unlock(void) +void RecordingStream::unlock(void) { int rc = RTCritSectLeave(&CritSect); Index: /trunk/src/VBox/Main/src-client/RecordingUtils.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/RecordingUtils.cpp (revision 75353) +++ /trunk/src/VBox/Main/src-client/RecordingUtils.cpp (revision 75354) @@ -147,5 +147,5 @@ * @param uSrcHeight Height (Y, in pixels) of source buffer. */ -int videoRecRGBToYUV(uint32_t uPixelFormat, +int recordingRGBToYUV(uint32_t uPixelFormat, uint8_t *paDst, uint32_t uDstWidth, uint32_t uDstHeight, uint8_t *paSrc, uint32_t uSrcWidth, uint32_t uSrcHeight) @@ -153,15 +153,15 @@ switch (uPixelFormat) { - case VIDEORECPIXELFMT_RGB32: + case RECORDINGPIXELFMT_RGB32: if (!videoRecColorConvWriteYUV420p(paDst, uDstWidth, uDstHeight, paSrc, uSrcWidth, uSrcHeight)) return VERR_INVALID_PARAMETER; break; - case VIDEORECPIXELFMT_RGB24: + case RECORDINGPIXELFMT_RGB24: if (!videoRecColorConvWriteYUV420p(paDst, uDstWidth, uDstHeight, paSrc, uSrcWidth, uSrcHeight)) return VERR_INVALID_PARAMETER; break; - case VIDEORECPIXELFMT_RGB565: + case RECORDINGPIXELFMT_RGB565: if (!videoRecColorConvWriteYUV420p(paDst, uDstWidth, uDstHeight, paSrc, uSrcWidth, uSrcHeight))