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; }
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"); }
static int interpolate(double k, CvVideoWriter *out, IplImage *p, IplImage *n) { static double late; int i, times; IplImage *img; img = cvCreateImage(cvSize(p->width, p->height), p->depth, p->nChannels); if (!img) { ERROR("Failed to create container for interpolated frame"); return -1; } late += k; times = late; late -= times; for (i = 0; i < times; ++i) { blend(p, n, (float)i / times, img); cvWriteFrame(out, img); } cvReleaseImage(&img); return 0; }
bool mitk::MovieGeneratorOpenCV::AddFrame( void *data ) { //cvSetImageData(m_currentFrame,data,m_width*3); memcpy(m_currentFrame->imageData,data,m_width*m_height*3); cvWriteFrame(m_aviWriter,m_currentFrame); return true; }
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"); }
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 ); }
void CRecordProcessor::process() { if( outfile != NULL) { cvWriteFrame( outfile, imgdb->get_actual_image()); } }
void THISCLASS::BufferedFrames_Write() { for (int i = 0; i < mFrameBufferWriteCounter; i++) { cvWriteFrame(mWriter, mFrameBuffer[i]); cvReleaseImage(&(mFrameBuffer[i])); } mFrameBufferWriteCounter = 0; }
int main(int argc, char **argv) { struct ctx ctx = { }; int key; char *imageFile = argv[1]; ctx.image = cvLoadImage(imageFile, 1); //init_capture(&ctx); //init_recording(&ctx); init_windows(); init_ctx(&ctx); //do { // ctx.image = cvQueryFrame(ctx.capture); //ctx.image = cvLoadImage("/home/csrobot/Downloads/grab_box/images/OtivvoH.jpg", 1); //fprintf(stdout, "image loaded\n"); filter_and_threshold(&ctx); find_contour(&ctx); find_convex_hull(&ctx); find_fingers(&ctx); display(&ctx); cvWriteFrame(ctx.writer, ctx.image); key = cvWaitKey(0); //} while (key != 'q'); return 0; }
void MT_MovieExporter::saveFrame(const IplImage* frame) { m_iNumSinceLastFrame++; char _filename[MAX_FILENAME_LENGTH]; if(m_iNumSinceLastFrame < m_iSkip) { return; } switch(m_METype) { case MT_ME_CV_VIDEO_WRITER: #ifndef MT_NO_OPENCV cvWriteFrame(m_pVideoWriter, frame); #endif break; case MT_ME_IMAGE_SEQUENCE: sprintf(_filename, m_sFilename.c_str(), m_iFrameNumber); #ifndef MT_NO_OPENCV cvSaveImage(_filename, frame); #endif break; case MT_ME_NONE: default: break; } m_iNumSinceLastFrame = 0; m_iFrameNumber++; }
Integer CV_Video_Writer__write_frame( CV_Video_Writer writer, CV_Image frame) { return cvWriteFrame(writer, frame); }
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); }
void write_video_frame(raster_t *image, char *path, double fps, int action) // FIXME can only handle one video file at a time { static CvVideoWriter *writer=NULL; static IplImage *frame=NULL; return ; if (action==0 && path) // initiate new file { if (writer) { cvReleaseVideoWriter(writer); cvReleaseImage(frame); } writer = cvCreateVideoWriter(path, CV_FOURCC('X','V','I','D'), fps, cvSize(image->dim.x, image->dim.y), 1); frame = cvCreateImage(cvSize(image->dim.x, image->dim.y), IPL_DEPTH_8U, 3); } if (action==2 && writer) // close and clean up { cvReleaseImage(frame); // FIXME crashes frame = NULL; cvReleaseVideoWriter(writer); writer = NULL; } if (action==1 && writer) { convert_srgb_to_cvimage(image, frame); cvWriteFrame(writer, frame); } }
void StereoDisplay::Draw() // Draw Our Scene { IplImage* camera_image; GLfloat z=-20.0; if( show_right_ == TRUE) camera_image = camera1_->QueryFrame(); else camera_image = camera0_->QueryFrame(); show_right_ = !show_right_; glLoadIdentity(); // Reset The Modelview Matrix glBegin(GL_QUADS); // Begin drawing the image texture // Front Face glTexCoord2f(1.0f, 1.0f); glVertex3f( 11.0f, 8.3f, z); glTexCoord2f(0.0f, 1.0f); glVertex3f(-11.0f, 8.3f, z); glTexCoord2f(0.0f, 0.0f); glVertex3f(-11.0f, -8.3f, z); glTexCoord2f(1.0f, 0.0f); glVertex3f( 11.0f, -8.3f, z); glEnd(); // Done drawing texture glFlush (); // Flush The GL Rendering Pipeline if( true == recording_ ) { cvLogPolar( camera_image, logpolarframe_, cvPoint2D32f(camera_image->width/2,camera_image->height/2), 40, CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS); cvWriteFrame( writer_, logpolarframe_); } }
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 Tracker::saveFrame(CvVideoWriter* writer) { void* frame = psmove_tracker_get_frame(m_tracker); if (frame) { cvWriteFrame(writer, (const IplImage*) frame); } else { std::cout << "Frame failed to save" << std::endl; } }
void OpenCVVideoWriter::write(const ImgBase *image){ ICLASSERT_RETURN(image); ICLASSERT_RETURN(image->getDim()); ICLASSERT_RETURN(image->getChannels()); IplImage *im = 0; im = core::img_to_ipl(image,&im); cvWriteFrame(writer,im ); cvReleaseImage(&im); }
static void screenCapture(int width, int height){ unsigned char *raw_image = (unsigned char*) calloc(width * height * 3, sizeof(char)); glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, raw_image); IplImage* img = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 3); img->imageData = (char *)raw_image; cvWriteFrame(writer, img); // add the frame to the file cvReleaseImage(&img); }
//Write image to output int videoWriter::imageToWriter(IplImage * frame) { if (!this->writerOpen) return WRITER_ERROR_WRITER_NOT_OPEN; if (frame == 0) { return WRITER_ERROR_NO_FRAME; } cvWriteFrame(this->writer,frame); return WRITER_OK; }
int main(int arg, char** args) { int count = psmove_count_connected(); int i; void *frame; if (count == 0) { printf("No controllers connected.\n"); return 1; } PSMove **moves = (PSMove **)calloc(count, sizeof(PSMove *)); PSMoveTracker* tracker = psmove_tracker_new(); for (i=0; i<count; i++) { moves[i] = psmove_connect_by_id(i); assert(moves[i] != NULL); while (psmove_tracker_enable(tracker, moves[i]) != Tracker_CALIBRATED); } unsigned char r, g, b; psmove_tracker_get_camera_color(tracker, moves[0], &r, &g, &b); printf("Controller color: %02x%02x%02x\n", r, g, b); CvVideoWriter *writer = cvCreateVideoWriter("out.avi", CV_FOURCC('M','J','P','G'), 30, cvSize(640, 480), 1); while ((cvWaitKey(1) & 0xFF) != 27) { psmove_tracker_update_image(tracker); psmove_tracker_update(tracker, NULL); frame = psmove_tracker_get_frame(tracker); if (frame) { cvWriteFrame(writer, frame); } psmove_tracker_annotate(tracker); frame = psmove_tracker_get_frame(tracker); if (frame) { cvShowImage("live camera feed", frame); } } cvReleaseVideoWriter(&writer); for (i=0; i<count; i++) { psmove_disconnect(moves[i]); } psmove_tracker_free(tracker); free(moves); return 0; }
void *record_main(void *data) { RecWindow *window = (RecWindow*)data; IplImage *imagesrc = cvQueryFrame(window->capture);//Init the video read double fps = 30; CvSize size = cvSize((int)cvGetCaptureProperty( window->capture, CV_CAP_PROP_FRAME_WIDTH), (int)cvGetCaptureProperty( window->capture, CV_CAP_PROP_FRAME_HEIGHT)); CvVideoWriter *writer = cvCreateVideoWriter(TEMP_VIDEO_ADDRESS, CV_FOURCC('M','P','E','G'), fps, size ); int i = 0; timeval time_start,time_now; gettimeofday(&time_start,NULL); i = gettimeofday(&time_now,NULL); while (true) { i++; imagesrc = cvQueryFrame( window->capture ); if (window->a_preview->isChecked()) //slow mode { if (imagesrc == NULL) { window->imageView = QImage((const unsigned char*)(window->NA_image->imageData), window->NA_image->width,window->NA_image->height,QImage::Format_RGB888).rgbSwapped(); window->surface->setPixmap(QPixmap::fromImage(window->imageView.scaled(window->surface_width, floor((window->surface_width/window->NA_image->width)*window->NA_image->height),Qt::IgnoreAspectRatio,Qt::SmoothTransformation))); return NULL; } window->imageView = QImage((const unsigned char*)(imagesrc->imageData), imagesrc->width,imagesrc->height,QImage::Format_RGB888).rgbSwapped(); window->surface->setPixmap(QPixmap::fromImage(window->imageView.scaled(window->surface_width, floor((window->surface_width/imagesrc->width)*imagesrc->height),Qt::IgnoreAspectRatio,Qt::SmoothTransformation))); } cvWriteFrame( writer, imagesrc ); if (gettimeofday( &time_now , NULL ) < 0) { printf("Error in getting time"); return NULL; } //update info window->info_frameNum->setText(QString("Farme = %1").arg(i)); window->info_time->setText(QString("Time : 0:%1:%2").arg((int)(time_now.tv_sec) - (int)(time_start.tv_sec)).arg((int)(time_now.tv_usec/100000))); int elapsed = ((int)(time_now.tv_sec) - (int)(time_start.tv_sec)); if (elapsed) window->info_fps->setText(QString("RPS = %1").arg(i/elapsed)); if (!window->isRec) { break; } } cvReleaseVideoWriter( &writer ); return NULL; }
bool VideoIO::saveStream(IplImage* image) { if(!m_videoWriterInUse || !m_videoWriterHandle) { clog << "Unable to write frame out to file as no current video writer handle exists" << endl; return false; } cvWriteFrame(m_videoWriterHandle.get(), image); return m_videoWriterInUse; }
void VideoSaver<scLiveStream>::run() { if (scLiveStream) { long tTimeToWait = (mStartTime+ (long) (mFrameCount*mMillisecondPerFrame+0.5))-Time::MillisTimestamp(); if (tTimeToWait <= 0) std::cerr << -tTimeToWait << "ms delay at saving frame #" << mFrameCount << std::endl; else Time::Sleep(tTimeToWait); } cvWriteFrame(mVideoWriter,*mInputImage); ++mFrameCount; }
void MyVideo::writeVideo(char* folder) { //write video char* out_src = (char*)malloc(sizeof(char)); strcpy(out_src, folder); strcat(out_src, "output/out.avi"); outputvideo = cvCreateVideoWriter(out_src, CV_FOURCC('M','J','P','G'), fps, cvSize(width, height), 1); for(int i = 0; i < resizeimages.size(); i++) { int j = 20; drawText(resizeimages[i]); while((j--) > 0) cvWriteFrame(outputvideo, resizeimages[i]); } IplImage *img = 0; for(int i = 0; i < framecount; i++) { img = cvQueryFrame(inputvideo); drawText(img); cvWriteFrame(outputvideo, img); } cvReleaseVideoWriter(&outputvideo); }
void aplicar_original (const char *archivo_entrada, bool verbose, bool frames, const char *carpeta_frames){ static size_t bufsize = 1024; char namebuff[bufsize + 1]; const char *filename = basename(archivo_entrada); CvCapture *srcVid = abrir_video(archivo_entrada); CvSize dst_size; dst_size.width = cvGetCaptureProperty(srcVid,CV_CAP_PROP_FRAME_WIDTH); dst_size.height = cvGetCaptureProperty(srcVid,CV_CAP_PROP_FRAME_HEIGHT); double fps = cvGetCaptureProperty(srcVid,CV_CAP_PROP_FPS); typedef struct CvVideoWriter CvVideoWriter; snprintf(namebuff, bufsize, "%s.original.avi", archivo_entrada); printf("\n\n%s\n\n",namebuff); CvVideoWriter* dstVid = abrir_writer(namebuff, fps, dst_size); if (verbose) { cvNamedWindow("procesanding", CV_WINDOW_AUTOSIZE); } unsigned int framenum = 0; while(1) { /* Capturo un frame */ IplImage *frame = cvQueryFrame(srcVid); framenum ++; if(framenum==100)break; cvWriteFrame(dstVid, frame); if (frames) { /* Escribo el frame */ snprintf(namebuff, bufsize, "%s/%s.original.%d.bmp", carpeta_frames, filename, framenum); cvSaveImage(namebuff, frame, NULL); } if (verbose) { cvShowImage("procesanding", frame); cvWaitKey(1); } } if (verbose) { cvDestroyWindow("procesanding"); } cvReleaseVideoWriter(&dstVid); cvReleaseCapture(&srcVid); }
inline void MainWindow::record_activity(IplImage* image) { //perpare_for_recording(image); //Record when there is substantial motion if (tracker->motion_is_detected()) { if (!recording) //if not previously recording, write the images that are in the buffer { recording = true; perpare_for_recording(image); image_buffer->write(writer); extra_frame_countdown = config->buffer_size; } //Save this frame to an avi file cout << "Motion Detected" << endl; cvWriteFrame(writer,image); } else { if (extra_frame_countdown > 0) { cout << "extra frame countdown = " << extra_frame_countdown << endl; cvWriteFrame(writer,image); extra_frame_countdown--; if (extra_frame_countdown == 0) { recording = false; //stop_record_frame = video_loader.get_frame_number(); //this is the last recorded frame number } } else { image_buffer->next_image(image); } } }
void THISCLASS::BufferedFrames_Add(IplImage *inputimage) { // No buffering? if (! mFrameBuffer) { cvWriteFrame(mWriter, inputimage); return; } // Add to the buffer, and write the whole buffer if it is full mFrameBuffer[mFrameBufferWriteCounter] = cvCloneImage(inputimage); mFrameBufferWriteCounter++; if (mFrameBufferWriteCounter >= mFrameBufferCount) { BufferedFrames_Write(); } }