FFmpegFB.cpp@ 24364

Last change on this file since 24364 was 22176, checked in by vboxsync, 15 years ago
Main: fix burns with ffmpeg enabled
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.2 KB

Line
1	/** @file
2	*
3	* Framebuffer implementation that interfaces with FFmpeg
4	* to create a video of the guest.
5	*/
6
7	/*
8	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*
18	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
19	* Clara, CA 95054 USA or visit http://www.sun.com if you need
20	* additional information or have any questions.
21	*/
22
23	#define LOG_GROUP LOG_GROUP_GUI
24
25	#include "FFmpegFB.h"
26
27	#include <iprt/file.h>
28	#include <iprt/param.h>
29	#include <iprt/assert.h>
30	#include <VBox/log.h>
31	#include <png.h>
32	#include <iprt/stream.h>
33
34	#define VBOX_SHOW_AVAILABLE_FORMATS
35
36	// external constructor for dynamic loading
37	/////////////////////////////////////////////////////////////////////////////
38
39	/**
40	* Callback function to register an ffmpeg framebuffer.
41	*
42	* @returns COM status code.
43	* @param width Framebuffer width.
44	* @param height Framebuffer height.
45	* @param bitrate Bitrate of mpeg file to be created.
46	* @param filename Name of mpeg file to be created
47	* @retval retVal The new framebuffer
48	*/
49	extern "C" DECLEXPORT(HRESULT) VBoxRegisterFFmpegFB(ULONG width,
50	ULONG height, ULONG bitrate,
51	com::Bstr filename,
52	IFramebuffer **retVal)
53	{
54	Log2(("VBoxRegisterFFmpegFB: called\n"));
55	FFmpegFB *pFramebuffer = new FFmpegFB(width, height, bitrate, filename);
56	int rc = pFramebuffer->init();
57	AssertMsg(rc == S_OK,
58	("failed to initialise the FFmpeg framebuffer, rc = %d\n",
59	rc));
60	if (rc == S_OK)
61	{
62	*retVal = pFramebuffer;
63	return S_OK;
64	}
65	delete pFramebuffer;
66	return rc;
67	}
68
69
70
71
72
73	// constructor / destructor
74	/////////////////////////////////////////////////////////////////////////////
75
76	/**
77	* Perform parts of initialisation which are guaranteed not to fail
78	* unless we run out of memory. In this case, we just set the guest
79	* buffer to 0 so that RequestResize() does not free it the first time
80	* it is called.
81	*/
82	FFmpegFB::FFmpegFB(ULONG width, ULONG height, ULONG bitrate,
83	com::Bstr filename) :
84	mfUrlOpen(false),
85	mBitRate(bitrate),
86	mPixelFormat(FramebufferPixelFormat_Opaque),
87	mBitsPerPixel(0),
88	mFileName(filename),
89	mBytesPerLine(0),
90	mFrameWidth(width), mFrameHeight(height),
91	mYUVFrameSize(width * height * 3 / 2),
92	mRGBBuffer(0), mpFormatContext(0), mpStream(0),
93	mOutOfMemory(false), mToggle(false)
94	{
95	ULONG cPixels = width * height;
96
97	LogFlow(("Creating FFmpegFB object %p, width=%lu, height=%lu\n",
98	this, (unsigned long) width, (unsigned long) height));
99	Assert(width % 2 == 0 && height % 2 == 0);
100	/* For temporary RGB frame we allocate enough memory to deal with
101	RGB16 to RGB32 */
102	mTempRGBBuffer = reinterpret_cast<uint8_t >(av_malloc(cPixels 4));
103	if (mTempRGBBuffer == 0)
104	goto nomem_temp_rgb_buffer;
105	mYUVBuffer = reinterpret_cast<uint8_t *>(av_malloc(mYUVFrameSize));
106	if (mYUVBuffer == 0)
107	goto nomem_yuv_buffer;
108	mFrame = avcodec_alloc_frame();
109	if (mFrame == 0)
110	goto nomem_mframe;
111	mOutBuf = reinterpret_cast<uint8_t >(av_malloc(mYUVFrameSize 2));
112	if (mOutBuf == 0)
113	goto nomem_moutbuf;
114
115	return;
116
117	/* C-based memory allocation and how to deal with it in C++ :) */
118	nomem_moutbuf:
119	Log(("Failed to allocate memory for mOutBuf\n"));
120	av_free(mFrame);
121	nomem_mframe:
122	Log(("Failed to allocate memory for mFrame\n"));
123	av_free(mYUVBuffer);
124	nomem_yuv_buffer:
125	Log(("Failed to allocate memory for mYUVBuffer\n"));
126	av_free(mTempRGBBuffer);
127	nomem_temp_rgb_buffer:
128	Log(("Failed to allocate memory for mTempRGBBuffer\n"));
129	mOutOfMemory = true;
130	}
131
132
133	/**
134	* Write the last frame to disk and free allocated memory
135	*/
136	FFmpegFB::~FFmpegFB()
137	{
138	LogFlow(("Destroying FFmpegFB object %p\n", this));
139	if (mpFormatContext != 0)
140	{
141	if (mfUrlOpen)
142	{
143	/* Dummy update to make sure we get all the frame (timing). */
144	NotifyUpdate(0, 0, 0, 0);
145	/* Write the last pending frame before exiting */
146	int rc = do_rgb_to_yuv_conversion();
147	if (rc == S_OK)
148	do_encoding_and_write();
149	#if 1
150	/* Add another 10 seconds. */
151	for (int i = 10*25; i > 0; i--)
152	do_encoding_and_write();
153	#endif
154	/* write a png file of the last frame */
155	write_png();
156	avcodec_close(mpStream->codec);
157	av_write_trailer(mpFormatContext);
158	/* free the streams */
159	for(unsigned i = 0; i < (unsigned)mpFormatContext->nb_streams; i++) {
160	av_freep(&mpFormatContext->streams[i]->codec);
161	av_freep(&mpFormatContext->streams[i]);
162	}
163	/* Changed sometime between 50.5.0 and 52.7.0 */
164	#if LIBAVFORMAT_VERSION_INT >= (52 << 16)
165	url_fclose(mpFormatContext->pb);
166	#else /* older version */
167	url_fclose(&mpFormatContext->pb);
168	#endif /* older version */
169	}
170	av_free(mpFormatContext);
171	}
172	RTCritSectDelete(&mCritSect);
173	/* We have already freed the stream above */
174	mpStream = 0;
175	if (mTempRGBBuffer != 0)
176	av_free(mTempRGBBuffer);
177	if (mYUVBuffer != 0)
178	av_free(mYUVBuffer);
179	if (mFrame != 0)
180	av_free(mFrame);
181	if (mOutBuf != 0)
182	av_free(mOutBuf);
183	if (mRGBBuffer != 0)
184	RTMemFree(mRGBBuffer);
185	}
186
187	// public methods only for internal purposes
188	/////////////////////////////////////////////////////////////////////////////
189
190	/**
191	* Perform any parts of the initialisation which could potentially fail
192	* for reasons other than "out of memory".
193	*
194	* @returns COM status code
195	* @param width width to be used for MPEG frame framebuffer and initially
196	* for the guest frame buffer - must be a multiple of two
197	* @param height height to be used for MPEG frame framebuffer and
198	* initially for the guest framebuffer - must be a multiple
199	* of two
200	* @param depth depth to be used initially for the guest framebuffer
201	*/
202	HRESULT FFmpegFB::init()
203	{
204	LogFlow(("Initialising FFmpegFB object %p\n", this));
205	if (mOutOfMemory == true)
206	return E_OUTOFMEMORY;
207	int rc = RTCritSectInit(&mCritSect);
208	AssertReturn(rc == VINF_SUCCESS, E_UNEXPECTED);
209	int rcSetupLibrary = setup_library();
210	AssertReturn(rcSetupLibrary == S_OK, rcSetupLibrary);
211	int rcSetupFormat = setup_output_format();
212	AssertReturn(rcSetupFormat == S_OK, rcSetupFormat);
213	int rcOpenCodec = open_codec();
214	AssertReturn(rcOpenCodec == S_OK, rcOpenCodec);
215	int rcOpenFile = open_output_file();
216	AssertReturn(rcOpenFile == S_OK, rcOpenFile);
217	/* Fill in the picture data for the AVFrame - not particularly
218	elegant, but that is the API. */
219	avpicture_fill((AVPicture *) mFrame, mYUVBuffer, PIX_FMT_YUV420P,
220	mFrameWidth, mFrameHeight);
221	/* Set the initial framebuffer size to the mpeg frame dimensions */
222	BOOL finished;
223	RequestResize(0, FramebufferPixelFormat_Opaque, NULL, 0, 0,
224	mFrameWidth, mFrameHeight, &finished);
225	/* Start counting time */
226	mLastTime = RTTimeMilliTS();
227	mLastTime = mLastTime - mLastTime % 40;
228	return rc;
229	}
230
231	// IFramebuffer properties
232	/////////////////////////////////////////////////////////////////////////////
233
234	/**
235	* Return the address of the frame buffer for the virtual VGA device to
236	* write to. If COMGETTER(UsesGuestVRAM) returns FLASE (or if this address
237	* is not the same as the guests VRAM buffer), the device will perform
238	* translation.
239	*
240	* @returns COM status code
241	* @retval address The address of the buffer
242	*/
243	STDMETHODIMP FFmpegFB::COMGETTER(Address) (BYTE **address)
244	{
245	if (!address)
246	return E_POINTER;
247	LogFlow(("FFmpeg::COMGETTER(Address): returning address %p\n", mBufferAddress));
248	*address = mBufferAddress;
249	return S_OK;
250	}
251
252	/**
253	* Return the width of our frame buffer.
254	*
255	* @returns COM status code
256	* @retval width The width of the frame buffer
257	*/
258	STDMETHODIMP FFmpegFB::COMGETTER(Width) (ULONG *width)
259	{
260	if (!width)
261	return E_POINTER;
262	LogFlow(("FFmpeg::COMGETTER(Width): returning width %lu\n",
263	(unsigned long) mGuestWidth));
264	*width = mGuestWidth;
265	return S_OK;
266	}
267
268	/**
269	* Return the height of our frame buffer.
270	*
271	* @returns COM status code
272	* @retval height The height of the frame buffer
273	*/
274	STDMETHODIMP FFmpegFB::COMGETTER(Height) (ULONG *height)
275	{
276	if (!height)
277	return E_POINTER;
278	LogFlow(("FFmpeg::COMGETTER(Height): returning height %lu\n",
279	(unsigned long) mGuestHeight));
280	*height = mGuestHeight;
281	return S_OK;
282	}
283
284	/**
285	* Return the colour depth of our frame buffer. Note that we actually
286	* store the pixel format, not the colour depth internally, since
287	* when display sets FramebufferPixelFormat_Opaque, it
288	* wants to retreive FramebufferPixelFormat_Opaque and
289	* nothing else.
290	*
291	* @returns COM status code
292	* @retval bitsPerPixel The colour depth of the frame buffer
293	*/
294	STDMETHODIMP FFmpegFB::COMGETTER(BitsPerPixel) (ULONG *bitsPerPixel)
295	{
296	if (!bitsPerPixel)
297	return E_POINTER;
298	*bitsPerPixel = mBitsPerPixel;
299	LogFlow(("FFmpeg::COMGETTER(BitsPerPixel): returning depth %lu\n",
300	(unsigned long) *bitsPerPixel));
301	return S_OK;
302	}
303
304	/**
305	* Return the number of bytes per line in our frame buffer.
306	*
307	* @returns COM status code
308	* @retval bytesPerLine The number of bytes per line
309	*/
310	STDMETHODIMP FFmpegFB::COMGETTER(BytesPerLine) (ULONG *bytesPerLine)
311	{
312	if (!bytesPerLine)
313	return E_POINTER;
314	LogFlow(("FFmpeg::COMGETTER(BytesPerLine): returning line size %lu\n",
315	(unsigned long) mBytesPerLine));
316	*bytesPerLine = mBytesPerLine;
317	return S_OK;
318	}
319
320	/**
321	* Return the pixel layout of our frame buffer.
322	*
323	* @returns COM status code
324	* @retval pixelFormat The pixel layout
325	*/
326	STDMETHODIMP FFmpegFB::COMGETTER(PixelFormat) (ULONG *pixelFormat)
327	{
328	if (!pixelFormat)
329	return E_POINTER;
330	LogFlow(("FFmpeg::COMGETTER(PixelFormat): returning pixel format: %lu\n",
331	(unsigned long) mPixelFormat));
332	*pixelFormat = mPixelFormat;
333	return S_OK;
334	}
335
336	/**
337	* Return whether we use the guest VRAM directly.
338	*
339	* @returns COM status code
340	* @retval pixelFormat The pixel layout
341	*/
342	STDMETHODIMP FFmpegFB::COMGETTER(UsesGuestVRAM) (BOOL *usesGuestVRAM)
343	{
344	if (!usesGuestVRAM)
345	return E_POINTER;
346	LogFlow(("FFmpeg::COMGETTER(UsesGuestVRAM): uses guest VRAM? %d\n",
347	mRGBBuffer == NULL));
348	*usesGuestVRAM = (mRGBBuffer == NULL);
349	return S_OK;
350	}
351
352	/**
353	* Return the number of lines of our frame buffer which can not be used
354	* (e.g. for status lines etc?).
355	*
356	* @returns COM status code
357	* @retval heightReduction The number of unused lines
358	*/
359	STDMETHODIMP FFmpegFB::COMGETTER(HeightReduction) (ULONG *heightReduction)
360	{
361	if (!heightReduction)
362	return E_POINTER;
363	/* no reduction */
364	*heightReduction = 0;
365	LogFlow(("FFmpeg::COMGETTER(HeightReduction): returning 0\n"));
366	return S_OK;
367	}
368
369	/**
370	* Return a pointer to the alpha-blended overlay used to render status icons
371	* etc above the framebuffer.
372	*
373	* @returns COM status code
374	* @retval aOverlay The overlay framebuffer
375	*/
376	STDMETHODIMP FFmpegFB::COMGETTER(Overlay) (IFramebufferOverlay **aOverlay)
377	{
378	if (!aOverlay)
379	return E_POINTER;
380	/* not yet implemented */
381	*aOverlay = 0;
382	LogFlow(("FFmpeg::COMGETTER(Overlay): returning 0\n"));
383	return S_OK;
384	}
385
386	/**
387	* Return id of associated window
388	*
389	* @returns COM status code
390	* @retval winId Associated window id
391	*/
392	STDMETHODIMP FFmpegFB::COMGETTER(WinId) (ULONG64 *winId)
393	{
394	if (!winId)
395	return E_POINTER;
396	*winId = 0;
397	return S_OK;
398	}
399
400	// IFramebuffer methods
401	/////////////////////////////////////////////////////////////////////////////
402
403	STDMETHODIMP FFmpegFB::Lock()
404	{
405	LogFlow(("FFmpeg::Lock: called\n"));
406	int rc = RTCritSectEnter(&mCritSect);
407	AssertRC(rc);
408	if (rc == VINF_SUCCESS)
409	return S_OK;
410	return E_UNEXPECTED;
411	}
412
413	STDMETHODIMP FFmpegFB::Unlock()
414	{
415	LogFlow(("FFmpeg::Unlock: called\n"));
416	RTCritSectLeave(&mCritSect);
417	return S_OK;
418	}
419
420
421	/**
422	* This method is used to notify us that an area of the guest framebuffer
423	* has been updated.
424	*
425	* @returns COM status code
426	* @param x X co-ordinate of the upper left-hand corner of the
427	* area which has been updated
428	* @param y Y co-ordinate of the upper left-hand corner of the
429	* area which has been updated
430	* @param w width of the area which has been updated
431	* @param h height of the area which has been updated
432	*/
433	STDMETHODIMP FFmpegFB::NotifyUpdate(ULONG x, ULONG y, ULONG w, ULONG h)
434	{
435	int rc;
436	int64_t iCurrentTime = RTTimeMilliTS();
437
438	LogFlow(("FFmpeg::NotifyUpdate called: x=%lu, y=%lu, w=%lu, h=%lu\n",
439	(unsigned long) x, (unsigned long) y, (unsigned long) w,
440	(unsigned long) h));
441
442	/* We always leave at least one frame update pending, which we
443	process when the time until the next frame has elapsed. */
444	if (iCurrentTime - mLastTime >= 40)
445	{
446	rc = do_rgb_to_yuv_conversion();
447	if (rc != S_OK)
448	{
449	copy_to_intermediate_buffer(x, y, w, h);
450	return rc;
451	}
452	rc = do_encoding_and_write();
453	if (rc != S_OK)
454	{
455	copy_to_intermediate_buffer(x, y, w, h);
456	return rc;
457	}
458	mLastTime = mLastTime + 40;
459	/* Write frames for the time in-between. Not a good way
460	to handle this. */
461	while (iCurrentTime - mLastTime >= 40)
462	{
463	/* rc = do_rgb_to_yuv_conversion();
464	if (rc != S_OK)
465	{
466	copy_to_intermediate_buffer(x, y, w, h);
467	return rc;
468	}
469	*/ rc = do_encoding_and_write();
470	if (rc != S_OK)
471	{
472	copy_to_intermediate_buffer(x, y, w, h);
473	return rc;
474	}
475	mLastTime = mLastTime + 40;
476	}
477	}
478	/* Finally we copy the updated data to the intermediate buffer,
479	ready for the next update. */
480	copy_to_intermediate_buffer(x, y, w, h);
481	return S_OK;
482	}
483
484
485	/**
486	* Requests a resize of our "screen".
487	*
488	* @returns COM status code
489	* @param pixelFormat Layout of the guest video RAM (i.e. 16, 24,
490	* 32 bpp)
491	* @param vram host context pointer to the guest video RAM,
492	* in case we can cope with the format
493	* @param bitsPerPixel color depth of the guest video RAM
494	* @param bytesPerLine length of a screen line in the guest video RAM
495	* @param w video mode width in pixels
496	* @param h video mode height in pixels
497	* @retval finished set to true if the method is synchronous and
498	* to false otherwise
499	*
500	* This method is called when the guest attempts to resize the virtual
501	* screen. The pointer to the guest's video RAM is supplied in case
502	* the framebuffer can handle the pixel format. If it can't, it should
503	* allocate a memory buffer itself, and the virtual VGA device will copy
504	* the guest VRAM to that in a format we can handle. The
505	* COMGETTER(UsesGuestVRAM) method is used to tell the VGA device which method
506	* we have chosen, and the other COMGETTER methods tell the device about
507	* the layout of our buffer. We currently handle all VRAM layouts except
508	* FramebufferPixelFormat_Opaque (which cannot be handled by
509	* definition).
510	*/
511	STDMETHODIMP FFmpegFB::RequestResize(ULONG aScreenId, ULONG pixelFormat,
512	BYTE *vram, ULONG bitsPerPixel,
513	ULONG bytesPerLine,
514	ULONG w, ULONG h, BOOL *finished)
515	{
516	NOREF(aScreenId);
517	if (!finished)
518	return E_POINTER;
519	LogFlow(("FFmpeg::RequestResize called: pixelFormat=%lu, vram=%lu, "
520	"bpp=%lu bpl=%lu, w=%lu, h=%lu\n",
521	(unsigned long) pixelFormat, (unsigned long) vram,
522	(unsigned long) bitsPerPixel, (unsigned long) bytesPerLine,
523	(unsigned long) w, (unsigned long) h));
524	/* For now, we are doing things synchronously */
525	*finished = true;
526
527	/* We always reallocate our buffer */
528	if (mRGBBuffer)
529	RTMemFree(mRGBBuffer);
530	mGuestWidth = w;
531	mGuestHeight = h;
532
533	bool fallback = false;
534
535	/* See if there are conditions under which we can use the guest's VRAM,
536	* fallback to our own memory buffer otherwise */
537
538	if (pixelFormat == FramebufferPixelFormat_FOURCC_RGB)
539	{
540	switch (bitsPerPixel)
541	{
542	case 32:
543	mFFMPEGPixelFormat = PIX_FMT_RGBA32;
544	Log2(("FFmpeg::RequestResize: setting ffmpeg pixel format to PIX_FMT_RGBA32\n"));
545	break;
546	case 24:
547	mFFMPEGPixelFormat = PIX_FMT_RGB24;
548	Log2(("FFmpeg::RequestResize: setting ffmpeg pixel format to PIX_FMT_RGB24\n"));
549	break;
550	case 16:
551	mFFMPEGPixelFormat = PIX_FMT_RGB565;
552	Log2(("FFmpeg::RequestResize: setting ffmpeg pixel format to PIX_FMT_RGB565\n"));
553	break;
554	default:
555	fallback = true;
556	break;
557	}
558	}
559	else
560	{
561	fallback = true;
562	}
563
564	if (!fallback)
565	{
566	mPixelFormat = FramebufferPixelFormat_FOURCC_RGB;
567	mBufferAddress = reinterpret_cast<uint8_t *>(vram);
568	mBytesPerLine = bytesPerLine;
569	mBitsPerPixel = bitsPerPixel;
570	mRGBBuffer = 0;
571	Log2(("FFmpeg::RequestResize: setting mBufferAddress to vram and mLineSize to %lu\n",
572	(unsigned long) mBytesPerLine));
573	}
574	else
575	{
576	/* we always fallback to 32bpp RGB */
577	mPixelFormat = FramebufferPixelFormat_FOURCC_RGB;
578	mFFMPEGPixelFormat = PIX_FMT_RGBA32;
579	Log2(("FFmpeg::RequestResize: setting ffmpeg pixel format to PIX_FMT_RGBA32\n"));
580
581	mBytesPerLine = w * 4;
582	mBitsPerPixel = 32;
583	mRGBBuffer = reinterpret_cast<uint8_t >(RTMemAlloc(mBytesPerLine h));
584	AssertReturn(mRGBBuffer != 0, E_OUTOFMEMORY);
585	Log2(("FFmpeg::RequestResize: alloc'ing mBufferAddress and mRGBBuffer to %p and mBytesPerLine to %lu\n",
586	mBufferAddress, (unsigned long) mBytesPerLine));
587	mBufferAddress = mRGBBuffer;
588	}
589
590	/* Blank out the intermediate frame framebuffer */
591	memset(mTempRGBBuffer, 0, mFrameWidth * mFrameHeight * 4);
592	return S_OK;
593	}
594
595	/**
596	* Returns whether we like the given video mode.
597	*
598	* @returns COM status code
599	* @param width video mode width in pixels
600	* @param height video mode height in pixels
601	* @param bpp video mode bit depth in bits per pixel
602	* @param supported pointer to result variable
603	*
604	* As far as I know, the only restruction we have on video modes is that
605	* we have to have an even number of horizontal and vertical pixels.
606	* I sincerely doubt that anything else will be requested, and if it
607	* is anyway, we will just silently amputate one line when we write to
608	* the mpeg file.
609	*/
610	STDMETHODIMP FFmpegFB::VideoModeSupported(ULONG width, ULONG height,
611	ULONG bpp, BOOL *supported)
612	{
613	if (!supported)
614	return E_POINTER;
615	*supported = true;
616	return S_OK;
617	}
618
619	/** Stubbed */
620	STDMETHODIMP FFmpegFB::GetVisibleRegion(BYTE rectangles, ULONG / count /, ULONG /* countCopied */)
621	{
622	if (!rectangles)
623	return E_POINTER;
624	*rectangles = 0;
625	return S_OK;
626	}
627
628	/** Stubbed */
629	STDMETHODIMP FFmpegFB::SetVisibleRegion(BYTE rectangles, ULONG / count */)
630	{
631	if (!rectangles)
632	return E_POINTER;
633	return S_OK;
634	}
635
636	STDMETHODIMP FFmpegFB::ProcessVHWACommand(BYTE *pCommand)
637	{
638	return E_NOTIMPL;
639	}
640	// Private Methods
641	//////////////////////////////////////////////////////////////////////////
642	//
643
644	HRESULT FFmpegFB::setup_library()
645	{
646	/* Set up the avcodec library */
647	avcodec_init();
648	/* Register all codecs in the library. */
649	avcodec_register_all();
650	/* Register all formats in the format library */
651	av_register_all();
652	mpFormatContext = av_alloc_format_context();
653	AssertReturn(mpFormatContext != 0, E_OUTOFMEMORY);
654	mpStream = av_new_stream(mpFormatContext, 0);
655	AssertReturn(mpStream != 0, E_UNEXPECTED);
656	strncpy(mpFormatContext->filename, com::Utf8Str(mFileName).c_str(),
657	sizeof(mpFormatContext->filename));
658	return S_OK;
659	}
660
661
662	/**
663	* Determine the correct output format and codec for our MPEG file.
664	*
665	* @returns COM status code
666	*
667	* @pre The format context (mpFormatContext) should have already been
668	* allocated.
669	*/
670	HRESULT FFmpegFB::setup_output_format()
671	{
672	Assert(mpFormatContext != 0);
673	AVOutputFormat *pOutFormat = guess_format(0, com::Utf8Str(mFileName).c_str(),
674	0);
675	#ifdef VBOX_SHOW_AVAILABLE_FORMATS
676	if (!pOutFormat)
677	{
678	RTPrintf("Could not guess an output format for that extension.\n"
679	"Available formats:\n");
680	list_formats();
681	}
682	#endif
683	AssertMsgReturn(pOutFormat != 0,
684	("Could not deduce output format from file name\n"),
685	E_INVALIDARG);
686	AssertMsgReturn((pOutFormat->flags & AVFMT_RAWPICTURE) == 0,
687	("Can't handle output format for file\n"),
688	E_INVALIDARG);
689	AssertMsgReturn((pOutFormat->flags & AVFMT_NOFILE) == 0,
690	("pOutFormat->flags=%x, pOutFormat->name=%s\n",
691	pOutFormat->flags, pOutFormat->name), E_UNEXPECTED);
692	AssertMsgReturn(pOutFormat->video_codec != CODEC_ID_NONE,
693	("No video codec available - you have probably selected a non-video file format\n"), E_UNEXPECTED);
694	mpFormatContext->oformat = pOutFormat;
695	/* Set format specific parameters - requires the format to be set. */
696	int rcSetParam = av_set_parameters(mpFormatContext, 0);
697	AssertReturn(rcSetParam >= 0, E_UNEXPECTED);
698	#if 1 /* bird: This works for me on the mac, please review & test elsewhere. */
699	/* Fill in any uninitialized parameters like opt_output_file in ffpmeg.c does.
700	This fixes most of the buffer underflow warnings:
701	http://lists.mplayerhq.hu/pipermail/ffmpeg-devel/2005-June/001699.html */
702	if (!mpFormatContext->preload)
703	mpFormatContext->preload = (int)(0.5 * AV_TIME_BASE);
704	if (!mpFormatContext->max_delay)
705	mpFormatContext->max_delay = (int)(0.7 * AV_TIME_BASE);
706	#endif
707	return S_OK;
708	}
709
710
711	HRESULT FFmpegFB::list_formats()
712	{
713	AVCodec *codec;
714	for (codec = first_avcodec; codec != NULL; codec = codec->next)
715	{
716	if (codec->type == CODEC_TYPE_VIDEO && codec->encode)
717	{
718	AVOutputFormat *ofmt;
719	for (ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next)
720	{
721	if (ofmt->video_codec == codec->id)
722	RTPrintf(" %20s: %20s => '%s'\n", codec->name, ofmt->extensions, ofmt->long_name);
723	}
724	}
725	}
726	return S_OK;
727	}
728
729
730	/**
731	* Open the FFmpeg codec and set it up (width, etc) for our MPEG file.
732	*
733	* @returns COM status code
734	*
735	* @pre The format context (mpFormatContext) and the stream (mpStream)
736	* should have already been allocated.
737	*/
738	HRESULT FFmpegFB::open_codec()
739	{
740	Assert(mpFormatContext != 0);
741	Assert(mpStream != 0);
742	AVOutputFormat *pOutFormat = mpFormatContext->oformat;
743	AVCodecContext *pCodecContext = mpStream->codec;
744	AssertReturn(pCodecContext != 0, E_UNEXPECTED);
745	AVCodec *pCodec = avcodec_find_encoder(pOutFormat->video_codec);
746	#ifdef VBOX_SHOW_AVAILABLE_FORMATS
747	if (!pCodec)
748	{
749	RTPrintf("Could not find a suitable codec for the output format on your system\n"
750	"Available formats:\n");
751	list_formats();
752	}
753	#endif
754	AssertReturn(pCodec != 0, E_UNEXPECTED);
755	pCodecContext->codec_id = pOutFormat->video_codec;
756	pCodecContext->codec_type = CODEC_TYPE_VIDEO;
757	pCodecContext->bit_rate = mBitRate;
758	pCodecContext->width = mFrameWidth;
759	pCodecContext->height = mFrameHeight;
760	pCodecContext->time_base.den = 25;
761	pCodecContext->time_base.num = 1;
762	pCodecContext->gop_size = 12; /* at most one intra frame in 12 */
763	pCodecContext->max_b_frames = 1;
764	pCodecContext->pix_fmt = PIX_FMT_YUV420P;
765	/* taken from the ffmpeg output example */
766	// some formats want stream headers to be seperate
767	if (!strcmp(pOutFormat->name, "mp4")
768	\|\| !strcmp(pOutFormat->name, "mov")
769	\|\| !strcmp(pOutFormat->name, "3gp"))
770	pCodecContext->flags \|= CODEC_FLAG_GLOBAL_HEADER;
771	/* end output example section */
772	int rcOpenCodec = avcodec_open(pCodecContext, pCodec);
773	AssertReturn(rcOpenCodec >= 0, E_UNEXPECTED);
774	return S_OK;
775	}
776
777
778	/**
779	* Open our MPEG file and write the header.
780	*
781	* @returns COM status code
782	*
783	* @pre The format context (mpFormatContext) and the stream (mpStream)
784	* should have already been allocated and set up.
785	*/
786	HRESULT FFmpegFB::open_output_file()
787	{
788	char szFileName[RTPATH_MAX];
789	Assert(mpFormatContext);
790	Assert(mpFormatContext->oformat);
791	strcpy(szFileName, com::Utf8Str(mFileName).c_str());
792	int rcUrlFopen = url_fopen(&mpFormatContext->pb,
793	szFileName, URL_WRONLY);
794	AssertReturn(rcUrlFopen >= 0, E_UNEXPECTED);
795	mfUrlOpen = true;
796	av_write_header(mpFormatContext);
797	return S_OK;
798	}
799
800
801	/**
802	* Copy an area from the output buffer used by the virtual VGA (may
803	* just be the guest's VRAM) to our fixed size intermediate buffer.
804	* The picture in the intermediate buffer is centred if the guest
805	* screen dimensions are smaller and amputated if they are larger than
806	* our frame dimensions.
807	*
808	* @param x X co-ordinate of the upper left-hand corner of the
809	* area which has been updated
810	* @param y Y co-ordinate of the upper left-hand corner of the
811	* area which has been updated
812	* @param w width of the area which has been updated
813	* @param h height of the area which has been updated
814	*/
815	void FFmpegFB::copy_to_intermediate_buffer(ULONG x, ULONG y, ULONG w, ULONG h)
816	{
817	Log2(("FFmpegFB::copy_to_intermediate_buffer: x=%lu, y=%lu, w=%lu, h=%lu\n",
818	(unsigned long) x, (unsigned long) y, (unsigned long) w, (unsigned long) h));
819	/* Perform clipping and calculate the destination co-ordinates */
820	ULONG destX, destY, bpp;
821	LONG xDiff = (LONG(mFrameWidth) - LONG(mGuestWidth)) / 2;
822	LONG yDiff = (LONG(mFrameHeight) - LONG(mGuestHeight)) / 2;
823	if (LONG(w) + xDiff + LONG(x) <= 0) /* nothing visible */
824	return;
825	if (LONG(x) < -xDiff)
826	{
827	w = LONG(w) + xDiff + x;
828	x = -xDiff;
829	destX = 0;
830	}
831	else
832	destX = x + xDiff;
833	if (LONG(h) + yDiff + LONG(y) <= 0) /* nothing visible */
834	return;
835	if (LONG(y) < -yDiff)
836	{
837	h = LONG(h) + yDiff + LONG(y);
838	y = -yDiff;
839	destY = 0;
840	}
841	else
842	destY = y + yDiff;
843	if (destX > mFrameWidth \|\| destY > mFrameHeight)
844	return; /* nothing visible */
845	if (destX + w > mFrameWidth)
846	w = mFrameWidth - destX;
847	if (destY + h > mFrameHeight)
848	h = mFrameHeight - destY;
849	/* Calculate bytes per pixel */
850	if (mPixelFormat == FramebufferPixelFormat_FOURCC_RGB)
851	{
852	switch (mBitsPerPixel)
853	{
854	case 32:
855	case 24:
856	case 16:
857	bpp = mBitsPerPixel / 8;
858	break;
859	default:
860	AssertMsgFailed(("Unknown color depth! mBitsPerPixel=%d\n", mBitsPerPixel));
861	bpp = 1;
862	break;
863	}
864	}
865	else
866	{
867	AssertMsgFailed(("Unknown pixel format! mPixelFormat=%d\n", mPixelFormat));
868	bpp = 1;
869	}
870	/* Calculate start offset in source and destination buffers */
871	ULONG srcOffs = y * mBytesPerLine + x * bpp;
872	ULONG destOffs = (destY * mFrameWidth + destX) * bpp;
873	/* do the copy */
874	for (unsigned int i = 0; i < h; i++)
875	{
876	/* Overflow check */
877	Assert(srcOffs + w * bpp <= mGuestHeight * mBytesPerLine);
878	Assert(destOffs + w * bpp <= mFrameHeight * mFrameWidth * bpp);
879	memcpy(mTempRGBBuffer + destOffs, mBufferAddress + srcOffs,
880	w * bpp);
881	srcOffs = srcOffs + mBytesPerLine;
882	destOffs = destOffs + mFrameWidth * bpp;
883	}
884	}
885
886
887	/**
888	* Copy the RGB data in the intermediate framebuffer to YUV data in
889	* the YUV framebuffer.
890	*
891	* @returns COM status code
892	*/
893	HRESULT FFmpegFB::do_rgb_to_yuv_conversion()
894	{
895	switch (mFFMPEGPixelFormat)
896	{
897	case PIX_FMT_RGBA32:
898	if (!FFmpegWriteYUV420p<FFmpegBGRA32Iter>(mFrameWidth, mFrameHeight,
899	mYUVBuffer, mTempRGBBuffer))
900	return E_UNEXPECTED;
901	break;
902	case PIX_FMT_RGB24:
903	if (!FFmpegWriteYUV420p<FFmpegBGR24Iter>(mFrameWidth, mFrameHeight,
904	mYUVBuffer, mTempRGBBuffer))
905	return E_UNEXPECTED;
906	break;
907	case PIX_FMT_RGB565:
908	if (!FFmpegWriteYUV420p<FFmpegBGR565Iter>(mFrameWidth, mFrameHeight,
909	mYUVBuffer, mTempRGBBuffer))
910	return E_UNEXPECTED;
911	break;
912	default:
913	return E_UNEXPECTED;
914	}
915	return S_OK;
916	}
917
918
919	/**
920	* Encode the YUV framebuffer as an MPEG frame and write it to the file.
921	*
922	* @returns COM status code
923	*/
924	HRESULT FFmpegFB::do_encoding_and_write()
925	{
926	AVCodecContext *pContext = mpStream->codec;
927
928	/* A hack: ffmpeg mpeg2 only writes a frame if something has
929	changed. So we flip the low luminance bit of the first
930	pixel every frame. */
931	if (mToggle)
932	mYUVBuffer[0] \|= 1;
933	else
934	mYUVBuffer[0] &= 0xfe;
935	mToggle = !mToggle;
936	int cSize = avcodec_encode_video(pContext, mOutBuf, mYUVFrameSize * 2,
937	mFrame);
938	AssertMsgReturn(cSize >= 0,
939	("avcodec_encode_video() failed with rc=%d.\n"
940	"mFrameWidth=%u, mFrameHeight=%u\n", cSize,
941	mFrameWidth, mFrameHeight), E_UNEXPECTED);
942	if (cSize > 0)
943	{
944	AVPacket Packet;
945	av_init_packet(&Packet);
946	Packet.pts = av_rescale_q(pContext->coded_frame->pts,
947	pContext->time_base,
948	mpStream->time_base);
949	if(pContext->coded_frame->key_frame)
950	Packet.flags \|= PKT_FLAG_KEY;
951	Packet.stream_index = mpStream->index;
952	Packet.data = mOutBuf;
953	Packet.size = cSize;
954
955	/* write the compressed frame in the media file */
956	int rcWriteFrame = av_write_frame(mpFormatContext, &Packet);
957	AssertReturn(rcWriteFrame == 0, E_UNEXPECTED);
958	}
959	return S_OK;
960	}
961
962
963	/**
964	* Capture the current (i.e. the last) frame as a PNG file with the
965	* same basename as the captured video file.
966	*/
967	HRESULT FFmpegFB::write_png()
968	{
969	HRESULT errorCode = E_OUTOFMEMORY;
970	png_bytep *row_pointers;
971	char PNGFileName[RTPATH_MAX], oldName[RTPATH_MAX];
972	png_structp png_ptr;
973	png_infop info_ptr;
974	uint8_t *PNGBuffer;
975	/* Work out the new file name - for some reason, we can't use
976	the com::Utf8Str() directly, but have to copy it */
977	strcpy(oldName, com::Utf8Str(mFileName).c_str());
978	int baseLen = strrchr(oldName, '.') - oldName;
979	if (baseLen == 0)
980	baseLen = strlen(oldName);
981	if (baseLen >= RTPATH_MAX - 5) /* for whatever reason */
982	baseLen = RTPATH_MAX - 5;
983	memcpy(&PNGFileName[0], oldName, baseLen);
984	PNGFileName[baseLen] = '.';
985	PNGFileName[baseLen + 1] = 'p';
986	PNGFileName[baseLen + 2] = 'n';
987	PNGFileName[baseLen + 3] = 'g';
988	PNGFileName[baseLen + 4] = 0;
989	/* Open output file */
990	FILE *fp = fopen(PNGFileName, "wb");
991	if (fp == 0)
992	{
993	errorCode = E_UNEXPECTED;
994	goto fopen_failed;
995	}
996	/* Create libpng basic structures */
997	png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
998	0 /* error function /, 0 / warning function */);
999	if (png_ptr == 0)
1000	goto png_create_write_struct_failed;
1001	info_ptr = png_create_info_struct(png_ptr);
1002	if (info_ptr == 0)
1003	{
1004	png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
1005	goto png_create_info_struct_failed;
1006	}
1007	/* Convert image to standard RGB24 to simplify life */
1008	PNGBuffer = reinterpret_cast<uint8_t *>(av_malloc(mFrameWidth
1009	* mFrameHeight * 4));
1010	if (PNGBuffer == 0)
1011	goto av_malloc_buffer_failed;
1012	row_pointers =
1013	reinterpret_cast<png_bytep *>(av_malloc(mFrameHeight
1014	* sizeof(png_bytep)));
1015	if (row_pointers == 0)
1016	goto av_malloc_pointers_failed;
1017	switch (mFFMPEGPixelFormat)
1018	{
1019	case PIX_FMT_RGBA32:
1020	if (!FFmpegWriteRGB24<FFmpegBGRA32Iter>(mFrameWidth, mFrameHeight,
1021	PNGBuffer, mTempRGBBuffer))
1022	goto setjmp_exception;
1023	break;
1024	case PIX_FMT_RGB24:
1025	if (!FFmpegWriteRGB24<FFmpegBGR24Iter>(mFrameWidth, mFrameHeight,
1026	PNGBuffer, mTempRGBBuffer))
1027	goto setjmp_exception;
1028	break;
1029	case PIX_FMT_RGB565:
1030	if (!FFmpegWriteRGB24<FFmpegBGR565Iter>(mFrameWidth, mFrameHeight,
1031	PNGBuffer, mTempRGBBuffer))
1032	goto setjmp_exception;
1033	break;
1034	default:
1035	goto setjmp_exception;
1036	}
1037	/* libpng exception handling */
1038	if (setjmp(png_jmpbuf(png_ptr)))
1039	goto setjmp_exception;
1040	/* pass libpng the file pointer */
1041	png_init_io(png_ptr, fp);
1042	/* set the image properties */
1043	png_set_IHDR(png_ptr, info_ptr, mFrameWidth, mFrameHeight,
1044	8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
1045	PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
1046	/* set up the information about the bitmap for libpng */
1047	row_pointers[0] = png_bytep(PNGBuffer);
1048	for (unsigned i = 1; i < mFrameHeight; i++)
1049	row_pointers[i] = row_pointers[i - 1] + mFrameWidth * 3;
1050	png_set_rows(png_ptr, info_ptr, &row_pointers[0]);
1051	/* and write the thing! */
1052	png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);
1053	/* drop through to cleanup */
1054	errorCode = S_OK;
1055	setjmp_exception:
1056	av_free(row_pointers);
1057	av_malloc_pointers_failed:
1058	av_free(PNGBuffer);
1059	av_malloc_buffer_failed:
1060	png_destroy_write_struct(&png_ptr, &info_ptr);
1061	png_create_info_struct_failed:
1062	png_create_write_struct_failed:
1063	fclose(fp);
1064	fopen_failed:
1065	if (errorCode != S_OK)
1066	Log(("FFmpegFB::write_png: Failed to write .png image of final frame\n"));
1067	return errorCode;
1068	}
1069
1070
1071	#ifdef VBOX_WITH_XPCOM
1072	NS_DECL_CLASSINFO(FFmpegFB)
1073	NS_IMPL_THREADSAFE_ISUPPORTS1_CI(FFmpegFB, IFramebuffer)
1074	#endif

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

source: vbox/trunk/src/VBox/Frontends/VBoxHeadless/VideoCapture/FFmpegFB.cpp@ 24364

Download in other formats: