void ofxRaspicam::setup()
{
MMAL_STATUS_T status = MMAL_SUCCESS;
bcm_host_init();
create_camera_component();
create_encoder_component();
camera_still_port = photo.camera->output[MMAL_CAMERA_CAPTURE_PORT];
encoder_input_port = photo.encoder_component->input[0];
encoder_output_port = photo.encoder_component->output[0];
VCOS_STATUS_T vcos_status;
ofLogVerbose() << "Connecting camera stills port to encoder input port";
// Now connect the camera to the encoder
status = connect_ports(camera_still_port, encoder_input_port, &photo.encoder_connection);
if (status != MMAL_SUCCESS)
{
ofLogVerbose() << "connect camera video port to encoder input FAIL";
}else
{
ofLogVerbose() << "connect camera video port to encoder input PASS";
}
// Set up our userdata - this is passed though to the callback where we need the information.
// Null until we open our filename
callback_data.file_handle = NULL;
callback_data.photo = &photo;
vcos_status = vcos_semaphore_create(&callback_data.complete_semaphore, "RaspiStill-sem", 0);
vcos_assert(vcos_status == VCOS_SUCCESS);
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
ofLogVerbose() << "Enabling encoder output port";
// Enable the encoder output port and tell it its callback function
status = mmal_port_enable(encoder_output_port, encoder_buffer_callback);
if (status != MMAL_SUCCESS)
{
ofLogVerbose() << "Setup encoder output FAIL, error: " << status;
}else
{
ofLogVerbose() << "Setup encoder output PASS";
}
}
MMAL_COMPONENT_T* CCamera::createEncoderComponentAndSetupPorts(){
if ((status = create_encoder_component(&state)) != MMAL_SUCCESS)
{
printf("%s: Failed to create encode component", __func__);
return NULL;
}
return state->encoder_component;
}
/**
* main
*/
int main(int argc, const char **argv)
{
// Our main data storage vessel..
RASPIVID_STATE state;
MMAL_STATUS_T status = MMAL_SUCCESS;
MMAL_PORT_T *camera_preview_port = NULL;
MMAL_PORT_T *camera_video_port = NULL;
MMAL_PORT_T *camera_still_port = NULL;
MMAL_PORT_T *preview_input_port = NULL;
MMAL_PORT_T *encoder_input_port = NULL;
MMAL_PORT_T *encoder_output_port = NULL;
FILE *output_file = NULL;
bcm_host_init();
// Register our application with the logging system
vcos_log_register("RaspiVid", VCOS_LOG_CATEGORY);
signal(SIGINT, signal_handler);
default_status(&state);
// Do we have any parameters
if (argc == 1)
{
fprintf(stderr, "\n%s Camera App %s\n\n", basename(argv[0]), VERSION_STRING);
display_valid_parameters(basename(argv[0]));
exit(0);
}
// Parse the command line and put options in to our status structure
if (parse_cmdline(argc, argv, &state))
{
status = -1;
exit(0);
}
if (state.verbose)
{
fprintf(stderr, "\n%s Camera App %s\n\n", basename(argv[0]), VERSION_STRING);
dump_status(&state);
}
// OK, we have a nice set of parameters. Now set up our components
// We have three components. Camera, Preview and encoder.
if ((status = create_camera_component(&state)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create camera component", __func__);
}
else if ((status = raspipreview_create(&state.preview_parameters)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create preview component", __func__);
destroy_camera_component(&state);
}
else if ((status = create_encoder_component(&state)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create encode component", __func__);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
}
else
{
PORT_USERDATA callback_data;
if (state.verbose)
fprintf(stderr, "Starting component connection stage\n");
camera_preview_port = state.camera_component->output[MMAL_CAMERA_PREVIEW_PORT];
camera_video_port = state.camera_component->output[MMAL_CAMERA_VIDEO_PORT];
camera_still_port = state.camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
preview_input_port = state.preview_parameters.preview_component->input[0];
encoder_input_port = state.encoder_component->input[0];
encoder_output_port = state.encoder_component->output[0];
if (state.preview_parameters.wantPreview )
{
if (state.verbose)
{
fprintf(stderr, "Connecting camera preview port to preview input port\n");
fprintf(stderr, "Starting video preview\n");
}
// Connect camera to preview
status = connect_ports(camera_preview_port, preview_input_port, &state.preview_connection);
}
else
{
status = MMAL_SUCCESS;
}
if (status == MMAL_SUCCESS)
{
if (state.verbose)
fprintf(stderr, "Connecting camera stills port to encoder input port\n");
// Now connect the camera to the encoder
status = connect_ports(camera_video_port, encoder_input_port, &state.encoder_connection);
if (status != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to connect camera video port to encoder input", __func__);
goto error;
}
if (state.filename)
{
if (state.filename[0] == '-')
{
output_file = stdout;
// Ensure we don't upset the output stream with diagnostics/info
state.verbose = 0;
}
else
{
if (state.verbose)
fprintf(stderr, "Opening output file \"%s\"\n", state.filename);
output_file = fopen(state.filename, "wb");
}
if (!output_file)
{
// Notify user, carry on but discarding encoded output buffers
vcos_log_error("%s: Error opening output file: %s\nNo output file will be generated\n", __func__, state.filename);
}
}
// Set up our userdata - this is passed though to the callback where we need the information.
callback_data.file_handle = output_file;
callback_data.image = Mat(Size(state.width, state.height), CV_8UC1);
callback_data.pstate = &state;
callback_data.abort = 0;
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
if (state.verbose)
fprintf(stderr, "Enabling encoder output port\n");
// Enable the encoder output port and tell it its callback function
status = mmal_port_enable(encoder_output_port, encoder_buffer_callback);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Failed to setup encoder output");
goto error;
}
if (state.demoMode)
{
// Run for the user specific time..
int num_iterations = state.timeout / state.demoInterval;
int i;
if (state.verbose)
fprintf(stderr, "Running in demo mode\n");
for (i=0;state.timeout == 0 || i<num_iterations;i++)
{
raspicamcontrol_cycle_test(state.camera_component);
vcos_sleep(state.demoInterval);
}
}
else
{
// Only encode stuff if we have a filename and it opened
if (output_file)
{
int wait;
if (state.verbose)
fprintf(stderr, "Starting video capture\n");
if (mmal_port_parameter_set_boolean(camera_video_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
goto error;
}
// Send all the buffers to the encoder output port
{
int num = mmal_queue_length(state.encoder_pool->queue);
int q;
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(state.encoder_pool->queue);
if (!buffer)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(encoder_output_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to encoder output port (%d)", q);
}
}
// Now wait until we need to stop. Whilst waiting we do need to check to see if we have aborted (for example
// out of storage space)
// Going to check every ABORT_INTERVAL milliseconds
for (wait = 0; state.timeout == 0 || wait < state.timeout; wait+= ABORT_INTERVAL)
{
vcos_sleep(ABORT_INTERVAL);
if (callback_data.abort)
break;
}
if (state.verbose)
fprintf(stderr, "Finished capture\n");
}
else
{
if (state.timeout)
vcos_sleep(state.timeout);
else
for (;;) vcos_sleep(ABORT_INTERVAL);
}
}
}
else
{
mmal_status_to_int(status);
vcos_log_error("%s: Failed to connect camera to preview", __func__);
}
error:
mmal_status_to_int(status);
if (state.verbose)
fprintf(stderr, "Closing down\n");
// Disable all our ports that are not handled by connections
check_disable_port(camera_still_port);
check_disable_port(encoder_output_port);
if (state.preview_parameters.wantPreview )
mmal_connection_destroy(state.preview_connection);
mmal_connection_destroy(state.encoder_connection);
// Can now close our file. Note disabling ports may flush buffers which causes
// problems if we have already closed the file!
if (output_file && output_file != stdout)
fclose(output_file);
/* Disable components */
if (state.encoder_component)
mmal_component_disable(state.encoder_component);
if (state.preview_parameters.preview_component)
mmal_component_disable(state.preview_parameters.preview_component);
if (state.camera_component)
mmal_component_disable(state.camera_component);
destroy_encoder_component(&state);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
if (state.verbose)
fprintf(stderr, "Close down completed, all components disconnected, disabled and destroyed\n\n");
}
if (status != MMAL_SUCCESS)
raspicamcontrol_check_configuration(128);
return 0;
}
RaspiCamCvCapture * raspiCamCvCreateCameraCapture(int index)
{
RaspiCamCvCapture * capture = (RaspiCamCvCapture*)malloc(sizeof(RaspiCamCvCapture));
// Our main data storage vessel..
RASPIVID_STATE * state = (RASPIVID_STATE*)malloc(sizeof(RASPIVID_STATE));
capture->pState = state;
MMAL_STATUS_T status = -1;
MMAL_PORT_T *camera_video_port = NULL;
MMAL_PORT_T *camera_video_port_2 = NULL;
//MMAL_PORT_T *camera_still_port = NULL;
MMAL_PORT_T *encoder_input_port = NULL;
MMAL_PORT_T *encoder_output_port = NULL;
bcm_host_init();
// read default status
default_status(state);
int w = state->width;
int h = state->height;
state->py = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 3); // Y component of YUV I420 frame
if (state->graymode==0)
{
state->pu = cvCreateImage(cvSize(w/2,h/2), IPL_DEPTH_8U, 1); // U component of YUV I420 frame
state->pv = cvCreateImage(cvSize(w/2,h/2), IPL_DEPTH_8U, 1); // V component of YUV I420 frame
}
vcos_semaphore_create(&state->capture_sem, "Capture-Sem", 0);
vcos_semaphore_create(&state->capture_done_sem, "Capture-Done-Sem", 0);
if (state->graymode==0)
{
state->pu_big = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 1);
state->pv_big = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 1);
state->yuvImage = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 3);
state->dstImage = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 3); // final picture to display
}
//printf("point2.0\n");
// create camera
if (!create_camera_component(state))
{
vcos_log_error("%s: Failed to create camera component", __func__);
raspiCamCvReleaseCapture(&capture);
return NULL;
} else if ((status = create_encoder_component(state)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create encode component", __func__);
destroy_camera_component(state);
return NULL;
}
//printf("point2.1\n");
//create_encoder_component(state);
camera_video_port = state->camera_component->output[MMAL_CAMERA_VIDEO_PORT];
camera_video_port_2 = state->camera_component->output[MMAL_CAMERA_VIDEO_PORT_2];
//camera_still_port = state->camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
encoder_input_port = state->encoder_component->input[0];
encoder_output_port = state->encoder_component->output[0];
// assign data to use for callback
camera_video_port->userdata = (struct MMAL_PORT_USERDATA_T *)state;
// assign data to use for callback
camera_video_port_2->userdata = (struct MMAL_PORT_USERDATA_T *)state;
// Now connect the camera to the encoder
status = connect_ports(camera_video_port_2, encoder_input_port, &state->encoder_connection);
if (state->filename)
{
if (state->filename[0] == '-')
{
state->callback_data.file_handle = stdout;
}
else
{
state->callback_data.file_handle = open_filename(state);
}
if (!state->callback_data.file_handle)
{
// Notify user, carry on but discarding encoded output buffers
vcos_log_error("%s: Error opening output file: %s\nNo output file will be generated\n", __func__, state->filename);
}
}
// Set up our userdata - this is passed though to the callback where we need the information.
state->callback_data.pstate = state;
state->callback_data.abort = 0;
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *)&state->callback_data;
// Enable the encoder output port and tell it its callback function
status = mmal_port_enable(encoder_output_port, encoder_buffer_callback);
if (status != MMAL_SUCCESS)
{
state->encoder_connection = NULL;
vcos_log_error("%s: Failed to connect camera video port to encoder input", __func__);
return NULL;
}
if (status != MMAL_SUCCESS)
{
vcos_log_error("Failed to setup encoder output");
return NULL;
}
//mmal_port_enable(encoder_output_port, encoder_buffer_callback);
// Only encode stuff if we have a filename and it opened
// Note we use the copy in the callback, as the call back MIGHT change the file handle
if (state->callback_data.file_handle)
{
int running = 1;
// Send all the buffers to the encoder output port
{
int num = mmal_queue_length(state->encoder_pool->queue);
int q;
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer2 = mmal_queue_get(state->encoder_pool->queue);
if (!buffer2)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(encoder_output_port, buffer2)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to encoder output port (%d)", q);
}
}
}
// start capture
if (mmal_port_parameter_set_boolean(camera_video_port_2, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to start capture", __func__);
raspiCamCvReleaseCapture(&capture);
return NULL;
}
// Send all the buffers to the video port
int num = mmal_queue_length(state->video_pool->queue);
int q;
for (q = 0; q < num; q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(state->video_pool->queue);
if (!buffer)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(camera_video_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to encoder output port (%d)", q);
}
//mmal_status_to_int(status);
// Disable all our ports that are not handled by connections
//check_disable_port(camera_still_port);
//if (status != 0)
// raspicamcontrol_check_configuration(128);
vcos_semaphore_wait(&state->capture_done_sem);
return capture;
}
/**
* main
*/
int main(int argc, const char **argv)
{
// Our main data storage vessel..
RASPISTILL_STATE state;
MMAL_STATUS_T status = -1;
MMAL_PORT_T *camera_preview_port = NULL;
MMAL_PORT_T *camera_video_port = NULL;
MMAL_PORT_T *camera_still_port = NULL;
MMAL_PORT_T *preview_input_port = NULL;
MMAL_PORT_T *encoder_input_port = NULL;
MMAL_PORT_T *encoder_output_port = NULL;
bcm_host_init();
signal(SIGINT, signal_handler);
default_status(&state);
if (!create_camera_component(&state))
{
vcos_log_error("%s: Failed to create camera component", __func__);
}
//else if (!raspipreview_create(&state.preview_parameters))
//{
// vcos_log_error("%s: Failed to create preview component", __func__);
// destroy_camera_component(&state);
//}
else if (!create_encoder_component(&state))
{
vcos_log_error("%s: Failed to create encode component", __func__);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
}
else
{
PORT_USERDATA callback_data;
// *** PR : we don't want preview
camera_preview_port = NULL;//state.camera_component->output[MMAL_CAMERA_PREVIEW_PORT];
camera_video_port = state.camera_component->output[MMAL_CAMERA_VIDEO_PORT];
camera_still_port = state.camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
preview_input_port = state.preview_parameters.preview_component->input[0];
encoder_input_port = state.encoder_component->input[0];
encoder_output_port = state.encoder_component->output[0];
if (state.preview_parameters.wantPreview )
{
if (state.verbose)
{
fprintf(stderr, "Connecting camera preview port to preview input port\n");
fprintf(stderr, "Starting video preview\n");
}
// PR : we don't want preview
// Connect camera to preview
// status = connect_ports(camera_preview_port, preview_input_port, &state.preview_connection);
}
VCOS_STATUS_T vcos_status;
if (state.verbose)
fprintf(stderr, "Connecting camera stills port to encoder input port\n");
// Now connect the camera to the encoder
status = connect_ports(camera_still_port, encoder_input_port, &state.encoder_connection);
if (status != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to connect camera video port to encoder input", __func__);
goto error;
}
// Set up our userdata - this is passed though to the callback where we need the information.
// Null until we open our filename
callback_data.file_handle = NULL;
callback_data.pstate = &state;
vcos_status = vcos_semaphore_create(&callback_data.complete_semaphore, "RaspiStill-sem", 0);
vcos_assert(vcos_status == VCOS_SUCCESS);
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
if (state.verbose)
fprintf(stderr, "Enabling encoder output port\n");
// Enable the encoder output port and tell it its callback function
status = mmal_port_enable(encoder_output_port, encoder_buffer_callback);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Failed to setup encoder output");
goto error;
}
{
int num_iterations = state.timelapse ? state.timeout / state.timelapse : 1;
int frame;
for (frame = 1;frame<=num_iterations; frame++)
{
if (state.timelapse)
vcos_sleep(state.timelapse);
else
vcos_sleep(state.timeout);
// Send all the buffers to the encoder output port
int num = mmal_queue_length(state.encoder_pool->queue);
int q;
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(state.encoder_pool->queue);
if (!buffer)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(encoder_output_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to encoder output port (%d)", q);
}
if (mmal_port_parameter_set_boolean(camera_still_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to start capture", __func__);
}
else
{
// Wait for capture to complete
// For some reason using vcos_semaphore_wait_timeout sometimes returns immediately with bad parameter error
// even though it appears to be all correct, so reverting to untimed one until figure out why its erratic
vcos_semaphore_wait(&callback_data.complete_semaphore);
}
} // end for (frame)
vcos_semaphore_delete(&callback_data.complete_semaphore);
}
error:
mmal_status_to_int(status);
// Disable all our ports that are not handled by connections
check_disable_port(camera_video_port);
check_disable_port(encoder_output_port);
// PR : we don't want preview
//if (state.preview_parameters.wantPreview )
// mmal_connection_destroy(state.preview_connection);
mmal_connection_destroy(state.encoder_connection);
/* Disable components */
if (state.encoder_component)
mmal_component_disable(state.encoder_component);
if (state.preview_parameters.preview_component)
mmal_component_disable(state.preview_parameters.preview_component);
if (state.camera_component)
mmal_component_disable(state.camera_component);
destroy_encoder_component(&state);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
if (state.verbose)
fprintf(stderr, "Close down completed, all components disconnected, disabled and destroyed\n\n");
}
if (status != 0)
raspicamcontrol_check_configuration(128);
return 0;
}
/**
* main
*/
int main(int argc, const char **argv)
{
// *** MODIFICATION: OpenCV modifications.
// Load previous image.
IplImage* prevImage = cvLoadImage("motion1.jpg", CV_LOAD_IMAGE_COLOR);
// Create two arrays with the same number of channels than the original one.
avg1 = cvCreateMat(prevImage->height,prevImage->width,CV_32FC3);
avg2 = cvCreateMat(prevImage->height,prevImage->width,CV_32FC3);
// Create image of 32 bits.
IplImage* image32 = cvCreateImage(cvSize(prevImage->width,prevImage->height), 32,3);
// Convert image to 32 bits.
cvConvertScale(prevImage,image32,1/255,0);
// Set data from previous image into arrays.
cvSetData(avg1,image32->imageData,image32->widthStep);
cvSetData(avg2,image32->imageData,image32->widthStep);
// *** MODIFICATION end
// Our main data storage vessel..
RASPISTILL_STATE state;
MMAL_STATUS_T status = MMAL_SUCCESS;
MMAL_PORT_T *camera_preview_port = NULL;
MMAL_PORT_T *camera_video_port = NULL;
MMAL_PORT_T *camera_still_port = NULL;
MMAL_PORT_T *preview_input_port = NULL;
MMAL_PORT_T *encoder_input_port = NULL;
MMAL_PORT_T *encoder_output_port = NULL;
bcm_host_init();
// Register our application with the logging system
vcos_log_register("fast", VCOS_LOG_CATEGORY);
signal(SIGINT, signal_handler);
default_status(&state);
if (state.verbose)
{
fprintf(stderr, "\n%s Camera App %s\n\n", basename(argv[0]), VERSION_STRING);
}
// OK, we have a nice set of parameters. Now set up our components
// We have three components. Camera, Preview and encoder.
// Camera and encoder are different in stills/video, but preview
// is the same so handed off to a separate module
if ((status = create_camera_component(&state)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create camera component", __func__);
}
else if ((status = raspipreview_create(&state.preview_parameters)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create preview component", __func__);
destroy_camera_component(&state);
}
else if ((status = create_encoder_component(&state)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create encode component", __func__);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
}
else
{
PORT_USERDATA callback_data;
if (state.verbose)
fprintf(stderr, "Starting component connection stage\n");
camera_preview_port = state.camera_component->output[MMAL_CAMERA_PREVIEW_PORT];
camera_video_port = state.camera_component->output[MMAL_CAMERA_VIDEO_PORT];
camera_still_port = state.camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
preview_input_port = state.preview_parameters.preview_component->input[0];
encoder_input_port = state.encoder_component->input[0];
encoder_output_port = state.encoder_component->output[0];
if (state.preview_parameters.wantPreview )
{
if (state.verbose)
{
fprintf(stderr, "Connecting camera preview port to preview input port\n");
fprintf(stderr, "Starting video preview\n");
}
// *** USER: remove preview
// Connect camera to preview
//status = connect_ports(camera_preview_port, preview_input_port, &state.preview_connection);
}
else
{
status = MMAL_SUCCESS;
}
if (status == MMAL_SUCCESS)
{
VCOS_STATUS_T vcos_status;
if (state.verbose)
fprintf(stderr, "Connecting camera stills port to encoder input port\n");
// Now connect the camera to the encoder
status = connect_ports(camera_still_port, encoder_input_port, &state.encoder_connection);
if (status != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to connect camera video port to encoder input", __func__);
goto error;
}
// Set up our userdata - this is passed though to the callback where we need the information.
// Null until we open our filename
callback_data.file_handle = NULL;
callback_data.pstate = &state;
vcos_status = vcos_semaphore_create(&callback_data.complete_semaphore, "RaspiStill-sem", 0);
vcos_assert(vcos_status == VCOS_SUCCESS);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Failed to setup encoder output");
goto error;
}
FILE *output_file = NULL;
int frame = 1;
// Enable the encoder output port
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
if (state.verbose)
fprintf(stderr, "Enabling encoder output port\n");
// Enable the encoder output port and tell it its callback function
status = mmal_port_enable(encoder_output_port, encoder_buffer_callback);
// Create an empty matrix with the size of the buffer.
CvMat* buf = cvCreateMat(1,60000,CV_8UC1);
// Keep buffer that gets frames from queue.
MMAL_BUFFER_HEADER_T *buffer;
// Image to be displayed.
IplImage* image;
// Keep number of buffers and index for the loop.
int num, q;
while(1)
{
// Send all the buffers to the encoder output port
num = mmal_queue_length(state.encoder_pool->queue);
for (q=0;q<num;q++)
{
buffer = mmal_queue_get(state.encoder_pool->queue);
if (!buffer)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(encoder_output_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to encoder output port (%d)", q);
} // for
if (mmal_port_parameter_set_boolean(camera_still_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
vcos_log_error("%s: Failed to start capture", __func__);
else
{
// Wait for capture to complete
// For some reason using vcos_semaphore_wait_timeout sometimes returns immediately with bad parameter error
// even though it appears to be all correct, so reverting to untimed one until figure out why its erratic
vcos_semaphore_wait(&callback_data.complete_semaphore);
if (state.verbose)
fprintf(stderr, "Finished capture %d\n", frame);
} // else
// Copy buffer from camera to matrix.
buf->data.ptr = buffer->data;
// This workaround is needed for the code to work
// *** TODO: investigate why.
printf("Until here works\n");
// Decode the image and display it.
image = cvDecodeImage(buf, CV_LOAD_IMAGE_COLOR);
// Destinations
CvMat* res1 = cvCreateMat(image->height,image->width,CV_8UC3);
CvMat* res2 = cvCreateMat(image->height,image->width,CV_8UC3);
// Update running averages and then scale, calculate absolute values
// and convert the result 8-bit.
// *** USER:change the value of the weight.
cvRunningAvg(image,avg2,0.0001, NULL);
cvConvertScaleAbs(avg2, res2, 1,0);
cvRunningAvg(image,avg1,0.1, NULL);
cvConvertScaleAbs(avg1, res1, 1,0);
// Show images
cvShowImage("img",image);
cvShowImage("avg1",res1);
cvShowImage("avg2",res2);
cvWaitKey(20);
// Update previous image.
cvSaveImage("motion1.jpg", image, 0);
} // end while
vcos_semaphore_delete(&callback_data.complete_semaphore);
}
else
{
mmal_status_to_int(status);
vcos_log_error("%s: Failed to connect camera to preview", __func__);
}
error:
mmal_status_to_int(status);
if (state.verbose)
fprintf(stderr, "Closing down\n");
// Disable all our ports that are not handled by connections
check_disable_port(camera_video_port);
check_disable_port(encoder_output_port);
if (state.preview_parameters.wantPreview )
mmal_connection_destroy(state.preview_connection);
mmal_connection_destroy(state.encoder_connection);
/* Disable components */
if (state.encoder_component)
mmal_component_disable(state.encoder_component);
if (state.preview_parameters.preview_component)
mmal_component_disable(state.preview_parameters.preview_component);
if (state.camera_component)
mmal_component_disable(state.camera_component);
destroy_encoder_component(&state);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
if (state.verbose)
fprintf(stderr, "Close down completed, all components disconnected, disabled and destroyed\n\n");
}
if (status != MMAL_SUCCESS)
raspicamcontrol_check_configuration(128);
return 0;
}
void camera_thread(
void
)
{
static MMAL_STATUS_T status;
static RASPIVID_STATE state;
static MMAL_PORT_T *camera_preview_port = NULL;
static MMAL_PORT_T *camera_video_port = NULL;
static MMAL_PORT_T *camera_still_port = NULL;
static MMAL_PORT_T *preview_input_port = NULL;
static MMAL_PORT_T *encoder_input_port = NULL;
static MMAL_PORT_T *encoder_output_port = NULL;
static FILE *output_file = NULL;
f_nal_queue = sx_queue_create();
bcm_host_init();
default_status(&state);
state.verbose = 1;
status = create_camera_component(&state);
assert(status == MMAL_SUCCESS);
status = raspipreview_create(&state.preview_parameters);
assert(status == MMAL_SUCCESS);
status = create_encoder_component(&state);
assert(status == MMAL_SUCCESS);
PORT_USERDATA callback_data;
camera_preview_port = state.camera_component->output[MMAL_CAMERA_PREVIEW_PORT];
camera_video_port = state.camera_component->output[MMAL_CAMERA_VIDEO_PORT];
camera_still_port = state.camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
preview_input_port = state.preview_parameters.preview_component->input[0];
encoder_input_port = state.encoder_component->input[0];
encoder_output_port = state.encoder_component->output[0];
// Now connect the camera to the encoder
status = connect_ports(camera_video_port,
encoder_input_port,
&state.encoder_connection);
assert(status == MMAL_SUCCESS);
char *filename = "output.h264";
state.filename = filename;
output_file = fopen(state.filename, "wb");
// Set up our userdata - this is passed though to the callback where we need the information.
callback_data.file_handle = output_file;
callback_data.pstate = &state;
callback_data.abort = 0;
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *) &callback_data;
// Enable the encoder output port and tell it its callback function
status = mmal_port_enable(encoder_output_port, encoder_buffer_callback);
assert(status == MMAL_SUCCESS);
// Only encode stuff if we have a filename and it opened
if (output_file)
{
int wait;
if (state.verbose)
fprintf(stderr, "Starting video capture\n");
status = mmal_port_parameter_set_boolean(camera_video_port, MMAL_PARAMETER_CAPTURE, 1);
assert(status == MMAL_SUCCESS);
// Send all the buffers to the encoder output port
{
int num = mmal_queue_length(state.encoder_pool->queue);
int q;
fprintf(stderr, "mmal_queue_len = %d\n", num);
for (q=0;q<num;q++)
{
printf("start current time = %d\n", get_time_ns());
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(state.encoder_pool->queue);
assert(buffer != NULL);
status = mmal_port_send_buffer(encoder_output_port, buffer);
assert(status == MMAL_SUCCESS);
}
}
// Now wait until we need to stop. Whilst waiting we do need to check to see if we have aborted (for example
// out of storage space)
// Going to check every ABORT_INTERVAL milliseconds
#if 1
while(1)
{
// sleep forever.
vcos_sleep(ABORT_INTERVAL);
}
#endif
#if 0
for (wait = 0; state.timeout == 0 || wait < state.timeout; wait+= ABORT_INTERVAL)
{
vcos_sleep(ABORT_INTERVAL);
if (callback_data.abort)
{
fprintf(stderr, "333\n");
break;
}
fprintf(stderr, "222\n");
}
fprintf(stderr, "wait = %u\n", wait);
if (state.verbose)
fprintf(stderr, "Finished capture\n");
#endif
}
}
/**
* main
*/
int main(int argc, const char **argv)
{
// Our main data storage vessel..
RASPIVID_STATE state;
MMAL_STATUS_T status;
MMAL_PORT_T *camera_preview_port = NULL;
MMAL_PORT_T *camera_video_port = NULL;
MMAL_PORT_T *camera_still_port = NULL;
MMAL_PORT_T *preview_input_port = NULL;
MMAL_PORT_T *encoder_input_port = NULL;
MMAL_PORT_T *encoder_output_port = NULL;
FILE *output_file = NULL;
// Register our application with the logging system
vcos_log_register("RaspiVid", VCOS_LOG_CATEGORY);
printf("\nRaspiVid Camera App\n");
printf("===================\n\n");
signal(SIGINT, signal_handler);
default_status(&state);
// Do we have any parameters
if (argc == 1)
{
display_valid_parameters();
exit(0);
}
// Parse the command line and put options in to our status structure
if (parse_cmdline(argc, argv, &state))
{
status = -1;
exit(0);
}
if (state.verbose)
dump_status(&state);
// OK, we have a nice set of parameters. Now set up our components
// We have three components. Camera, Preview and encoder.
if (!create_camera_component(&state))
{
vcos_log_error("%s: Failed to create camera component", __func__);
}
else if (!raspipreview_create(&state.preview_parameters))
{
vcos_log_error("%s: Failed to create preview component", __func__);
destroy_camera_component(&state);
}
else if (!create_encoder_component(&state))
{
vcos_log_error("%s: Failed to create encode component", __func__);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
}
else
{
PORT_USERDATA callback_data;
if (state.verbose)
printf("Starting component connection stage\n");
camera_preview_port = state.camera_component->output[MMAL_CAMERA_PREVIEW_PORT];
camera_video_port = state.camera_component->output[MMAL_CAMERA_VIDEO_PORT];
camera_still_port = state.camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
preview_input_port = state.preview_parameters.preview_component->input[0];
encoder_input_port = state.encoder_component->input[0];
encoder_output_port = state.encoder_component->output[0];
if (state.preview_parameters.wantPreview )
{
if (state.verbose)
{
printf("Connecting camera preview port to preview input port\n");
printf("Starting video preview\n");
}
// Connect camera to preview
status = connect_ports(camera_preview_port, preview_input_port, &state.preview_connection);
}
if (status == MMAL_SUCCESS)
{
VCOS_STATUS_T vcos_status;
if (state.verbose)
printf("Connecting camera stills port to encoder input port\n");
// Now connect the camera to the encoder
status = connect_ports(camera_video_port, encoder_input_port, &state.encoder_connection);
if (status != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to connect camera video port to encoder input", __func__);
goto error;
}
if (state.filename)
{
if (state.verbose)
printf("Opening output file %s\n", state.filename);
output_file = fopen(state.filename, "wb");
if (!output_file)
{
// Notify user, carry on but discarding encoded output buffers
vcos_log_error("%s: Error opening output file: %s\nNo output file will be generated\n", __func__, state.filename);
}
}
// Set up our userdata - this is passed though to the callback where we need the information.
callback_data.file_handle = output_file;
callback_data.pstate = &state;
vcos_status = vcos_semaphore_create(&callback_data.complete_semaphore, "RaspiStill-sem", 0);
vcos_assert(vcos_status == VCOS_SUCCESS);
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
if (state.verbose)
printf("Enabling encoder output port\n");
// Enable the encoder output port and tell it its callback function
status = mmal_port_enable(encoder_output_port, encoder_buffer_callback);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Failed to setup encoder output");
goto error;
}
if (state.demoMode)
{
// Run for the user specific time..
int num_iterations = state.timeout / state.demoInterval;
int i;
printf("Running in demo mode\n");
for (i=0;i<num_iterations;i++)
{
raspicamcontrol_cycle_test(state.camera_component);
vcos_sleep(state.demoInterval);
}
}
else
{
// Only encode stuff if we have a filename and it opened
if (output_file)
{
if (state.verbose)
printf("Starting video capture\n");
if (mmal_port_parameter_set_boolean(camera_video_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
goto error;
}
// Send all the buffers to the encoder output port
{
int num = mmal_queue_length(state.encoder_pool->queue);
int q;
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(state.encoder_pool->queue);
if (!buffer)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(encoder_output_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to encoder output port (%d)", q);
}
}
// Now wait until we need to stop
vcos_sleep(state.timeout);
printf("Finished capture\n");
}
else
vcos_sleep(state.timeout);
}
}
else
{
mmal_status_to_int(status);
vcos_log_error("%s: Failed to connect camera to preview", __func__);
}
error:
mmal_status_to_int(status);
if (state.verbose)
printf("Closing down\n");
// Disable all our ports that are not handled by connections
check_disable_port(camera_still_port);
check_disable_port(encoder_output_port);
if (state.preview_parameters.wantPreview )
mmal_connection_destroy(state.preview_connection);
mmal_connection_destroy(state.encoder_connection);
// Can now close our file. Note disabling ports may flush buffers which causes
// problems if we have already closed the file!
if (output_file)
fclose(output_file);
/* Disable components */
if (state.encoder_component)
mmal_component_disable(state.encoder_component);
if (state.preview_parameters.preview_component)
mmal_component_disable(state.preview_parameters.preview_component);
if (state.camera_component)
mmal_component_disable(state.camera_component);
destroy_encoder_component(&state);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
if (state.verbose)
printf("Close down completed, all components disconnected, disabled and destroyed\n\n");
}
return 0;
}
uint8_t *internelPhotoWithDetails(int width, int height, int quality,MMAL_FOURCC_T encoding, PicamParams *parms, long *sizeread) {
RASPISTILL_STATE state;
MMAL_STATUS_T status = MMAL_SUCCESS;
MMAL_PORT_T *preview_input_port = NULL;
MMAL_PORT_T *camera_preview_port = NULL;
MMAL_PORT_T *camera_still_port = NULL;
MMAL_PORT_T *encoder_input_port = NULL;
MMAL_PORT_T *encoder_output_port = NULL;
if (width > 2592) {
width = 2592;
} else if (width < 20) {
width = 20;
}
if (height > 1944) {
height = 1944;
} else if (height < 20) {
height = 20;
}
if (quality > 100) {
quality = 100;
} else if (quality < 0) {
quality = 85;
}
bcm_host_init();
default_status(&state);
state.width = width;
state.height = height;
state.quality = quality;
state.encoding = encoding;
state.videoEncode = 0;
state.camera_parameters.exposureMode = parms->exposure;
state.camera_parameters.exposureMeterMode = parms->meterMode;
state.camera_parameters.awbMode = parms->awbMode;
state.camera_parameters.imageEffect = parms->imageFX;
state.camera_parameters.ISO = parms->ISO;
state.camera_parameters.sharpness = parms->sharpness;
state.camera_parameters.contrast = parms->contrast;
state.camera_parameters.brightness= parms->brightness;
state.camera_parameters.saturation = parms->saturation;
state.camera_parameters.videoStabilisation = parms->videoStabilisation; /// 0 or 1 (false or true)
state.camera_parameters.exposureCompensation = parms->exposureCompensation;
state.camera_parameters.rotation = parms->rotation;
state.camera_parameters.hflip = parms->hflip;
state.camera_parameters.vflip = parms->vflip;
MMAL_COMPONENT_T *preview = 0;
if ((status = create_video_camera_component(&state)) != MMAL_SUCCESS) {
vcos_log_error("%s: Failed to create camera component", __func__);
} else if ((status = mmal_component_create("vc.null_sink", &preview)) != MMAL_SUCCESS) {
vcos_log_error("%s: Failed to create preview component", __func__);
destroy_camera_component(&state);
} else if ((status = create_encoder_component(&state)) != MMAL_SUCCESS) {
vcos_log_error("%s: Failed to create encode component", __func__);
destroy_camera_component(&state);
} else {
status = mmal_component_enable(preview);
state.preview_component = preview;
PORT_USERDATA callback_data;
camera_preview_port = state.camera_component->output[MMAL_CAMERA_PREVIEW_PORT];
camera_still_port = state.camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
encoder_input_port = state.encoder_component->input[0];
encoder_output_port = state.encoder_component->output[0];
preview_input_port = state.preview_component->input[0];
status = connect_ports(camera_preview_port, preview_input_port, &state.preview_connection);
VCOS_STATUS_T vcos_status;
// Now connect the camera to the encoder
status = connect_ports(camera_still_port, encoder_input_port, &state.encoder_connection);
if (status != MMAL_SUCCESS) {
vcos_log_error("%s: Failed to connect camera video port to encoder input", __func__);
goto error;
}
// Set up our userdata - this is passed though to the callback where we need the information.
// Null until we open our filename
callback_data.pstate = &state;
vcos_status = vcos_semaphore_create(&callback_data.complete_semaphore, "picam-sem", 0);
vcos_assert(vcos_status == VCOS_SUCCESS);
if (status != MMAL_SUCCESS) {
vcos_log_error("Failed to setup encoder output");
goto error;
}
int num, q;
// Enable the encoder output port
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
// Enable the encoder output port and tell it its callback function
status = mmal_port_enable(encoder_output_port, encoder_buffer_callback);
// Send all the buffers to the encoder output port
num = mmal_queue_length(state.encoder_pool->queue);
for (q=0;q<num;q++) {
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(state.encoder_pool->queue);
if (!buffer)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(encoder_output_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to encoder output port (%d)", q);
}
if (mmal_port_parameter_set_boolean(camera_still_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS) {
vcos_log_error("%s: Failed to start capture", __func__);
} else {
// Wait for capture to complete
// For some reason using vcos_semaphore_wait_timeout sometimes returns immediately with bad parameter error
// even though it appears to be all correct, so reverting to untimed one until figure out why its erratic
vcos_semaphore_wait(&callback_data.complete_semaphore);
}
// Disable encoder output port
status = mmal_port_disable(encoder_output_port);
*sizeread = state.bytesStored;
vcos_semaphore_delete(&callback_data.complete_semaphore);
}
error:
mmal_status_to_int(status);
// Disable all our ports that are not handled by connections
check_disable_port(encoder_output_port);
mmal_connection_destroy(state.encoder_connection);
if (state.encoder_component)
mmal_component_disable(state.encoder_component);
if (state.preview_component) {
mmal_component_disable(state.preview_component);
mmal_component_destroy(state.preview_component);
state.preview_component = NULL;
}
if (state.camera_component)
mmal_component_disable(state.camera_component);
destroy_encoder_component(&state);
destroy_camera_component(&state);
if (status != MMAL_SUCCESS)
raspicamcontrol_check_configuration(128);
return state.filedata;
}
/**
* main
*/
int main(int argc, const char **argv)
{
// Our main data storage vessel..
RASPISTILL_STATE state;
MMAL_STATUS_T status = -1;
MMAL_PORT_T *camera_preview_port = NULL;
MMAL_PORT_T *camera_video_port = NULL;
MMAL_PORT_T *camera_still_port = NULL;
MMAL_PORT_T *preview_input_port = NULL;
MMAL_PORT_T *encoder_input_port = NULL;
MMAL_PORT_T *encoder_output_port = NULL;
bcm_host_init();
clock_t elapsedTime;
time_t timer_begin,timer_end;
double secondsElapsed;
time(&timer_begin); /* get current time; same as: timer = time(NULL) */
// create window
cvNamedWindow("camcvWin", CV_WINDOW_AUTOSIZE);//CV_WINDOW_NORMAL);//CV_WINDOW_AUTOSIZE);
//cvResizeWindow("camcvWin",640,480);
signal(SIGINT, signal_handler);
default_status(&state);
if (!create_camera_component(&state))
{
vcos_log_error("%s: Failed to create camera component", __func__);
}
else if ( (status = raspipreview_create(&state.preview_parameters)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create preview component", __func__);
destroy_camera_component(&state);
}
else if (!create_encoder_component(&state))
{
vcos_log_error("%s: Failed to create encode component", __func__);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
}
else
{
PORT_USERDATA callback_data;
// *** PR : we don't want preview
camera_preview_port = NULL;//state.camera_component->output[MMAL_CAMERA_PREVIEW_PORT];
camera_video_port = state.camera_component->output[MMAL_CAMERA_VIDEO_PORT];
camera_still_port = state.camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
preview_input_port = state.preview_parameters.preview_component->input[0];
encoder_input_port = state.encoder_component->input[0];
encoder_output_port = state.encoder_component->output[0];
if (state.preview_parameters.wantPreview )
{
// PR : we don't want preview
// Connect camera to preview
// status = connect_ports(camera_preview_port, preview_input_port, &state.preview_connection);
}
VCOS_STATUS_T vcos_status;
// Now connect the camera to the encoder
status = connect_ports(camera_still_port, encoder_input_port, &state.encoder_connection);
if (status != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to connect camera video port to encoder input", __func__);
goto error;
}
// Set up our userdata - this is passed though to the callback where we need the information.
// Null until we open our filename
//callback_data.file_handle = NULL;
callback_data.pstate = &state;
vcos_status = vcos_semaphore_create(&callback_data.complete_semaphore, "RaspiStill-sem", 0);
vcos_assert(vcos_status == VCOS_SUCCESS);
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
// Enable the encoder output port and tell it its callback function
status = mmal_port_enable(encoder_output_port, encoder_buffer_callback);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Failed to setup encoder output");
goto error;
}
int num_iterations = 100;
int frame,num,q;
elapsedTime= clock();
printf("time=%d\n",elapsedTime);
for (frame = 1;frame<=num_iterations; frame++)
{
// Send all the buffers to the encoder output port
num = mmal_queue_length(state.encoder_pool->queue);
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(state.encoder_pool->queue);
//if (!buffer)
// vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(encoder_output_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to encoder output port (%d)", q);
}
if (mmal_port_parameter_set_boolean(camera_still_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to start capture", __func__);
}
else
{
// Wait for capture to complete
// For some reason using vcos_semaphore_wait_timeout sometimes returns immediately with bad parameter error
// even though it appears to be all correct, so reverting to untimed one until figure out why its erratic
vcos_semaphore_wait(&callback_data.complete_semaphore);
}
} // end for (frame)
vcos_semaphore_delete(&callback_data.complete_semaphore);
// compute elapsed time since begin of the loop and display
error:
mmal_status_to_int(status);
// Disable all our ports that are not handled by connections
check_disable_port(camera_video_port);
check_disable_port(encoder_output_port);
// PR : we don't want preview
//if (state.preview_parameters.wantPreview )
// mmal_connection_destroy(state.preview_connection);
mmal_connection_destroy(state.encoder_connection);
/* Disable components */
if (state.encoder_component)
mmal_component_disable(state.encoder_component);
if (state.preview_parameters.preview_component)
mmal_component_disable(state.preview_parameters.preview_component);
if (state.camera_component)
mmal_component_disable(state.camera_component);
destroy_encoder_component(&state);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
}
if (status != 0)
raspicamcontrol_check_configuration(128);
// compute FPS
time(&timer_end); /* get current time; same as: timer = time(NULL) */
secondsElapsed = difftime(timer_end,timer_begin);
printf ("%.f seconds for %d frames : FPS = %f", secondsElapsed,nbFrames,(float)((float)(nbFrames)/secondsElapsed));
printf("time=%d\n",clock());
elapsedTime=clock()-elapsedTime;
printf ("(time) %d clicks (%f seconds). nb Frames = %d. FPS = %f\n",elapsedTime,((float)elapsedTime)/CLOCKS_PER_SEC, nbFrames, (float)nbFrames/(((float)elapsedTime)/CLOCKS_PER_SEC));
return 0;
}
