/* Connect a component output[portnum] to a components input[0] using
| TUNNELLING to keep processing within the GPU (no callbacks to the
| ARM for these connections).
*/
boolean
ports_tunnel_connect(CameraObject *out, int port_num, CameraObject *in)
{
MMAL_PORT_T *out_port, *in_port;
MMAL_CONNECTION_T *connection = NULL;
MMAL_STATUS_T status;
char *msg = "mmal_connection_create";
boolean result = TRUE;
if (!out->component || !in->component)
return FALSE;
out_port = out->component->output[port_num];
in_port = in->component->input[0];
if ((status = mmal_connection_create(&connection, out_port, in_port,
MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT
| MMAL_CONNECTION_FLAG_TUNNELLING)) == MMAL_SUCCESS)
{
msg = "mmal_connection_enable";
status = mmal_connection_enable(connection);
}
if (status != MMAL_SUCCESS)
{
if (connection)
mmal_connection_destroy(connection);
connection = NULL;
result = FALSE;
log_printf("ports_tunnel_connect %s_out->%s_in: %s failed. Status %s\n",
out->name, in->name, msg, mmal_status[status]);
}
in->input_connection = connection;
return result;
}
MMAL_STATUS_T Private_Impl_Still::connectPorts ( MMAL_PORT_T *output_port, MMAL_PORT_T *input_port, MMAL_CONNECTION_T **connection ) {
MMAL_STATUS_T status = mmal_connection_create ( connection, output_port, input_port, MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT );
if ( status == MMAL_SUCCESS ) {
status = mmal_connection_enable ( *connection );
if ( status != MMAL_SUCCESS )
mmal_connection_destroy ( *connection );
}
return status;
}
/* Start SVP. Enables MMAL connection + creates worker thread. */
int svp_start(SVP_T *svp)
{
MMAL_STATUS_T st;
VCOS_STATUS_T vst;
/* Ensure SVP is stopped first */
svp_stop(svp);
/* Reset the worker thread stop status, before enabling ports that might trigger a stop */
svp_reset_stop(svp);
if (svp->connection)
{
/* Enable reader->decoder connection */
st = mmal_connection_enable(svp->connection);
CHECK_STATUS(st, "Failed to create connection");
}
/* Enable video output port */
st = svp_port_enable(svp, svp->video_output, svp_bh_output_cb);
CHECK_STATUS(st, "Failed to enable output port");
/* Reset stats */
svp->stats.video_frame_count = 0;
/* Create worker thread */
vst = vcos_thread_create(&svp->thread, "svp-worker", NULL, svp_worker, svp);
CHECK_STATUS((vst == VCOS_SUCCESS ? MMAL_SUCCESS : MMAL_ENOMEM), "Failed to create connection");
svp->created |= SVP_CREATED_THREAD;
/* Set timer */
if (svp->camera)
{
unsigned ms = svp->opts.duration_ms;
vcos_timer_set(&svp->timer, ((ms == 0) ? SVP_CAMERA_DURATION_MS : ms));
}
/* Start watchdog timer */
vcos_timer_set(&svp->wd_timer, SVP_WATCHDOG_TIMEOUT_MS);
return 0;
error:
return -1;
}
/**
* Connect two specific ports together
*
* @param output_port Pointer the output port
* @param input_port Pointer the input port
* @param Pointer to a mmal connection pointer, reassigned if function successful
* @return Returns a MMAL_STATUS_T giving result of operation
*
*/
static MMAL_STATUS_T connect_ports(MMAL_PORT_T *output_port, MMAL_PORT_T *input_port, MMAL_CONNECTION_T **connection)
{
MMAL_STATUS_T status;
status = mmal_connection_create(connection, output_port, input_port, MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if (status == MMAL_SUCCESS)
{
status = mmal_connection_enable(*connection);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Failed to connect ports %s and %s - status %d", output_port->name, input_port->name);
mmal_connection_destroy(*connection);
}
}
return status;
}
int setup_preview(PORT_USERDATA *userdata) {
MMAL_STATUS_T status;
MMAL_COMPONENT_T *preview = 0;
MMAL_CONNECTION_T *camera_preview_connection = 0;
MMAL_PORT_T *preview_input_port;
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_RENDERER, &preview);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: unable to create preview (%u)\n", status);
return -1;
}
userdata->preview = preview;
preview_input_port = preview->input[0];
{
MMAL_DISPLAYREGION_T param;
param.hdr.id = MMAL_PARAMETER_DISPLAYREGION;
param.hdr.size = sizeof (MMAL_DISPLAYREGION_T);
param.set = MMAL_DISPLAY_SET_LAYER;
param.layer = 0;
param.set |= MMAL_DISPLAY_SET_FULLSCREEN;
param.fullscreen = 1;
status = mmal_port_parameter_set(preview_input_port, ¶m.hdr);
if (status != MMAL_SUCCESS && status != MMAL_ENOSYS) {
fprintf(stderr, "Error: unable to set preview port parameters (%u)\n", status);
return -1;
}
}
status = mmal_connection_create(&camera_preview_connection, userdata->camera_preview_port, preview_input_port, MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: unable to create connection (%u)\n", status);
return -1;
}
status = mmal_connection_enable(camera_preview_connection);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: unable to enable connection (%u)\n", status);
return -1;
}
//fprintf(stderr, "INFO: preview created\n");
return 0;
}
void CMMALVideo::Reset(void)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s", CLASSNAME, __func__);
if (m_dec_input && m_dec_input->is_enabled)
mmal_port_disable(m_dec_input);
if (m_deint_connection && m_deint_connection->is_enabled)
mmal_connection_disable(m_deint_connection);
if (m_dec_output && m_dec_output->is_enabled)
mmal_port_disable(m_dec_output);
if (!m_finished)
{
if (m_dec_input)
mmal_port_enable(m_dec_input, dec_input_port_cb);
if (m_deint_connection)
mmal_connection_enable(m_deint_connection);
if (m_dec_output)
mmal_port_enable(m_dec_output, dec_output_port_cb_static);
}
// blow all ready video frames
bool old_drop_state = m_drop_state;
SetDropState(true);
pthread_mutex_lock(&m_output_mutex);
while(!m_dts_queue.empty())
m_dts_queue.pop();
while (!m_demux_queue.empty())
m_demux_queue.pop();
m_demux_queue_length = 0;
pthread_mutex_unlock(&m_output_mutex);
if (!old_drop_state)
SetDropState(false);
if (!m_finished)
SendCodecConfigData();
m_startframe = false;
m_decoderPts = DVD_NOPTS_VALUE;
m_droppedPics = 0;
m_decode_frame_number = 1;
m_preroll = !m_hints.stills && (m_speed == DVD_PLAYSPEED_NORMAL || m_speed == DVD_PLAYSPEED_PAUSE);
}
bool CCameraOutput::Init(int width, int height, MMAL_COMPONENT_T* input_component, int input_port_idx, bool do_argb_conversion)
{
printf("Init camera output with %d/%d\n",width,height);
Width = width;
Height = height;
MMAL_COMPONENT_T *resizer = 0;
MMAL_CONNECTION_T* connection = 0;
MMAL_STATUS_T status;
MMAL_POOL_T* video_buffer_pool = 0;
MMAL_QUEUE_T* output_queue = 0;
//got the port we're receiving from
MMAL_PORT_T* input_port = input_component->output[input_port_idx];
//check if user wants conversion to argb or the width or height is different to the input
if(do_argb_conversion || width != input_port->format->es->video.width || height != input_port->format->es->video.height)
{
//create the resizing component, reading from the splitter output
resizer = CreateResizeComponentAndSetupPorts(input_port,do_argb_conversion);
if(!resizer)
goto error;
//create and enable a connection between the video output and the resizer input
status = mmal_connection_create(&connection, input_port, resizer->input[0], MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if (status != MMAL_SUCCESS)
{
printf("Failed to create connection\n");
goto error;
}
status = mmal_connection_enable(connection);
if (status != MMAL_SUCCESS)
{
printf("Failed to enable connection\n");
goto error;
}
//set the buffer pool port to be the resizer output
BufferPort = resizer->output[0];
}
else
{
//no convert/resize needed so just set the buffer pool port to be the input port
BufferPort = input_port;
}
//setup the video buffer callback
video_buffer_pool = EnablePortCallbackAndCreateBufferPool(BufferPort,VideoBufferCallback,3);
if(!video_buffer_pool)
goto error;
//create the output queue
output_queue = mmal_queue_create();
if(!output_queue)
{
printf("Failed to create output queue\n");
goto error;
}
ResizerComponent = resizer;
BufferPool = video_buffer_pool;
OutputQueue = output_queue;
Connection = connection;
return true;
error:
if(output_queue)
mmal_queue_destroy(output_queue);
if(video_buffer_pool)
mmal_port_pool_destroy(resizer->output[0],video_buffer_pool);
if(connection)
mmal_connection_destroy(connection);
if(resizer)
mmal_component_destroy(resizer);
return false;
}
bool CCamera::Init(int width, int height, int framerate, int num_levels, bool do_argb_conversion)
{
//init broadcom host - QUESTION: can this be called more than once??
bcm_host_init();
//store basic parameters
Width = width;
Height = height;
FrameRate = framerate;
// Set up the camera_parameters to default
raspicamcontrol_set_defaults(&CameraParameters);
// Change default parameter, i.e .rotate image
int rotation = 90;
int my_rotation = ((rotation % 360 ) / 90) * 90;
CameraParameters.rotation = my_rotation;
//ret = mmal_port_parameter_set_int32(camera->output[0], MMAL_PARAMETER_ROTATION, my_rotation);
//mmal_port_parameter_set_int32(camera->output[1], MMAL_PARAMETER_ROTATION, my_rotation);
//mmal_port_parameter_set_int32(camera->output[2], MMAL_PARAMETER_ROTATION, my_rotation);
#ifdef WITH_ENCODER
MMAL_COMPONENT_T *encoder = 0;
#endif
MMAL_COMPONENT_T *camera = 0;
MMAL_COMPONENT_T *splitter = 0;
MMAL_CONNECTION_T* vid_to_split_connection = 0;
MMAL_PORT_T *video_port = NULL;
MMAL_STATUS_T status;
CCameraOutput* outputs[4]; memset(outputs,0,sizeof(outputs));
//create the camera component
camera = CreateCameraComponentAndSetupPorts();
if (!camera)
goto error;
//get the video port
video_port = camera->output[MMAL_CAMERA_VIDEO_PORT];
video_port->buffer_num = 3;
//create the splitter component
splitter = CreateSplitterComponentAndSetupPorts(video_port);
if(!splitter)
goto error;
//create and enable a connection between the video output and the resizer input
status = mmal_connection_create(&vid_to_split_connection, video_port, splitter->input[0], MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if (status != MMAL_SUCCESS)
{
printf("Failed to create connection\n");
goto error;
}
status = mmal_connection_enable(vid_to_split_connection);
if (status != MMAL_SUCCESS)
{
printf("Failed to enable connection\n");
goto error;
}
//setup all the outputs
for(int i = 0; i < num_levels; i++)
{
outputs[i] = new CCameraOutput();
if(!outputs[i]->Init(Width >> i,Height >> i,splitter,i,do_argb_conversion))
{
printf("Failed to initialize output %d\n",i);
goto error;
}
}
#ifdef WITH_ENCODER
encoder = CreateEncoderComponentAndSetupPorts();
if (!encoder)
goto error;
#endif
//begin capture
if (mmal_port_parameter_set_boolean(video_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
printf("Failed to start capture\n");
goto error;
}
//store created info
CameraComponent = camera;
SplitterComponent = splitter;
VidToSplitConn = vid_to_split_connection;
memcpy(Outputs,outputs,sizeof(outputs));
//return success
printf("Camera successfully created\n");
return true;
error:
if(vid_to_split_connection)
mmal_connection_destroy(vid_to_split_connection);
if(camera)
mmal_component_destroy(camera);
if(splitter)
mmal_component_destroy(splitter);
for(int i = 0; i < 4; i++)
{
if(outputs[i])
{
outputs[i]->Release();
delete outputs[i];
}
}
#ifdef WITH_ENCODER
if(encoder){}
#endif
return false;
}
int main(int argc, char **argv)
{
MMAL_COMPONENT_T *camera =0;
MMAL_COMPONENT_T *preview=0;
MMAL_COMPONENT_T *encoder=0;
MMAL_CONNECTION_T *preview_conn=0;
MMAL_CONNECTION_T *encoder_conn=0;
USERDATA_T callback_data;
// bcm should be initialized before any GPU call is made
bcm_host_init();
setNonDefaultOptions(argc, argv);
// Open file to save the video
open_new_file_handle(&callback_data, output_file_name);
fprintf(stderr, "Output Filename: %s\n", output_file_name);
// Create Camera, set default values and enable it
vcos_assert((mmal_component_create(MMAL_COMPONENT_DEFAULT_CAMERA, &camera) == MMAL_SUCCESS)
&& "Failed creating camera component");
vcos_assert((set_camera_component_defaults(camera)) == MMAL_SUCCESS
&& "Failed setting camera components default values");
vcos_assert((mmal_component_enable(camera) == MMAL_SUCCESS)
&& "Failed to enable camera component");
// Create Preview, set default values and enable it
vcos_assert((mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_RENDERER, &preview) == MMAL_SUCCESS)
&& "Failed creating preview component");
vcos_assert((set_preview_component_defaults(preview) == MMAL_SUCCESS)
&& "Failed setting preview components default values");
vcos_assert((mmal_component_enable(preview) == MMAL_SUCCESS)
&& "Failed to enable camera component");
// Create Encoder, set defaults, enable it and create encoder pool
vcos_assert((mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_ENCODER, &encoder) == MMAL_SUCCESS)
&& "Failed to create encoder component");
vcos_assert((encoder->input_num && encoder->output_num)
&& "Video encoder does not have input/output ports\n");
set_encoder_component_defaults(encoder);
vcos_assert((mmal_component_enable(encoder) == MMAL_SUCCESS)
&& "Failed enabling encoder component");
callback_data.pool = (MMAL_POOL_T *)mmal_port_pool_create(encoder->output[0],
encoder->output[0]->buffer_num, encoder->output[0]->buffer_size);
vcos_assert(callback_data.pool && "Failed creating encoder pool\n");
// Setup connections
vcos_assert((mmal_connection_create(&preview_conn, camera->output[0], preview->input[0],
MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT) == MMAL_SUCCESS)
&& "Failed stablishing connection between camera output 0 and preview");
vcos_assert((mmal_connection_enable(preview_conn) == MMAL_SUCCESS)
&& "Failed enabling connection between camera output 0 and preview");
vcos_assert((mmal_connection_create(&encoder_conn, camera->output[1], encoder->input[0],
// MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT) == MMAL_SUCCESS)
MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT) == MMAL_SUCCESS)
&& "Failed creating encoder connection to capture (camera output 1)");
vcos_assert((mmal_connection_enable(encoder_conn) == MMAL_SUCCESS)
&& "Failed enabling encoder connection to capture (campera output 1)");
encoder_conn->callback = connection_video2encoder_callback;
// Set callback and enable encoder port
encoder->output[0]->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
vcos_assert(MMAL_SUCCESS == mmal_port_enable(encoder->output[0], encoder_callback));
// Send the buffer to encode output port
MMAL_BUFFER_HEADER_T *buffer = mmal_queue_get(callback_data.pool->queue);
vcos_assert((mmal_port_send_buffer(encoder->output[0], buffer)== MMAL_SUCCESS)
&& "Unable to send buffer to encoder output port");
vcos_assert((mmal_port_parameter_set_boolean(camera->output[1], MMAL_PARAMETER_CAPTURE, 1) == MMAL_SUCCESS)
&& "Unable to set camera->output[1] capture parameter");
consume_queue_on_connection(encoder_conn->out, encoder_conn->pool->queue);
while(1)
{
vcos_sleep(1000); // wait for exit call
if (exit_prog){
vcos_sleep(500); // exit called, wait for all buffers be flushed
break;
}
}
return 0;
}
/** Create an instance of mmalplay.
* Note: this is test code. Do not use it in your app. It *will* change or even be removed without notice.
*/
MMALPLAY_T *mmalplay_create(const char *uri, MMALPLAY_OPTIONS_T *opts, MMAL_STATUS_T *pstatus)
{
MMAL_STATUS_T status = MMAL_SUCCESS, status_audio, status_video, status_clock;
MMALPLAY_T *ctx;
MMAL_COMPONENT_T *component;
MMALPLAY_CONNECTIONS_T connections;
unsigned int i;
LOG_TRACE("%s", uri);
if (pstatus) *pstatus = MMAL_ENOMEM;
/* Allocate and initialise context */
ctx = malloc(sizeof(MMALPLAY_T));
if (!ctx)
return NULL;
memset(ctx, 0, sizeof(*ctx));
memset(&connections, 0, sizeof(connections));
if (vcos_semaphore_create(&ctx->event, "MMALTest", 1) != VCOS_SUCCESS)
{
free(ctx);
return NULL;
}
ctx->uri = uri;
if (opts)
ctx->options = *opts;
ctx->options.output_num = MMAL_MAX(ctx->options.output_num, 1);
ctx->options.output_num = MMAL_MIN(ctx->options.output_num, MMALPLAY_MAX_RENDERERS);
connections.num = 0;
/* Create and setup the container reader component */
component = mmalplay_component_create(ctx, MMAL_COMPONENT_DEFAULT_CONTAINER_READER, &status);
if (!component)
goto error;
status_video = mmalplay_pipeline_video_create(ctx, ctx->reader_video, &connections);
status_audio = mmalplay_pipeline_audio_create(ctx, ctx->reader_audio, &connections);
status_clock = mmalplay_pipeline_clock_create(ctx, &connections);
if (status_video != MMAL_SUCCESS && status_audio != MMAL_SUCCESS && status_clock != MMAL_SUCCESS)
{
status = status_video;
goto error;
}
/* Create our connections */
for (i = 0; i < connections.num; i++)
{
status = mmalplay_connection_create(ctx, connections.connection[i].out, connections.connection[i].in,
connections.connection[i].flags);
if (status != MMAL_SUCCESS)
goto error;
}
/* Enable our connections */
for (i = 0; i < ctx->connection_num; i++)
{
status = mmal_connection_enable(ctx->connection[i]);
if (status != MMAL_SUCCESS)
goto error;
}
if (pstatus) *pstatus = MMAL_SUCCESS;
return ctx;
error:
mmalplay_destroy(ctx);
if (status == MMAL_SUCCESS) status = MMAL_ENOSPC;
if (pstatus) *pstatus = status;
return NULL;
}
bool CMMALVideo::CreateDeinterlace(EINTERLACEMETHOD interlace_method)
{
MMAL_STATUS_T status;
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s method:%d", CLASSNAME, __func__, interlace_method);
assert(!m_deint);
assert(m_dec_output == m_dec->output[0]);
status = mmal_port_disable(m_dec_output);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to disable decoder output port (status=%x %s)", CLASSNAME, __func__, status, mmal_status_to_string(status));
return false;
}
/* Create deinterlace filter */
status = mmal_component_create("vc.ril.image_fx", &m_deint);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to create deinterlace component (status=%x %s)", CLASSNAME, __func__, status, mmal_status_to_string(status));
return false;
}
MMAL_PARAMETER_IMAGEFX_PARAMETERS_T imfx_param = {{MMAL_PARAMETER_IMAGE_EFFECT_PARAMETERS, sizeof(imfx_param)},
interlace_method == VS_INTERLACEMETHOD_MMAL_ADVANCED || interlace_method == VS_INTERLACEMETHOD_MMAL_ADVANCED_HALF ?
MMAL_PARAM_IMAGEFX_DEINTERLACE_ADV : MMAL_PARAM_IMAGEFX_DEINTERLACE_FAST,
3, {3, 0, interlace_method == VS_INTERLACEMETHOD_MMAL_ADVANCED_HALF || interlace_method == VS_INTERLACEMETHOD_MMAL_BOB_HALF }};
status = mmal_port_parameter_set(m_deint->output[0], &imfx_param.hdr);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to set deinterlace parameters (status=%x %s)", CLASSNAME, __func__, status, mmal_status_to_string(status));
return false;
}
MMAL_PORT_T *m_deint_input = m_deint->input[0];
m_deint_input->userdata = (struct MMAL_PORT_USERDATA_T *)this;
// Now connect the decoder output port to deinterlace input port
status = mmal_connection_create(&m_deint_connection, m_dec->output[0], m_deint->input[0], MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to connect deinterlacer component %s (status=%x %s)", CLASSNAME, __func__, m_deint->name, status, mmal_status_to_string(status));
return false;
}
status = mmal_connection_enable(m_deint_connection);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to enable connection %s (status=%x %s)", CLASSNAME, __func__, m_deint->name, status, mmal_status_to_string(status));
return false;
}
mmal_format_copy(m_deint->output[0]->format, m_es_format);
status = mmal_port_format_commit(m_deint->output[0]);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to commit deint output format (status=%x %s)", CLASSNAME, __func__, status, mmal_status_to_string(status));
return false;
}
status = mmal_component_enable(m_deint);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to enable deinterlacer component %s (status=%x %s)", CLASSNAME, __func__, m_deint->name, status, mmal_status_to_string(status));
return false;
}
m_deint->output[0]->buffer_size = m_deint->output[0]->buffer_size_min;
m_deint->output[0]->buffer_num = m_deint->output[0]->buffer_num_recommended;
m_deint->output[0]->userdata = (struct MMAL_PORT_USERDATA_T *)this;
status = mmal_port_enable(m_deint->output[0], dec_output_port_cb_static);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to enable decoder output port (status=%x %s)", CLASSNAME, __func__, status, mmal_status_to_string(status));
return false;
}
m_dec_output = m_deint->output[0];
m_interlace_method = interlace_method;
return true;
}
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;
}
void start_all (void) {
MMAL_STATUS_T status;
MMAL_ES_FORMAT_T *format;
int max, i;
unsigned int video_width, video_height;
//
// get resolution
//
if(preview_mode == RES_16_9_STD) {
video_width = 1920;
video_height = 1080;
}
else if(preview_mode == RES_16_9_WIDE) {
video_width = 1296;
video_height = 730;
}
else {
video_width = 1296;
video_height = 976;
}
//
// create camera
//
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_CAMERA, &camera);
if(status != MMAL_SUCCESS) error("Could not create camera");
status = mmal_port_enable(camera->control, camera_control_callback);
if(status != MMAL_SUCCESS) error("Could not enable camera control port");
MMAL_PARAMETER_CAMERA_CONFIG_T cam_config = {
{MMAL_PARAMETER_CAMERA_CONFIG, sizeof(cam_config)},
.max_stills_w = 2592,
.max_stills_h = 1944,
.stills_yuv422 = 0,
.one_shot_stills = 1,
.max_preview_video_w = video_width,
.max_preview_video_h = video_height,
.num_preview_video_frames = 3,
.stills_capture_circular_buffer_height = 0,
.fast_preview_resume = 0,
.use_stc_timestamp = MMAL_PARAM_TIMESTAMP_MODE_RESET_STC
};
mmal_port_parameter_set(camera->control, &cam_config.hdr);
format = camera->output[0]->format;
format->es->video.width = video_width;
format->es->video.height = video_height;
format->es->video.crop.x = 0;
format->es->video.crop.y = 0;
format->es->video.crop.width = video_width;
format->es->video.crop.height = video_height;
format->es->video.frame_rate.num = 0;
format->es->video.frame_rate.den = 1;
status = mmal_port_format_commit(camera->output[0]);
if(status != MMAL_SUCCESS) error("Coult not set preview format");
format = camera->output[1]->format;
format->encoding_variant = MMAL_ENCODING_I420;
format->encoding = MMAL_ENCODING_OPAQUE;
format->es->video.width = video_width;
format->es->video.height = video_height;
format->es->video.crop.x = 0;
format->es->video.crop.y = 0;
format->es->video.crop.width = video_width;
format->es->video.crop.height = video_height;
format->es->video.frame_rate.num = 25;
format->es->video.frame_rate.den = 1;
status = mmal_port_format_commit(camera->output[1]);
if(status != MMAL_SUCCESS) error("Could not set video format");
if(camera->output[1]->buffer_num < 3)
camera->output[1]->buffer_num = 3;
format = camera->output[2]->format;
format->encoding = MMAL_ENCODING_OPAQUE;
format->es->video.width = 2592;
format->es->video.height = 1944;
format->es->video.crop.x = 0;
format->es->video.crop.y = 0;
format->es->video.crop.width = 2592;
format->es->video.crop.height = 1944;
format->es->video.frame_rate.num = 0;
format->es->video.frame_rate.den = 1;
status = mmal_port_format_commit(camera->output[2]);
if(status != MMAL_SUCCESS) error("Could not set still format");
if(camera->output[2]->buffer_num < 3)
camera->output[2]->buffer_num = 3;
status = mmal_component_enable(camera);
if(status != MMAL_SUCCESS) error("Could not enable camera");
//
// create jpeg-encoder
//
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_IMAGE_ENCODER, &jpegencoder);
if(status != MMAL_SUCCESS && status != MMAL_ENOSYS) error("Could not create image encoder");
mmal_format_copy(jpegencoder->output[0]->format, jpegencoder->input[0]->format);
jpegencoder->output[0]->format->encoding = MMAL_ENCODING_JPEG;
jpegencoder->output[0]->buffer_size = jpegencoder->output[0]->buffer_size_recommended;
if(jpegencoder->output[0]->buffer_size < jpegencoder->output[0]->buffer_size_min)
jpegencoder->output[0]->buffer_size = jpegencoder->output[0]->buffer_size_min;
jpegencoder->output[0]->buffer_num = jpegencoder->output[0]->buffer_num_recommended;
if(jpegencoder->output[0]->buffer_num < jpegencoder->output[0]->buffer_num_min)
jpegencoder->output[0]->buffer_num = jpegencoder->output[0]->buffer_num_min;
status = mmal_port_format_commit(jpegencoder->output[0]);
if(status != MMAL_SUCCESS) error("Could not set image format");
status = mmal_port_parameter_set_uint32(jpegencoder->output[0], MMAL_PARAMETER_JPEG_Q_FACTOR, quality);
if(status != MMAL_SUCCESS) error("Could not set jpeg quality");
status = mmal_component_enable(jpegencoder);
if(status != MMAL_SUCCESS) error("Could not enable image encoder");
pool_jpegencoder = mmal_port_pool_create(jpegencoder->output[0], jpegencoder->output[0]->buffer_num, jpegencoder->output[0]->buffer_size);
if(!pool_jpegencoder) error("Could not create image buffer pool");
//
// create second jpeg-encoder
//
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_IMAGE_ENCODER, &jpegencoder2);
if(status != MMAL_SUCCESS && status != MMAL_ENOSYS) error("Could not create image encoder 2");
mmal_format_copy(jpegencoder2->output[0]->format, jpegencoder2->input[0]->format);
jpegencoder2->output[0]->format->encoding = MMAL_ENCODING_JPEG;
jpegencoder2->output[0]->buffer_size = jpegencoder2->output[0]->buffer_size_recommended;
if(jpegencoder2->output[0]->buffer_size < jpegencoder2->output[0]->buffer_size_min)
jpegencoder2->output[0]->buffer_size = jpegencoder2->output[0]->buffer_size_min;
jpegencoder2->output[0]->buffer_num = jpegencoder2->output[0]->buffer_num_recommended;
if(jpegencoder2->output[0]->buffer_num < jpegencoder2->output[0]->buffer_num_min)
jpegencoder2->output[0]->buffer_num = jpegencoder2->output[0]->buffer_num_min;
status = mmal_port_format_commit(jpegencoder2->output[0]);
if(status != MMAL_SUCCESS) error("Could not set image format 2");
status = mmal_port_parameter_set_uint32(jpegencoder2->output[0], MMAL_PARAMETER_JPEG_Q_FACTOR, 85);
if(status != MMAL_SUCCESS) error("Could not set jpeg quality 2");
status = mmal_component_enable(jpegencoder2);
if(status != MMAL_SUCCESS) error("Could not enable image encoder 2");
pool_jpegencoder2 = mmal_port_pool_create(jpegencoder2->output[0], jpegencoder2->output[0]->buffer_num, jpegencoder2->output[0]->buffer_size);
if(!pool_jpegencoder2) error("Could not create image buffer pool 2");
//
// create h264-encoder
//
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_ENCODER, &h264encoder);
if(status != MMAL_SUCCESS && status != MMAL_ENOSYS) error("Could not create video encoder");
mmal_format_copy(h264encoder->output[0]->format, h264encoder->input[0]->format);
h264encoder->output[0]->format->encoding = MMAL_ENCODING_H264;
h264encoder->output[0]->format->bitrate = 17000000;
h264encoder->output[0]->buffer_size = h264encoder->output[0]->buffer_size_recommended;
if(h264encoder->output[0]->buffer_size < h264encoder->output[0]->buffer_size_min)
h264encoder->output[0]->buffer_size = h264encoder->output[0]->buffer_size_min;
h264encoder->output[0]->buffer_num = h264encoder->output[0]->buffer_num_recommended;
if(h264encoder->output[0]->buffer_num < h264encoder->output[0]->buffer_num_min)
h264encoder->output[0]->buffer_num = h264encoder->output[0]->buffer_num_min;
h264encoder->output[0]->format->es->video.frame_rate.num = 0;
h264encoder->output[0]->format->es->video.frame_rate.den = 1;
status = mmal_port_format_commit(h264encoder->output[0]);
if(status != MMAL_SUCCESS) error("Could not set video format");
MMAL_PARAMETER_UINT32_T param2 = {{ MMAL_PARAMETER_VIDEO_ENCODE_INITIAL_QUANT, sizeof(param2)}, 25};
status = mmal_port_parameter_set(h264encoder->output[0], ¶m2.hdr);
if(status != MMAL_SUCCESS) error("Could not set video quantisation");
MMAL_PARAMETER_UINT32_T param3 = {{ MMAL_PARAMETER_VIDEO_ENCODE_QP_P, sizeof(param3)}, 31};
status = mmal_port_parameter_set(h264encoder->output[0], ¶m3.hdr);
if(status != MMAL_SUCCESS) error("Could not set video quantisation");
MMAL_PARAMETER_VIDEO_PROFILE_T param4;
param4.hdr.id = MMAL_PARAMETER_PROFILE;
param4.hdr.size = sizeof(param4);
param4.profile[0].profile = MMAL_VIDEO_PROFILE_H264_HIGH;
param4.profile[0].level = MMAL_VIDEO_LEVEL_H264_4;
status = mmal_port_parameter_set(h264encoder->output[0], ¶m4.hdr);
if(status != MMAL_SUCCESS) error("Could not set video port format");
status = mmal_port_parameter_set_boolean(h264encoder->input[0], MMAL_PARAMETER_VIDEO_IMMUTABLE_INPUT, 1);
if(status != MMAL_SUCCESS) error("Could not set immutable flag");
status = mmal_port_parameter_set_boolean(h264encoder->output[0], MMAL_PARAMETER_VIDEO_ENCODE_INLINE_HEADER, 0);
if(status != MMAL_SUCCESS) error("Could not set inline flag");
//
// create image-resizer
//
status = mmal_component_create("vc.ril.resize", &resizer);
if(status != MMAL_SUCCESS && status != MMAL_ENOSYS) error("Could not create image resizer");
format = resizer->output[0]->format;
format->es->video.width = (preview_mode==RES_4_3) ? width_pic : width;
format->es->video.height = (preview_mode==RES_4_3) ? height_pic : height;
format->es->video.crop.x = 0;
format->es->video.crop.y = 0;
format->es->video.crop.width = (preview_mode==RES_4_3) ? width_pic : width;
format->es->video.crop.height = (preview_mode==RES_4_3) ? height_pic : height;
format->es->video.frame_rate.num = 30;
format->es->video.frame_rate.den = 1;
status = mmal_port_format_commit(resizer->output[0]);
if(status != MMAL_SUCCESS) error("Could not set image resizer output");
status = mmal_component_enable(resizer);
if(status != MMAL_SUCCESS) error("Could not enable image resizer");
//
// connect
//
status = mmal_connection_create(&con_cam_res, camera->output[0], resizer->input[0], MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if(status != MMAL_SUCCESS) error("Could not create connection camera -> resizer");
status = mmal_connection_enable(con_cam_res);
if(status != MMAL_SUCCESS) error("Could not enable connection camera -> resizer");
status = mmal_connection_create(&con_res_jpeg, resizer->output[0], jpegencoder->input[0], MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if(status != MMAL_SUCCESS) error("Could not create connection resizer -> encoder");
status = mmal_connection_enable(con_res_jpeg);
if(status != MMAL_SUCCESS) error("Could not enable connection resizer -> encoder");
status = mmal_port_enable(jpegencoder->output[0], jpegencoder_buffer_callback);
if(status != MMAL_SUCCESS) error("Could not enable jpeg port");
max = mmal_queue_length(pool_jpegencoder->queue);
for(i=0;i<max;i++) {
MMAL_BUFFER_HEADER_T *jpegbuffer = mmal_queue_get(pool_jpegencoder->queue);
if(!jpegbuffer) error("Could not create jpeg buffer header");
status = mmal_port_send_buffer(jpegencoder->output[0], jpegbuffer);
if(status != MMAL_SUCCESS) error("Could not send buffers to jpeg port");
}
status = mmal_connection_create(&con_cam_jpeg, camera->output[2], jpegencoder2->input[0], MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if(status != MMAL_SUCCESS) error("Could not create connection camera -> encoder");
status = mmal_connection_enable(con_cam_jpeg);
if(status != MMAL_SUCCESS) error("Could not enable connection camera -> encoder");
status = mmal_port_enable(jpegencoder2->output[0], jpegencoder2_buffer_callback);
if(status != MMAL_SUCCESS) error("Could not enable jpeg port 2");
max = mmal_queue_length(pool_jpegencoder2->queue);
for(i=0;i<max;i++) {
MMAL_BUFFER_HEADER_T *jpegbuffer2 = mmal_queue_get(pool_jpegencoder2->queue);
if(!jpegbuffer2) error("Could not create jpeg buffer header 2");
status = mmal_port_send_buffer(jpegencoder2->output[0], jpegbuffer2);
if(status != MMAL_SUCCESS) error("Could not send buffers to jpeg port 2");
}
}
bool CCamera::Init(int width, int height, int framerate, int num_levels, bool do_argb_conversion)
{
//init broadcom host - QUESTION: can this be called more than once??
bcm_host_init();
//store basic parameters
Width = width;
Height = height;
FrameRate = framerate;
// Set up the camera_parameters to default
raspicamcontrol_set_defaults(&CameraParameters);
MMAL_COMPONENT_T *camera = 0;
MMAL_COMPONENT_T *splitter = 0;
MMAL_CONNECTION_T* vid_to_split_connection = 0;
MMAL_PORT_T *video_port = NULL;
MMAL_STATUS_T status;
CCameraOutput* outputs[4]; memset(outputs,0,sizeof(outputs));
//create the camera component
camera = CreateCameraComponentAndSetupPorts();
if (!camera)
goto error;
//get the video port
video_port = camera->output[MMAL_CAMERA_VIDEO_PORT];
video_port->buffer_num = 3;
//create the splitter component
splitter = CreateSplitterComponentAndSetupPorts(video_port);
if(!splitter)
goto error;
//create and enable a connection between the video output and the resizer input
status = mmal_connection_create(&vid_to_split_connection, video_port, splitter->input[0], MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if (status != MMAL_SUCCESS)
{
printf("Failed to create connection\n");
goto error;
}
status = mmal_connection_enable(vid_to_split_connection);
if (status != MMAL_SUCCESS)
{
printf("Failed to enable connection\n");
goto error;
}
//setup all the outputs
for(int i = 0; i < num_levels; i++)
{
outputs[i] = new CCameraOutput();
if(!outputs[i]->Init(Width >> i,Height >> i,splitter,i,do_argb_conversion))
{
printf("Failed to initialize output %d\n",i);
goto error;
}
}
//begin capture
if (mmal_port_parameter_set_boolean(video_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
{
printf("Failed to start capture\n");
goto error;
}
//store created info
CameraComponent = camera;
SplitterComponent = splitter;
VidToSplitConn = vid_to_split_connection;
memcpy(Outputs,outputs,sizeof(outputs));
//custom parameters
raspicamcontrol_set_saturation(camera, 0);
raspicamcontrol_set_contrast(camera, 100);
raspicamcontrol_set_brightness(camera, 50);
//raspicamcontrol_set_exposure_mode(camera, MMAL_PARAM_EXPOSUREMODE_OFF);
//raspicamcontrol_set_awb_mode(camera, MMAL_PARAM_AWBMODE_OFF);
raspicamcontrol_set_shutter_speed(camera, 2400);
//return success
printf("Camera successfully created\n");
return true;
error:
if(vid_to_split_connection)
mmal_connection_destroy(vid_to_split_connection);
if(camera)
mmal_component_destroy(camera);
if(splitter)
mmal_component_destroy(splitter);
for(int i = 0; i < 4; i++)
{
if(outputs[i])
{
outputs[i]->Release();
delete outputs[i];
}
}
return false;
}
int main(int argc, char** argv) {
MMAL_COMPONENT_T *camera = 0;
MMAL_COMPONENT_T *preview = 0;
MMAL_ES_FORMAT_T *format;
MMAL_STATUS_T status;
MMAL_PORT_T *camera_preview_port = NULL, *camera_video_port = NULL, *camera_still_port = NULL;
MMAL_PORT_T *preview_input_port = NULL;
MMAL_CONNECTION_T *camera_preview_connection = 0;
printf("Running...\n");
bcm_host_init();
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_CAMERA, &camera);
if (status != MMAL_SUCCESS) {
printf("Error: create camera %x\n", status);
return -1;
}
camera_preview_port = camera->output[MMAL_CAMERA_PREVIEW_PORT];
camera_video_port = camera->output[MMAL_CAMERA_VIDEO_PORT];
camera_still_port = camera->output[MMAL_CAMERA_CAPTURE_PORT];
{
MMAL_PARAMETER_CAMERA_CONFIG_T cam_config = {
{ MMAL_PARAMETER_CAMERA_CONFIG, sizeof (cam_config)},
.max_stills_w = 1280,
.max_stills_h = 720,
.stills_yuv422 = 0,
.one_shot_stills = 1,
.max_preview_video_w = 1280,
.max_preview_video_h = 720,
.num_preview_video_frames = 3,
.stills_capture_circular_buffer_height = 0,
.fast_preview_resume = 0,
.use_stc_timestamp = MMAL_PARAM_TIMESTAMP_MODE_RESET_STC
};
mmal_port_parameter_set(camera->control, &cam_config.hdr);
}
format = camera_preview_port->format;
format->encoding = MMAL_ENCODING_OPAQUE;
format->encoding_variant = MMAL_ENCODING_I420;
format->es->video.width = 1280;
format->es->video.height = 720;
format->es->video.crop.x = 0;
format->es->video.crop.y = 0;
format->es->video.crop.width = 1280;
format->es->video.crop.height = 720;
status = mmal_port_format_commit(camera_preview_port);
if (status != MMAL_SUCCESS) {
printf("Error: camera viewfinder format couldn't be set\n");
return -1;
}
status = mmal_component_enable(camera);
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_RENDERER, &preview);
if (status != MMAL_SUCCESS) {
printf("Error: unable to create preview (%u)\n", status);
return -1;
}
preview_input_port = preview->input[0];
{
MMAL_DISPLAYREGION_T param;
param.hdr.id = MMAL_PARAMETER_DISPLAYREGION;
param.hdr.size = sizeof (MMAL_DISPLAYREGION_T);
param.set = MMAL_DISPLAY_SET_LAYER;
param.layer = 0;
param.set |= MMAL_DISPLAY_SET_FULLSCREEN;
param.fullscreen = 1;
status = mmal_port_parameter_set(preview_input_port, ¶m.hdr);
if (status != MMAL_SUCCESS && status != MMAL_ENOSYS) {
printf("Error: unable to set preview port parameters (%u)\n", status);
return -1;
}
}
status = mmal_connection_create(&camera_preview_connection, camera_preview_port, preview_input_port, MMAL_CONNECTION_FLAG_TUNNELLING | MMAL_CONNECTION_FLAG_ALLOCATION_ON_INPUT);
if (status != MMAL_SUCCESS) {
printf("Error: unable to create connection (%u)\n", status);
return -1;
}
status = mmal_connection_enable(camera_preview_connection);
if (status != MMAL_SUCCESS) {
printf("Error: unable to enable connection (%u)\n", status);
return -1;
}
while (1);
return 0;
}
