C++ cvReleaseVideoWriter函数代码示例

void Video_OP::Turn_Pics_into_Video(string *file_names_arr, int arr_size, int frame_rate)
{
	    // load first image of filename array
        IplImage *img = cvLoadImage(file_names_arr[0].c_str());

		// determine size of image for CvVideoWriter
		CvSize size = cvSize(img->width,img->height);

		string file_name_movie = file_names_arr[0];
		// file-ending avi is added to filename of video
		file_name_movie += ".avi";
		
        //Creates Video Writer; parameters: (1) path where video is stored; (2) Codec for videooutput;
		  //(3) frame rate; (4) size of image to be stored; (5) is_color is optional; if 0 => black/white
	    CvVideoWriter *video_writer = cvCreateVideoWriter(file_name_movie.c_str(), CV_FOURCC('M','J','P','G'), //corresponding codec must be installed on machine
         frame_rate,size);

		// adds first image to videofile
		int x = cvWriteFrame(video_writer,img);

		// loops that loads images whose names are stored in array
		// and adds images to avi file
		for(int i = 1; i < arr_size; i++)
		{
           img = cvLoadImage(file_names_arr[i].c_str());
		   x = cvWriteFrame(video_writer,img);
		
		}

		cvReleaseVideoWriter(&video_writer);
		cvReleaseImage(&img);

}

int main(int argc, const char * argv[]) {
    CvCapture* capture = cvCreateFileCapture( argv[1] );
    if (!capture) return -1;
    
    IplImage* bgr_frame = cvQueryFrame( capture );
    double fps = cvGetCaptureProperty( capture ,  CV_CAP_PROP_FPS );
    CvSize size = cvSize(
        (int)cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH),
        (int)cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT)
    );
    CvVideoWriter* writer = cvCreateVideoWriter( argv[2], CV_FOURCC('M', 'J', 'P', 'G'), fps, size);
    IplImage* logpolar_frame = cvCreateImage(size, IPL_DEPTH_8U, 3);
    
    while ( (bgr_frame = cvQueryFrame(capture)) != NULL ) {
        cvLogPolar(bgr_frame, logpolar_frame,
                   cvPoint2D32f(bgr_frame->width/2, bgr_frame->height/2),
                   40,
                   CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS );
        cvWriteFrame(writer, logpolar_frame);
    }
    cvReleaseVideoWriter( &writer );
    cvReleaseImage( &logpolar_frame );
    cvReleaseCapture( &capture );
    return 0;
}

bool CaptureManager::SaveMovie(const char* avi)
{
	bool resize = false;
	CvSize newsize = size;
	if ( Preferences::GetSavingSizeOverride() && !cvSizeEquals(Preferences::GetSavingSize(), size) ){
		resize = true;
		newsize = Preferences::GetSavingSize();
	}
	CvVideoWriter* writer = cvCreateVideoWriter(avi,
		Preferences::GetSavingCodec(),
		Preferences::GetSavingFpsOverride() || !fps ? Preferences::GetSavingFpsDefault() : fps,
		newsize, 1);
	IplImage *resized;
	if (resize)
		resized = cvCreateImage(newsize,8,3);
	IplImage *frame_flip = cvCreateImage(newsize,8,3);
	wxProgressDialog progressDlg(_T("Saving movie..."), wxString::Format(_T("Frame 0 of %d"), frameCount),frameCount, NULL, wxPD_APP_MODAL|wxPD_ELAPSED_TIME|wxPD_REMAINING_TIME|wxPD_AUTO_HIDE);
	for (int i=0; i<frameCount; i++) {
		progressDlg.Update(i+1, wxString::Format(_T("Frame %d of %d"), i+1, frameCount));
		if (resize)
			cvResize(book[i*offset]->ToIplImage(), resized);
		else
			resized = book[i*offset]->ToIplImage();
		cvConvertImage( resized, frame_flip, CV_CVTIMG_SWAP_RB );
		cvWriteFrame(writer, frame_flip);
	}
	cvReleaseVideoWriter(&writer);
	cvReleaseImage(&frame_flip);
	frame_flip = NULL;
	if (resize)
		cvReleaseImage(&resized);
	return true;
}

void			Tracker::replayTracker(vector<Matrixu> &vid, string statesfile, string outputvid, uint R, uint G, uint B)
{
	Matrixf states;
	states.DLMRead(statesfile.c_str());
	Matrixu colorframe;

	// save video file
	CvVideoWriter* w = NULL;
	if( ! outputvid.empty() ){
		w = cvCreateVideoWriter( outputvid.c_str(), CV_FOURCC('I','Y','U','V'), 15, cvSize(vid[0].cols(), vid[0].rows()), 3 );
		if( w==NULL ) abortError(__LINE__,__FILE__,"Error opening video file for output");
	}

	for( uint k=0; k<vid.size(); k++ )
	{	
		vid[k].conv2RGB(colorframe);
		colorframe.drawRect(states(k,2),states(k,3),states(k,0),states(k,1),1,0,2,R,G,B);
		colorframe.drawText(("#"+int2str(k,3)).c_str(),1,25,255,255,0);
		colorframe._keepIpl=true;
		colorframe.display(1,2);
		cvWaitKey(1);
		if( w != NULL )
			cvWriteFrame( w, colorframe.getIpl() );
		colorframe._keepIpl=false; colorframe.freeIpl();
	}

	// clean up
	if( w != NULL )
		cvReleaseVideoWriter( &w );
}

int main(int argc, char * const argv[])
{
	/* Initialize the camera */
	CvCapture *CamCapture = 0;
	CamCapture = cvCreateFileCapture("http://192.168.2.135:81/videostream.asf?user=viki&pwd=viki&resolution=640*480");
	if (!CamCapture)
	{printf("IP Cam not ready\n");
	return -1;}
	/* initialize video writer */
	CvVideoWriter *IPCamWriter = 0;
	CvSize size;
	size.width = 640;
	size.height = 480;
	IPCamWriter = cvCreateVideoWriter("/home/viki/Videos/IPCamOut.avi", CV_FOURCC('D','I','V','X'), 4, size, 1); //needs time index in naming

	/* time */
	time_t current_time;
	current_time = time (NULL);
	long int stop_time = current_time + 10;
	
	/* main loop */
	while( current_time < stop_time )
		{
		/* write image to file */
		cvWriteFrame(IPCamWriter, cvQueryFrame( CamCapture ));
		}
 
	/* Clean up memory */
	cvReleaseCapture ( &CamCapture );
	cvReleaseVideoWriter(&IPCamWriter);
}

int main(int argc, char* argv[])
{

  int frame = 11;
  CvMat *orientation = cvCreateMat(3,3,CV_32FC1);
  cvSetIdentity(orientation);
  CvVideoWriter *writer = 0;
  int isColor = 1;
  int fps     = 30;
  int frameW  = 1280;
  int frameH  = 720;
  writer=cvCreateVideoWriter("/Users/kroo/Desktop/out.avi",-1,
    fps,cvSize(frameW,frameH),isColor);
 
 
  int firstFrame = 22560;
  int lastFrame = 26640;
  
  for(frame = firstFrame+1; frame<lastFrame-1; frame++) {
    char firstImage  [32];
    char secondImage [32];
    // char outImage    [64];
    sprintf(firstImage, "frame%d.ppm", frame);
    sprintf(secondImage, "frame%d.ppm", frame+1);
    // sprintf(outImage, "global_frame%d.png", frame+1);
    processImagePair(firstImage, secondImage, writer, orientation);
  }
 
  cvReleaseVideoWriter(&writer);
 
	return 0;
}

int main(int argc, char** argv){
  setupVideoWriting();

  int width = image_width;
  int height = image_height;

  setupBoard(width, height, argc, argv);

  setupScreen(width, height);

  initShaders();

  loadTexture();
  setupTexture();

  setupBuffers();

  glutDisplayFunc(&drawScene);
  glutIdleFunc(&replay);

  glutMainLoop();

  cvReleaseVideoWriter(&writer);
  return 0;
}

int main()
{
    CvCapture *capture;
    IplImage *frame;

    capture=cvCreateCameraCapture(0);
    cvNamedWindow("Webcam",0);

    CvVideoWriter *writer = NULL;
    char AviFileName[]="Output.avi";
    int AviForamt = 1;
    int FPS = 20;
    CvSize AviSize = cvSize(640,480);
    int AviColor = 1;
    writer=cvCreateVideoWriter(AviFileName, CV_FOURCC('P','I','M','1'), FPS,AviSize,AviColor);
	if(writer == NULL)
		printf("writer null..\n");

    int i=0;
    while(true)
    {
        frame = cvQueryFrame(capture);
        cvWriteFrame(writer,frame);

        cvShowImage("Webcam",frame);
        printf("%d\n",i);

        if(cvWaitKey(20)>0)     break;
        i++;
    }

    cvReleaseCapture(&capture);
    cvReleaseVideoWriter(&writer);
    cvDestroyWindow("Webcam");
}

StereoDisplay::~StereoDisplay(void)									// Any User DeInitialization Goes Here
{
    if( true == recording_  )
      cvReleaseVideoWriter(&writer_);
    delete camera0_;
    delete camera1_;
}

    bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa)
	{
		switch(ea.getEventType())
		{
			case(osgGA::GUIEventAdapter::KEYDOWN):
			{
				switch(ea.getKey())
				{
				case 'f':
				case 'F':
					flip = !flip;
					break;
				case 'q':
				case 'Q':
					if(writer) cvReleaseVideoWriter(&writer);
					if(capture) cvReleaseCapture(&capture);
					exit(0);
					break;
				case ' ':
					tracker->GetDetector()->SetThreshold(15.0);
					tracker->AttatchReferenceImage(gray);
					tracker->TrainingReference(4.0, 8);
					tracker->GetDetector()->SetThreshold(fastThreshold);
					break;
				}
			}
			break;
			default:
				return false;
				break;
		}	
	}

void Image_to_video()
{
int i = 0;
IplImage* img = 0;
char image_name[13];
printf("------------- image to video ... ----------------\n");
//初始化视频编写器，参数根据实际视频文件修改
CvVideoWriter *writer = 0;
int isColor = 1;
int fps     = 30; // or 25
int frameW = 400; // 744 for firewire cameras
int frameH = 240; // 480 for firewire cameras
writer=cvCreateVideoWriter("out.avi",CV_FOURCC('X','V','I','D'),fps,cvSize(frameW,frameH),isColor);
printf("\tvideo height : %d\n\tvideo width : %d\n\tfps : %d\n", frameH, frameW, fps);
//创建窗口
cvNamedWindow( "mainWin", CV_WINDOW_AUTOSIZE );
while(i<NUM_FRAME)
{
   sprintf(image_name, "%s%d%s", "image", ++i, ".jpg");
   img = cvLoadImage(image_name);
   if(!img)
   {
    printf("Could not load image file...\n");
    exit(0);
   }
   cvShowImage("mainWin", img);
   char key = cvWaitKey(20);
   cvWriteFrame(writer, img);
}
cvReleaseVideoWriter(&writer);
cvDestroyWindow("mainWin");
}

void CRecordProcessor::init(QSettings* settings)
{
    time_t rawtime;
    struct tm * timeinfo;
    char buffer [80];


    QObject::connect( this, SIGNAL(updateFileText(QString)), parentwnd, SLOT(getFileText(QString)));
    QString txt = tr("none");
    emit updateFileText( txt );

    CvSize imgsize = imgdb->getImageSize();

    time ( &rawtime );
    timeinfo = localtime ( &rawtime );

    strftime (buffer,80,"sensbli-%Y-%m-%d_%H%M%S.avi",timeinfo);

    if( outfile != NULL )
    {
    	cvReleaseVideoWriter( &outfile );
    }
	outfile =cvCreateVideoWriter( buffer, CV_FOURCC('I','Y','U','V'), 25, cvSize(640,480), 1);

	QString filetext = buffer;
	emit updateFileText( filetext );


}

int
main(int argc, char *argv[])
{
    CvCapture *capture = NULL;
    IplImage *src_frame, *image, *dst_frame;
    char *infile, *outfile;
    Matrix matrix;
    Args args;
    int64 t0, t1;
    double tps, deltatime;
    CvVideoWriter *writer;
    CvSize size;
    double fps;
    int frame_count;
    int i;

    infile = argv[1];
    outfile = argv[2];
    args.c = argc - 3;
    for (i = 0; i < 3; i++)
        args.v[i] = argv[i + 3];
    capture = cvCaptureFromFile(infile);
    if (capture == NULL) {
        printf("Could not load video \"%s\".\n", infile);
        return EXIT_FAILURE;
    }
    src_frame = cvQueryFrame(capture);
    fps = cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);
    size = cvSize(
        (int) cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH),
        (int) cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT)
    );
    writer = cvCreateVideoWriter(outfile, CV_FOURCC('M', 'J', 'P', 'G'), fps, size, 1);
    printf("Saving to \"%s\"...\n", outfile);
    image = cvCreateImage(size, IPL_DEPTH_8U, 1);
    dst_frame = cvCreateImage(size, IPL_DEPTH_8U, 3);
    matrix.width = dst_frame->width;
    matrix.height = dst_frame->height;
    frame_count = 0;
    t0 = cvGetTickCount();
    while ((src_frame = cvQueryFrame(capture)) != NULL) {
        cvCvtColor(src_frame, image, CV_BGR2GRAY);
        matrix.data = (unsigned char *) image->imageData;
        proc(&matrix, &args);
        cvCvtColor(image, dst_frame, CV_GRAY2BGR);
        cvWriteFrame(writer, dst_frame);
        frame_count++;
    }
    t1 = cvGetTickCount();
    tps = cvGetTickFrequency() * 1.0e6;
    deltatime = (double) (t1 - t0) / tps;
    printf("%d frames of %dx%d processed in %.3f seconds.\n",
           frame_count, dst_frame->width, dst_frame->height,
           deltatime);
    cvReleaseVideoWriter(&writer);
    cvReleaseImage(&dst_frame);
    cvReleaseCapture(&capture);
    return EXIT_SUCCESS;
}

int
main (int argc, char **argv)
{
  CvCapture *capture = 0;
  IplImage *frame = 0;
  CvVideoWriter *writer;
  int c, num = 0;
  //CvFont font;
  //char str[64];

  double fps, width, height;
  if ( argc == 1 || (argc >= 2 && strlen (argv[1]) == 1 && isdigit (argv[1][0])) )
  {
    capture = cvCreateCameraCapture (argc == 2 ? argv[1][0] - '0' : 0);
    fps     = 20.0;
    width   = 320;
    height  = 240;
    //fps     = cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);
    //cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_WIDTH, width);
    //cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_HEIGHT, height);
  }
  else if ( argc >= 2 )
  {
    capture = cvCaptureFromFile(argv[1]);
    fps     = cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);
    width   = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH);
    height  = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT);
  }
  printf ("fps=%f width=%f height=%f\n", fps, width, height);

  printf ("Write to cap.avi. Finish with Esc.\n");
  // FourCC http://www.fourcc.org/codecs.php
  //writer = cvCreateVideoWriter( "cap.avi", 
  //                              CV_FOURCC('D','I','V','X'),
  //                              fps, cvSize((int)width,(int)height) );
  writer = cvCreateVideoWriter( "cap.avi", -1,
      fps, cvSize((int)width,(int)height) );

  //cvInitFont (&font, CV_FONT_HERSHEY_COMPLEX, 0.7, 0.7);
  cvNamedWindow ("Capture", CV_WINDOW_AUTOSIZE);

  while (1) {
    frame = cvQueryFrame (capture);
    if( frame == NULL ) break;
    //snprintf (str, 64, "%03d[frame]", num);
    //cvPutText (frame, str, cvPoint (10, 20), &font, CV_RGB (0, 255, 100));
    cvWriteFrame (writer, frame);
    cvShowImage ("Capture", frame);
    num++;
    c = cvWaitKey (10);
    if (c == 'q') // exit
      break;
  }
  cvReleaseVideoWriter (&writer);
  cvReleaseCapture (&capture);
  cvDestroyWindow ("Capture");

  return 0;
}

void MainWindow::ReleaseVideoWriter()
{
	if (writer)
	{
		cvReleaseVideoWriter(&writer);
		writer = NULL;
	}
}