static void fill_output_port(decoder_t *dec)
{
decoder_sys_t *sys = dec->p_sys;
unsigned max_buffers_in_transit = 0;
int buffers_available = 0;
int buffers_to_send = 0;
int i;
if (sys->output_pool) {
max_buffers_in_transit = __MAX(sys->output_pool->headers_num,
MIN_NUM_BUFFERS_IN_TRANSIT);
buffers_available = mmal_queue_length(sys->output_pool->queue);
} else {
max_buffers_in_transit = __MAX(sys->output->buffer_num, MIN_NUM_BUFFERS_IN_TRANSIT);
buffers_available = NUM_DECODER_BUFFER_HEADERS - atomic_load(&sys->output_in_transit) -
mmal_queue_length(sys->decoded_pictures);
}
buffers_to_send = max_buffers_in_transit - atomic_load(&sys->output_in_transit);
if (buffers_to_send > buffers_available)
buffers_to_send = buffers_available;
#ifndef NDEBUG
msg_Dbg(dec, "Send %d buffers to output port (available: %d, "
"in_transit: %d, decoded: %d, buffer_num: %d)",
buffers_to_send, buffers_available,
atomic_load(&sys->output_in_transit),
mmal_queue_length(sys->decoded_pictures),
sys->output->buffer_num);
#endif
for (i = 0; i < buffers_to_send; ++i)
if (send_output_buffer(dec) < 0)
break;
}
void take_frame( char * dump_pointer )
{
gCallback_data.data_dump = dump_pointer;
int num = mmal_queue_length(gState.camera_pool->queue);
int q;
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(gState.camera_pool->queue);
if (!buffer)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(gCamera_still_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to camera output port (%d)", q);
}
if (mmal_port_parameter_set_boolean(gCamera_still_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to start capture", __func__);
}
else
{
vcos_semaphore_wait(&gCallback_data.complete_semaphore);
}
}
void CCameraOutput::OnVideoBufferCallback(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
{
//to handle the user not reading frames, remove and return any pre-existing ones
if(mmal_queue_length(OutputQueue)>=2)
{
if(MMAL_BUFFER_HEADER_T* existing_buffer = mmal_queue_get(OutputQueue))
{
mmal_buffer_header_release(existing_buffer);
if (port->is_enabled)
{
MMAL_STATUS_T status;
MMAL_BUFFER_HEADER_T *new_buffer;
new_buffer = mmal_queue_get(BufferPool->queue);
if (new_buffer)
status = mmal_port_send_buffer(port, new_buffer);
if (!new_buffer || status != MMAL_SUCCESS)
printf("Unable to return a buffer to the video port\n");
}
}
}
//add the buffer to the output queue
mmal_queue_put(OutputQueue,buffer);
//printf("Video buffer callback, output queue len=%d\n", mmal_queue_length(OutputQueue));
}
int start_capture(RASPIVID_STATE *state) {
if (!(state->isInit)) init_cam(state);
//raspicamcontrol_set_flips(state->camera_component, state->camera_parameters.hflip, state->camera_parameters.vflip);
raspicamcontrol_set_flips(state->camera_component, hflip, vflip);
MMAL_PORT_T *camera_video_port = state->camera_component->output[MMAL_CAMERA_VIDEO_PORT];
//MMAL_PORT_T *encoder_output_port = state->encoder_component->output[0];
ROS_INFO("Starting video capture (%d, %d, %d, %d)\n", state->width, state->height, state->quality, state->framerate);
if (mmal_port_parameter_set_boolean(camera_video_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS) {
return 1;
}
// Send all the buffers to the video port
{
int num = mmal_queue_length(state->camera_pool->queue);
int q;
for (q=0; q < num; q++) {
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(state->camera_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)
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);
}
}
ROS_INFO("Video capture started\n");
return 0;
}
/**After setting parameters video port is initialized with empty buffers
*/
bool Private_Impl::startCapture() {
if ( !_isOpened ) {
cerr << __FILE__ << ":" << __LINE__ << ":" << __func__ << " not opened." << endl;
return false; //already opened
}
// start capture
if ( mmal_port_parameter_set_boolean ( camera_video_port, MMAL_PARAMETER_CAPTURE, 1 ) != MMAL_SUCCESS ) {
release();
return false;
}
// 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 )
cerr << "Unable to get a required buffer" << q << " from pool queue" << endl;
if ( mmal_port_send_buffer ( camera_video_port, buffer ) != MMAL_SUCCESS )
cerr << "Unable to send a buffer to encoder output port " << q << endl;
}
_isCapturing = true;
return true;
}
int Private_Impl_Still::startCapture() {
// If the parameters were changed and this function wasn't called, it will be called here
// However if the parameters weren't changed, the function won't do anything - it will return right away
commitParameters();
if ( encoder_output_port->is_enabled ) {
cout << API_NAME << ": Could not enable encoder output port. Try waiting longer before attempting to take another picture.\n";
return -1;
}
if ( mmal_port_enable ( encoder_output_port, buffer_callback ) != MMAL_SUCCESS ) {
cout << API_NAME << ": Could not enable encoder output port.\n";
return -1;
}
int num = mmal_queue_length ( encoder_pool->queue );
for ( int b = 0; b < num; b++ ) {
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get ( encoder_pool->queue );
if ( !buffer )
cout << API_NAME << ": Could not get buffer (#" << b << ") from pool queue.\n";
if ( mmal_port_send_buffer ( encoder_output_port, buffer ) != MMAL_SUCCESS )
cout << API_NAME << ": Could not send a buffer (#" << b << ") to encoder output port.\n";
}
if ( mmal_port_parameter_set_boolean ( camera_still_port, MMAL_PARAMETER_CAPTURE, 1 ) != MMAL_SUCCESS ) {
cout << API_NAME << ": Failed to start capture.\n";
return -1;
}
return 0;
}
/* This is a camera path endpoint callback setup for GPU encoder data
| to the ARM. The callback should handle final disposition of encoder data.
*/
boolean
out_port_callback(CameraObject *obj, int port_num, void callback())
{
MMAL_PORT_T *port;
MMAL_STATUS_T status;
char *msg = "mmal_port_enable";
int i, n;
if (!obj->component)
return FALSE;
port = obj->component->output[port_num];
/* Create an initial queue of buffers for the output port.
| FIXME? Can't handle callbacks for more than one splitter port
| because I only have one pool_out per component.
*/
if (!obj->pool_out)
{
if ((obj->pool_out = mmal_port_pool_create(port,
port->buffer_num, port->buffer_size)) == NULL)
{
log_printf("out_port_callback %s: mmal_port_pool_create failed.\n",
obj->name);
return FALSE;
}
}
/* Connect the callback and initialize buffer pool of data that will
| be sent to the callback.
*/
if ((status = mmal_port_enable(port, callback)) == MMAL_SUCCESS)
{
obj->port_out = port;
port->userdata = (struct MMAL_PORT_USERDATA_T *) obj;
/* Send all buffers in the created queue to the GPU output port.
| These buffers will then be delivered back to the ARM with filled
| GPU data via the above callback where we can process the data
| and then resend the buffer back to the port to be refilled.
*/
msg = "mmal_port_send_buffer";
n = mmal_queue_length(obj->pool_out->queue);
for (i = 0; i < n; ++i)
{
status = mmal_port_send_buffer(port,
mmal_queue_get(obj->pool_out->queue));
if (status != MMAL_SUCCESS)
break;
}
}
if (status != MMAL_SUCCESS)
{
log_printf("out_port_callback %s: %s failed. Status %s\n",
obj->name, msg, mmal_status[status]);
return FALSE;
}
return TRUE;
}
MMAL_POOL_T* CCameraOutput::EnablePortCallbackAndCreateBufferPool(MMAL_PORT_T* port, MMAL_PORT_BH_CB_T cb, int buffer_count)
{
MMAL_STATUS_T status;
MMAL_POOL_T* buffer_pool = 0;
//setup video port buffer and a pool to hold them
port->buffer_num = buffer_count;
port->buffer_size = port->buffer_size_recommended;
printf("Creating pool with %d buffers of size %d\n", port->buffer_num, port->buffer_size);
buffer_pool = mmal_port_pool_create(port, port->buffer_num, port->buffer_size);
if (!buffer_pool)
{
printf("Couldn't create video buffer pool\n");
goto error;
}
//enable the port and hand it the callback
port->userdata = (struct MMAL_PORT_USERDATA_T *)this;
status = mmal_port_enable(port, cb);
if (status != MMAL_SUCCESS)
{
printf("Failed to set video buffer callback\n");
goto error;
}
//send all the buffers in our pool to the video port ready for use
{
int num = mmal_queue_length(buffer_pool->queue);
int q;
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(buffer_pool->queue);
if (!buffer)
{
printf("Unable to get a required buffer %d from pool queue\n", q);
goto error;
}
else if (mmal_port_send_buffer(port, buffer)!= MMAL_SUCCESS)
{
printf("Unable to send a buffer to port (%d)\n", q);
goto error;
}
}
}
return buffer_pool;
error:
if(buffer_pool)
mmal_port_pool_destroy(port,buffer_pool);
return NULL;
}
int fill_port_buffer(MMAL_PORT_T *port, MMAL_POOL_T *pool) {
int q;
int num = mmal_queue_length(pool->queue);
for (q = 0; q < num; q++) {
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(pool->queue);
if (!buffer) {
fprintf(stderr, "Unable to get a required buffer %d from pool queue\n", q);
}
if (mmal_port_send_buffer(port, buffer) != MMAL_SUCCESS) {
fprintf(stderr, "Unable to send a buffer to port (%d)\n", q);
}
}
}
void PiCam::start() {
if (mmal_port_parameter_set_boolean(videoPort, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
throw std::runtime_error("Couldn't start video capture");
}
vcos_semaphore_create(&frame_semaphore, "frame_semaphore", 0);
int num = mmal_queue_length(videoPool->queue);
int q;
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(videoPool->queue);
// TODO: Add numbers to these error messages.
if (!buffer)
throw std::runtime_error("Unable to get a required buffer from pool queue");
if (mmal_port_send_buffer(videoPort, buffer)!= MMAL_SUCCESS)
throw std::runtime_error("Unable to send a buffer to an encoder output port");
}
std::chrono::time_point<std::chrono::system_clock> t1, t2;
t1 = std::chrono::system_clock::now();
/*
while(true) {
if(vcos_semaphore_wait(&frame_semaphore) == VCOS_SUCCESS) {
callback(frame);
++numFrames;
if(numFrames >= 30) {
t2 = std::chrono::system_clock::now();
std::chrono::duration<float> secs = t2-t1;
t1 = t2;
std::cout << (numFrames / secs.count()) << " FPS\n";
numFrames = 0;
}
cv::waitKey(1);
}
}
*/
}
/**
* MMAL Callback from camera preview output port.
* @param port The camera preview port.
* @param buf The new preview buffer.
**/
static void preview_output_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buf)
{
RASPITEX_STATE *state = (RASPITEX_STATE*) port->userdata;
if (buf->length == 0)
{
vcos_log_trace("%s: zero-length buffer => EOS", port->name);
state->preview_stop = 1;
mmal_buffer_header_release(buf);
}
else if (buf->data == NULL)
{
vcos_log_trace("%s: zero buffer handle", port->name);
mmal_buffer_header_release(buf);
}
else
{
/* Enqueue the preview frame for rendering and return to
* avoid blocking MMAL core.
*/
//mmal_queue_put(state->preview_queue, buf);
//to handle the user not reading frames, remove and return any pre-existing ones
if(mmal_queue_length( state->preview_queue ) >= 2)
{
//fprintf(stderr, "mmal_queue_length too long\n" );
MMAL_BUFFER_HEADER_T *existing_buffer = mmal_queue_get( state->preview_queue );
if(existing_buffer)
{
mmal_buffer_header_release(existing_buffer);
if (port->is_enabled)
{
fill_port_buffer_simple( port, state->preview_pool, "preview_output_cb" );
} // if (port->is_enabled)
} // if(existing_buffer)
}
//add the buffer to the output queue
mmal_queue_put(state->preview_queue, buf );
}
}
void CMMALRenderer::Process()
{
SetPriority(THREAD_PRIORITY_ABOVE_NORMAL);
CLog::Log(LOGDEBUG, "%s::%s - starting", CLASSNAME, __func__);
while (!m_bStop)
{
g_RBP.WaitVsync();
double dfps = g_graphicsContext.GetFPS();
if (dfps <= 0.0)
dfps = m_fps;
// This algorithm is basically making the decision according to Bresenham's line algorithm. Imagine drawing a line where x-axis is display frames, and y-axis is video frames
m_error += m_fps / dfps;
// we may need to discard frames if queue length gets too high or video frame rate is above display frame rate
assert(m_queue);
while (mmal_queue_length(m_queue) > 2 || m_error > 1.0)
{
if (m_error > 1.0)
m_error -= 1.0;
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(m_queue);
if (buffer)
{
CMMALBuffer *omvb = (CMMALBuffer *)buffer->user_data;
assert(buffer == omvb->mmal_buffer);
m_inflight--;
omvb->Release();
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s - discard buffer:%p vsync:%d queue:%d diff:%f", CLASSNAME, __func__, buffer, g_RBP.LastVsync(), mmal_queue_length(m_queue), m_error);
}
}
// this is case where we would like to display a new frame
if (m_error > 0.0)
{
m_error -= 1.0;
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(m_queue);
if (buffer)
mmal_port_send_buffer(m_vout_input, buffer);
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s - buffer:%p vsync:%d queue:%d diff:%f", CLASSNAME, __func__, buffer, g_RBP.LastVsync(), mmal_queue_length(m_queue), m_error);
}
}
CLog::Log(LOGDEBUG, "%s::%s - stopping", CLASSNAME, __func__);
}
void MmalVideoCamera::sendBuffers()
{
// Send all the buffers to the encoder output port
int num = mmal_queue_length(m_pool->queue);
for (int q = 0; q < num; q++)
{
MMAL_BUFFER_HEADER_T *new_buffer = mmal_queue_get(m_pool->queue);
if (new_buffer == NULL)
{
std::cerr << "Unable to get buffer " << q << " from the pool" << std::endl;
}
if (mmal_port_send_buffer(m_videoPort, new_buffer)!= MMAL_SUCCESS)
{
std::cerr << "Unable to send buffer " << (q + 1) << " to encoder output port " << std::endl;
}
}
}
/** Disable processing on a port */
static MMAL_STATUS_T mmal_vc_port_disable(MMAL_PORT_T *port)
{
MMAL_PORT_MODULE_T *module = port->priv->module;
MMAL_STATUS_T status;
mmal_worker_reply reply;
mmal_worker_port_action msg;
size_t replylen = sizeof(reply);
msg.component_handle = module->component_handle;
msg.action = MMAL_WORKER_PORT_ACTION_DISABLE;
msg.port_handle = module->port_handle;
status = mmal_vc_sendwait_message(mmal_vc_get_client(), &msg.header, sizeof(msg),
MMAL_WORKER_PORT_ACTION, &reply, &replylen, MMAL_FALSE);
if (status == MMAL_SUCCESS)
{
vcos_assert(replylen == sizeof(reply));
status = reply.status;
}
if (status != MMAL_SUCCESS)
LOG_ERROR("failed to disable port - reason %d", status);
if (module->has_pool)
{
/* MMAL server should make sure that all buffers are sent back before it
* disables the port. */
vcos_assert(vcos_blockpool_available_count(&module->pool) == port->buffer_num);
vcos_blockpool_delete(&module->pool);
module->has_pool = 0;
}
/* We need to make sure all the queued callbacks have been done */
while (mmal_queue_length(port->component->priv->module->callback_queue))
mmal_vc_do_callback(port->component);
if (module->connected)
mmal_vc_port_info_get(module->connected);
return status;
}
static void fill_output_port(filter_t *filter)
{
filter_sys_t *sys = filter->p_sys;
/* allow at least 2 buffers in transit */
unsigned max_buffers_in_transit = __MAX(2, MIN_NUM_BUFFERS_IN_TRANSIT);
int buffers_available = sys->output->buffer_num -
atomic_load(&sys->output_in_transit) -
mmal_queue_length(sys->filtered_pictures);
int buffers_to_send = max_buffers_in_transit - sys->output_in_transit;
int i;
if (buffers_to_send > buffers_available)
buffers_to_send = buffers_available;
#ifndef NDEBUG
msg_Dbg(filter, "Send %d buffers to output port (available: %d, in_transit: %d, buffer_num: %d)",
buffers_to_send, buffers_available, sys->output_in_transit,
sys->output->buffer_num);
#endif
for (i = 0; i < buffers_to_send; ++i) {
if (send_output_buffer(filter) < 0)
break;
}
}
/**
* main
*/
int main(int argc, const char **argv)
{
// Our main data storage vessel..
RASPIVID_STATE state;
MMAL_STATUS_T status = -1;
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;
time_t timer_begin,timer_end;
double secondsElapsed;
bcm_host_init();
signal(SIGINT, signal_handler);
// read default status
default_status(&state);
// init windows and OpenCV Stuff
cvNamedWindow("camcvWin", CV_WINDOW_AUTOSIZE);
int w=state.width;
int h=state.height;
dstImage = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 3);
py = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 1); // Y component of YUV I420 frame
pu = cvCreateImage(cvSize(w/2,h/2), IPL_DEPTH_8U, 1); // U component of YUV I420 frame
pv = cvCreateImage(cvSize(w/2,h/2), IPL_DEPTH_8U, 1); // V component of YUV I420 frame
pu_big = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 1);
pv_big = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 1);
image = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 3); // final picture to display
// create camera
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
{
PORT_USERDATA callback_data;
camera_video_port = state.camera_component->output[MMAL_CAMERA_VIDEO_PORT];
camera_still_port = state.camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
VCOS_STATUS_T vcos_status;
callback_data.pstate = &state;
vcos_status = vcos_semaphore_create(&callback_data.complete_semaphore, "RaspiStill-sem", 0);
vcos_assert(vcos_status == VCOS_SUCCESS);
// assign data to use for callback
camera_video_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
// init timer
time(&timer_begin);
// start capture
if (mmal_port_parameter_set_boolean(camera_video_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
goto error;
}
// 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);
}
// Now wait until we need to stop
vcos_sleep(state.timeout);
error:
mmal_status_to_int(status);
// Disable all our ports that are not handled by connections
check_disable_port(camera_still_port);
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);
time(&timer_end); /* get current time; same as: timer = time(NULL) */
cvReleaseImage(&dstImage);
cvReleaseImage(&pu);
cvReleaseImage(&pv);
cvReleaseImage(&py);
cvReleaseImage(&pu_big);
cvReleaseImage(&pv_big);
secondsElapsed = difftime(timer_end,timer_begin);
printf ("%.f seconds for %d frames : FPS = %f\n", secondsElapsed,nCount,(float)((float)(nCount)/secondsElapsed));
return 0;
}
/**
* main
*/
int main(int argc, const char **argv)
{
// Our main data storage vessel..
RASPISTILLYUV_STATE state;
int exit_code = EX_OK;
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;
FILE *output_file = NULL;
bcm_host_init();
// Register our application with the logging system
vcos_log_register("RaspiStill", VCOS_LOG_CATEGORY);
signal(SIGINT, signal_handler);
// Disable USR1 for the moment - may be reenabled if go in to signal capture mode
signal(SIGUSR1, SIG_IGN);
default_status(&state);
// Do we have any parameters
if (argc == 1)
{
fprintf(stdout, "\n%s Camera App %s\n\n", basename(argv[0]), VERSION_STRING);
display_valid_parameters(basename(argv[0]));
exit(EX_USAGE);
}
default_status(&state);
// Parse the command line and put options in to our status structure
if (parse_cmdline(argc, argv, &state))
{
status = -1;
exit(EX_USAGE);
}
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 two components. Camera and Preview
// Camera is 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__);
exit_code = EX_SOFTWARE;
}
else if ((status = raspipreview_create(&state.preview_parameters)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create preview component", __func__);
destroy_camera_component(&state);
exit_code = EX_SOFTWARE;
}
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];
// Note we are lucky that the preview and null sink components use the same input port
// so we can simple do this without conditionals
preview_input_port = state.preview_parameters.preview_component->input[0];
// Connect camera to preview (which might be a null_sink if no preview required)
status = connect_ports(camera_preview_port, preview_input_port, &state.preview_connection);
if (status == MMAL_SUCCESS)
{
VCOS_STATUS_T vcos_status;
// 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);
camera_still_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
if (state.verbose)
fprintf(stderr, "Enabling camera still output port\n");
// Enable the camera still output port and tell it its callback function
status = mmal_port_enable(camera_still_port, camera_buffer_callback);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Failed to setup camera output");
goto error;
}
if (state.verbose)
fprintf(stderr, "Starting video preview\n");
int frame, keep_looping = 1;
FILE *output_file = NULL;
char *use_filename = NULL; // Temporary filename while image being written
char *final_filename = NULL; // Name that file gets once writing complete
frame = 0;
while (keep_looping)
{
keep_looping = wait_for_next_frame(&state, &frame);
// Open the file
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
{
vcos_assert(use_filename == NULL && final_filename == NULL);
status = create_filenames(&final_filename, &use_filename, state.filename, frame);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to create filenames");
goto error;
}
if (state.verbose)
fprintf(stderr, "Opening output file %s\n", final_filename);
// Technically it is opening the temp~ filename which will be ranamed to the final filename
output_file = fopen(use_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__, use_filename);
}
}
callback_data.file_handle = output_file;
}
if (output_file)
{
int num, q;
// There is a possibility that shutter needs to be set each loop.
if (mmal_status_to_int(mmal_port_parameter_set_uint32(state.camera_component->control, MMAL_PARAMETER_SHUTTER_SPEED, state.camera_parameters.shutter_speed) != MMAL_SUCCESS))
vcos_log_error("Unable to set shutter speed");
// Send all the buffers to the camera output port
num = mmal_queue_length(state.camera_pool->queue);
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(state.camera_pool->queue);
if (!buffer)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(camera_still_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to camera output port (%d)", q);
}
if (state.burstCaptureMode && frame==1)
{
mmal_port_parameter_set_boolean(state.camera_component->control, MMAL_PARAMETER_CAMERA_BURST_CAPTURE, 1);
}
if (state.verbose)
fprintf(stderr, "Starting capture %d\n", frame);
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);
}
// Ensure we don't die if get callback with no open file
callback_data.file_handle = NULL;
if (output_file != stdout)
{
rename_file(&state, output_file, final_filename, use_filename, frame);
}
}
if (use_filename)
{
free(use_filename);
use_filename = NULL;
}
if (final_filename)
{
free(final_filename);
final_filename = NULL;
}
} // end for (frame)
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");
if (output_file)
fclose(output_file);
// Disable all our ports that are not handled by connections
check_disable_port(camera_video_port);
if (state.preview_connection)
mmal_connection_destroy(state.preview_connection);
/* Disable components */
if (state.preview_parameters.preview_component)
mmal_component_disable(state.preview_parameters.preview_component);
if (state.camera_component)
mmal_component_disable(state.camera_component);
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 exit_code;
}
void MmalStillCamera::initialize(CameraMode cameraMode)
{
m_resolution = MmalUtil::get()->getClosestResolution(m_name, cameraMode);
if (m_imageWidth != -1)
{
throw Exception("Camera is already initialized");
}
m_imageWidth = m_resolution.width;
m_imageHeight = m_resolution.height;
m_callbackData = new MmalStillCallbackData(m_imageWidth, m_imageHeight, 3);
// Handle the sensor properties
real sensorWidth, sensorHeight, focalLength;
MmalUtil::get()->getSensorProperties(m_name, sensorWidth, sensorHeight, focalLength);
setSensorProperties(sensorWidth, sensorHeight, focalLength);
createCameraComponent();
InfoLog << "Created camera" << Logger::ENDL;
createPreview();
InfoLog << "Created preview" << Logger::ENDL;
InfoLog << "Target Image Width: " << VCOS_ALIGN_UP(m_imageWidth, 32) << Logger::ENDL;
InfoLog << "Target Image Height: " << VCOS_ALIGN_UP(m_imageHeight, 16) << Logger::ENDL;
MMAL_STATUS_T status;
m_targetPort = m_stillPort;
// Create pool of buffer headers for the output port to consume
m_pool = mmal_port_pool_create(m_targetPort, m_targetPort->buffer_num, m_targetPort->buffer_size);
if (m_pool == NULL)
{
throw Exception("Failed to create buffer header pool for encoder output port");
}
MMAL_CONNECTION_T *preview_connection = NULL;
status = connect_ports(m_previewPort, m_preview->input[0], &preview_connection);
if (status != MMAL_SUCCESS)
{
throw Exception("Error connecting preview port");
}
m_targetPort->userdata = (struct MMAL_PORT_USERDATA_T *) m_callbackData;
m_callbackData->image = NULL;
m_callbackData->pool = m_pool;
// Enable the encoder output port and tell it its callback function
if (mmal_port_enable(m_targetPort, EncoderBufferCallback) != MMAL_SUCCESS)
{
ErrorLog << "Error enabling the encoder buffer callback" << Logger::ENDL;
}
// Send all the buffers to the encoder output port
int num = mmal_queue_length(m_pool->queue);
for (int q = 0; q < num; q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(m_pool->queue);
if (buffer == NULL)
{
ErrorLog << "Unable to get buffer " << q << " from the pool" << Logger::ENDL;
}
if (mmal_port_send_buffer(m_targetPort, buffer) != MMAL_SUCCESS)
{
ErrorLog << "Unable to send a buffer " << q << " to encoder output port " << Logger::ENDL;
}
}
// Enable burst mode
if (m_burstModeEnabled)
{
if (mmal_port_parameter_set_boolean(m_camera->control, MMAL_PARAMETER_CAMERA_BURST_CAPTURE, 1) != MMAL_SUCCESS)
{
ErrorLog << "Error enabling burst mode" << Logger::ENDL;
}
InfoLog << "Enabled burst mode for still images" << Logger::ENDL;
}
InfoLog << "Initialized camera" << Logger::ENDL;
}
int main (int argc, char* argv[]) {
MMAL_STATUS_T status;
int i, max, fd, length, cam_setting;
unsigned long int cam_setting_long;
char readbuf[20];
char *filename_temp, *filename_temp2, *cmd_temp;
bcm_host_init();
//
// read arguments
//
unsigned char of_set = 0;
for(i=1; i<argc; i++) {
if(strcmp(argv[i], "--version") == 0) {
printf("RaspiMJPEG Version ");
printf(VERSION);
printf("\n");
exit(0);
}
else if(strcmp(argv[i], "-w") == 0) {
i++;
width = atoi(argv[i]);
}
else if(strcmp(argv[i], "-h") == 0) {
i++;
height = atoi(argv[i]);
}
else if(strcmp(argv[i], "-wp") == 0) {
i++;
width_pic = atoi(argv[i]);
}
else if(strcmp(argv[i], "-hp") == 0) {
i++;
height_pic = atoi(argv[i]);
}
else if(strcmp(argv[i], "-q") == 0) {
i++;
quality = atoi(argv[i]);
}
else if(strcmp(argv[i], "-d") == 0) {
i++;
divider = atoi(argv[i]);
}
else if(strcmp(argv[i], "-p") == 0) {
mp4box = 1;
}
else if(strcmp(argv[i], "-ic") == 0) {
i++;
image2_cnt = atoi(argv[i]);
}
else if(strcmp(argv[i], "-vc") == 0) {
i++;
video_cnt = atoi(argv[i]);
}
else if(strcmp(argv[i], "-of") == 0) {
i++;
jpeg_filename = argv[i];
of_set = 1;
}
else if(strcmp(argv[i], "-if") == 0) {
i++;
jpeg2_filename = argv[i];
of_set = 1;
}
else if(strcmp(argv[i], "-cf") == 0) {
i++;
pipe_filename = argv[i];
}
else if(strcmp(argv[i], "-vf") == 0) {
i++;
h264_filename = argv[i];
}
else if(strcmp(argv[i], "-sf") == 0) {
i++;
status_filename = argv[i];
}
else if(strcmp(argv[i], "-pa") == 0) {
autostart = 0;
idle = 1;
}
else if(strcmp(argv[i], "-md") == 0) {
motion_detection = 1;
}
else if(strcmp(argv[i], "-fp") == 0) {
preview_mode = RES_4_3;
}
else if(strcmp(argv[i], "-audio") == 0) {
audio_mode = 1;
}
else error("Invalid arguments");
}
if(!of_set) error("Output file not specified");
//
// init
//
if(autostart) start_all();
if(motion_detection) {
if(system("motion") == -1) error("Could not start Motion");
}
//
// run
//
if(autostart) {
if(pipe_filename != 0) printf("MJPEG streaming, ready to receive commands\n");
else printf("MJPEG streaming\n");
}
else {
if(pipe_filename != 0) printf("MJPEG idle, ready to receive commands\n");
else printf("MJPEG idle\n");
}
struct sigaction action;
memset(&action, 0, sizeof(struct sigaction));
action.sa_handler = term;
sigaction(SIGTERM, &action, NULL);
sigaction(SIGINT, &action, NULL);
if(status_filename != 0) {
status_file = fopen(status_filename, "w");
if(!status_file) error("Could not open/create status-file");
if(autostart) {
if(!motion_detection) {
fprintf(status_file, "ready");
}
else fprintf(status_file, "md_ready");
}
else fprintf(status_file, "halted");
fclose(status_file);
}
while(running) {
if(pipe_filename != 0) {
fd = open(pipe_filename, O_RDONLY | O_NONBLOCK);
if(fd < 0) error("Could not open PIPE");
fcntl(fd, F_SETFL, 0);
length = read(fd, readbuf, 20);
close(fd);
if(length) {
if((readbuf[0]=='p') && (readbuf[1]=='m')) {
stop_all();
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
if(strcmp(readbuf, " 4_3") == 0) preview_mode = RES_4_3;
else if(strcmp(readbuf, " 16_9_STD") == 0) preview_mode = RES_16_9_STD;
else if(strcmp(readbuf, " 16_9_WIDE") == 0) preview_mode = RES_16_9_WIDE;
start_all();
printf("Changed preview mode\n");
if(status_filename != 0) {
status_file = fopen(status_filename, "w");
fprintf(status_file, "ready");
fclose(status_file);
}
}
else if((readbuf[0]=='c') && (readbuf[1]=='a')) {
if(readbuf[3]=='1') {
if(!capturing) {
status = mmal_component_enable(h264encoder);
if(status != MMAL_SUCCESS) error("Could not enable h264encoder");
pool_h264encoder = mmal_port_pool_create(h264encoder->output[0], h264encoder->output[0]->buffer_num, h264encoder->output[0]->buffer_size);
if(!pool_h264encoder) error("Could not create pool");
status = mmal_connection_create(&con_cam_h264, camera->output[1], h264encoder->input[0], MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if(status != MMAL_SUCCESS) error("Could not create connecton camera -> video converter");
status = mmal_connection_enable(con_cam_h264);
if(status != MMAL_SUCCESS) error("Could not enable connection camera -> video converter");
currTime = time(NULL);
localTime = localtime (&currTime);
if(mp4box) {
asprintf(&filename_temp, h264_filename, video_cnt, localTime->tm_year+1900, localTime->tm_mon+1, localTime->tm_mday, localTime->tm_hour, localTime->tm_min, localTime->tm_sec);
asprintf(&filename_temp2, "%s.h264", filename_temp);
}
else {
asprintf(&filename_temp2, h264_filename, video_cnt, localTime->tm_year+1900, localTime->tm_mon+1, localTime->tm_mday, localTime->tm_hour, localTime->tm_min, localTime->tm_sec);
}
h264output_file = fopen(filename_temp2, "wb");
free(filename_temp2);
if(mp4box) {
if(audio_mode) {
asprintf(&cmd_temp, "/usr/bin/arecord -q -D hw:1,0 -f S16_LE -t wav | /usr/bin/lame - %s.mp3 -S &", filename_temp);
printf("Audio recording with \"%s\\n", cmd_temp);
if(system(cmd_temp) == -1) error("Could not start audio recording");
}
free(filename_temp);
}
if(!h264output_file) error("Could not open/create video-file");
status = mmal_port_enable(h264encoder->output[0], h264encoder_buffer_callback);
if(status != MMAL_SUCCESS) error("Could not enable video port");
max = mmal_queue_length(pool_h264encoder->queue);
for(i=0;i<max;i++) {
MMAL_BUFFER_HEADER_T *h264buffer = mmal_queue_get(pool_h264encoder->queue);
if(!h264buffer) error("Could not create video pool header");
status = mmal_port_send_buffer(h264encoder->output[0], h264buffer);
if(status != MMAL_SUCCESS) error("Could not send buffers to video port");
}
mmal_port_parameter_set_boolean(camera->output[1], MMAL_PARAMETER_CAPTURE, 1);
if(status != MMAL_SUCCESS) error("Could not start capture");
printf("Capturing started\n");
if(status_filename != 0) {
status_file = fopen(status_filename, "w");
if(!motion_detection) fprintf(status_file, "video");
else fprintf(status_file, "md_video");
fclose(status_file);
}
capturing = 1;
}
}
else {
if(capturing) {
mmal_port_parameter_set_boolean(camera->output[1], MMAL_PARAMETER_CAPTURE, 0);
if(status != MMAL_SUCCESS) error("Could not stop capture");
status = mmal_port_disable(h264encoder->output[0]);
if(status != MMAL_SUCCESS) error("Could not disable video port");
status = mmal_connection_destroy(con_cam_h264);
if(status != MMAL_SUCCESS) error("Could not destroy connection camera -> video encoder");
mmal_port_pool_destroy(h264encoder->output[0], pool_h264encoder);
if(status != MMAL_SUCCESS) error("Could not destroy video buffer pool");
status = mmal_component_disable(h264encoder);
if(status != MMAL_SUCCESS) error("Could not disable video converter");
fclose(h264output_file);
h264output_file = NULL;
printf("Capturing stopped\n");
if(mp4box) {
printf("Boxing started\n");
status_file = fopen(status_filename, "w");
if(!motion_detection) fprintf(status_file, "boxing");
else fprintf(status_file, "md_boxing");
fclose(status_file);
asprintf(&filename_temp, h264_filename, video_cnt, localTime->tm_year+1900, localTime->tm_mon+1, localTime->tm_mday, localTime->tm_hour, localTime->tm_min, localTime->tm_sec);
if(audio_mode) {
asprintf(&cmd_temp, "/usr/bin/killall arecord > /dev/null");
if(system(cmd_temp) == -1) error("Could not stop audio recording");
free(cmd_temp);
asprintf(&cmd_temp, "MP4Box -fps 25 -add %s.h264 -add %s.mp3 %s > /dev/null", filename_temp, filename_temp, filename_temp);
} else {
asprintf(&cmd_temp, "MP4Box -fps 25 -add %s.h264 %s > /dev/null", filename_temp, filename_temp);
}
if(system(cmd_temp) == -1) error("Could not start MP4Box");
asprintf(&filename_temp2, "%s.h264", filename_temp);
remove(filename_temp2);
free(filename_temp2);
if (audio_mode) {
asprintf(&filename_temp2, "%s.mp3", filename_temp);
remove(filename_temp2);
free(filename_temp2);
}
free(filename_temp);
free(cmd_temp);
printf("Boxing stopped\n");
}
video_cnt++;
if(status_filename != 0) {
status_file = fopen(status_filename, "w");
if(!motion_detection) fprintf(status_file, "ready");
else fprintf(status_file, "md_ready");
fclose(status_file);
}
capturing = 0;
}
}
}
else if((readbuf[0]=='i') && (readbuf[1]=='m')) {
capt_img();
}
else if((readbuf[0]=='t') && (readbuf[1]=='l')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
time_between_pic = atoi(readbuf);
if(time_between_pic) {
if(status_filename != 0) {
status_file = fopen(status_filename, "w");
fprintf(status_file, "timelapse");
fclose(status_file);
}
timelapse = 1;
printf("Timelapse started\n");
}
else {
if(status_filename != 0) {
status_file = fopen(status_filename, "w");
fprintf(status_file, "ready");
fclose(status_file);
}
timelapse = 0;
printf("Timelapse stopped\n");
}
}
else if((readbuf[0]=='s') && (readbuf[1]=='h')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
cam_setting = atoi(readbuf);
MMAL_RATIONAL_T value = {cam_setting, 100};
status = mmal_port_parameter_set_rational(camera->control, MMAL_PARAMETER_SHARPNESS, value);
if(status != MMAL_SUCCESS) error("Could not set sharpness");
printf("Sharpness: %d\n", cam_setting);
}
else if((readbuf[0]=='c') && (readbuf[1]=='o')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
cam_setting = atoi(readbuf);
MMAL_RATIONAL_T value = {cam_setting, 100};
status = mmal_port_parameter_set_rational(camera->control, MMAL_PARAMETER_CONTRAST, value);
if(status != MMAL_SUCCESS) error("Could not set contrast");
printf("Contrast: %d\n", cam_setting);
}
else if((readbuf[0]=='b') && (readbuf[1]=='r')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
cam_setting = atoi(readbuf);
MMAL_RATIONAL_T value = {cam_setting, 100};
status = mmal_port_parameter_set_rational(camera->control, MMAL_PARAMETER_BRIGHTNESS, value);
if(status != MMAL_SUCCESS) error("Could not set brightness");
printf("Brightness: %d\n", cam_setting);
}
else if((readbuf[0]=='s') && (readbuf[1]=='a')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
cam_setting = atoi(readbuf);
MMAL_RATIONAL_T value = {cam_setting, 100};
status = mmal_port_parameter_set_rational(camera->control, MMAL_PARAMETER_SATURATION, value);
if(status != MMAL_SUCCESS) error("Could not set saturation");
printf("Saturation: %d\n", cam_setting);
}
else if((readbuf[0]=='i') && (readbuf[1]=='s')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
cam_setting = atoi(readbuf);
status = mmal_port_parameter_set_uint32(camera->control, MMAL_PARAMETER_ISO, cam_setting);
if(status != MMAL_SUCCESS) error("Could not set ISO");
printf("ISO: %d\n", cam_setting);
}
else if((readbuf[0]=='v') && (readbuf[1]=='s')) {
if(readbuf[3]=='1') {
status = mmal_port_parameter_set_boolean(camera->control, MMAL_PARAMETER_VIDEO_STABILISATION, 1);
printf("Video Stabilisation ON\n");
}
else {
status = mmal_port_parameter_set_boolean(camera->control, MMAL_PARAMETER_VIDEO_STABILISATION, 0);
printf("Video Stabilisation OFF\n");
}
if(status != MMAL_SUCCESS) error("Could not set video stabilisation");
}
else if((readbuf[0]=='e') && (readbuf[1]=='c')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
cam_setting = atoi(readbuf);
status = mmal_port_parameter_set_int32(camera->control, MMAL_PARAMETER_EXPOSURE_COMP, cam_setting);
if(status != MMAL_SUCCESS) error("Could not set exposure compensation");
printf("Exposure Compensation: %d\n", cam_setting);
}
else if((readbuf[0]=='e') && (readbuf[1]=='m')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
MMAL_PARAM_EXPOSUREMODE_T mode = MMAL_PARAM_EXPOSUREMODE_OFF;
if(strcmp(readbuf, " auto") == 0) mode = MMAL_PARAM_EXPOSUREMODE_AUTO;
else if(strcmp(readbuf, " night") == 0) mode = MMAL_PARAM_EXPOSUREMODE_NIGHT;
else if(strcmp(readbuf, " nightpreview") == 0) mode = MMAL_PARAM_EXPOSUREMODE_NIGHTPREVIEW;
else if(strcmp(readbuf, " backlight") == 0) mode = MMAL_PARAM_EXPOSUREMODE_BACKLIGHT;
else if(strcmp(readbuf, " spotlight") == 0) mode = MMAL_PARAM_EXPOSUREMODE_SPOTLIGHT;
else if(strcmp(readbuf, " sports") == 0) mode = MMAL_PARAM_EXPOSUREMODE_SPORTS;
else if(strcmp(readbuf, " snow") == 0) mode = MMAL_PARAM_EXPOSUREMODE_SNOW;
else if(strcmp(readbuf, " beach") == 0) mode = MMAL_PARAM_EXPOSUREMODE_BEACH;
else if(strcmp(readbuf, " verylong") == 0) mode = MMAL_PARAM_EXPOSUREMODE_VERYLONG;
else if(strcmp(readbuf, " fixedfps") == 0) mode = MMAL_PARAM_EXPOSUREMODE_FIXEDFPS;
else if(strcmp(readbuf, " antishake") == 0) mode = MMAL_PARAM_EXPOSUREMODE_ANTISHAKE;
else if(strcmp(readbuf, " fireworks") == 0) mode = MMAL_PARAM_EXPOSUREMODE_FIREWORKS;
MMAL_PARAMETER_EXPOSUREMODE_T exp_mode = {{MMAL_PARAMETER_EXPOSURE_MODE,sizeof(exp_mode)}, mode};
status = mmal_port_parameter_set(camera->control, &exp_mode.hdr);
if(status != MMAL_SUCCESS) error("Could not set exposure mode");
printf("Exposure mode changed\n");
}
else if((readbuf[0]=='w') && (readbuf[1]=='b')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
MMAL_PARAM_AWBMODE_T awb_mode = MMAL_PARAM_AWBMODE_OFF;
if(strcmp(readbuf, " auto") == 0) awb_mode = MMAL_PARAM_AWBMODE_AUTO;
else if(strcmp(readbuf, " auto") == 0) awb_mode = MMAL_PARAM_AWBMODE_AUTO;
else if(strcmp(readbuf, " sun") == 0) awb_mode = MMAL_PARAM_AWBMODE_SUNLIGHT;
else if(strcmp(readbuf, " cloudy") == 0) awb_mode = MMAL_PARAM_AWBMODE_CLOUDY;
else if(strcmp(readbuf, " shade") == 0) awb_mode = MMAL_PARAM_AWBMODE_SHADE;
else if(strcmp(readbuf, " tungsten") == 0) awb_mode = MMAL_PARAM_AWBMODE_TUNGSTEN;
else if(strcmp(readbuf, " fluorescent") == 0) awb_mode = MMAL_PARAM_AWBMODE_FLUORESCENT;
else if(strcmp(readbuf, " incandescent") == 0) awb_mode = MMAL_PARAM_AWBMODE_INCANDESCENT;
else if(strcmp(readbuf, " flash") == 0) awb_mode = MMAL_PARAM_AWBMODE_FLASH;
else if(strcmp(readbuf, " horizon") == 0) awb_mode = MMAL_PARAM_AWBMODE_HORIZON;
MMAL_PARAMETER_AWBMODE_T param = {{MMAL_PARAMETER_AWB_MODE,sizeof(param)}, awb_mode};
status = mmal_port_parameter_set(camera->control, ¶m.hdr);
if(status != MMAL_SUCCESS) error("Could not set white balance");
printf("White balance changed\n");
}
else if((readbuf[0]=='r') && (readbuf[1]=='o')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
cam_setting = atoi(readbuf);
status = mmal_port_parameter_set_int32(camera->output[0], MMAL_PARAMETER_ROTATION, cam_setting);
if(status != MMAL_SUCCESS) error("Could not set rotation (0)");
status = mmal_port_parameter_set_int32(camera->output[1], MMAL_PARAMETER_ROTATION, cam_setting);
if(status != MMAL_SUCCESS) error("Could not set rotation (1)");
status = mmal_port_parameter_set_int32(camera->output[2], MMAL_PARAMETER_ROTATION, cam_setting);
if(status != MMAL_SUCCESS) error("Could not set rotation (2)");
printf("Rotation: %d\n", cam_setting);
}
else if((readbuf[0]=='q') && (readbuf[1]=='u')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
cam_setting = atoi(readbuf);
status = mmal_port_parameter_set_uint32(jpegencoder2->output[0], MMAL_PARAMETER_JPEG_Q_FACTOR, cam_setting);
if(status != MMAL_SUCCESS) error("Could not set quality");
printf("Quality: %d\n", cam_setting);
}
else if((readbuf[0]=='b') && (readbuf[1]=='i')) {
readbuf[0] = ' ';
readbuf[1] = ' ';
readbuf[length] = 0;
cam_setting_long = strtoull(readbuf, NULL, 0);
h264encoder->output[0]->format->bitrate = cam_setting_long;
status = mmal_port_format_commit(h264encoder->output[0]);
if(status != MMAL_SUCCESS) error("Could not set bitrate");
printf("Bitrate: %lu\n", cam_setting_long);
}
else if((readbuf[0]=='r') && (readbuf[1]=='u')) {
if(readbuf[3]=='0') {
stop_all();
idle = 1;
printf("Stream halted\n");
if(status_filename != 0) {
status_file = fopen(status_filename, "w");
fprintf(status_file, "halted");
fclose(status_file);
}
}
else {
start_all();
idle = 0;
printf("Stream continued\n");
if(status_filename != 0) {
status_file = fopen(status_filename, "w");
fprintf(status_file, "ready");
fclose(status_file);
}
}
}
else if((readbuf[0]=='m') && (readbuf[1]=='d')) {
if(readbuf[3]=='0') {
motion_detection = 0;
if(system("killall motion") == -1) error("Could not stop Motion");
printf("Motion detection stopped\n");
if(status_filename != 0) {
status_file = fopen(status_filename, "w");
fprintf(status_file, "ready");
fclose(status_file);
}
}
else {
motion_detection = 1;
if(system("motion") == -1) error("Could not start Motion");
printf("Motion detection started\n");
if(status_filename != 0) {
status_file = fopen(status_filename, "w");
fprintf(status_file, "md_ready");
fclose(status_file);
}
}
}
}
}
if(timelapse) {
tl_cnt++;
if(tl_cnt >= time_between_pic) {
if(capturing == 0) {
capt_img();
tl_cnt = 0;
}
}
}
usleep(100000);
}
printf("SIGINT/SIGTERM received, stopping\n");
//
// tidy up
//
if(!idle) stop_all();
return 0;
}
/**
* main
*/
int main(int argc, const char **argv)
{
// Our main data storage vessel..
RASPISTILLYUV_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;
FILE *output_file = NULL;
// Register our application with the logging system
vcos_log_register("RaspiStill", VCOS_LOG_CATEGORY);
printf("\nRaspiStillYUV Camera App\n");
printf( "========================\n\n");
signal(SIGINT, signal_handler);
// Do we have any parameters
if (argc == 1)
{
display_valid_parameters();
exit(0);
}
default_status(&state);
// 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 two components. Camera and Preview
// Camera is different in stills/video, but preview
// is the same so handed off to a separate module
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
{
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];
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.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);
camera_still_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
if (state.verbose)
printf("Enabling camera still output port\n");
// Enable the camera still output port and tell it its callback function
status = mmal_port_enable(camera_still_port, camera_buffer_callback);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Failed to setup camera output");
goto error;
}
if (state.verbose)
printf("Starting video preview\n");
// Send all the buffers to the encoder output port
{
int num = mmal_queue_length(state.camera_pool->queue);
int q;
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(state.camera_pool->queue);
if (!buffer)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(camera_still_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to encoder output port (%d)", q);
}
}
// Now wait until we need to do the capture
vcos_sleep(state.timeout);
// And only do the capture if we have specified a filename and its opened OK
if (output_file)
{
if (state.verbose)
printf("Starting capture\n");
// Fire the capture
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)
printf("Finished capture\n");
}
}
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)
printf("Closing down\n");
if (output_file)
fclose(output_file);
// Disable all our ports that are not handled by connections
check_disable_port(camera_video_port);
if (state.preview_parameters.wantPreview )
mmal_connection_destroy(state.preview_connection);
/* Disable components */
if (state.preview_parameters.preview_component)
mmal_component_disable(state.preview_parameters.preview_component);
if (state.camera_component)
mmal_component_disable(state.camera_component);
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;
}
void ofxRaspicam::takePhoto()
{
ofFile myFile;
FILE *output_file = NULL;
vcos_sleep(photo.timeout);
// Open the file
string fileName = ofToDataPath("photos/"+ ofGetTimestampString()+".jpg", true);
char *toChar = const_cast<char*> ( fileName.c_str() );
photo.filename = toChar;
ofLogVerbose() << "Opening output file" << fileName;
output_file = fopen(photo.filename, "wb");
if (!output_file)
{
// Notify user, carry on but discarding encoded output buffers
ofLogVerbose() << "Error opening output file";
}
photo.add_exif_tags();
callback_data.file_handle = output_file;
// We only capture if a filename was specified and it opened
if (output_file)
{
// Send all the buffers to the encoder output port
int num = mmal_queue_length(photo.encoder_pool->queue);
int q;
for (q=0;q<num;q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(photo.encoder_pool->queue);
if (!buffer)
{
ofLogVerbose() << "Unable to get a required buffer " << q << " from pool queue";
}
if (mmal_port_send_buffer(encoder_output_port, buffer)!= MMAL_SUCCESS)
{
ofLogVerbose() << "Unable to send a buffer to encoder output port " << q;
}
}
ofLogVerbose() << "Starting capture";
if (mmal_port_parameter_set_boolean(camera_still_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
ofLogVerbose() << "Failed to start capture";
}
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);
ofLogVerbose() << "Finished capture " << fileName;
lastImage.loadImage(callback_data.photo->filename);
}
// Ensure we don't die if get callback with no open file
callback_data.file_handle = NULL;
fclose(output_file);
}
vcos_semaphore_delete(&callback_data.complete_semaphore);
}
/**
* 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;
}
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_still_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, 1); // 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
}
// create camera
if (!create_camera_component(state))
{
vcos_log_error("%s: Failed to create camera component", __func__);
raspiCamCvReleaseCapture(&capture);
return NULL;
}
camera_video_port = state->camera_component->output[MMAL_CAMERA_VIDEO_PORT];
camera_still_port = state->camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
// assign data to use for callback
camera_video_port->userdata = (struct MMAL_PORT_USERDATA_T *)state;
// start capture
if (mmal_port_parameter_set_boolean(camera_video_port, 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;
}
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..
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;
}
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
}
}
int CMMALVideo::Decode(uint8_t* pData, int iSize, double dts, double pts)
{
//if (g_advancedSettings.CanLogComponent(LOGVIDEO))
// CLog::Log(LOGDEBUG, "%s::%s - %-8p %-6d dts:%.3f pts:%.3f dts_queue(%d) ready_queue(%d) busy_queue(%d)",
// CLASSNAME, __func__, pData, iSize, dts == DVD_NOPTS_VALUE ? 0.0 : dts*1e-6, pts == DVD_NOPTS_VALUE ? 0.0 : pts*1e-6, m_dts_queue.size(), m_output_ready.size(), m_output_busy);
unsigned int demuxer_bytes = 0;
uint8_t *demuxer_content = NULL;
MMAL_BUFFER_HEADER_T *buffer;
MMAL_STATUS_T status;
while (buffer = mmal_queue_get(m_dec_output_pool->queue), buffer)
Recycle(buffer);
// we need to queue then de-queue the demux packet, seems silly but
// mmal might not have an input buffer available when we are called
// and we must store the demuxer packet and try again later.
// try to send any/all demux packets to mmal decoder.
unsigned space = mmal_queue_length(m_dec_input_pool->queue) * m_dec_input->buffer_size;
if (pData && m_demux_queue.empty() && space >= (unsigned int)iSize)
{
demuxer_bytes = iSize;
demuxer_content = pData;
}
else if (pData && iSize)
{
mmal_demux_packet demux_packet;
demux_packet.dts = dts;
demux_packet.pts = pts;
demux_packet.size = iSize;
demux_packet.buff = new uint8_t[iSize];
memcpy(demux_packet.buff, pData, iSize);
m_demux_queue_length += demux_packet.size;
m_demux_queue.push(demux_packet);
}
uint8_t *buffer_to_free = NULL;
while (1)
{
while (buffer = mmal_queue_get(m_dec_output_pool->queue), buffer)
Recycle(buffer);
space = mmal_queue_length(m_dec_input_pool->queue) * m_dec_input->buffer_size;
if (!demuxer_bytes && !m_demux_queue.empty())
{
mmal_demux_packet &demux_packet = m_demux_queue.front();
if (space >= (unsigned int)demux_packet.size)
{
// need to lock here to retrieve an input buffer and pop the queue
m_demux_queue_length -= demux_packet.size;
m_demux_queue.pop();
demuxer_bytes = (unsigned int)demux_packet.size;
demuxer_content = demux_packet.buff;
buffer_to_free = demux_packet.buff;
dts = demux_packet.dts;
pts = demux_packet.pts;
}
}
if (demuxer_content)
{
// 500ms timeout
buffer = mmal_queue_timedwait(m_dec_input_pool->queue, 500);
if (!buffer)
{
CLog::Log(LOGERROR, "%s::%s - mmal_queue_get failed", CLASSNAME, __func__);
return VC_ERROR;
}
mmal_buffer_header_reset(buffer);
buffer->cmd = 0;
if (m_startframe && pts == DVD_NOPTS_VALUE)
pts = 0;
buffer->pts = pts == DVD_NOPTS_VALUE ? MMAL_TIME_UNKNOWN : pts;
buffer->dts = dts == DVD_NOPTS_VALUE ? MMAL_TIME_UNKNOWN : dts;
buffer->length = demuxer_bytes > buffer->alloc_size ? buffer->alloc_size : demuxer_bytes;
buffer->user_data = (void *)m_decode_frame_number;
// set a flag so we can identify primary frames from generated frames (deinterlace)
buffer->flags = MMAL_BUFFER_HEADER_FLAG_USER0;
// Request decode only (maintain ref frames, but don't return a picture)
if (m_drop_state)
buffer->flags |= MMAL_BUFFER_HEADER_FLAG_DECODEONLY;
memcpy(buffer->data, demuxer_content, buffer->length);
demuxer_bytes -= buffer->length;
demuxer_content += buffer->length;
if (demuxer_bytes == 0)
buffer->flags |= MMAL_BUFFER_HEADER_FLAG_FRAME_END;
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s - %-8p %-6d/%-6d dts:%.3f pts:%.3f flags:%x dts_queue(%d) ready_queue(%d) busy_queue(%d) demux_queue(%d) space(%d)",
CLASSNAME, __func__, buffer, buffer->length, demuxer_bytes, dts == DVD_NOPTS_VALUE ? 0.0 : dts*1e-6, pts == DVD_NOPTS_VALUE ? 0.0 : pts*1e-6, buffer->flags, m_dts_queue.size(), m_output_ready.size(), m_output_busy, m_demux_queue_length, mmal_queue_length(m_dec_input_pool->queue) * m_dec_input->buffer_size);
assert((int)buffer->length > 0);
status = mmal_port_send_buffer(m_dec_input, buffer);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed send buffer to decoder input port (status=%x %s)", CLASSNAME, __func__, status, mmal_status_to_string(status));
return VC_ERROR;
}
if (demuxer_bytes == 0)
{
m_decode_frame_number++;
m_startframe = true;
if (m_drop_state)
{
m_droppedPics += m_deint ? 2:1;
}
else
{
// only push if we are successful with feeding mmal
pthread_mutex_lock(&m_output_mutex);
m_dts_queue.push(dts);
assert(m_dts_queue.size() < 5000);
pthread_mutex_unlock(&m_output_mutex);
}
if (m_changed_count_dec != m_changed_count)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s format changed frame:%d(%d)", CLASSNAME, __func__, m_changed_count_dec, m_changed_count);
m_changed_count_dec = m_changed_count;
if (!change_dec_output_format())
{
CLog::Log(LOGERROR, "%s::%s - change_dec_output_format() failed", CLASSNAME, __func__);
return VC_ERROR;
}
}
EDEINTERLACEMODE deinterlace_request = CMediaSettings::Get().GetCurrentVideoSettings().m_DeinterlaceMode;
EINTERLACEMETHOD interlace_method = g_renderManager.AutoInterlaceMethod(CMediaSettings::Get().GetCurrentVideoSettings().m_InterlaceMethod);
bool deinterlace = m_interlace_mode != MMAL_InterlaceProgressive;
if (deinterlace_request == VS_DEINTERLACEMODE_OFF)
deinterlace = false;
else if (deinterlace_request == VS_DEINTERLACEMODE_FORCE)
deinterlace = true;
if (((deinterlace && interlace_method != m_interlace_method) || !deinterlace) && m_deint)
DestroyDeinterlace();
if (deinterlace && !m_deint)
CreateDeinterlace(interlace_method);
if (buffer_to_free)
{
delete [] buffer_to_free;
buffer_to_free = NULL;
demuxer_content = NULL;
continue;
}
while (buffer = mmal_queue_get(m_dec_output_pool->queue), buffer)
Recycle(buffer);
}
}
if (!demuxer_bytes)
break;
}
int ret = 0;
if (!m_output_ready.empty())
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s - got space for output: demux_queue(%d) space(%d)", CLASSNAME, __func__, m_demux_queue_length, mmal_queue_length(m_dec_input_pool->queue) * m_dec_input->buffer_size);
ret |= VC_PICTURE;
}
if (mmal_queue_length(m_dec_input_pool->queue) > 0 && !m_demux_queue_length)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s - got output picture:%d", CLASSNAME, __func__, m_output_ready.size());
ret |= VC_BUFFER;
}
if (!ret)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s - Nothing to do: dts_queue(%d) ready_queue(%d) busy_queue(%d) demux_queue(%d) space(%d)",
CLASSNAME, __func__, m_dts_queue.size(), m_output_ready.size(), m_output_busy, m_demux_queue_length, mmal_queue_length(m_dec_input_pool->queue) * m_dec_input->buffer_size);
Sleep(10); // otherwise we busy spin
}
return ret;
}
/**
* 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;
}
MmalStillCamera::MmalStillCamera(int imageWidth, int imageHeight, bool enableBurstMode) :
m_imageWidth(imageWidth),
m_imageHeight(imageHeight),
m_callbackData(NULL),
m_cs(),
m_camera(NULL),
m_preview(NULL),
m_encoder(NULL),
m_pool(NULL),
m_previewPort(NULL),
m_videoPort(NULL),
m_stillPort(NULL),
m_targetPort(NULL)
{
m_callbackData = new MmalStillCallbackData(m_imageWidth, m_imageHeight, 3);
createCameraComponent();
std::cout << "Created camera" << std::endl;
createPreview();
std::cout << "Created preview" << std::endl;
std::cout << "Target Image Width: " << VCOS_ALIGN_UP(m_imageWidth, 32) << std::endl;
std::cout << "Target Image Height: " << VCOS_ALIGN_UP(m_imageHeight, 16) << std::endl;
MMAL_STATUS_T status;
m_targetPort = m_stillPort;
// Create pool of buffer headers for the output port to consume
m_pool = mmal_port_pool_create(m_targetPort, m_targetPort->buffer_num, m_targetPort->buffer_size);
if (m_pool == NULL)
{
throw Exception("Failed to create buffer header pool for encoder output port");
}
MMAL_CONNECTION_T *preview_connection = NULL;
status = connect_ports(m_previewPort, m_preview->input[0], &preview_connection);
if (status != MMAL_SUCCESS)
{
throw Exception("Error connecting preview port");
}
m_targetPort->userdata = (struct MMAL_PORT_USERDATA_T *) m_callbackData;
m_callbackData->image = NULL;
m_callbackData->pool = m_pool;
// Enable the encoder output port and tell it its callback function
if (mmal_port_enable(m_targetPort, EncoderBufferCallback) != MMAL_SUCCESS)
{
std::cerr << "Error enabling the encoder buffer callback" << std::endl;
}
// Send all the buffers to the encoder output port
int num = mmal_queue_length(m_pool->queue);
for (int q = 0; q < num; q++)
{
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(m_pool->queue);
if (buffer == NULL)
{
std::cerr << "Unable to get buffer " << q << " from the pool" << std::endl;
}
if (mmal_port_send_buffer(m_targetPort, buffer)!= MMAL_SUCCESS)
{
std::cerr << "Unable to send a buffer " << q << " to encoder output port " << std::endl;
}
}
// Enable burst mode
if (enableBurstMode)
{
if (mmal_port_parameter_set_boolean(m_camera->control, MMAL_PARAMETER_CAMERA_BURST_CAPTURE, 1) != MMAL_SUCCESS)
{
std::cerr << "Error enabling burst mode" << std::endl;
}
std::cout << "Enabled burst mode for still images" << std::endl;
}
std::cout << "Initialized camera" << std::endl;
}
/**
* 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;
}
