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