bool AVIDump::SetCompressionOptions()
{
memset(&m_options, 0, sizeof(m_options));
m_arrayOptions[0] = &m_options;
return (AVISaveOptions(m_emuWnd, 0, 1, &m_stream, m_arrayOptions) != 0);
}
bool MovieMaker::CreateCompressedStream(const string &codec, uint frameRate)
{
//Get the compression options
HRESULT result = AVIERR_OK;
AVICOMPRESSOPTIONS opts;
AVICOMPRESSOPTIONS FAR * aopts[1] = {&opts};
memset(&opts, 0, sizeof(opts));
//If using the menu
if(codec == "menu")
{
//Load the memu options
if (!AVISaveOptions(GetActiveWindow(), 0, 1, &ps, (LPAVICOMPRESSOPTIONS FAR *)&aopts))
{
AVISaveOptionsFree(1,(LPAVICOMPRESSOPTIONS FAR *) &aopts);
return false;
}
//Create a compressed stream using codec options.
result = AVIMakeCompressedStream(&psCompressed,
ps,
&opts,
NULL);
if (result != AVIERR_OK)
{
AVISaveOptionsFree(1,(LPAVICOMPRESSOPTIONS FAR *) &aopts);
return false;
}
//Release save options
result = AVISaveOptionsFree(1,(LPAVICOMPRESSOPTIONS FAR *) &aopts);
if (result!=AVIERR_OK)
{
LOGERR(("CreateCompressedStream -Error releasing memory"));
return false;
}
}
else
{
opts.fccType=streamtypeVIDEO;
opts.fccHandler= CreateCodecDWORD(codec); // mmioFOURCC('M','P','G','4');
opts.dwFlags=AVICOMPRESSF_KEYFRAMES | AVICOMPRESSF_VALID;//|AVICOMPRESSF_DATARATE;
opts.dwKeyFrameEvery=frameRate;
//Create a compressed stream using codec options.
result = AVIMakeCompressedStream(&psCompressed,
ps,
&opts,
NULL);
if (result != AVIERR_OK)
{
return false;
}
}
return true;
}
bool CvVideoWriter_VFW::createStreams( CvSize frameSize, bool isColor )
{
if( !avifile )
return false;
AVISTREAMINFO aviinfo;
BITMAPINFO_8Bit bmih;
bmih.bmiHeader = icvBitmapHeader( frameSize.width, frameSize.height, isColor ? 24 : 8 );
for( int i = 0; i < 256; i++ )
{
bmih.bmiColors[i].rgbBlue = (BYTE)i;
bmih.bmiColors[i].rgbGreen = (BYTE)i;
bmih.bmiColors[i].rgbRed = (BYTE)i;
bmih.bmiColors[i].rgbReserved = 0;
}
memset( &aviinfo, 0, sizeof(aviinfo));
aviinfo.fccType = streamtypeVIDEO;
aviinfo.fccHandler = 0;
// use highest possible accuracy for dwRate/dwScale
aviinfo.dwScale = (DWORD)((double)0x7FFFFFFF / fps);
aviinfo.dwRate = cvRound(fps * aviinfo.dwScale);
aviinfo.rcFrame.top = aviinfo.rcFrame.left = 0;
aviinfo.rcFrame.right = frameSize.width;
aviinfo.rcFrame.bottom = frameSize.height;
if( AVIFileCreateStream( avifile, &uncompressed, &aviinfo ) == AVIERR_OK )
{
AVICOMPRESSOPTIONS copts, *pcopts = &copts;
copts.fccType = streamtypeVIDEO;
copts.fccHandler = fourcc != -1 ? fourcc : 0;
copts.dwKeyFrameEvery = 1;
copts.dwQuality = 10000;
copts.dwBytesPerSecond = 0;
copts.dwFlags = AVICOMPRESSF_VALID;
copts.lpFormat = &bmih;
copts.cbFormat = (isColor ? sizeof(BITMAPINFOHEADER) : sizeof(bmih));
copts.lpParms = 0;
copts.cbParms = 0;
copts.dwInterleaveEvery = 0;
if( fourcc != -1 || AVISaveOptions( 0, 0, 1, &uncompressed, &pcopts ) == TRUE )
{
if( AVIMakeCompressedStream( &compressed, uncompressed, pcopts, 0 ) == AVIERR_OK &&
AVIStreamSetFormat( compressed, 0, &bmih, sizeof(bmih)) == AVIERR_OK )
{
fps = fps;
fourcc = (int)copts.fccHandler;
frameSize = frameSize;
tempFrame = cvCreateImage( frameSize, 8, (isColor ? 3 : 1) );
return true;
}
}
}
return false;
}
bool CAVIFile::Open(const char *filename)
{
HRESULT hr = AVIFileOpen(&pfile, // returned file pointer
filename, // file name
OF_WRITE | OF_CREATE, // mode to open file with
NULL); // use handler determined
// from file extension....
if (hr != AVIERR_OK) {
bOK = false;
return false;
}
memset(&strhdr, 0, sizeof(strhdr));
strhdr.fccType = streamtypeVIDEO;// stream type
strhdr.fccHandler = 0;
strhdr.dwScale = 1;
strhdr.dwRate = rate;
strhdr.dwSuggestedBufferSize = bitmap.biSizeImage;
SetRect(&strhdr.rcFrame,
0,
0, // rectangle for stream
(int) bitmap.biWidth,
(int) bitmap.biHeight);
// And create the stream;
hr = AVIFileCreateStream(pfile, // file pointer
&ps, // returned stream pointer
&strhdr); // stream header
if (hr != AVIERR_OK) {
bOK = false;
return false;
}
memset(&opts, 0, sizeof(opts));
if(!AVISaveOptions(hWindow, 0, 1, &ps, aopts)) {
bOK = false;
return false;
}
hr = AVIMakeCompressedStream(&psCompressed, ps, &opts, NULL);
if (hr != AVIERR_OK) {
bOK = false;
return false;
}
hr = AVIStreamSetFormat(psCompressed, 0,
&bitmap, // stream format
bitmap.biSize + // format size
bitmap.biClrUsed * sizeof(RGBQUAD));
if (hr != AVIERR_OK) {
bOK = false;
return false;
}
return true;
}
bool AVIWrite::Open(const char *filename)
{
// create the AVI file
if(FAILED(AVIFileOpen(&m_file,
filename,
OF_WRITE | OF_CREATE,
NULL))) {
m_failed = true;
return false;
}
// setup the video stream information
ZeroMemory(&m_header, sizeof(AVISTREAMINFO));
m_header.fccType = streamtypeVIDEO;
m_header.dwScale = 1;
m_header.dwRate = m_fps;
m_header.dwSuggestedBufferSize = m_bitmap.biSizeImage;
// create the video stream
if(FAILED(AVIFileCreateStream(m_file,
&m_stream,
&m_header))) {
m_failed = true;
return false;
}
ZeroMemory(&m_options, sizeof(AVICOMPRESSOPTIONS));
m_arrayOptions[0] = &m_options;
// call the dialog to setup the compress options to be used
if(!AVISaveOptions(AfxGetApp()->m_pMainWnd->GetSafeHwnd(), 0, 1, &m_stream, m_arrayOptions)) {
m_failed = true;
return false;
}
// create the compressed stream
if(FAILED(AVIMakeCompressedStream(&m_streamCompressed, m_stream, &m_options, NULL))) {
m_failed = true;
return false;
}
// setup the video stream format
if(FAILED( AVIStreamSetFormat(m_streamCompressed, 0,
&m_bitmap,
m_bitmap.biSize +
m_bitmap.biClrUsed * sizeof(RGBQUAD)))) {
m_failed = true;
return false;
}
return true;
}
static void test_AVISaveOptions(void)
{
AVICOMPRESSOPTIONS options[2];
LPAVICOMPRESSOPTIONS poptions[2];
PAVISTREAM streams[2] = {NULL, NULL};
HRESULT hres;
DWORD res;
LONG lres;
poptions[0] = &options[0];
poptions[1] = &options[1];
ZeroMemory(options, sizeof(options));
SetLastError(0xdeadbeef);
hres = CreateEditableStream(&streams[0], NULL);
ok(hres == AVIERR_OK, "0: got 0x%x and %p (expected AVIERR_OK)\n", hres, streams[0]);
SetLastError(0xdeadbeef);
hres = CreateEditableStream(&streams[1], NULL);
ok(hres == AVIERR_OK, "1: got 0x%x and %p (expected AVIERR_OK)\n", hres, streams[1]);
SetLastError(0xdeadbeef);
hres = EditStreamSetNameA(streams[0], winetest0);
ok(hres == AVIERR_OK, "0: got 0x%x (expected AVIERR_OK)\n", hres);
SetLastError(0xdeadbeef);
hres = EditStreamSetNameA(streams[1], winetest1);
ok(hres == AVIERR_OK, "1: got 0x%x (expected AVIERR_OK)\n", hres);
if (winetest_interactive) {
SetLastError(0xdeadbeef);
res = AVISaveOptions(0, ICMF_CHOOSE_DATARATE |ICMF_CHOOSE_KEYFRAME | ICMF_CHOOSE_ALLCOMPRESSORS,
2, streams, poptions);
trace("got %u with 0x%x/%u\n", res, GetLastError(), GetLastError());
}
SetLastError(0xdeadbeef);
lres = AVISaveOptionsFree(2, poptions);
ok(lres == AVIERR_OK, "got 0x%x with 0x%x/%u\n", lres, GetLastError(), GetLastError());
SetLastError(0xdeadbeef);
res = AVIStreamRelease(streams[0]);
ok(res == 0, "0: got refcount %u (expected 0)\n", res);
SetLastError(0xdeadbeef);
res = AVIStreamRelease(streams[1]);
ok(res == 0, "1: got refcount %u (expected 0)\n", res);
}
bool AVIDump::SetCompressionOptions()
{
memset(&s_options, 0, sizeof(s_options));
s_array_options[0] = &s_options;
if (SConfig::GetInstance().m_DumpFramesSilent)
{
s_options.fccType = streamtypeVIDEO;
s_options.fccHandler = mmioFOURCC('D', 'I', 'B', ' '); // Uncompressed
return true;
}
else
{
return (AVISaveOptions(s_emu_wnd, 0, 1, &s_stream, s_array_options) != 0);
}
}
HRESULT SetAviVideoCompression(HAVI avi, HBITMAP hbm, AVICOMPRESSOPTIONS *opts, bool ShowDialog, HWND hparent)
{ if (avi==NULL) return AVIERR_BADHANDLE;
if (hbm==NULL) return AVIERR_BADPARAM;
DIBSECTION dibs; int sbm = GetObject(hbm,sizeof(dibs),&dibs);
if (sbm!=sizeof(DIBSECTION)) return AVIERR_BADPARAM;
TAviUtil *au = (TAviUtil*)avi;
if (au->iserr) return AVIERR_ERROR;
if (au->psCompressed!=0) return AVIERR_COMPRESSOR;
//
if (au->ps==0) // create the stream, if it wasn't there before
{ AVISTREAMINFO strhdr; ZeroMemory(&strhdr,sizeof(strhdr));
strhdr.fccType = streamtypeVIDEO;// stream type
strhdr.fccHandler = 0;
strhdr.dwScale = au->period;
strhdr.dwRate = 1000;
strhdr.dwSuggestedBufferSize = dibs.dsBmih.biSizeImage;
SetRect(&strhdr.rcFrame, 0, 0, dibs.dsBmih.biWidth, dibs.dsBmih.biHeight);
HRESULT hr=AVIFileCreateStream(au->pfile, &au->ps, &strhdr);
if (hr!=AVIERR_OK) {au->iserr=true; return hr;}
}
//
if (au->psCompressed==0) // set the compression, prompting dialog if necessary
{ AVICOMPRESSOPTIONS myopts; ZeroMemory(&myopts,sizeof(myopts));
AVICOMPRESSOPTIONS *aopts[1];
if (opts!=NULL) aopts[0]=opts; else aopts[0]=&myopts;
if (ShowDialog)
{ BOOL res = (BOOL)AVISaveOptions(hparent,0,1,&au->ps,aopts);
if (!res) {AVISaveOptionsFree(1,aopts); au->iserr=true; return AVIERR_USERABORT;}
}
HRESULT hr = AVIMakeCompressedStream(&au->psCompressed, au->ps, aopts[0], NULL);
AVISaveOptionsFree(1,aopts);
if (hr != AVIERR_OK) {au->iserr=true; return hr;}
DIBSECTION dibs; GetObject(hbm,sizeof(dibs),&dibs);
hr = AVIStreamSetFormat(au->psCompressed, 0, &dibs.dsBmih, dibs.dsBmih.biSize+dibs.dsBmih.biClrUsed*sizeof(RGBQUAD));
if (hr!=AVIERR_OK) {au->iserr=true; return hr;}
}
//
return AVIERR_OK;
}
void *
avi_begin_encode(const char *filename, int width, int height, int fps, const char *preferences_filename)
{
#ifdef HAVE_VFW
avi_encode_context *context;
HRESULT hr;
BOOL ret;
AVISTREAMINFO strhdr;
BITMAPINFO bi;
AVICOMPRESSOPTIONS opts;
AVICOMPRESSOPTIONS * aopts[1];
int rowsize;
int imagesize;
int numbits;
int prefsReadFromFile;
if ( (width % 4 != 0) || (height % 4 != 0) )
return NULL; /* width and height must be divisible by 4 (several codecs crashes if this is not true) */
context = (avi_encode_context *) malloc(sizeof(avi_encode_context));
avi_init_context(context);
context->width = width;
context->height = height;
AVIFileInit();
/* Open file */
hr = AVIFileOpen(&context->pfile , filename, OF_WRITE | OF_CREATE, NULL);
if (hr != AVIERR_OK) {
avi_cleanup_context(context);
free(context);
return NULL;
}
/*
fixme 20020304 thammer: Investigate what happens if the file allready exists.
Preliminary tests indicate that the new stream is just added to the existing
file (increasing the file size), instead of truncating the file first, as the
documentation for AVIFileOpen states.
*/
numbits = 24;
rowsize = (width * numbits + 31) / 32 * 4; /* aligned to 32 bits */
imagesize = rowsize * height;
memset(&strhdr, 0, sizeof(strhdr));
strhdr.fccType = streamtypeVIDEO;
strhdr.fccHandler = 0;
strhdr.dwScale = 1;
strhdr.dwRate = fps;
strhdr.dwSuggestedBufferSize = imagesize;
strhdr.rcFrame.left = 0;
strhdr.rcFrame.top = 0;
strhdr.rcFrame.right = width;
strhdr.rcFrame.bottom = height;
/* Create stream */
hr = AVIFileCreateStream(context->pfile, &context->ps, &strhdr);
if (hr != AVIERR_OK) {
avi_cleanup_context(context);
free(context);
return NULL;
}
aopts[0] = &opts;
memset(&opts, 0, sizeof(opts));
prefsReadFromFile = 0;
if ( (preferences_filename != NULL) && (strlen(preferences_filename)>0) ) {
FILE *file;
int size;
file = fopen(preferences_filename, "rb");
if (file==NULL) {
/* file doesn't exist, must pop up GUI to get options */
ret = AVISaveOptions(NULL, ICMF_CHOOSE_KEYFRAME | ICMF_CHOOSE_DATARATE, 1, &context->ps, (LPAVICOMPRESSOPTIONS *) &aopts);
if (!ret) {
/* User pressed [Cancel] */
avi_cleanup_context(context);
free(context);
return NULL;
}
/* Save options to file*/
file = fopen(preferences_filename, "wb");
if (file == NULL) {
avi_cleanup_context(context);
free(context);
return NULL;
}
/* write AVICOMPRESSOPTIONS struct */
size = fwrite(&opts, sizeof(AVICOMPRESSOPTIONS), 1, file);
/* write AVICOMPRESSOPTIONS.cbFormat */
size = fwrite(&opts.cbFormat, 4, 1, file);
/* write AVICOMPRESSOPTIONS.lpFormat */
size = fwrite(opts.lpFormat, opts.cbFormat, 1, file);
/* write AVICOMPRESSOPTIONS.cbParms */
size = fwrite(&opts.cbParms, 4, 1, file);
/* write AVICOMPRESSOPTIONS.lpParms */
size = fwrite(opts.lpParms, opts.cbParms, 1, file);
fclose(file);
} else {
/* Read options from file */
file = fopen(preferences_filename, "rb");
if (file == NULL) {
avi_cleanup_context(context);
free(context);
return NULL;
}
/* read AVICOMPRESSOPTIONS struct */
size = fread(&opts, sizeof(AVICOMPRESSOPTIONS), 1, file);
/* read AVICOMPRESSOPTIONS.cbFormat */
size = fread(&opts.cbFormat, 4, 1, file);
/* read AVICOMPRESSOPTIONS.lpFormat */
opts.lpFormat = (void *) malloc(opts.cbFormat);
size = fread(opts.lpFormat, opts.cbFormat, 1, file);
/* read AVICOMPRESSOPTIONS.cbParms */
size = fread(&opts.cbParms, 4, 1, file);
/* read AVICOMPRESSOPTIONS.lpParms */
opts.lpParms = (void *) malloc(opts.cbParms);
size = fread(opts.lpParms, opts.cbParms, 1, file);
fclose(file);
prefsReadFromFile = 1;
}
}
else {
ret = AVISaveOptions(NULL, ICMF_CHOOSE_KEYFRAME | ICMF_CHOOSE_DATARATE, 1, &context->ps, (LPAVICOMPRESSOPTIONS *) &aopts);
if (!ret) {
/* User pressed [Cancel] */
avi_cleanup_context(context);
free(context);
return NULL;
}
};
hr = AVIMakeCompressedStream( &context->pscomp, context->ps, &opts, NULL);
if (hr != AVIERR_OK) {
avi_cleanup_context(context);
free(context);
return NULL;
}
if (prefsReadFromFile)
{
/* Since we don't know if our method of allocating memory (malloc) differs from
whatever AVISaveOptions() uses, we free what we created ourselves.
*/
free(opts.lpFormat);
opts.lpFormat = NULL;
free(opts.lpParms);
opts.lpParms = NULL;
}
else
AVISaveOptionsFree(1, (LPAVICOMPRESSOPTIONS *) &aopts);
memset(&bi, 0, sizeof(BITMAPINFO));
bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER) ;
bi.bmiHeader.biWidth = width ;
bi.bmiHeader.biHeight = height ;
bi.bmiHeader.biPlanes = 1 ;
bi.bmiHeader.biBitCount = numbits ;
bi.bmiHeader.biCompression = BI_RGB ;
bi.bmiHeader.biSizeImage = imagesize ;
bi.bmiHeader.biXPelsPerMeter = 0 ;
bi.bmiHeader.biYPelsPerMeter = 0 ;
bi.bmiHeader.biClrUsed = (numbits <= 8) ? 1 << numbits : 0;
bi.bmiHeader.biClrImportant = 0 ;
hr = AVIStreamSetFormat(context->pscomp, 0, &bi, bi.bmiHeader.biSize + bi.bmiHeader.biClrUsed * sizeof(RGBQUAD));
if (hr != AVIERR_OK) {
avi_cleanup_context(context);
free(context);
return NULL;
}
return (void *)context;
#else /* HAVE_VFW */
return NULL;
#endif /* HAVE_VFW*/
}
HRESULT CAVIGenerator::InitEngine()
{
AVISTREAMINFO strHdr; // information for a single stream
static AVICOMPRESSOPTIONS opts;
static AVICOMPRESSOPTIONS FAR * aopts[1] = {&opts};
static bool first = true;
TCHAR szBuffer[1024];
HRESULT hr;
m_sError=_T("Ok");
// Step 0 : Let's make sure we are running on 1.1
DWORD wVer = HIWORD(VideoForWindowsVersion());
if (wVer < 0x010a)
{
// oops, we are too old, blow out of here
m_sError=_T("Version of Video for Windows too old. Come on, join the 21th century!");
return S_FALSE;
}
// Step 1 : initialize AVI engine
AVIFileInit();
// Step 2 : Open the movie file for writing....
hr = AVIFileOpen(&m_pAVIFile, // Address to contain the new file interface pointer
(LPCSTR)m_sFile, // Null-terminated string containing the name of the file to open
OF_WRITE | OF_CREATE, // Access mode to use when opening the file.
NULL); // use handler determined from file extension.
// Name your file .avi -> very important
if (hr != AVIERR_OK)
{
// sprintf(szBuffer,_T("AVI Engine failed to initialize. Check filename %s."),m_sFile);
m_sError=szBuffer;
// Check it succeded.
switch(hr)
{
case AVIERR_BADFORMAT:
m_sError+=_T("The file couldn't be read, indicating a corrupt file or an unrecognized format.");
break;
case AVIERR_MEMORY:
m_sError+=_T("The file could not be opened because of insufficient memory.");
break;
case AVIERR_FILEREAD:
m_sError+=_T("A disk error occurred while reading the file.");
break;
case AVIERR_FILEOPEN:
m_sError+=_T("A disk error occurred while opening the file.");
break;
case REGDB_E_CLASSNOTREG:
m_sError+=_T("According to the registry, the type of file specified in AVIFileOpen does not have a handler to process it");
break;
}
return hr;
}
// Fill in the header for the video stream....
memset(&strHdr, 0, sizeof(strHdr));
strHdr.fccType = streamtypeVIDEO; // video stream type
strHdr.fccHandler = 0;
strHdr.dwScale = 1; // should be one for video
strHdr.dwRate = m_dwRate; // fps
strHdr.dwSuggestedBufferSize = m_bih.biSizeImage; // Recommended buffer size, in bytes, for the stream.
SetRect(&strHdr.rcFrame, 0, 0, // rectangle for stream
(int) m_bih.biWidth,
(int) m_bih.biHeight);
// Step 3 : Create the stream;
hr = AVIFileCreateStream(m_pAVIFile, // file pointer
&m_pStream, // returned stream pointer
&strHdr); // stream header
// Check it succeded.
if (hr != AVIERR_OK)
{
m_sError=_T("AVI Stream creation failed. Check Bitmap info.");
if (hr==AVIERR_READONLY)
{
m_sError+=_T(" Read only file.");
}
return hr;
}
// if (first)
{
// Step 4: Get codec and infos about codec
memset(&opts, 0, sizeof(opts));
// Poping codec dialog
if (!AVISaveOptions(NULL, 0, 1, &m_pStream, (LPAVICOMPRESSOPTIONS FAR *) &aopts))
{
AVISaveOptionsFree(1,(LPAVICOMPRESSOPTIONS FAR *) &aopts);
return S_FALSE;
}
// first = false;
}
// Step 5: Create a compressed stream using codec options.
hr = AVIMakeCompressedStream(&m_pStreamCompressed,
m_pStream,
&opts,
NULL);
if (hr != AVIERR_OK)
{
m_sError=_T("AVI Compressed Stream creation failed.");
switch(hr)
{
case AVIERR_NOCOMPRESSOR:
m_sError+=_T(" A suitable compressor cannot be found.");
break;
case AVIERR_MEMORY:
m_sError+=_T(" There is not enough memory to complete the operation.");
break;
case AVIERR_UNSUPPORTED:
m_sError+=_T("Compression is not supported for this type of data. This error might be returned if you try to compress data that is not audio or video.");
break;
}
return hr;
}
// releasing memory allocated by AVISaveOptionFree
hr = AVISaveOptionsFree(1,(LPAVICOMPRESSOPTIONS FAR *) &aopts);
if (hr!=AVIERR_OK)
{
m_sError=_T("Error releasing memory");
return hr;
}
// Step 6 : sets the format of a stream at the specified position
hr = AVIStreamSetFormat(m_pStreamCompressed,
0, // position
&m_bih, // stream format
m_bih.biSize + // format size
m_bih.biClrUsed * sizeof(RGBQUAD));
if (hr != AVIERR_OK)
{
m_sError=_T("AVI Compressed Stream format setting failed.");
return hr;
}
// Step 6 : Initialize step counter
m_lFrame=0;
return hr;
}
static int avi_open(const char* filename, const BITMAPINFOHEADER* pbmih, const WAVEFORMATEX* pwfex, const struct VideoSystemInfo* vsi)
{
int error = 1;
int result = 0;
do
{
// close existing first
FCEUI_AviEnd();
if(!truncate_existing(filename))
break;
if(!pbmih)
break;
// create the object
avi_create(&avi_file);
// set video size and framerate
avi_file->start_scanline = vsi->start_scanline;
avi_file->end_scanline = vsi->end_scanline;
//zero 20-oct-2012 - AVIFileClose has bugs in it which cause overflows in the calculation of dwTotalFrames, so some programs are unhappy with the resulting files.
//so I reduced the precision here by the minimum number of shifts necessary to make it not overflow
avi_file->fps = vsi->fps >> 3;
avi_file->fps_scale = (16 * 1024 * 1024) >> 3;
avi_file->convert_buffer = (uint8*)malloc(VIDEO_WIDTH*(vsi->end_scanline-vsi->start_scanline)*3);
// open the file
if(FAILED(AVIFileOpen(&avi_file->avi_file, filename, OF_CREATE | OF_WRITE, NULL)))
break;
// create the video stream
set_video_format(pbmih, avi_file);
memset(&avi_file->avi_video_header, 0, sizeof(AVISTREAMINFO));
avi_file->avi_video_header.fccType = streamtypeVIDEO;
avi_file->avi_video_header.dwScale = avi_file->fps_scale;
avi_file->avi_video_header.dwRate = avi_file->fps;
avi_file->avi_video_header.dwSuggestedBufferSize = avi_file->bitmap_format.biSizeImage;
if(FAILED(AVIFileCreateStream(avi_file->avi_file, &avi_file->streams[VIDEO_STREAM], &avi_file->avi_video_header)))
break;
if(use_prev_options)
{
avi_file->compress_options[VIDEO_STREAM] = saved_avi_info.compress_options[VIDEO_STREAM];
avi_file->compress_options_ptr[VIDEO_STREAM] = &avi_file->compress_options[0];
}
else
{
// get compression options
memset(&avi_file->compress_options[VIDEO_STREAM], 0, sizeof(AVICOMPRESSOPTIONS));
avi_file->compress_options_ptr[VIDEO_STREAM] = &avi_file->compress_options[0];
//retryAviSaveOptions: //mbg merge 7/17/06 removed
error = 0;
if(!AVISaveOptions(hAppWnd, 0, 1, &avi_file->streams[VIDEO_STREAM], &avi_file->compress_options_ptr[VIDEO_STREAM]))
break;
error = 1;
}
// create compressed stream
if(FAILED(AVIMakeCompressedStream(&avi_file->compressed_streams[VIDEO_STREAM], avi_file->streams[VIDEO_STREAM], &avi_file->compress_options[VIDEO_STREAM], NULL)))
break;
// set the stream format
if(FAILED(AVIStreamSetFormat(avi_file->compressed_streams[VIDEO_STREAM], 0, (void*)&avi_file->bitmap_format, avi_file->bitmap_format.biSize)))
break;
// add sound (if requested)
if(pwfex)
{
// add audio format
set_sound_format(pwfex, avi_file);
// create the audio stream
memset(&avi_file->avi_sound_header, 0, sizeof(AVISTREAMINFO));
avi_file->avi_sound_header.fccType = streamtypeAUDIO;
avi_file->avi_sound_header.dwQuality = (DWORD)-1;
avi_file->avi_sound_header.dwScale = avi_file->wave_format.nBlockAlign;
avi_file->avi_sound_header.dwRate = avi_file->wave_format.nAvgBytesPerSec;
avi_file->avi_sound_header.dwSampleSize = avi_file->wave_format.nBlockAlign;
avi_file->avi_sound_header.dwInitialFrames = 1;
if(FAILED(AVIFileCreateStream(avi_file->avi_file, &avi_file->streams[AUDIO_STREAM], &avi_file->avi_sound_header)))
break;
// AVISaveOptions doesn't seem to work for audio streams
// so here we just copy the pointer for the compressed stream
avi_file->compressed_streams[AUDIO_STREAM] = avi_file->streams[AUDIO_STREAM];
// set the stream format
if(FAILED(AVIStreamSetFormat(avi_file->compressed_streams[AUDIO_STREAM], 0, (void*)&avi_file->wave_format, sizeof(WAVEFORMATEX))))
break;
}
// initialize counters
avi_file->video_frames = 0;
avi_file->sound_samples = 0;
avi_file->tBytes = 0;
avi_file->ByteBuffer = 0;
avi_file->audio_buffer_pos = 0;
// success
error = 0;
result = 1;
avi_file->valid = 1;
} while(0);
if(!result)
{
avi_destroy(&avi_file);
if(error)
FCEUD_PrintError("Error writing AVI file");
}
return result;
}
int AVIBegin(const char* filename, struct AVIFile* _avi_out)
{
AVIFile& avi = *_avi_out;
int result = 0;
do
{
if(!avi.video_added)
break;
if(!truncate_existing(filename))
break;
// open the file
if(FAILED(AVIFileOpen(&avi.avi_file, filename, OF_CREATE | OF_WRITE, NULL)))
break;
// create the video stream
memset(&avi.avi_video_header, 0, sizeof(AVISTREAMINFO));
avi.avi_video_header.fccType = streamtypeVIDEO;
avi.avi_video_header.dwScale = avi.frameskip;
avi.avi_video_header.dwRate = avi.fps;
avi.avi_video_header.dwSuggestedBufferSize = avi.bitmap_format.biSizeImage;
if(FAILED(AVIFileCreateStream(avi.avi_file, &avi.streams[VIDEO_STREAM], &avi.avi_video_header)))
break;
// get compression options
memset(&avi.compress_options[VIDEO_STREAM], 0, sizeof(AVICOMPRESSOPTIONS));
avi.compress_options_ptr[VIDEO_STREAM] = &avi.compress_options[0];
if(!AVISaveOptions(GUI.hWnd, 0, 1, &avi.streams[VIDEO_STREAM], &avi.compress_options_ptr[VIDEO_STREAM]))
break;
// create compressed stream
if(FAILED(AVIMakeCompressedStream(&avi.compressed_streams[VIDEO_STREAM], avi.streams[VIDEO_STREAM], &avi.compress_options[VIDEO_STREAM], NULL)))
break;
// set the stream format
if(FAILED(AVIStreamSetFormat(avi.compressed_streams[VIDEO_STREAM], 0, (void*)&avi.bitmap_format, avi.bitmap_format.biSize)))
break;
// add sound (if requested)
if(avi.sound_added)
{
// create the audio stream
memset(&avi.avi_sound_header, 0, sizeof(AVISTREAMINFO));
avi.avi_sound_header.fccType = streamtypeAUDIO;
avi.avi_sound_header.dwQuality = (DWORD)-1;
avi.avi_sound_header.dwScale = avi.wave_format.nBlockAlign;
avi.avi_sound_header.dwRate = avi.wave_format.nAvgBytesPerSec;
avi.avi_sound_header.dwSampleSize = avi.wave_format.nBlockAlign;
avi.avi_sound_header.dwInitialFrames = 1;
if(FAILED(AVIFileCreateStream(avi.avi_file, &avi.streams[AUDIO_STREAM], &avi.avi_sound_header)))
break;
// AVISaveOptions doesn't seem to work for audio streams
// so here we just copy the pointer for the compressed stream
avi.compressed_streams[AUDIO_STREAM] = avi.streams[AUDIO_STREAM];
// set the stream format
if(FAILED(AVIStreamSetFormat(avi.compressed_streams[AUDIO_STREAM], 0, (void*)&avi.wave_format, sizeof(WAVEFORMATEX))))
break;
}
// initialize counters
avi.video_frames = 0;
avi.sound_samples = 0;
// success
result = 1;
avi.valid = true;
} while(false);
if(!result)
{
clean_up(&avi);
avi.valid = false;
}
return result;
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CAviRenderer
// - prototype : bool StartRender(CWindowGL *pWindowGL, std::string strAviFile, int nFramerate)
//
// - Purpose : Prepares the object for capturing the opengl window to an AVI.
//
// -----------------------------------------------------------------------------
bool CAviRenderer::StartRender(CWindowGL *pWindowGL, std::string strAviFile, int nFramerate)
{
assert(pWindowGL);
m_pWindowGL = NULL;
m_bIsWorking = false;
// Check VFW version.
WORD wVer = HIWORD(VideoForWindowsVersion());
if(wVer < 0x010A)
{
CLogger::ErrorWindow("Video For Windows outdated version");
return false;
}
// Init library
AVIFileInit();
// Get an image and stuff it into a bitmap.
HRESULT hr;
HBITMAP bmp;
if((bmp = LoadBMPFromFB(pWindowGL)) == NULL)
{
return false;
}
LPBITMAPINFOHEADER lpInfoHeader = (LPBITMAPINFOHEADER)GlobalLock(MakeDib(bmp, 32));
DeleteObject(bmp);
if(lpInfoHeader == NULL)
{
LOG.Write("\nERROR - CAviRenderer::StartRender(): GlobalLock() failed.");
return false;
}
m_nWidth = (int)lpInfoHeader->biWidth;
m_nHeight = (int)lpInfoHeader->biHeight;
// Open an avi file for writing
hr = AVIFileOpen( &m_pAviFile, // returned file pointer
strAviFile.data(), // file name
OF_WRITE | OF_CREATE, // mode to open file with
NULL); // use handler determined
// from file extension....
if (hr != AVIERR_OK)
{
LOG.Write("\nERROR - CAviRenderer::StartRender(): AVIFileOpen() failed.");
GlobalFreePtr(lpInfoHeader);
return false;
}
// Configure the stream
_fmemset(&m_aviStreamInfo, 0, sizeof(m_aviStreamInfo));
m_aviStreamInfo.fccType = streamtypeVIDEO; // stream type
m_aviStreamInfo.fccHandler = 0;
m_aviStreamInfo.dwScale = 1;
m_aviStreamInfo.dwRate = nFramerate;
m_aviStreamInfo.dwSuggestedBufferSize = lpInfoHeader->biSizeImage;
SetRect(&m_aviStreamInfo.rcFrame, 0, 0, // rectangle for stream
(int)lpInfoHeader->biWidth,
(int)lpInfoHeader->biHeight);
// And create the stream
hr = AVIFileCreateStream(m_pAviFile, // file pointer
&m_pAviStream, // returned stream pointer
&m_aviStreamInfo); // stream header
if(hr != AVIERR_OK)
{
LOG.Write("\nERROR - CAviRenderer::StartRender(): AVIFileCreateStream() failed.");
GlobalFreePtr(lpInfoHeader);
return false;
}
// Get save options (prompt dialog)
_fmemset(&m_aviOptions, 0, sizeof(m_aviOptions));
if(!AVISaveOptions(NULL, 0, 1, &m_pAviStream, (LPAVICOMPRESSOPTIONS FAR *) &m_pAviOptions))
{
LOG.Write("\nERROR - CAviRenderer::StartRender(): AVISaveOptions() failed.");
GlobalFreePtr(lpInfoHeader);
return false;
}
// Create compressed stream
hr = AVIMakeCompressedStream(&m_pAviStreamCompressed, m_pAviStream, &m_aviOptions, NULL);
if(hr != AVIERR_OK)
{
LOG.Write("\nERROR - CAviRenderer::StartRender(): AVIMakeCompressedStream() failed.");
GlobalFreePtr(lpInfoHeader);
return false;
}
// Set it's format
hr = AVIStreamSetFormat(m_pAviStreamCompressed, 0,
lpInfoHeader, // stream format
lpInfoHeader->biSize + // format size
lpInfoHeader->biClrUsed * sizeof(RGBQUAD));
if(hr != AVIERR_OK)
{
LOG.Write("\nERROR - CAviRenderer::StartRender(): AVIStreamSetFormat() failed.");
GlobalFreePtr(lpInfoHeader);
return false;
}
m_pWindowGL = pWindowGL;
m_bIsWorking = true;
UpdateWindow(pWindowGL->GetHWND());
return true;
}
int aviOpen(HWND hwndOwner, char* filename, int fps)
{
AVICOMPRESSOPTIONS options;
AVICOMPRESSOPTIONS* optionsPtr;
AVISTREAMINFO steamHdr;
AVISTREAMINFO soundHdr;
WAVEFORMATEX wfex;
BITMAPINFOHEADER bi;
AVIFileInit();
frameCount = 0;
sampleCount = 0;
aviStatusOk = 0;
if (AVIFileOpen(&aviFile, filename, OF_WRITE | OF_CREATE, NULL) != 0) {
return 0;
}
memset(&bi, 0, sizeof(bi));
bi.biSize = 0x28;
bi.biPlanes = 1;
bi.biBitCount = 32;
bi.biWidth = 320 * zoom;
bi.biHeight = 240 * zoom;
bi.biSizeImage = bi.biWidth * bi.biHeight * bi.biBitCount / 8;
memset(&steamHdr, 0, sizeof(steamHdr));
steamHdr.fccType = streamtypeVIDEO;
steamHdr.dwScale = 1;
steamHdr.dwRate = fps;
steamHdr.dwSuggestedBufferSize = bi.biSizeImage;
if (AVIFileCreateStream(aviFile, &aviStream, &steamHdr) != 0) {
return 0;
}
memset(&options, 0, sizeof(options));
optionsPtr = &options;
if (!AVISaveOptions(hwndOwner, 0, 1, &aviStream, &optionsPtr)) {
return 0;
}
if (AVIMakeCompressedStream(&aviVidStream, aviStream, &options, NULL) != 0) {
return 0;
}
// setup the video stream format
if (AVIStreamSetFormat(aviVidStream, 0, &bi, bi.biSize + bi.biClrUsed * sizeof(RGBQUAD)) != 0) {
return 0;
}
memset(&wfex, 0, sizeof(wfex));
wfex.wFormatTag = WAVE_FORMAT_PCM;
wfex.nChannels = 2;
wfex.nSamplesPerSec = 44100;
wfex.wBitsPerSample = 8 * sizeof(Int16);
wfex.nBlockAlign = wfex.nChannels * wfex.wBitsPerSample / 8;
wfex.nAvgBytesPerSec = wfex.nSamplesPerSec * wfex.nBlockAlign;
memset(&soundHdr, 0, sizeof(soundHdr));
soundHdr.fccType = streamtypeAUDIO;
soundHdr.dwQuality = (DWORD)-1;
soundHdr.dwScale = wfex.nBlockAlign;
soundHdr.dwInitialFrames = 0;
soundHdr.dwRate = wfex.nAvgBytesPerSec;
soundHdr.dwSampleSize = wfex.nBlockAlign;
if (AVIFileCreateStream(aviFile, &aviSndStream, &soundHdr) != 0) {
return 0;
}
if (AVIStreamSetFormat(aviSndStream, 0, (void *)&wfex, sizeof(wfex)) != 0) {
return 0;
}
aviStatusOk = 1;
return 1;
}
bool CAVIFile::AddFrame(CBitmap& bmp)
{
HRESULT hr;
// char szMessage[BUFSIZE];
if (!bOK)
return false;
LPBITMAPINFOHEADER alpbi = (LPBITMAPINFOHEADER)GlobalLock(MakeDib(bmp, 8));
if (alpbi == NULL)
return false;
if (xDim>=0 && xDim != alpbi->biWidth)
{
GlobalFreePtr(alpbi);
return false;
}
if (yDim>=0 && yDim != alpbi->biHeight)
{
GlobalFreePtr(alpbi);
return false;
}
xDim = alpbi->biWidth;
yDim = alpbi->biHeight;
if (nFrames == 0)
{
hr = AVIFileOpen(&pfile, // returned file pointer
FName, // file name
OF_WRITE | OF_CREATE, // mode to open file with
NULL); // use handler determined
// from file extension....
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
_fmemset(&strhdr, 0, sizeof(strhdr));
strhdr.fccType = streamtypeVIDEO;// stream type
strhdr.fccHandler = 0;
strhdr.dwScale = 1;
strhdr.dwRate = 15; // 15 fps
strhdr.dwSuggestedBufferSize = alpbi->biSizeImage;
SetRect(&strhdr.rcFrame, 0, 0, // rectangle for stream
(int) alpbi->biWidth,
(int) alpbi->biHeight);
// And create the stream;
hr = AVIFileCreateStream(pfile, // file pointer
&ps, // returned stream pointer
&strhdr); // stream header
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
_fmemset(&opts, 0, sizeof(opts));
if (!AVISaveOptions(NULL, 0, 1, &ps, (LPAVICOMPRESSOPTIONS FAR *) &aopts))
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
hr = AVIMakeCompressedStream(&psCompressed, ps, &opts, NULL);
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
hr = AVIStreamSetFormat(psCompressed, 0,
alpbi, // stream format
alpbi->biSize + // format size
alpbi->biClrUsed * sizeof(RGBQUAD));
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
// Fill in the stream header for the text stream....
// The text stream is in 60ths of a second....
/*
_fmemset(&strhdr, 0, sizeof(strhdr));
strhdr.fccType = streamtypeTEXT;
strhdr.fccHandler = mmioFOURCC('D', 'R', 'A', 'W');
strhdr.dwScale = 1;
strhdr.dwRate = 60;
strhdr.dwSuggestedBufferSize = sizeof(szText);
SetRect(&strhdr.rcFrame, 0, (int) alpbi->biHeight,
(int) alpbi->biWidth, (int) alpbi->biHeight + TEXT_HEIGHT);
// ....and create the stream.
hr = AVIFileCreateStream(pfile, &psText, &strhdr);
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
dwTextFormat = sizeof(dwTextFormat);
hr = AVIStreamSetFormat(psText, 0, &dwTextFormat, sizeof(dwTextFormat));
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
*/
}
// Jetzt eigentliches Schreiben
hr = AVIStreamWrite(psCompressed, // stream pointer
nFrames * 10, // time of this frame
1, // number to write
(LPBYTE) alpbi + // pointer to data
alpbi->biSize +
alpbi->biClrUsed * sizeof(RGBQUAD),
alpbi->biSizeImage, // size of this frame
AVIIF_KEYFRAME, // flags....
NULL,
NULL);
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
// Make some text to put in the file ...
//LoadString(hInstance, IDS_TEXTFORMAT, szMessage, BUFSIZE );
/*
strcpy(szMessage, "This is frame #%d");
int iLen = wsprintf(szText, szMessage, (int)(nFrames + 1));
// ... and write it as well.
hr = AVIStreamWrite(psText,
nFrames * 40,
1,
szText,
iLen + 1,
AVIIF_KEYFRAME,
NULL,
NULL);
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
*/
GlobalFreePtr(alpbi);
nFrames++;
return true;
}
bool MovieMaker::Snap()
{
HRESULT hr;
if (!bOK)
return false;
// Get an image and stuff it into a bitmap.
HBITMAP bmp;
bmp = LoadBMPFromFB( width, height );
LPBITMAPINFOHEADER alpbi = (LPBITMAPINFOHEADER)GlobalLock(MakeDib(bmp, 32));
DeleteObject( bmp );
if (alpbi == NULL)
{
bOK = false;
return false;
}
if (width>=0 && width != alpbi->biWidth)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
if (height>=0 && height != alpbi->biHeight)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
width = alpbi->biWidth;
height = alpbi->biHeight;
if (nFrames == 0)
{
hr = AVIFileOpenA(&pfile, // returned file pointer
fname, // file name
OF_WRITE | OF_CREATE, // mode to open file with
NULL); // use handler determined
// from file extension....
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
_fmemset(&strhdr, 0, sizeof(strhdr));
strhdr.fccType = streamtypeVIDEO;// stream type
strhdr.fccHandler = 0;
strhdr.dwScale = 1;
strhdr.dwRate = 15;
strhdr.dwSuggestedBufferSize = alpbi->biSizeImage;
SetRect(&strhdr.rcFrame, 0, 0, // rectangle for stream
(int) alpbi->biWidth,
(int) alpbi->biHeight);
// And create the stream;
hr = AVIFileCreateStream(pfile, // file pointer
&ps, // returned stream pointer
&strhdr); // stream header
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
_fmemset(&opts, 0, sizeof(opts));
if (!AVISaveOptions(NULL, ICMF_CHOOSE_KEYFRAME, 1, &ps, (LPAVICOMPRESSOPTIONS FAR *) &aopts))
{
fprintf( stderr, "AVISaveOptions failed.\n" );
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
hr = AVIMakeCompressedStream(&psCompressed, ps, &opts, NULL);
if (hr != AVIERR_OK)
{
fprintf( stderr, "AVIMakeCompressedStream failed.\n" );
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
hr = AVIStreamSetFormat(psCompressed, 0,
alpbi, // stream format
alpbi->biSize + // format size
alpbi->biClrUsed * sizeof(RGBQUAD));
if (hr != AVIERR_OK)
{
fprintf( stderr, "AVIStreamSetFormat failed.\n" );
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
// Fill in the stream header for the text stream....
// The text stream is in 60ths of a second....
/*
_fmemset(&strhdr, 0, sizeof(strhdr));
strhdr.fccType = streamtypeTEXT;
strhdr.fccHandler = mmioFOURCC('D', 'R', 'A', 'W');
strhdr.dwScale = 1;
strhdr.dwRate = 60;
strhdr.dwSuggestedBufferSize = sizeof(szText);
SetRect(&strhdr.rcFrame, 0, (int) alpbi->biHeight,
(int) alpbi->biWidth, (int) alpbi->biHeight + TEXT_HEIGHT);
// ....and create the stream.
hr = AVIFileCreateStream(pfile, &psText, &strhdr);
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
dwTextFormat = sizeof(dwTextFormat);
hr = AVIStreamSetFormat(psText, 0, &dwTextFormat, sizeof(dwTextFormat));
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
*/
}
// Now actual writing
hr = AVIStreamWrite(psCompressed, // stream pointer
nFrames * 1, // 10, // time of this frame
1, // number to write
(LPBYTE) alpbi + // pointer to data
alpbi->biSize +
alpbi->biClrUsed * sizeof(RGBQUAD),
alpbi->biSizeImage, // size of this frame
AVIIF_KEYFRAME, // flags....
NULL,
NULL);
if (hr != AVIERR_OK)
{
fprintf( stderr, "AVIStreamWrite failed.\n" );
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
// Make some text to put in the file ...
//LoadString(hInstance, IDS_TEXTFORMAT, szMessage, BUFSIZE );
/*
strcpy(szMessage, "This is frame #%d");
int iLen = wsprintf(szText, szMessage, (int)(nFrames + 1));
// ... and write it as well.
hr = AVIStreamWrite(psText,
nFrames * 40,
1,
szText,
iLen + 1,
AVIIF_KEYFRAME,
NULL,
NULL);
if (hr != AVIERR_OK)
{
GlobalFreePtr(alpbi);
bOK = false;
return false;
}
*/
GlobalFreePtr(alpbi);
nFrames++;
fprintf( stderr, "Wrote frame %d.\r", nFrames );
return true;
}
bool plAVIWriterImp::Open(const char* fileName, plPipeline* pipeline)
{
#if HS_BUILD_FOR_WIN32
// 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;
}
#endif
plgDispatch::Dispatch()->RegisterForExactType(plRenderMsg::Index(), GetKey());
return true;
}
static int avi_open(const char* filename, const BITMAPINFOHEADER* pbmih, const WAVEFORMATEX* pwfex)
{
int error = 1;
int result = 0;
do
{
// close existing first
DRV_AviEnd();
if(!truncate_existing(filename))
break;
if(!pbmih)
break;
// create the object
avi_create(&avi_file);
// set video size and framerate
/*avi_file->start_scanline = vsi->start_scanline;
avi_file->end_scanline = vsi->end_scanline;
avi_file->fps = vsi->fps;
avi_file->fps_scale = 16777216-1;
avi_file->convert_buffer = new u8[256*384*3];*/
// open the file
if(FAILED(AVIFileOpen(&avi_file->avi_file, filename, OF_CREATE | OF_WRITE, NULL)))
break;
// create the video stream
set_video_format(pbmih, avi_file);
memset(&avi_file->avi_video_header, 0, sizeof(AVISTREAMINFO));
avi_file->avi_video_header.fccType = streamtypeVIDEO;
avi_file->avi_video_header.dwScale = 6*355*263;
avi_file->avi_video_header.dwRate = 33513982;
avi_file->avi_video_header.dwSuggestedBufferSize = avi_file->bitmap_format.biSizeImage;
if(FAILED(AVIFileCreateStream(avi_file->avi_file, &avi_file->streams[VIDEO_STREAM], &avi_file->avi_video_header)))
break;
if(use_prev_options)
{
avi_file->compress_options[VIDEO_STREAM] = saved_avi_info.compress_options[VIDEO_STREAM];
avi_file->compress_options_ptr[VIDEO_STREAM] = &avi_file->compress_options[0];
}
else
{
// get compression options
memset(&avi_file->compress_options[VIDEO_STREAM], 0, sizeof(AVICOMPRESSOPTIONS));
avi_file->compress_options_ptr[VIDEO_STREAM] = &avi_file->compress_options[0];
//retryAviSaveOptions: //mbg merge 7/17/06 removed
error = 0;
if(!AVISaveOptions(MainWindow->getHWnd(), 0, 1, &avi_file->streams[VIDEO_STREAM], &avi_file->compress_options_ptr[VIDEO_STREAM]))
break;
error = 1;
}
// create compressed stream
if(FAILED(AVIMakeCompressedStream(&avi_file->compressed_streams[VIDEO_STREAM], avi_file->streams[VIDEO_STREAM], &avi_file->compress_options[VIDEO_STREAM], NULL)))
break;
// set the stream format
if(FAILED(AVIStreamSetFormat(avi_file->compressed_streams[VIDEO_STREAM], 0, (void*)&avi_file->bitmap_format, avi_file->bitmap_format.biSize)))
break;
// add sound (if requested)
if(pwfex)
{
// add audio format
set_sound_format(pwfex, avi_file);
// create the audio stream
memset(&avi_file->avi_sound_header, 0, sizeof(AVISTREAMINFO));
avi_file->avi_sound_header.fccType = streamtypeAUDIO;
avi_file->avi_sound_header.dwQuality = (DWORD)-1;
avi_file->avi_sound_header.dwScale = avi_file->wave_format.nBlockAlign;
avi_file->avi_sound_header.dwRate = avi_file->wave_format.nAvgBytesPerSec;
avi_file->avi_sound_header.dwSampleSize = avi_file->wave_format.nBlockAlign;
avi_file->avi_sound_header.dwInitialFrames = 1;
if(FAILED(AVIFileCreateStream(avi_file->avi_file, &avi_file->streams[AUDIO_STREAM], &avi_file->avi_sound_header)))
break;
// AVISaveOptions doesn't seem to work for audio streams
// so here we just copy the pointer for the compressed stream
avi_file->compressed_streams[AUDIO_STREAM] = avi_file->streams[AUDIO_STREAM];
// set the stream format
if(FAILED(AVIStreamSetFormat(avi_file->compressed_streams[AUDIO_STREAM], 0, (void*)&avi_file->wave_format, sizeof(WAVEFORMATEX))))
break;
}
// initialize counters
avi_file->video_frames = 0;
avi_file->sound_samples = 0;
avi_file->tBytes = 0;
avi_file->ByteBuffer = 0;
avi_file->audio_buffer_pos = 0;
// success
error = 0;
result = 1;
avi_file->valid = 1;
} while(0);
if(!result)
{
avi_destroy(&avi_file);
if(error)
EMU_PrintError("Error writing AVI file");
}
return result;
}
int AVIBegin(const char* filename, struct AVIFile* _avi_out)
{
AVIFile& avi = *_avi_out;
int result = 0;
do
{
if(!avi.video_added)
break;
if(!truncate_existing(filename))
break;
// open the file
if(FAILED(AVIFileOpen(&avi.avi_file, filename, OF_CREATE | OF_WRITE, NULL)))
break;
// create the video stream
memset(&avi.avi_video_header, 0, sizeof(AVISTREAMINFO));
avi.avi_video_header.fccType = streamtypeVIDEO;
avi.avi_video_header.dwScale = ONE_DOT_CYCLE*SNES_HCOUNTER_MAX*SNES_MAX_NTSC_VCOUNTER;
avi.avi_video_header.dwRate = (int)NTSC_MASTER_CLOCK;
avi.avi_video_header.dwSuggestedBufferSize = avi.bitmap_format.biSizeImage;
if(FAILED(AVIFileCreateStream(avi.avi_file, &avi.streams[VIDEO_STREAM], &avi.avi_video_header)))
break;
if(use_prev_options)
{
avi.compress_options[VIDEO_STREAM] = saved_avi_info.compress_options[VIDEO_STREAM];
avi.compress_options_ptr[VIDEO_STREAM] = &avi.compress_options[0];
}
else
{
// get compression options
memset(&avi.compress_options[VIDEO_STREAM], 0, sizeof(AVICOMPRESSOPTIONS));
avi.compress_options_ptr[VIDEO_STREAM] = &avi.compress_options[0];
if(!AVISaveOptions(GUI.hWnd, 0, 1, &avi.streams[VIDEO_STREAM], &avi.compress_options_ptr[VIDEO_STREAM]))
break;
}
// create compressed stream
if(FAILED(AVIMakeCompressedStream(&avi.compressed_streams[VIDEO_STREAM], avi.streams[VIDEO_STREAM], &avi.compress_options[VIDEO_STREAM], NULL)))
break;
// set the stream format
if(FAILED(AVIStreamSetFormat(avi.compressed_streams[VIDEO_STREAM], 0, (void*)&avi.bitmap_format, avi.bitmap_format.biSize)))
break;
// add sound (if requested)
if(avi.sound_added)
{
// create the audio stream
memset(&avi.avi_sound_header, 0, sizeof(AVISTREAMINFO));
avi.avi_sound_header.fccType = streamtypeAUDIO;
avi.avi_sound_header.dwQuality = (DWORD)-1;
avi.avi_sound_header.dwScale = avi.wave_format.nBlockAlign;
avi.avi_sound_header.dwRate = avi.wave_format.nAvgBytesPerSec;
avi.avi_sound_header.dwSampleSize = avi.wave_format.nBlockAlign;
avi.avi_sound_header.dwInitialFrames = 1;
if(FAILED(AVIFileCreateStream(avi.avi_file, &avi.streams[AUDIO_STREAM], &avi.avi_sound_header)))
break;
// AVISaveOptions doesn't seem to work for audio streams
// so here we just copy the pointer for the compressed stream
avi.compressed_streams[AUDIO_STREAM] = avi.streams[AUDIO_STREAM];
// set the stream format
if(FAILED(AVIStreamSetFormat(avi.compressed_streams[AUDIO_STREAM], 0, (void*)&avi.wave_format, sizeof(WAVEFORMATEX))))
break;
}
// initialize counters
avi.video_frames = 0;
avi.sound_samples = 0;
avi.tBytes = 0;
avi.ByteBuffer = 0;
avi.audio_buffer_pos = 0;
strncpy(saved_cur_avi_fnameandext,filename,MAX_PATH);
strncpy(saved_avi_fname,filename,MAX_PATH);
char* dot = strrchr(saved_avi_fname, '.');
if(dot && dot > strrchr(saved_avi_fname, '/') && dot > strrchr(saved_avi_fname, '\\'))
{
strcpy(saved_avi_ext,dot);
dot[0]='\0';
}
// success
result = 1;
avi.valid = true;
} while(false);
if(!result)
{
clean_up(&avi);
avi.valid = false;
}
return result;
}
//在錄製OpengL動畫之前，首先需要設置AVI文件名稱、錄製幀的大小、錄製幀率、AVI文件壓縮方式等信息，具體的源代碼如下：
bool CAVICapture::start(CString filename,int w, int h,float fps)
{
if (capturing)
return false;
width = w;
height = h;
frameRate = fps;
if (HIWORD(VideoForWindowsVersion()) < 0x010a)
{
// 版本號必須大於1.1
return false;
}
int rowBytes = (width * 3 + 3) & ~0x3;
image = new unsigned char[rowBytes * height];
// 創建AVI文件
HRESULT hr = AVIFileOpen(&aviFile,
filename,
OF_WRITE | OF_CREATE,
NULL);
if (hr != AVIERR_OK)
{
MessageBox(NULL,"創建AVI文件失敗","錯誤",MB_OK);
return false;
}
// AVI文件的頭信息
AVISTREAMINFO info;
ZeroMemory(&info, sizeof info);
info.fccType = streamtypeVIDEO;
info.fccHandler = 0;
info.dwScale = 1;
info.dwRate = (DWORD) frameRate;
info.dwSuggestedBufferSize = rowBytes * height;
SetRect(&info.rcFrame, 0, 0, width, height);
hr = AVIFileCreateStream(aviFile, &aviStream, &info);//創建AVI文件流
if (hr != AVIERR_OK)
{
MessageBox(NULL,"創建AVI文件流失敗","錯誤",MB_OK);
cleanup(); //清空內存
return false;
}
// 允許用戶選擇壓縮方式
AVICOMPRESSOPTIONS options;
AVICOMPRESSOPTIONS* arrOptions[1] = { &options };
ZeroMemory(&options, sizeof options);
if (!AVISaveOptions(NULL, 0, 1, &aviStream,
(LPAVICOMPRESSOPTIONS*) &arrOptions))
{
cleanup();//清空內存
return false;
}
//設置AVI壓縮方式
hr = AVIMakeCompressedStream(&compAviStream, aviStream, &options, NULL);
if (hr != AVIERR_OK)
{
MessageBox(NULL,"設置AVI壓縮方式失敗", "錯誤",MB_OK);
cleanup();//清空內存
return false;
}
BITMAPINFOHEADER bi;
ZeroMemory(&bi, sizeof bi);
bi.biSize = sizeof bi;
bi.biWidth = width;
bi.biHeight = height;
bi.biPlanes = 1;
bi.biBitCount = 24;
bi.biCompression = BI_RGB;
bi.biSizeImage = rowBytes * height;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
// 設置數據格式
hr = AVIStreamSetFormat(compAviStream, 0, &bi, sizeof bi);
if (hr != AVIERR_OK)
{
MessageBox(NULL,"設置AVI數據格式","錯誤",MB_OK);
cleanup();//清空內存
return false;
}
capturing = true;
frameCounter = 0;
return true;
}
boolean VFWInit(){
AVIFileInit();
CoInitialize(NULL);
std::stringstream filename;
filename << directory<< "TheVideo.avi\0";
pfile = new PAVIFILE();
VFWReturnVal = AVIFileOpen(pfile, filename.str().c_str(),OF_SHARE_DENY_WRITE|OF_CREATE,0L);
if(VFWReturnVal !=0 ){
return false;
}
AVISTREAMINFO* strhdr = new AVISTREAMINFO();// ZeroMemory(&strhdr,sizeof(strhdr));
strhdr->fccType = streamtypeVIDEO;// stream type
strhdr->fccHandler = 0;
strhdr->dwScale = 1;
strhdr->dwRate = 60;//10;//100;//*/1000;
pstream = new PAVISTREAM();
VFWReturnVal = AVIFileCreateStream(*pfile,pstream,strhdr);
if(VFWReturnVal !=0 ){
return false;
}
poptions = new AVICOMPRESSOPTIONS();
aopts[0] = poptions;
AVISaveOptions(hWnd,0,1, pstream,aopts);
DWORD flag=poptions->dwFlags &AVICOMPRESSF_VALID;
if(!(poptions->dwFlags &AVICOMPRESSF_VALID)){
delete poptions;
return false;
}
pcompressedstream = new PAVISTREAM();
VFWReturnVal = AVIMakeCompressedStream(pcompressedstream,*pstream,aopts[0],NULL);
if(VFWReturnVal !=AVIERR_OK ){
AVIStreamRelease(*pcompressedstream);
delete(pcompressedstream);
AVIStreamRelease(*pstream);
delete pstream;
AVISaveOptionsFree(1,aopts);
AVIFileRelease(*pfile);
return false;
}
bi = new BITMAPINFOHEADER();
bi->biSize = sizeof (BITMAPINFOHEADER);
bi->biWidth = simWidth;
bi->biHeight = simHeight;
bi->biPlanes = 1;
bi->biBitCount = 32;
bi->biCompression = BI_RGB;
bi->biSizeImage = ((bi->biWidth*bi->biBitCount/8)*bi->biHeight);
bi->biXPelsPerMeter = 14173;
bi->biYPelsPerMeter = 14173;
bi->biClrUsed = 0;
bi->biClrImportant = 0;
VFWReturnVal = AVIStreamSetFormat(*pcompressedstream,0,bi,bi->biSize);
if(VFWReturnVal != 0 ){
AVIStreamRelease(*pcompressedstream);
delete(pcompressedstream);
AVIStreamRelease(*pstream);
delete pstream;
AVISaveOptionsFree(1,aopts);
AVIFileRelease(*pfile);
return false;
}
return true;
}