RecordingInternals.h@ 106884

Last change on this file since 106884 was 106061, checked in by vboxsync, 3 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.8 KB

Line
1	/* $Id: RecordingInternals.h 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* Recording internals header.
4	*/
5
6	/*
7	* Copyright (C) 2012-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	#ifndef MAIN_INCLUDED_RecordingInternals_h
29	#define MAIN_INCLUDED_RecordingInternals_h
30	#ifndef RT_WITHOUT_PRAGMA_ONCE
31	# pragma once
32	#endif
33
34	#include <list>
35
36	#include <iprt/assert.h>
37	#include <iprt/types.h> /* drag in stdint.h before vpx does it. */
38
39	#include "VBox/com/string.h"
40	#include "VBox/com/VirtualBox.h"
41	#include "VBox/settings.h"
42	#include <VBox/vmm/pdmaudioifs.h>
43
44	#ifdef VBOX_WITH_LIBVPX
45	# define VPX_CODEC_DISABLE_COMPAT 1
46	# include "vpx/vp8cx.h"
47	# include "vpx/vpx_image.h"
48	# include "vpx/vpx_encoder.h"
49	#endif /* VBOX_WITH_LIBVPX */
50
51	#ifdef VBOX_WITH_LIBVORBIS
52	# include "vorbis/vorbisenc.h"
53	#endif
54
55
56	/*********************************************************************************************************************************
57	* Defines *
58	*********************************************************************************************************************************/
59	#define VBOX_RECORDING_VORBIS_HZ_MAX 48000 /*< Maximum sample rate (in Hz) Vorbis can handle. /
60	#define VBOX_RECORDING_VORBIS_FRAME_MS_DEFAULT 20 /*< Default Vorbis frame size (in ms). /
61
62
63	/*********************************************************************************************************************************
64	* Prototypes *
65	*********************************************************************************************************************************/
66	struct RECORDINGCODEC;
67	typedef RECORDINGCODEC *PRECORDINGCODEC;
68
69	struct RECORDINGFRAME;
70	typedef RECORDINGFRAME *PRECORDINGFRAME;
71
72
73	/*********************************************************************************************************************************
74	* Internal structures, defines and APIs *
75	*********************************************************************************************************************************/
76
77	/**
78	* Enumeration for supported pixel formats.
79	*/
80	enum RECORDINGPIXELFMT
81	{
82	/** Unknown pixel format. */
83	RECORDINGPIXELFMT_UNKNOWN = 0,
84	/** BRGA 32. */
85	RECORDINGPIXELFMT_BRGA32 = 1,
86	/** The usual 32-bit hack. */
87	RECORDINGPIXELFMT_32BIT_HACK = 0x7fffffff
88	};
89
90	/**
91	* Structure for keeping recording surface information.
92	*/
93	typedef struct RECORDINGSURFACEINFO
94	{
95	/** Width (in pixel). */
96	uint32_t uWidth;
97	/** Height (in pixel). */
98	uint32_t uHeight;
99	/** Bits per pixel. */
100	uint8_t uBPP;
101	/** Pixel format. */
102	RECORDINGPIXELFMT enmPixelFmt;
103	/** Bytes per scan line (stride).
104	* Note: Does not necessarily match \a uWidth * (\a uBPP / 8). */
105	uint32_t uBytesPerLine;
106	} RECORDINGSURFACEINFO;
107	/** Pointer to recording surface information. */
108	typedef RECORDINGSURFACEINFO *PRECORDINGSURFACEINFO;
109
110	/**
111	* Structure for keeping recording relative or absolute position information.
112	*/
113	typedef struct RECORDINGPOS
114	{
115	uint32_t x;
116	uint32_t y;
117	} RECORDINGPOS;
118	/** Pointer to a RECORDINGRECT. */
119	typedef RECORDINGPOS *PRECORDINGPOS;
120
121	/** No flags set. */
122	#define RECORDINGVIDEOFRAME_F_NONE UINT32_C(0)
123	/** Frame is visible. */
124	#define RECORDINGVIDEOFRAME_F_VISIBLE RT_BIT(0)
125	/** Use blitting with alpha blending. */
126	#define RECORDINGVIDEOFRAME_F_BLIT_ALPHA RT_BIT(1)
127	/** Validation mask. */
128	#define RECORDINGVIDEOFRAME_F_VALID_MASK 0x3
129
130	/**
131	* Structure for keeping a single recording video frame.
132	*/
133	typedef struct RECORDINGVIDEOFRAME
134	{
135	/** Surface information of this frame. */
136	RECORDINGSURFACEINFO Info;
137	/** Pixel data buffer. */
138	uint8_t *pau8Buf;
139	/** Size (in bytes) of \a pau8Buf. */
140	size_t cbBuf;
141	/** X / Y positioning hint (in pixel) of this frame.
142	* Note: This does not mean offset within \a pau8Buf! */
143	RECORDINGPOS Pos;
144	/** Recording video frame flags of type RECORDINGVIDEOFRAME_F_XXX. */
145	uint32_t fFlags;
146	} RECORDINGVIDEOFRAME;
147	/** Pointer to a video recording frame. */
148	typedef RECORDINGVIDEOFRAME *PRECORDINGVIDEOFRAME;
149
150	/**
151	* Enumeration for supported scaling methods.
152	*/
153	enum RECORDINGSCALINGMETHOD
154	{
155	/** No scaling applied.
156	* Bigger frame buffers will be cropped (centered),
157	* smaller frame buffers will be centered. */
158	RECORDINGSCALINGMETHOD_NONE = 0,
159	/** The usual 32-bit hack. */
160	RECORDINGSCALINGMETHOD_32BIT_HACK = 0x7fffffff
161	};
162
163	/**
164	* Structure for keeping recording scaling information.
165	*/
166	typedef struct RECORDINGSCALINGINFO
167	{
168	/** The scaling method to use. */
169	RECORDINGSCALINGMETHOD enmMethod;
170	/** Union based on \a enmMethod. */
171	union
172	{
173	/** Cropping information. */
174	struct
175	{
176	/** X origin.
177	* If negative, the frame buffer will be cropped with centering applied,
178	* if positive, the frame buffer will be centered. */
179	int32_t m_iOriginX;
180	/** Y origin. *
181	* If negative, the frame buffer will be cropped with centering applied,
182	* if positive, the frame buffer will be centered. */
183	int32_t m_iOriginY;
184	} Crop;
185	} u;
186	} RECORDINGSCALINGINFO;
187	/** Pointer to a recording scaling information. */
188	typedef RECORDINGSCALINGINFO *PRECORDINGSCALINGINFO;
189
190	/**
191	* Enumeration for specifying a (generic) codec type.
192	*/
193	typedef enum RECORDINGCODECTYPE
194	{
195	/** Invalid codec type. Do not use. */
196	RECORDINGCODECTYPE_INVALID = 0,
197	/** Video codec. */
198	RECORDINGCODECTYPE_VIDEO,
199	/** Audio codec. */
200	RECORDINGCODECTYPE_AUDIO
201	} RECORDINGCODECTYPE;
202
203	/**
204	* Structure for keeping a codec operations table.
205	*/
206	typedef struct RECORDINGCODECOPS
207	{
208	/**
209	* Initializes a codec.
210	*
211	* @returns VBox status code.
212	* @param pCodec Codec instance to initialize.
213	*/
214	DECLCALLBACKMEMBER(int, pfnInit, (PRECORDINGCODEC pCodec));
215
216	/**
217	* Destroys a codec.
218	*
219	* @returns VBox status code.
220	* @param pCodec Codec instance to destroy.
221	*/
222	DECLCALLBACKMEMBER(int, pfnDestroy, (PRECORDINGCODEC pCodec));
223
224	/**
225	* Parses an options string to configure advanced / hidden / experimental features of a recording stream.
226	* Unknown values will be skipped. Optional.
227	*
228	* @returns VBox status code.
229	* @param pCodec Codec instance to parse options for.
230	* @param strOptions Options string to parse.
231	*/
232	DECLCALLBACKMEMBER(int, pfnParseOptions, (PRECORDINGCODEC pCodec, const com::Utf8Str &strOptions));
233
234	/**
235	* Feeds the codec encoder with data to encode.
236	*
237	* @returns VBox status code.
238	* @param pCodec Codec instance to use.
239	* @param pFrame Pointer to frame data to encode. Optional and can be NULL.
240	* @param msTimestamp Timestamp (PTS) of frame to encode.
241	* @param pvUser User data pointer. Optional and can be NULL.
242	*/
243	DECLCALLBACKMEMBER(int, pfnEncode, (PRECORDINGCODEC pCodec, const PRECORDINGFRAME pFrame, uint64_t msTimestamp, void *pvUser));
244
245	/**
246	* Tells the codec about a screen change. Optional.
247	*
248	* @returns VBox status code.
249	* @param pCodec Codec instance to use.
250	* @param pInfo Screen information to send.
251	*/
252	DECLCALLBACKMEMBER(int, pfnScreenChange, (PRECORDINGCODEC pCodec, PRECORDINGSURFACEINFO pInfo));
253
254	/**
255	* Tells the codec to finalize the current stream. Optional.
256	*
257	* @returns VBox status code.
258	* @param pCodec Codec instance to finalize stream for.
259	*/
260	DECLCALLBACKMEMBER(int, pfnFinalize, (PRECORDINGCODEC pCodec));
261	} RECORDINGCODECOPS, *PRECORDINGCODECOPS;
262
263	/** No encoding flags set. */
264	#define RECORDINGCODEC_ENC_F_NONE UINT32_C(0)
265	/** Data block is a key block. */
266	#define RECORDINGCODEC_ENC_F_BLOCK_IS_KEY RT_BIT_32(0)
267	/** Data block is invisible. */
268	#define RECORDINGCODEC_ENC_F_BLOCK_IS_INVISIBLE RT_BIT_32(1)
269	/** Encoding flags valid mask. */
270	#define RECORDINGCODEC_ENC_F_VALID_MASK 0x3
271
272	/**
273	* Structure for keeping a codec callback table.
274	*/
275	typedef struct RECORDINGCODECCALLBACKS
276	{
277	/**
278	* Callback for notifying that encoded data has been written.
279	*
280	* @returns VBox status code.
281	* @param pCodec Pointer to codec instance which has written the data.
282	* @param pvData Pointer to written data (encoded).
283	* @param cbData Size (in bytes) of \a pvData.
284	* @param msAbsPTS Absolute PTS (in ms) of the written data.
285	* @param uFlags Encoding flags of type RECORDINGCODEC_ENC_F_XXX.
286	* @param pvUser User-supplied pointer.
287	*/
288	DECLCALLBACKMEMBER(int, pfnWriteData, (PRECORDINGCODEC pCodec, const void pvData, size_t cbData, uint64_t msAbsPTS, uint32_t uFlags, void pvUser));
289	/** User-supplied data pointer. */
290	void *pvUser;
291	} RECORDINGCODECCALLBACKS, *PRECORDINGCODECCALLBACKS;
292
293	/**
294	* Structure for keeping generic codec parameters.
295	*/
296	typedef struct RECORDINGCODECPARMS
297	{
298	/** The generic codec type. */
299	RECORDINGCODECTYPE enmType;
300	/** The specific codec type, based on \a enmType. */
301	union
302	{
303	/** The container's video codec to use. */
304	RecordingVideoCodec_T enmVideoCodec;
305	/** The container's audio codec to use. */
306	RecordingAudioCodec_T enmAudioCodec;
307	};
308	union
309	{
310	struct
311	{
312	/** Frames per second. */
313	uint8_t uFPS;
314	/** Target width (in pixels) of encoded video image. */
315	uint32_t uWidth;
316	/** Target height (in pixels) of encoded video image. */
317	uint32_t uHeight;
318	/** Minimal delay (in ms) between two video frames.
319	* This value is based on the configured FPS rate. */
320	uint32_t uDelayMs;
321	/** Scaling information. */
322	RECORDINGSCALINGINFO Scaling;
323	} Video;
324	struct
325	{
326	/** The codec's used PCM properties. */
327	PDMAUDIOPCMPROPS PCMProps;
328	} Audio;
329	} u;
330	/** Desired (average) bitrate (in kbps) to use, for codecs which support bitrate management.
331	* Set to 0 to use a variable bit rate (VBR) (if available, otherwise fall back to CBR). */
332	uint32_t uBitrate;
333	/** Time (in ms) the encoder expects us to send data to encode.
334	*
335	* For Vorbis, valid frame sizes are powers of two from 64 to 8192 bytes.
336	*/
337	uint32_t msFrame;
338	/** The frame size in bytes (based on \a msFrame). */
339	uint32_t cbFrame;
340	/** The frame size in samples per frame (based on \a msFrame). */
341	uint32_t csFrame;
342	} RECORDINGCODECPARMS, *PRECORDINGCODECPARMS;
343
344	#ifdef VBOX_WITH_LIBVPX
345	/**
346	* VPX encoder state (needs libvpx).
347	*/
348	typedef struct RECORDINGCODECVPX
349	{
350	/** VPX codec context. */
351	vpx_codec_ctx_t Ctx;
352	/** VPX codec configuration. */
353	vpx_codec_enc_cfg_t Cfg;
354	/** VPX image context. */
355	vpx_image_t RawImage;
356	/** Pointer to the codec's internal YUV buffer.
357	* VP8 works exclusively with an 8-bit YUV 4:2:0 image, so frame packed, where U and V are half resolution images. */
358	uint8_t *pu8YuvBuf;
359	/** The encoder's deadline (in ms).
360	* The more time the encoder is allowed to spend encoding, the better the encoded
361	* result, in exchange for higher CPU usage and time spent encoding. */
362	unsigned int uEncoderDeadline;
363	/** Front buffer which is going to be encoded.
364	* Matches Main's framebuffer pixel format for faster / easier conversion.
365	* Not necessarily the same size as the encoder buffer. In such a case a scaling / cropping
366	* operation has to be performed first. */
367	RECORDINGVIDEOFRAME Front;
368	/** Back buffer which holds the framebuffer data before we blit anything to it.
369	* Needed for mouse cursor handling, if the mouse cursor is not actually part of the framebuffer data.
370	* Always matches the front buffer (\a Front) in terms of size. */
371	RECORDINGVIDEOFRAME Back;
372	/** The current cursor shape to use.
373	* Set to NULL if not used (yet). */
374	PRECORDINGVIDEOFRAME pCursorShape;
375	/** Old cursor position since last cursor position message. */
376	RECORDINGPOS PosCursorOld;
377
378	} RECORDINGCODECVPX;
379	/** Pointer to a VPX encoder state. */
380	typedef RECORDINGCODECVPX *PRECORDINGCODECVPX;
381	#endif /* VBOX_WITH_LIBVPX */
382
383	#ifdef VBOX_WITH_LIBVORBIS
384	/**
385	* Vorbis encoder state (needs libvorbis + libogg).
386	*/
387	typedef struct RECORDINGCODECVORBIS
388	{
389	/** Basic information about the audio in a Vorbis bitstream. */
390	vorbis_info info;
391	/** Encoder state. */
392	vorbis_dsp_state dsp_state;
393	/** Current block being worked on. */
394	vorbis_block block_cur;
395	} RECORDINGCODECVORBIS;
396	/** Pointer to a Vorbis encoder state. */
397	typedef RECORDINGCODECVORBIS *PRECORDINGCODECVORBIS;
398	#endif /* VBOX_WITH_LIBVORBIS */
399
400	/**
401	* Structure for keeping a codec's internal state.
402	*/
403	typedef struct RECORDINGCODECSTATE
404	{
405	/** Timestamp Timestamp (PTS, in ms) of the last frame was encoded. */
406	uint64_t tsLastWrittenMs;
407	/** Number of encoding errors. */
408	uint64_t cEncErrors;
409	} RECORDINGCODECSTATE;
410	/** Pointer to an internal encoder state. */
411	typedef RECORDINGCODECSTATE *PRECORDINGCODECSTATE;
412
413	/**
414	* Structure for keeping codec-specific data.
415	*/
416	typedef struct RECORDINGCODEC
417	{
418	/** Callback table for codec operations. */
419	RECORDINGCODECOPS Ops;
420	/** Table for user-supplied callbacks. */
421	RECORDINGCODECCALLBACKS Callbacks;
422	/** Generic codec parameters. */
423	RECORDINGCODECPARMS Parms;
424	/** Generic codec parameters. */
425	RECORDINGCODECSTATE State;
426	/** Crtitical section. */
427	RTCRITSECT CritSect;
428
429	#ifdef VBOX_WITH_LIBVPX
430	union
431	{
432	RECORDINGCODECVPX VPX;
433	} Video;
434	#endif
435
436	#ifdef VBOX_WITH_AUDIO_RECORDING
437	union
438	{
439	# ifdef VBOX_WITH_LIBVORBIS
440	RECORDINGCODECVORBIS Vorbis;
441	# endif /* VBOX_WITH_LIBVORBIS */
442	} Audio;
443	#endif /* VBOX_WITH_AUDIO_RECORDING */
444
445	/** Internal scratch buffer for en-/decoding steps.
446	* Might be NULL if not being used. */
447	void *pvScratch;
448	/** Size (in bytes) of \a pvScratch. */
449	uint32_t cbScratch;
450	} RECORDINGCODEC, *PRECORDINGCODEC;
451
452	/**
453	* Enumeration for a recording frame type.
454	*/
455	enum RECORDINGFRAME_TYPE
456	{
457	/** Invalid frame type; do not use. */
458	RECORDINGFRAME_TYPE_INVALID = 0,
459	/** Frame is an audio frame. */
460	RECORDINGFRAME_TYPE_AUDIO = 1,
461	/** Frame is an video frame. */
462	RECORDINGFRAME_TYPE_VIDEO = 2,
463	/** Frame is a cursor shape frame.
464	* Send when a (mouse) cursor shape has changed. */
465	RECORDINGFRAME_TYPE_CURSOR_SHAPE = 3,
466	/** Frame is a cursor position change request.
467	* Sent when a (mouse) cursor position has changed. */
468	RECORDINGFRAME_TYPE_CURSOR_POS = 4,
469	/** Screen change information.
470	* Sent when the screen properties (resolution, BPP, ...) have changed. */
471	RECORDINGFRAME_TYPE_SCREEN_CHANGE = 5
472	};
473
474	/**
475	* Structure for keeping a single recording audio frame.
476	*/
477	typedef struct RECORDINGAUDIOFRAME
478	{
479	/** Pointer to audio data. */
480	uint8_t *pvBuf;
481	/** Size (in bytes) of audio data. */
482	size_t cbBuf;
483	} RECORDINGAUDIOFRAME, *PRECORDINGAUDIOFRAME;
484
485	/**
486	* Structure for keeping cursor information.
487	*/
488	typedef struct RECORDINGCURSORINFO
489	{
490	/** Cursor ID. Currently always 0. */
491	uint8_t Id;
492	/** Current position. */
493	RECORDINGPOS Pos;
494	} RECORDINGCURSORINFO;
495	/** Pointer to a RECORDINGCURSORINFO. */
496	typedef RECORDINGCURSORINFO *PRECORDINGCURSORINFO;
497
498	/**
499	* Structure for keeping a single recording frame.
500	*/
501	typedef struct RECORDINGFRAME
502	{
503	/** List node. */
504	RTLISTNODE Node;
505	/** Stream index (hint) where this frame should go to.
506	* Specify UINT16_MAX to broadcast to all streams. */
507	uint16_t idStream;
508	/** The frame type. */
509	RECORDINGFRAME_TYPE enmType;
510	/** Timestamp (PTS, in ms). */
511	uint64_t msTimestamp;
512	/** Union holding different frame types depending on \a enmType. */
513	union
514	{
515	#ifdef VBOX_WITH_AUDIO_RECORDING
516	/** Audio data.
517	* Used by RECORDINGFRAME_TYPE_AUDIO. */
518	RECORDINGAUDIOFRAME Audio;
519	#endif
520	/** A (weak) pointer to a video frame. */
521	RECORDINGVIDEOFRAME Video;
522	/** Recording screen information. */
523	RECORDINGSURFACEINFO ScreenInfo;
524	/** Cursor shape frame.
525	* Used by RECORDINGFRAME_TYPE_CURSOR_SHAPE. */
526	RECORDINGVIDEOFRAME CursorShape;
527	/** Cursor information.
528	* Used by RECORDINGFRAME_TYPE_CURSOR_POS. */
529	RECORDINGCURSORINFO Cursor;
530	} u;
531	} RECORDINGFRAME;
532	/** Pointer to a RECORDINGFRAME. */
533	typedef RECORDINGFRAME *PRECORDINGFRAME;
534
535	PRECORDINGVIDEOFRAME RecordingVideoFrameAlloc(void);
536	PRECORDINGVIDEOFRAME RecordingVideoFrameAllocEx(const void *pvData, uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint8_t uBPP, RECORDINGPIXELFMT enmFmt);
537	void RecordingVideoFrameFree(PRECORDINGVIDEOFRAME pFrame);
538	int RecordingVideoFrameInit(PRECORDINGVIDEOFRAME pFrame, uint32_t fFlags, uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint8_t uBPP, RECORDINGPIXELFMT enmFmt);
539	void RecordingVideoFrameDestroy(PRECORDINGVIDEOFRAME pFrame);
540	PRECORDINGVIDEOFRAME RecordingVideoFrameDup(PRECORDINGVIDEOFRAME pFrame);
541	void RecordingVideoFrameClear(PRECORDINGVIDEOFRAME pFrame);
542	int RecordingVideoFrameBlitRawAlpha(PRECORDINGVIDEOFRAME pDstFrame, uint32_t uDstX, uint32_t uDstY, const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight, uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmFmt);
543	int RecordingVideoBlitRaw(uint8_t pu8Dst, size_t cbDst, uint32_t uDstX, uint32_t uDstY, uint32_t uDstBytesPerLine, uint8_t uDstBPP, RECORDINGPIXELFMT enmDstFmt, const uint8_t pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight, uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmSrcFmt);
544	int RecordingVideoFrameBlitRaw(PRECORDINGVIDEOFRAME pDstFrame, uint32_t uDstX, uint32_t uDstY, const uint8_t *pu8Src, size_t cbSrc, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight, uint32_t uSrcBytesPerLine, uint8_t uSrcBPP, RECORDINGPIXELFMT enmFmt);
545	int RecordingVideoFrameBlitFrame(PRECORDINGVIDEOFRAME pDstFrame, uint32_t uDstX, uint32_t uDstY, PRECORDINGVIDEOFRAME pSrcFrame, uint32_t uSrcX, uint32_t uSrcY, uint32_t uSrcWidth, uint32_t uSrcHeight);
546
547	#ifdef VBOX_WITH_AUDIO_RECORDING
548	void RecordingAudioFrameFree(PRECORDINGAUDIOFRAME pFrame);
549	#endif
550
551	void RecordingFrameFree(PRECORDINGFRAME pFrame);
552
553	/**
554	* Generic structure for keeping a single video recording (data) block.
555	*/
556	struct RecordingBlock
557	{
558	RecordingBlock()
559	: cRefs(0)
560	, uFlags(RECORDINGCODEC_ENC_F_NONE)
561	, pvData(NULL)
562	, cbData(0) { }
563
564	virtual ~RecordingBlock()
565	{
566	Destroy();
567	}
568
569	void Destroy(void)
570	{
571	PRECORDINGFRAME pFrame = (PRECORDINGFRAME)pvData;
572	if (!pFrame)
573	return;
574
575	RecordingFrameFree(pFrame);
576
577	cRefs = 0;
578	pvData = NULL;
579	cbData = 0;
580	}
581
582	/** Number of references held of this block. */
583	uint16_t cRefs;
584	/** Block flags of type RECORDINGCODEC_ENC_F_XXX. */
585	uint64_t uFlags;
586	/** The (absolute) timestamp (in ms, PTS) of this block. */
587	uint64_t msTimestamp;
588	/** Opaque data block to the actual block data. Currently only used with PRECORDINGFRAME. */
589	void *pvData;
590	/** Size (in bytes) of the (opaque) data block. */
591	size_t cbData;
592	};
593
594	/** List for keeping video recording (data) blocks. */
595	typedef std::list<RecordingBlock *> RecordingBlockList;
596
597	int recordingCodecCreateAudio(PRECORDINGCODEC pCodec, RecordingAudioCodec_T enmAudioCodec);
598	int recordingCodecCreateVideo(PRECORDINGCODEC pCodec, RecordingVideoCodec_T enmVideoCodec);
599	int recordingCodecInit(const PRECORDINGCODEC pCodec, const PRECORDINGCODECCALLBACKS pCallbacks, const settings::RecordingScreen &Settings);
600	int recordingCodecDestroy(PRECORDINGCODEC pCodec);
601	int recordingCodecEncodeFrame(PRECORDINGCODEC pCodec, const PRECORDINGFRAME pFrame, uint64_t msTimestamp, void *pvUser);
602	int recordingCodecEncodeCurrent(PRECORDINGCODEC pCodec, uint64_t msTimestamp);
603	int recordingCodecScreenChange(PRECORDINGCODEC pCodec, PRECORDINGSURFACEINFO pInfo);
604	int recordingCodecFinalize(PRECORDINGCODEC pCodec);
605	bool recordingCodecIsInitialized(const PRECORDINGCODEC pCodec);
606	uint32_t recordingCodecGetWritable(const PRECORDINGCODEC pCodec, uint64_t msTimestamp);
607	#endif /* !MAIN_INCLUDED_RecordingInternals_h */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/include/RecordingInternals.h@ 106884

Download in other formats: