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; }