CWE-ou-minkata/Sources/Plasma/PubUtilLib/plGImage/plAVIWriter.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "plAVIWriter.h"

#include "hsTypes.h"

#include "hsWindows.h"
#include <vfw.h>

#include "hsTimer.h"
#include "plMipmap.h"
#include "plMessage/plRenderMsg.h"
#include "plPipeline.h"
#include "pnDispatch/plDispatch.h"
#include "pnKeyedObject/plFixedKey.h"

bool plAVIWriter::fInitialized = false;

class plAVIWriterImp : public plAVIWriter
{
protected:
	PAVIFILE fFileHandle;
	PAVISTREAM fStreamHandle;
	PAVISTREAM fCompressedHandle;
	BITMAPINFOHEADER fBitmapInfo;

	hsBool fOldRealTime;
	hsScalar fOldFrameTimeInc;

	double fStartTime;

	void IFillStreamInfo(AVISTREAMINFO* inf, plPipeline* pipeline);
	void IFillBitmapInfo(BITMAPINFOHEADER* inf, plPipeline* pipeline);

	bool ICaptureFrame(plPipeline* pipeline);

public:
	plAVIWriterImp();
	virtual ~plAVIWriterImp();

	virtual hsBool MsgReceive(plMessage* msg);

	virtual void Shutdown();

	virtual bool Open(const char* fileName, plPipeline* pipeline);
	virtual void Close();
};

plAVIWriter::~plAVIWriter()
{
}

plAVIWriter& plAVIWriter::Instance()
{
	static plAVIWriterImp theInstance;

	if (!fInitialized)
	{
		theInstance.RegisterAs(kAVIWriter_KEY);
		fInitialized = true;
	}

	return theInstance;
}

////////////////////////////////////////////////////////////////////////////////

plAVIWriterImp::plAVIWriterImp() :
	fStartTime(0),
	fOldRealTime(false),
	fStreamHandle(nil),
	fCompressedHandle(nil),
	fFileHandle(nil)
{
	AVIFileInit();
}

plAVIWriterImp::~plAVIWriterImp()
{
}

void plAVIWriterImp::Shutdown()
{
	Close();
	UnRegisterAs(kAVIWriter_KEY);
	SetKey(nil);
}



#include "plProfile.h"
plProfile_CreateTimer("AviCapture", "RenderSetup", AviCapture);

hsBool plAVIWriterImp::MsgReceive(plMessage* msg)
{

	plRenderMsg* renderMsg = plRenderMsg::ConvertNoRef(msg);
	if (renderMsg)
	{
		plProfile_BeginTiming(AviCapture);

		ICaptureFrame(renderMsg->Pipeline());
		plProfile_EndTiming(AviCapture);

	}

	return hsKeyedObject::MsgReceive(msg);
}

static const int kFramesPerSec = 30;

bool plAVIWriterImp::Open(const char* fileName, plPipeline* pipeline)
{
	// Already writing, fail
	if (fStreamHandle)
		return false;

	fStartTime = hsTimer::GetSysSeconds();

	// If we're running in real time, set to frame time
	fOldRealTime = hsTimer::IsRealTime();
	if (fOldRealTime)
	{
		hsTimer::SetRealTime(false);
		hsTimer::SetFrameTimeInc(1.f / kFramesPerSec);
	}

	// Open AVI file
	HRESULT err;
	err = AVIFileOpen(	&fFileHandle,			// returned file pointer
						fileName,				// file name
						OF_WRITE | OF_CREATE,	// mode to open file with
						NULL);					// use handler determined
	hsAssert(err == AVIERR_OK, "Error creating AVI file in plAVIWriter::Open");
	if (err != AVIERR_OK)
	{
		Close();
		return false;
	}

	AVISTREAMINFO streamInfo;
	IFillStreamInfo(&streamInfo, pipeline);

	// Create a video stream in the file
	err = AVIFileCreateStream(	fFileHandle,		// file pointer
								&fStreamHandle,		// returned stream pointer
								&streamInfo );		// stream header
	hsAssert(err == AVIERR_OK, "Error creating video stream in plAVIWriter::Open");
	if (err != AVIERR_OK)
	{
		Close();
		return false;
	}

	do
	{
		AVICOMPRESSOPTIONS opts;
		AVICOMPRESSOPTIONS FAR * aopts[1] = {&opts};
		memset(&opts, 0, sizeof(opts));

		BOOL bErr = AVISaveOptions(NULL, ICMF_CHOOSE_DATARATE, 1, &fStreamHandle, (LPAVICOMPRESSOPTIONS FAR*)&aopts);
		hsAssert(bErr, "Error saving stream options in plAVIWriter::Open");
		if (!bErr)
		{
			Close();
			return false;
		}

		err = AVIMakeCompressedStream(&fCompressedHandle, fStreamHandle, &opts, NULL);
		hsAssert(err == AVIERR_OK, "Error creating compressed stream in plAVIWriter::Open");
		if (err != AVIERR_OK)
		{
			Close();
			return false;
		}

		IFillBitmapInfo(&fBitmapInfo, pipeline);
		err = AVIStreamSetFormat(	fCompressedHandle, 0, 
									&fBitmapInfo,	// stream format
									fBitmapInfo.biSize);
	} while (err != AVIERR_OK &&
			hsMessageBox("Codec unavailable, try again?", "AVI Writer", hsMessageBoxYesNo) == hsMBoxYes);

	if (err != AVIERR_OK)
	{
		Close();
		return false;
	}

	plgDispatch::Dispatch()->RegisterForExactType(plRenderMsg::Index(), GetKey());

	return true;
}

void plAVIWriterImp::Close()
{
	plgDispatch::Dispatch()->UnRegisterForExactType(plRenderMsg::Index(), GetKey());

	hsTimer::SetRealTime(fOldRealTime);

	if (fStreamHandle)
	{
		AVIStreamClose(fStreamHandle);
		fStreamHandle = nil;
	}

	if (fCompressedHandle)
	{
		AVIStreamClose(fCompressedHandle);
		fCompressedHandle = nil;
	}

	if (fFileHandle)
	{
		AVIFileClose(fFileHandle);
		fFileHandle = nil;
	}

	AVIFileExit();
}

void plAVIWriterImp::IFillStreamInfo(AVISTREAMINFO* inf, plPipeline* pipeline)
{
	memset(inf, 0, sizeof(AVISTREAMINFO));
    inf->fccType = streamtypeVIDEO;
	inf->fccHandler = 0;
	inf->dwScale = 1;
    inf->dwRate = kFramesPerSec;

	SetRect(&inf->rcFrame,
			0,0,
			pipeline->Width(),
			pipeline->Height());
}

void plAVIWriterImp::IFillBitmapInfo(BITMAPINFOHEADER* inf, plPipeline* pipeline)
{
	memset(inf,0,sizeof(BITMAPINFOHEADER));
	inf->biSize = sizeof(BITMAPINFOHEADER);
	inf->biPlanes = 1;
	inf->biBitCount = 32;
	inf->biCompression = BI_RGB;
	inf->biSizeImage = 0;
	inf->biXPelsPerMeter = 0;
	inf->biYPelsPerMeter = 0;
	inf->biClrUsed = 0;
	inf->biClrImportant = 0;
	inf->biWidth = pipeline->Width();
	inf->biHeight = pipeline->Height();
}

bool plAVIWriterImp::ICaptureFrame(plPipeline* pipeline)
{
	plMipmap frame;
	pipeline->CaptureScreen(&frame, true);

	double time = hsTimer::GetSysSeconds() - fStartTime;
	time *= kFramesPerSec;

	HRESULT err;
	err = AVIStreamWrite(	fCompressedHandle,
							int(time),
							1,
							(LPBYTE)frame.GetAddr32(0,0),
							frame.GetTotalSize(),
							AVIIF_KEYFRAME,
							NULL,
							NULL);

	return (err == AVIERR_OK);
}