/**
* Adjust the exposure time used for images
* @param camera Pointer to camera component
* @param shutter speed in microseconds
* @return 0 if successful, non-zero if any parameters out of range
*/
int raspicamcontrol_set_shutter_speed(MMAL_COMPONENT_T *camera, int speed)
{
if (!camera)
return 1;
return mmal_status_to_int(mmal_port_parameter_set_uint32(camera->control, MMAL_PARAMETER_SHUTTER_SPEED, speed));
}
static int ffmal_update_format(AVCodecContext *avctx)
{
MMALDecodeContext *ctx = avctx->priv_data;
MMAL_STATUS_T status;
int ret = 0;
MMAL_COMPONENT_T *decoder = ctx->decoder;
MMAL_ES_FORMAT_T *format_out = decoder->output[0]->format;
ffmmal_poolref_unref(ctx->pool_out);
if (!(ctx->pool_out = av_mallocz(sizeof(*ctx->pool_out)))) {
ret = AVERROR(ENOMEM);
goto fail;
}
ctx->pool_out->refcount = 1;
if (!format_out)
goto fail;
if ((status = mmal_port_parameter_set_uint32(decoder->output[0], MMAL_PARAMETER_EXTRA_BUFFERS, ctx->extra_buffers)))
goto fail;
if ((status = mmal_port_parameter_set_boolean(decoder->output[0], MMAL_PARAMETER_VIDEO_INTERPOLATE_TIMESTAMPS, 0)))
goto fail;
if (avctx->pix_fmt == AV_PIX_FMT_MMAL) {
format_out->encoding = MMAL_ENCODING_OPAQUE;
} else {
format_out->encoding_variant = format_out->encoding = MMAL_ENCODING_I420;
}
if ((status = mmal_port_format_commit(decoder->output[0])))
goto fail;
if ((ret = ff_set_dimensions(avctx, format_out->es->video.crop.x + format_out->es->video.crop.width,
format_out->es->video.crop.y + format_out->es->video.crop.height)) < 0)
goto fail;
if (format_out->es->video.par.num && format_out->es->video.par.den) {
avctx->sample_aspect_ratio.num = format_out->es->video.par.num;
avctx->sample_aspect_ratio.den = format_out->es->video.par.den;
}
avctx->colorspace = ffmmal_csp_to_av_csp(format_out->es->video.color_space);
decoder->output[0]->buffer_size =
FFMAX(decoder->output[0]->buffer_size_min, decoder->output[0]->buffer_size_recommended);
decoder->output[0]->buffer_num =
FFMAX(decoder->output[0]->buffer_num_min, decoder->output[0]->buffer_num_recommended) + ctx->extra_buffers;
ctx->pool_out->pool = mmal_pool_create(decoder->output[0]->buffer_num,
decoder->output[0]->buffer_size);
if (!ctx->pool_out->pool) {
ret = AVERROR(ENOMEM);
goto fail;
}
return 0;
fail:
return ret < 0 ? ret : AVERROR_UNKNOWN;
}
void MmalStillCamera::setShutterSpeed(unsigned shutterSpeedUs)
{
if (m_camera != NULL)
{
mmal_port_parameter_set_uint32(m_camera->control, MMAL_PARAMETER_SHUTTER_SPEED, shutterSpeedUs);
}
}
/**
* Adjust the ISO used for images
* @param camera Pointer to camera component
* @param ISO Value to set TODO :
* @return 0 if successful, non-zero if any parameters out of range
*/
int raspicamcontrol_set_ISO(MMAL_COMPONENT_T *camera, int ISO)
{
if (!camera)
return 1;
return mmal_status_to_int(mmal_port_parameter_set_uint32(camera->control, MMAL_PARAMETER_ISO, ISO));
}
/* A jpeg encoder should have a non NULL src_port argument if the input to
| the encoder will be callback connected to the src_port. If it will be
| tunnel connected, this src_port should be NULL.
*/
boolean
jpeg_encoder_create(char *name, CameraObject *encoder,
MMAL_PORT_T *src_port, int quality)
{
MMAL_PORT_T *in_port, *out_port;
MMAL_STATUS_T status;
char *msg = "mmal_component_create";
encoder->name = name;
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_IMAGE_ENCODER,
&encoder->component);
if (status == MMAL_SUCCESS)
{
in_port = encoder->component->input[0];
out_port = encoder->component->output[0];
if (src_port)
{
/* The jpeg encoder input will be fed buffers in an ARM side
| callback, so ensure port formats will match.
*/
mmal_format_copy(in_port->format, src_port->format);
in_port->buffer_size = src_port->buffer_size;
msg = "mmal_port_format_commit(in_port)";
status = mmal_port_format_commit(in_port);
}
if (status == MMAL_SUCCESS)
{
out_port->buffer_num =
MAX(out_port->buffer_num_recommended,
out_port->buffer_num_min);
out_port->buffer_size =
MAX(out_port->buffer_size_recommended,
out_port->buffer_size_min);
mmal_format_copy(out_port->format, in_port->format);
out_port->format->encoding = MMAL_ENCODING_JPEG;
msg = "mmal_port_format_commit(out_port)";
if ((status = mmal_port_format_commit(out_port)) == MMAL_SUCCESS)
{
mmal_port_parameter_set_uint32(out_port,
MMAL_PARAMETER_JPEG_Q_FACTOR, quality);
msg = "mmal_component_enable";
status = mmal_component_enable(encoder->component);
}
}
}
return component_create_check(encoder, status, msg);
}
void Private_Impl::video_buffer_callback ( MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer ) {
MMAL_BUFFER_HEADER_T *new_buffer;
PORT_USERDATA *pData = ( PORT_USERDATA * ) port->userdata;
bool hasGrabbed = false;
//pData->_mutex.lock();
std::unique_lock<std::mutex> lck ( pData->_mutex );
if ( pData ) {
if ( pData->wantToGrab && buffer->length ) {
mmal_buffer_header_mem_lock ( buffer );
//printf("pdata buff length%d\n",pData->_buffData.size);
pData->_buffData.resize ( buffer->length );
memcpy ( pData->_buffData.data, buffer->data, buffer->length );
pData->npts = buffer->pts;
//tst=buffer->pts;
pData->wantToGrab = false;
hasGrabbed = true;
mmal_buffer_header_mem_unlock ( buffer );
}
}
//pData->_mutex.unlock();
// if ( hasGrabbed ) pData->Thcond.BroadCast(); //wake up waiting client
// release buffer back to the pool
mmal_buffer_header_release ( buffer );
// and send one back to the port (if still open)
if ( port->is_enabled ) {
MMAL_STATUS_T status;
new_buffer = mmal_queue_get ( pData->pstate->video_pool->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 encoder port\n" );
}
if ( pData->pstate->shutterSpeed != 0 )
mmal_port_parameter_set_uint32 ( pData->pstate->camera_component->control, MMAL_PARAMETER_SHUTTER_SPEED, pData->pstate->shutterSpeed ) ;
if ( hasGrabbed ) pData->Thcond.BroadCast(); //wake up waiting client
}
static OMX_ERRORTYPE mmalomx_set_video_param(MMALOMX_PORT_T *port,
uint32_t profile, uint32_t level, uint32_t intraperiod)
{
MMAL_PARAMETER_VIDEO_PROFILE_T mmal_param = {{MMAL_PARAMETER_PROFILE, sizeof(mmal_param)},
{{(MMAL_VIDEO_PROFILE_T)0, (MMAL_VIDEO_LEVEL_T)0}}};
OMX_VIDEO_CODINGTYPE coding =
mmalil_encoding_to_omx_video_coding(port->mmal->format->encoding);
if (mmal_port_parameter_set_uint32(port->mmal, MMAL_PARAMETER_INTRAPERIOD,
intraperiod) != MMAL_SUCCESS)
return OMX_ErrorBadParameter;
mmal_param.profile[0].profile = (MMAL_VIDEO_PROFILE_T)
mmalil_omx_video_profile_to_mmal(profile, coding);
mmal_param.profile[0].level = (MMAL_VIDEO_LEVEL_T)
mmalil_omx_video_level_to_mmal(level, coding);
if (mmal_port_parameter_set(port->mmal, &mmal_param.hdr) != MMAL_SUCCESS)
return OMX_ErrorBadParameter;
return OMX_ErrorNone;
}
void MmalVideoCamera::createCameraComponent()
{
MMAL_COMPONENT_T *camera = 0;
MMAL_ES_FORMAT_T *format;
MMAL_PORT_T *preview_port = NULL, *video_port = NULL, *still_port = NULL;
MMAL_STATUS_T status;
try
{
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_CAMERA, &camera);
if (status != MMAL_SUCCESS)
{
throw Exception("Failed to create camera component");
}
if (camera->output_num == 0)
{
status = MMAL_ENOSYS;
throw Exception("Camera doesn't have output ports");
}
MMAL_CHECK(mmal_port_parameter_set_uint32(camera->control, MMAL_PARAMETER_CAMERA_CUSTOM_SENSOR_CONFIG, MMAL_VIDEO_SENSOR_MODE));
preview_port = camera->output[MMAL_CAMERA_PREVIEW_PORT];
video_port = camera->output[MMAL_CAMERA_VIDEO_PORT];
still_port = camera->output[MMAL_CAMERA_CAPTURE_PORT];
// Populate the camera configuration struct
MMAL_PARAMETER_CAMERA_CONFIG_T cameraConfig;
cameraConfig.hdr.id = MMAL_PARAMETER_CAMERA_CONFIG;
cameraConfig.hdr.size = sizeof(cameraConfig);
cameraConfig.max_stills_w = m_imageWidth;
cameraConfig.max_stills_h = m_imageHeight;
cameraConfig.stills_yuv422 = 0;
cameraConfig.one_shot_stills = 0;
cameraConfig.max_preview_video_w = m_imagePreviewWidth;
cameraConfig.max_preview_video_h = m_imagePreviewHeight;
cameraConfig.num_preview_video_frames = 3;
cameraConfig.stills_capture_circular_buffer_height = 0;
cameraConfig.fast_preview_resume = 0;
cameraConfig.use_stc_timestamp = MMAL_PARAM_TIMESTAMP_MODE_RESET_STC;
if (mmal_port_parameter_set(camera->control, &cameraConfig.hdr) != MMAL_SUCCESS)
{
throw Exception("Error calling mmal_port_parameter_set()");
}
//
// Setup the video port
//
format = video_port->format;
format->encoding = MMAL_ENCODING_BGR24;
format->encoding_variant = MMAL_ENCODING_BGR24;
format->es->video.width = VCOS_ALIGN_UP(m_imageWidth, 32);
format->es->video.height = VCOS_ALIGN_UP(m_imageHeight, 16);
format->es->video.crop.x = 0;
format->es->video.crop.y = 0;
format->es->video.crop.width = m_imageWidth;
format->es->video.crop.height = m_imageHeight;
format->es->video.frame_rate.num = m_frameRate;
format->es->video.frame_rate.den = FULL_RES_VIDEO_FRAME_RATE_DEN;
status = mmal_port_format_commit(video_port);
if (status != MMAL_SUCCESS)
{
throw Exception("Failure to setup camera video port");
}
// Make sure we have enough video buffers
if (video_port->buffer_num < VIDEO_OUTPUT_BUFFERS_NUM)
{
video_port->buffer_num = VIDEO_OUTPUT_BUFFERS_NUM;
}
// Flip the image
MMAL_PARAMETER_MIRROR_T mirror = {{MMAL_PARAMETER_MIRROR, sizeof(MMAL_PARAMETER_MIRROR_T)}, MMAL_PARAM_MIRROR_NONE};
mirror.value = MMAL_PARAM_MIRROR_BOTH;
mmal_port_parameter_set(preview_port, &mirror.hdr);
mmal_port_parameter_set(video_port, &mirror.hdr);
mmal_port_parameter_set(still_port, &mirror.hdr);
// Enable component
status = mmal_component_enable(camera);
if (status != MMAL_SUCCESS)
{
throw Exception("camera component couldn't be enabled");
}
//int iso = 100;
//MMAL_CHECK(mmal_port_parameter_set_uint32(camera->control, MMAL_PARAMETER_ISO, iso));
// MMAL_PARAM_EXPOSUREMODE_OFF
//MMAL_PARAMETER_EXPOSUREMODE_T exp_mode = {{MMAL_PARAMETER_EXPOSURE_MODE, sizeof(exp_mode)}, MMAL_PARAM_EXPOSUREMODE_AUTO};
//MMAL_CHECK(mmal_port_parameter_set(camera->control, &exp_mode.hdr));
/*
// AWB MODE
{
std::cout << "Disabling auto white balancing" << std::endl;
MMAL_PARAMETER_AWBMODE_T param = {{MMAL_PARAMETER_AWB_MODE,sizeof(param)}, MMAL_PARAM_AWBMODE_OFF};
mmal_port_parameter_set(camera->control, ¶m.hdr);
}
// AWB GAIN
{
real redGain = 0.2;
real blueGain = 1.0;
std::cout << "Setting color gain, r=" << redGain << ", b=" << blueGain << std::endl;
MMAL_PARAMETER_AWB_GAINS_T param = {{MMAL_PARAMETER_CUSTOM_AWB_GAINS,sizeof(param)}, {0,0}, {0,0}};
param.r_gain.num = (unsigned int)(redGain * 65536);
param.b_gain.num = (unsigned int)(blueGain * 65536);
param.r_gain.den = param.b_gain.den = 65536;
mmal_port_parameter_set(camera->control, ¶m.hdr);
}
*/
std::cout << "Camera Enabled..." << std::endl;
}
catch (...)
{
if (camera != NULL)
{
mmal_component_destroy(camera);
}
throw;
}
m_camera = camera;
m_videoPort = video_port;
m_stillPort = still_port;
m_previewPort = preview_port;
}
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 CMMALVideo::Open(CDVDStreamInfo &hints, CDVDCodecOptions &options, MMALVideoPtr myself)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s usemmal:%d software:%d %dx%d", CLASSNAME, __func__, CSettings::Get().GetBool("videoplayer.usemmal"), hints.software, hints.width, hints.height);
// we always qualify even if DVDFactoryCodec does this too.
if (!CSettings::Get().GetBool("videoplayer.usemmal") || hints.software)
return false;
m_hints = hints;
MMAL_STATUS_T status;
MMAL_PARAMETER_BOOLEAN_T error_concealment;
m_myself = myself;
m_decoded_width = hints.width;
m_decoded_height = hints.height;
// use aspect in stream if available
if (m_hints.forced_aspect)
m_aspect_ratio = m_hints.aspect;
else
m_aspect_ratio = 0.0;
switch (hints.codec)
{
case AV_CODEC_ID_H264:
// H.264
m_codingType = MMAL_ENCODING_H264;
m_pFormatName = "mmal-h264";
break;
case AV_CODEC_ID_H263:
case AV_CODEC_ID_MPEG4:
// MPEG-4, DivX 4/5 and Xvid compatible
m_codingType = MMAL_ENCODING_MP4V;
m_pFormatName = "mmal-mpeg4";
break;
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
// MPEG-2
m_codingType = MMAL_ENCODING_MP2V;
m_pFormatName = "mmal-mpeg2";
break;
case AV_CODEC_ID_VP6:
// this form is encoded upside down
// fall through
case AV_CODEC_ID_VP6F:
case AV_CODEC_ID_VP6A:
// VP6
m_codingType = MMAL_ENCODING_VP6;
m_pFormatName = "mmal-vp6";
break;
case AV_CODEC_ID_VP8:
// VP8
m_codingType = MMAL_ENCODING_VP8;
m_pFormatName = "mmal-vp8";
break;
case AV_CODEC_ID_THEORA:
// theora
m_codingType = MMAL_ENCODING_THEORA;
m_pFormatName = "mmal-theora";
break;
case AV_CODEC_ID_MJPEG:
case AV_CODEC_ID_MJPEGB:
// mjpg
m_codingType = MMAL_ENCODING_MJPEG;
m_pFormatName = "mmal-mjpg";
break;
case AV_CODEC_ID_VC1:
case AV_CODEC_ID_WMV3:
// VC-1, WMV9
m_codingType = MMAL_ENCODING_WVC1;
m_pFormatName = "mmal-vc1";
break;
default:
CLog::Log(LOGERROR, "%s::%s : Video codec unknown: %x", CLASSNAME, __func__, hints.codec);
return false;
break;
}
if ( (m_codingType == MMAL_ENCODING_MP2V && !g_RBP.GetCodecMpg2() ) ||
(m_codingType == MMAL_ENCODING_WVC1 && !g_RBP.GetCodecWvc1() ) )
{
CLog::Log(LOGWARNING, "%s::%s Codec %s is not supported", CLASSNAME, __func__, m_pFormatName);
return false;
}
// initialize mmal.
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_DECODER, &m_dec);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to create MMAL decoder component %s (status=%x %s)", CLASSNAME, __func__, MMAL_COMPONENT_DEFAULT_VIDEO_DECODER, status, mmal_status_to_string(status));
return false;
}
m_dec->control->userdata = (struct MMAL_PORT_USERDATA_T *)this;
status = mmal_port_enable(m_dec->control, dec_control_port_cb_static);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to enable decoder control port %s (status=%x %s)", CLASSNAME, __func__, MMAL_COMPONENT_DEFAULT_VIDEO_DECODER, status, mmal_status_to_string(status));
return false;
}
m_dec_input = m_dec->input[0];
m_dec_input->format->type = MMAL_ES_TYPE_VIDEO;
m_dec_input->format->encoding = m_codingType;
if (m_hints.width && m_hints.height)
{
m_dec_input->format->es->video.crop.width = m_hints.width;
m_dec_input->format->es->video.crop.height = m_hints.height;
m_dec_input->format->es->video.width = ALIGN_UP(m_hints.width, 32);
m_dec_input->format->es->video.height = ALIGN_UP(m_hints.height, 16);
}
m_dec_input->format->flags |= MMAL_ES_FORMAT_FLAG_FRAMED;
error_concealment.hdr.id = MMAL_PARAMETER_VIDEO_DECODE_ERROR_CONCEALMENT;
error_concealment.hdr.size = sizeof(MMAL_PARAMETER_BOOLEAN_T);
error_concealment.enable = MMAL_FALSE;
status = mmal_port_parameter_set(m_dec_input, &error_concealment.hdr);
if (status != MMAL_SUCCESS)
CLog::Log(LOGERROR, "%s::%s Failed to disable error concealment on %s (status=%x %s)", CLASSNAME, __func__, m_dec_input->name, status, mmal_status_to_string(status));
status = mmal_port_parameter_set_uint32(m_dec_input, MMAL_PARAMETER_EXTRA_BUFFERS, NUM_BUFFERS);
if (status != MMAL_SUCCESS)
CLog::Log(LOGERROR, "%s::%s Failed to enable extra buffers on %s (status=%x %s)", CLASSNAME, __func__, m_dec_input->name, status, mmal_status_to_string(status));
status = mmal_port_format_commit(m_dec_input);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to commit format for decoder input port %s (status=%x %s)", CLASSNAME, __func__, m_dec_input->name, status, mmal_status_to_string(status));
return false;
}
m_dec_input->buffer_size = m_dec_input->buffer_size_recommended;
m_dec_input->buffer_num = m_dec_input->buffer_num_recommended;
m_dec_input->userdata = (struct MMAL_PORT_USERDATA_T *)this;
status = mmal_port_enable(m_dec_input, dec_input_port_cb);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to enable decoder input port %s (status=%x %s)", CLASSNAME, __func__, m_dec_input->name, status, mmal_status_to_string(status));
return false;
}
m_dec_output = m_dec->output[0];
// set up initial decoded frame format - will likely change from this
m_dec_output->format->encoding = MMAL_ENCODING_OPAQUE;
mmal_format_copy(m_es_format, m_dec_output->format);
status = mmal_port_format_commit(m_dec_output);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to commit decoder output format (status=%x %s)", CLASSNAME, __func__, status, mmal_status_to_string(status));
return false;
}
m_dec_output->buffer_size = m_dec_output->buffer_size_min;
m_dec_output->buffer_num = m_dec_output->buffer_num_recommended;
m_dec_output->userdata = (struct MMAL_PORT_USERDATA_T *)this;
status = mmal_port_enable(m_dec_output, 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;
}
status = mmal_component_enable(m_dec);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to enable decoder component %s (status=%x %s)", CLASSNAME, __func__, m_dec->name, status, mmal_status_to_string(status));
return false;
}
m_dec_input_pool = mmal_pool_create(m_dec_input->buffer_num, m_dec_input->buffer_size);
if (!m_dec_input_pool)
{
CLog::Log(LOGERROR, "%s::%s Failed to create pool for decoder input port (status=%x %s)", CLASSNAME, __func__, status, mmal_status_to_string(status));
return false;
}
m_dec_output_pool = mmal_pool_create(m_dec_output->buffer_num, m_dec_output->buffer_size);
if(!m_dec_output_pool)
{
CLog::Log(LOGERROR, "%s::%s Failed to create pool for decode output port (status=%x %s)", CLASSNAME, __func__, status, mmal_status_to_string(status));
return false;
}
if (!SendCodecConfigData())
return false;
m_drop_state = false;
m_startframe = false;
return true;
}
bool ProtoCameraSettings::CommitISO()
{
return !mmal_status_to_int( mmal_port_parameter_set_uint32( m_component->m_mmal_component.GetControlPort(), MMAL_PARAMETER_ISO, m_parameters.iso() ) );
}
/**
* Adjust the ISO used for images
* @param camera Pointer to camera component
* @param ISO Value to set TODO :
* @return 0 if successful, non-zero if any parameters out of range
*/
void CameraSettings::set_ISO(int ISO)
{
if (!camera) return;
mmal_status_to_int(mmal_port_parameter_set_uint32(camera->control, MMAL_PARAMETER_ISO, ISO));
}
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 Private_Impl_Still::commitQuality() {
if ( encoder_output_port != NULL )
mmal_port_parameter_set_uint32 ( encoder_output_port, MMAL_PARAMETER_JPEG_Q_FACTOR, quality );
}
static int ffmal_update_format(AVCodecContext *avctx)
{
MMALDecodeContext *ctx = avctx->priv_data;
MMAL_STATUS_T status;
int ret = 0;
MMAL_COMPONENT_T *decoder = ctx->decoder;
MMAL_ES_FORMAT_T *format_out = decoder->output[0]->format;
MMAL_PARAMETER_VIDEO_INTERLACE_TYPE_T interlace_type;
ffmmal_poolref_unref(ctx->pool_out);
if (!(ctx->pool_out = av_mallocz(sizeof(*ctx->pool_out)))) {
ret = AVERROR(ENOMEM);
goto fail;
}
ctx->pool_out->refcount = 1;
if (!format_out)
goto fail;
if ((status = mmal_port_parameter_set_uint32(decoder->output[0], MMAL_PARAMETER_EXTRA_BUFFERS, ctx->extra_buffers)))
goto fail;
if ((status = mmal_port_parameter_set_boolean(decoder->output[0], MMAL_PARAMETER_VIDEO_INTERPOLATE_TIMESTAMPS, 0)))
goto fail;
if (avctx->pix_fmt == AV_PIX_FMT_MMAL) {
format_out->encoding = MMAL_ENCODING_OPAQUE;
} else {
format_out->encoding_variant = format_out->encoding = MMAL_ENCODING_I420;
}
if ((status = mmal_port_format_commit(decoder->output[0])))
goto fail;
interlace_type.hdr.id = MMAL_PARAMETER_VIDEO_INTERLACE_TYPE;
interlace_type.hdr.size = sizeof(MMAL_PARAMETER_VIDEO_INTERLACE_TYPE_T);
status = mmal_port_parameter_get(decoder->output[0], &interlace_type.hdr);
if (status != MMAL_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Cannot read MMAL interlace information!\n");
} else {
ctx->interlaced_frame = (interlace_type.eMode != MMAL_InterlaceProgressive);
ctx->top_field_first = (interlace_type.eMode == MMAL_InterlaceFieldsInterleavedUpperFirst);
}
if ((ret = ff_set_dimensions(avctx, format_out->es->video.crop.x + format_out->es->video.crop.width,
format_out->es->video.crop.y + format_out->es->video.crop.height)) < 0)
goto fail;
if (format_out->es->video.par.num && format_out->es->video.par.den) {
avctx->sample_aspect_ratio.num = format_out->es->video.par.num;
avctx->sample_aspect_ratio.den = format_out->es->video.par.den;
}
if (format_out->es->video.frame_rate.num && format_out->es->video.frame_rate.den) {
avctx->framerate.num = format_out->es->video.frame_rate.num;
avctx->framerate.den = format_out->es->video.frame_rate.den;
}
avctx->colorspace = ffmmal_csp_to_av_csp(format_out->es->video.color_space);
decoder->output[0]->buffer_size =
FFMAX(decoder->output[0]->buffer_size_min, decoder->output[0]->buffer_size_recommended);
decoder->output[0]->buffer_num =
FFMAX(decoder->output[0]->buffer_num_min, decoder->output[0]->buffer_num_recommended) + ctx->extra_buffers;
ctx->pool_out->pool = mmal_pool_create(decoder->output[0]->buffer_num,
decoder->output[0]->buffer_size);
if (!ctx->pool_out->pool) {
ret = AVERROR(ENOMEM);
goto fail;
}
return 0;
fail:
return ret < 0 ? ret : AVERROR_UNKNOWN;
}
/**
* Create the encoder component, set up its ports
*
* @param state Pointer to state control struct. encoder_component member set to the created camera_component if successfull.
*
* @return a MMAL_STATUS, MMAL_SUCCESS if all OK, something else otherwise
*/
static MMAL_STATUS_T create_encoder_component(RASPISTILL_STATE *state)
{
MMAL_COMPONENT_T *encoder = 0;
MMAL_PORT_T *encoder_input = NULL, *encoder_output = NULL;
MMAL_STATUS_T status;
MMAL_POOL_T *pool;
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_IMAGE_ENCODER, &encoder);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to create JPEG encoder component");
goto error;
}
if (!encoder->input_num || !encoder->output_num)
{
status = MMAL_ENOSYS;
vcos_log_error("JPEG encoder doesn't have input/output ports");
goto error;
}
encoder_input = encoder->input[0];
encoder_output = encoder->output[0];
// We want same format on input and output
mmal_format_copy(encoder_output->format, encoder_input->format);
// Specify out output format
encoder_output->format->encoding = state->encoding;
encoder_output->buffer_size = encoder_output->buffer_size_recommended;
if (encoder_output->buffer_size < encoder_output->buffer_size_min)
encoder_output->buffer_size = encoder_output->buffer_size_min;
encoder_output->buffer_num = encoder_output->buffer_num_recommended;
if (encoder_output->buffer_num < encoder_output->buffer_num_min)
encoder_output->buffer_num = encoder_output->buffer_num_min;
// Commit the port changes to the output port
status = mmal_port_format_commit(encoder_output);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set format on video encoder output port");
goto error;
}
// Set the JPEG quality level
status = mmal_port_parameter_set_uint32(encoder_output, MMAL_PARAMETER_JPEG_Q_FACTOR, state->quality);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set JPEG quality");
goto error;
}
// Set up any required thumbnail
{
MMAL_PARAMETER_THUMBNAIL_CONFIG_T param_thumb = {{MMAL_PARAMETER_THUMBNAIL_CONFIGURATION, sizeof(MMAL_PARAMETER_THUMBNAIL_CONFIG_T)}, 0, 0, 0, 0};
if ( state->thumbnailConfig.width > 0 && state->thumbnailConfig.height > 0 )
{
// Have a valid thumbnail defined
param_thumb.enable = 1;
param_thumb.width = state->thumbnailConfig.width;
param_thumb.height = state->thumbnailConfig.height;
param_thumb.quality = state->thumbnailConfig.quality;
}
status = mmal_port_parameter_set(encoder->control, ¶m_thumb.hdr);
}
// Enable component
status = mmal_component_enable(encoder);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to enable video encoder component");
goto error;
}
/* Create pool of buffer headers for the output port to consume */
pool = mmal_port_pool_create(encoder_output, encoder_output->buffer_num, encoder_output->buffer_size);
if (!pool)
{
vcos_log_error("Failed to create buffer header pool for encoder output port %s", encoder_output->name);
}
state->encoder_pool = pool;
state->encoder_component = encoder;
if (state->verbose)
fprintf(stderr, "Encoder component done\n");
return status;
error:
if (encoder)
mmal_component_destroy(encoder);
return status;
}
void Private_Impl::commitShutterSpeed() {
if ( mmal_port_parameter_set_uint32 ( State.camera_component->control, MMAL_PARAMETER_SHUTTER_SPEED, State.shutterSpeed ) != MMAL_SUCCESS )
cout << __func__ << ": Failed to set shutter parameter.\n";
}
void Private_Impl::commitISO() {
if ( mmal_port_parameter_set_uint32 ( State.camera_component->control, MMAL_PARAMETER_ISO, State.ISO ) != MMAL_SUCCESS )
cout << __func__ << ": Failed to set ISO parameter.\n";
}
/**
* Reset the camera component, set up its ports
*
* @param state Pointer to state control struct
*
* @return MMAL_SUCCESS if all OK, something else otherwise
*
*/
MMAL_STATUS_T reset_camera_component(RASPIVID_STATE *state)
{
MMAL_COMPONENT_T *camera = 0;
MMAL_ES_FORMAT_T *format;
MMAL_PORT_T *preview_port = NULL, *video_port = NULL, *still_port = NULL;
MMAL_STATUS_T status;
/* Get the camera component */
if( state->camera_component == NULL ) {
vcos_log_error("camera component does not exist");
}
else {
camera = state->camera_component;
}
#ifdef __NOT_REQURED__
status = raspicamcontrol_set_stereo_mode(camera->output[0], &state->camera_parameters.stereo_mode);
status += raspicamcontrol_set_stereo_mode(camera->output[1], &state->camera_parameters.stereo_mode);
status += raspicamcontrol_set_stereo_mode(camera->output[2], &state->camera_parameters.stereo_mode);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Could not set stereo mode : error %d", status);
goto error;
}
MMAL_PARAMETER_INT32_T camera_num =
{{MMAL_PARAMETER_CAMERA_NUM, sizeof(camera_num)}, state->cameraNum};
status = mmal_port_parameter_set(camera->control, &camera_num.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Could not select camera : error %d", status);
goto error;
}
if (!camera->output_num)
{
status = MMAL_ENOSYS;
vcos_log_error("Camera doesn't have output ports");
goto error;
}
status = mmal_port_parameter_set_uint32(camera->control, MMAL_PARAMETER_CAMERA_CUSTOM_SENSOR_CONFIG, state->sensor_mode);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Could not set sensor mode : error %d", status);
goto error;
}
#endif /* NOT_REQUIRED */
preview_port = camera->output[MMAL_CAMERA_PREVIEW_PORT];
video_port = camera->output[MMAL_CAMERA_VIDEO_PORT];
still_port = camera->output[MMAL_CAMERA_CAPTURE_PORT];
#ifdef __NOT_REQURED__
if (state->settings)
{
MMAL_PARAMETER_CHANGE_EVENT_REQUEST_T change_event_request =
{ {MMAL_PARAMETER_CHANGE_EVENT_REQUEST, sizeof(MMAL_PARAMETER_CHANGE_EVENT_REQUEST_T)},
MMAL_PARAMETER_CAMERA_SETTINGS, 1
};
status = mmal_port_parameter_set(camera->control, &change_event_request.hdr);
if ( status != MMAL_SUCCESS )
{
vcos_log_error("No camera settings events");
}
}
#endif /* NOT_REQUIRED */
//
mmal_encoder_set_camera_settings(camera);
// Enable the camera, and tell it its control callback function
status = mmal_port_enable(camera->control, camera_control_callback);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to enable control port : error %d", status);
goto error;
}
// set up the camera configuration
{
MMAL_PARAMETER_CAMERA_CONFIG_T cam_config =
{
{ MMAL_PARAMETER_CAMERA_CONFIG, sizeof(cam_config) },
.max_stills_w = state->width,
.max_stills_h = state->height,
.stills_yuv422 = 0,
.one_shot_stills = 0,
.max_preview_video_w = state->width,
.max_preview_video_h = state->height,
.num_preview_video_frames = 3,
.stills_capture_circular_buffer_height = 0,
.fast_preview_resume = 0,
.use_stc_timestamp = MMAL_PARAM_TIMESTAMP_MODE_RAW_STC
};
mmal_port_parameter_set(camera->control, &cam_config.hdr);
}
// Now set up the port formats
// Set the encode format on the Preview port
// HW limitations mean we need the preview to be the same size as the required recorded output
format = preview_port->format;
format->encoding = MMAL_ENCODING_OPAQUE;
format->encoding_variant = MMAL_ENCODING_I420;
if(state->camera_parameters.shutter_speed > 6000000)
{
MMAL_PARAMETER_FPS_RANGE_T fps_range = {{MMAL_PARAMETER_FPS_RANGE, sizeof(fps_range)},
{ 50, 1000 }, {166, 1000}
};
mmal_port_parameter_set(preview_port, &fps_range.hdr);
}
else if(state->camera_parameters.shutter_speed > 1000000)
{
MMAL_PARAMETER_FPS_RANGE_T fps_range = {{MMAL_PARAMETER_FPS_RANGE, sizeof(fps_range)},
{ 166, 1000 }, {999, 1000}
};
mmal_port_parameter_set(preview_port, &fps_range.hdr);
}
//enable dynamic framerate if necessary
if (state->camera_parameters.shutter_speed)
{
if (state->framerate > 1000000./state->camera_parameters.shutter_speed)
{
state->framerate=0;
if (state->verbose)
DLOG("Enable dynamic frame rate to fulfil shutter speed requirement");
}
}
format->encoding = MMAL_ENCODING_OPAQUE;
format->es->video.width = VCOS_ALIGN_UP(state->width, 32);
format->es->video.height = VCOS_ALIGN_UP(state->height, 16);
format->es->video.crop.x = 0;
format->es->video.crop.y = 0;
format->es->video.crop.width = state->width;
format->es->video.crop.height = state->height;
format->es->video.frame_rate.num = PREVIEW_FRAME_RATE_NUM;
format->es->video.frame_rate.den = PREVIEW_FRAME_RATE_DEN;
status = mmal_port_format_commit(preview_port);
if (status != MMAL_SUCCESS)
{
vcos_log_error("camera viewfinder format couldn't be set");
goto error;
}
// Set the encode format on the video port
format = video_port->format;
format->encoding_variant = MMAL_ENCODING_I420;
if(state->camera_parameters.shutter_speed > 6000000)
{
MMAL_PARAMETER_FPS_RANGE_T fps_range = {{MMAL_PARAMETER_FPS_RANGE, sizeof(fps_range)},
{ 50, 1000 }, {166, 1000}
};
mmal_port_parameter_set(video_port, &fps_range.hdr);
}
else if(state->camera_parameters.shutter_speed > 1000000)
{
MMAL_PARAMETER_FPS_RANGE_T fps_range = {{MMAL_PARAMETER_FPS_RANGE, sizeof(fps_range)},
{ 167, 1000 }, {999, 1000}
};
mmal_port_parameter_set(video_port, &fps_range.hdr);
}
format->encoding = MMAL_ENCODING_OPAQUE;
format->es->video.width = VCOS_ALIGN_UP(state->width, 32);
format->es->video.height = VCOS_ALIGN_UP(state->height, 16);
format->es->video.crop.x = 0;
format->es->video.crop.y = 0;
format->es->video.crop.width = state->width;
format->es->video.crop.height = state->height;
format->es->video.frame_rate.num = state->framerate;
format->es->video.frame_rate.den = VIDEO_FRAME_RATE_DEN;
status = mmal_port_format_commit(video_port);
if (status != MMAL_SUCCESS)
{
vcos_log_error("camera video format couldn't be set");
goto error;
}
// Ensure there are enough buffers to avoid dropping frames
if (video_port->buffer_num < VIDEO_OUTPUT_BUFFERS_NUM)
video_port->buffer_num = VIDEO_OUTPUT_BUFFERS_NUM;
// Set the encode format on the still port
format = still_port->format;
format->encoding = MMAL_ENCODING_OPAQUE;
format->encoding_variant = MMAL_ENCODING_I420;
format->es->video.width = VCOS_ALIGN_UP(state->width, 32);
format->es->video.height = VCOS_ALIGN_UP(state->height, 16);
format->es->video.crop.x = 0;
format->es->video.crop.y = 0;
format->es->video.crop.width = state->width;
format->es->video.crop.height = state->height;
format->es->video.frame_rate.num = 0;
format->es->video.frame_rate.den = 1;
status = mmal_port_format_commit(still_port);
if (status != MMAL_SUCCESS)
{
vcos_log_error("camera still format couldn't be set");
goto error;
}
/* Ensure there are enough buffers to avoid dropping frames */
if (still_port->buffer_num < VIDEO_OUTPUT_BUFFERS_NUM)
still_port->buffer_num = VIDEO_OUTPUT_BUFFERS_NUM;
/* Enable component */
status = mmal_component_enable(camera);
if (status != MMAL_SUCCESS)
{
vcos_log_error("camera component couldn't be enabled");
goto error;
}
raspicamcontrol_set_all_parameters(camera, &state->camera_parameters);
state->camera_component = camera;
update_annotation_data(state);
return status;
error:
if (camera)
mmal_component_destroy(camera);
return status;
}
void ofxRaspicam::create_encoder_component()
{
ofLogVerbose() << "create_encoder_component START";
MMAL_STATUS_T status;
MMAL_POOL_T *pool;
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_IMAGE_ENCODER, &encoder);
if (status != MMAL_SUCCESS)
{
ofLogVerbose() << "create JPEG encoder component FAIL error: " << status;
}else
{
ofLogVerbose() << "create JPEG encoder component PASS";
}
if (!encoder->input_num || !encoder->output_num)
{
ofLogVerbose() << "JPEG encoder doesn't have input/output ports";
}
encoder_input_port = encoder->input[0];
encoder_output_port = encoder->output[0];
// We want same format on input and output
mmal_format_copy(encoder_output_port->format, encoder_input_port->format);
// Specify out output format
encoder_output_port->format->encoding = photo.encoding;
encoder_output_port->buffer_size = encoder_output_port->buffer_size_recommended;
if (encoder_output_port->buffer_size < encoder_output_port->buffer_size_min)
{
encoder_output_port->buffer_size = encoder_output_port->buffer_size_min;
}
encoder_output_port->buffer_num = encoder_output_port->buffer_num_recommended;
if (encoder_output_port->buffer_num < encoder_output_port->buffer_num_min)
{
encoder_output_port->buffer_num = encoder_output_port->buffer_num_min;
}
// Commit the port changes to the output port
status = mmal_port_format_commit(encoder_output_port);
if (status != MMAL_SUCCESS)
{
ofLogVerbose() << "set format on video encoder output port FAIL, error: " << status;
}else
{
ofLogVerbose() << "set format on video encoder output port PASS";
}
// Set the JPEG quality level
status = mmal_port_parameter_set_uint32(encoder_output_port, MMAL_PARAMETER_JPEG_Q_FACTOR, photo.quality);
if (status != MMAL_SUCCESS)
{
ofLogVerbose() << "Set JPEG quality FAIL, error: " << status;
}else
{
ofLogVerbose() << "Set JPEG quality PASS";
}
// Enable component
status = mmal_component_enable(encoder);
if (status)
{
ofLogVerbose() << "Enable video encoder component FAIL, error: " << status;
}else
{
ofLogVerbose() << "Enable video encoder component PASS";
}
/* Create pool of buffer headers for the output port to consume */
pool = mmal_port_pool_create(encoder_output_port, encoder_output_port->buffer_num, encoder_output_port->buffer_size);
if (!pool)
{
ofLogVerbose() << "Failed to create buffer header pool for encoder output port " << encoder_output_port->name;
}else
{
ofLogVerbose() << "pool creation PASS";
}
photo.encoder_pool = pool;
photo.encoder_component = encoder;
ofLogVerbose() << "Encoder component done";
}
/**
* 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;
}
/* Configuration which needs to be done on a per encode basis */
static BRCMIMAGE_STATUS_T brcmimage_configure_encoder(BRCMIMAGE_T *ctx,
BRCMIMAGE_REQUEST_T *req)
{
MMAL_STATUS_T status = MMAL_SUCCESS;
MMAL_FOURCC_T encoding = brcmimage_pixfmt_to_encoding(req->pixel_format);
MMAL_PORT_T *port_in;
BRCMIMAGE_STATUS_T err = BRCMIMAGE_SUCCESS;
MMAL_BOOL_T slice_mode = MMAL_FALSE;
if (encoding == MMAL_ENCODING_UNKNOWN)
status = MMAL_EINVAL;
CHECK_MMAL_STATUS(status, INPUT_FORMAT, "format not supported (%i)",
req->pixel_format);
if (!req->buffer_width)
req->buffer_width = req->width;
if (!req->buffer_height)
req->buffer_height = req->height;
if (req->buffer_width < req->width || req->buffer_height < req->height)
status = MMAL_EINVAL;
CHECK_MMAL_STATUS(status, INPUT_FORMAT, "invalid buffer width/height "
"(%i<=%i %i<=%i)", req->buffer_width, req->width, req->buffer_height,
req->height);
ctx->slice_height = 0;
ctx->mmal->status = MMAL_SUCCESS;
port_in = ctx->mmal->input[0];
/* The input port needs to be re-configured to take into account
* the properties of the new frame to encode */
if (port_in->is_enabled)
{
status = mmal_wrapper_port_disable(port_in);
CHECK_MMAL_STATUS(status, EXECUTE, "failed to disable input port");
}
port_in->format->encoding = encoding;
port_in->format->es->video.width =
port_in->format->es->video.crop.width = req->width;
port_in->format->es->video.height =
port_in->format->es->video.crop.height = req->height;
port_in->buffer_num = 1;
if (!req->input_handle &&
(port_in->format->encoding == MMAL_ENCODING_I420 ||
port_in->format->encoding == MMAL_ENCODING_I422))
{
if (port_in->format->encoding == MMAL_ENCODING_I420)
port_in->format->encoding = MMAL_ENCODING_I420_SLICE;
else if (port_in->format->encoding == MMAL_ENCODING_I422)
port_in->format->encoding = MMAL_ENCODING_I422_SLICE;
slice_mode = MMAL_TRUE;
port_in->buffer_num = 3;
}
status = mmal_port_format_commit(port_in);
CHECK_MMAL_STATUS(status, INPUT_FORMAT, "failed to commit input port format");
ctx->slice_height = slice_mode ? 16 : port_in->format->es->video.height;
port_in->buffer_size = port_in->buffer_size_min;
if (req->input_handle)
status = mmal_wrapper_port_enable(port_in, MMAL_WRAPPER_FLAG_PAYLOAD_USE_SHARED_MEMORY);
else
status = mmal_wrapper_port_enable(port_in, MMAL_WRAPPER_FLAG_PAYLOAD_ALLOCATE);
CHECK_MMAL_STATUS(status, EXECUTE, "failed to enable input port");
mmal_port_parameter_set_uint32(ctx->mmal->output[0],
MMAL_PARAMETER_JPEG_Q_FACTOR, req->quality);
if (!ctx->mmal->output[0]->is_enabled)
{
status = mmal_wrapper_port_enable(ctx->mmal->output[0], 0);
CHECK_MMAL_STATUS(status, EXECUTE, "failed to enable output port");
}
LOG_DEBUG("encoder configured (%4.4s:%ux%u|%ux%u slice: %u)\n",
(char *)&port_in->format->encoding,
port_in->format->es->video.crop.width, port_in->format->es->video.crop.height,
port_in->format->es->video.width, port_in->format->es->video.height,
ctx->slice_height);
return BRCMIMAGE_SUCCESS;
error:
return err;
}
void Private_Impl_Still::commitISO() {
if ( mmal_port_parameter_set_uint32 ( camera->control, MMAL_PARAMETER_ISO, iso ) != MMAL_SUCCESS )
cout << API_NAME << ": Failed to set ISO parameter.\n";
}
/**
* Create the encoder component, set up its ports
*
* @param state Pointer to state control struct
*
* @return 0 if failed, pointer to component if successful
*
*/
static MMAL_COMPONENT_T *create_encoder_component(RASPISTILL_STATE *state)
{
MMAL_COMPONENT_T *encoder = 0;
MMAL_PORT_T *encoder_input = NULL, *encoder_output = NULL;
MMAL_STATUS_T status;
MMAL_POOL_T *pool;
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_IMAGE_ENCODER, &encoder);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to create JPEG encoder component");
goto error;
}
if (!encoder->input_num || !encoder->output_num)
{
vcos_log_error("JPEG encoder doesn't have input/output ports");
goto error;
}
encoder_input = encoder->input[0];
encoder_output = encoder->output[0];
// We want same format on input and output
mmal_format_copy(encoder_output->format, encoder_input->format);
// Specify out output format
encoder_output->format->encoding = state->encoding;
encoder_output->buffer_size = encoder_output->buffer_size_recommended;
if (encoder_output->buffer_size < encoder_output->buffer_size_min)
encoder_output->buffer_size = encoder_output->buffer_size_min;
encoder_output->buffer_num = encoder_output->buffer_num_recommended;
if (encoder_output->buffer_num < encoder_output->buffer_num_min)
encoder_output->buffer_num = encoder_output->buffer_num_min;
// Commit the port changes to the output port
status = mmal_port_format_commit(encoder_output);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set format on video encoder output port");
goto error;
}
// Set the JPEG quality level
status = mmal_port_parameter_set_uint32(encoder_output, MMAL_PARAMETER_JPEG_Q_FACTOR, state->quality);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set JPEG quality");
goto error;
}
// Enable component
status = mmal_component_enable(encoder);
if (status)
{
vcos_log_error("Unable to enable video encoder component");
goto error;
}
/* Create pool of buffer headers for the output port to consume */
pool = mmal_port_pool_create(encoder_output, encoder_output->buffer_num, encoder_output->buffer_size);
if (!pool)
{
vcos_log_error("Failed to create buffer header pool for encoder output port %s", encoder_output->name);
}
state->encoder_pool = pool;
state->encoder_component = encoder;
if (state->verbose)
fprintf(stderr, "Encoder component done\n");
return encoder;
error:
if (encoder)
mmal_component_destroy(encoder);
return 0;
}
static av_cold int ffmmal_init_decoder(AVCodecContext *avctx)
{
MMALDecodeContext *ctx = avctx->priv_data;
MMAL_STATUS_T status;
MMAL_ES_FORMAT_T *format_in;
MMAL_COMPONENT_T *decoder;
char tmp[32];
int ret = 0;
bcm_host_init();
if (mmal_vc_init()) {
av_log(avctx, AV_LOG_ERROR, "Cannot initialize MMAL VC driver!\n");
return AVERROR(ENOSYS);
}
if ((ret = ff_get_format(avctx, avctx->codec->pix_fmts)) < 0)
return ret;
avctx->pix_fmt = ret;
if ((status = mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_DECODER, &ctx->decoder)))
goto fail;
decoder = ctx->decoder;
format_in = decoder->input[0]->format;
format_in->type = MMAL_ES_TYPE_VIDEO;
switch (avctx->codec_id) {
case AV_CODEC_ID_MPEG2VIDEO:
format_in->encoding = MMAL_ENCODING_MP2V;
break;
case AV_CODEC_ID_MPEG4:
format_in->encoding = MMAL_ENCODING_MP4V;
break;
case AV_CODEC_ID_VC1:
format_in->encoding = MMAL_ENCODING_WVC1;
break;
case AV_CODEC_ID_H264:
default:
format_in->encoding = MMAL_ENCODING_H264;
break;
}
format_in->es->video.width = FFALIGN(avctx->width, 32);
format_in->es->video.height = FFALIGN(avctx->height, 16);
format_in->es->video.crop.width = avctx->width;
format_in->es->video.crop.height = avctx->height;
format_in->es->video.frame_rate.num = 24000;
format_in->es->video.frame_rate.den = 1001;
format_in->es->video.par.num = avctx->sample_aspect_ratio.num;
format_in->es->video.par.den = avctx->sample_aspect_ratio.den;
format_in->flags = MMAL_ES_FORMAT_FLAG_FRAMED;
av_get_codec_tag_string(tmp, sizeof(tmp), format_in->encoding);
av_log(avctx, AV_LOG_DEBUG, "Using MMAL %s encoding.\n", tmp);
#if HAVE_MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS
if (mmal_port_parameter_set_uint32(decoder->input[0], MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS,
-1 - ctx->extra_decoder_buffers)) {
av_log(avctx, AV_LOG_WARNING, "Could not set input buffering limit.\n");
}
#endif
if ((status = mmal_port_format_commit(decoder->input[0])))
goto fail;
decoder->input[0]->buffer_num =
FFMAX(decoder->input[0]->buffer_num_min, 20);
decoder->input[0]->buffer_size =
FFMAX(decoder->input[0]->buffer_size_min, 512 * 1024);
ctx->pool_in = mmal_pool_create(decoder->input[0]->buffer_num, 0);
if (!ctx->pool_in) {
ret = AVERROR(ENOMEM);
goto fail;
}
if ((ret = ffmal_update_format(avctx)) < 0)
goto fail;
ctx->queue_decoded_frames = mmal_queue_create();
if (!ctx->queue_decoded_frames)
goto fail;
decoder->input[0]->userdata = (void*)avctx;
decoder->output[0]->userdata = (void*)avctx;
decoder->control->userdata = (void*)avctx;
if ((status = mmal_port_enable(decoder->control, control_port_cb)))
goto fail;
if ((status = mmal_port_enable(decoder->input[0], input_callback)))
goto fail;
if ((status = mmal_port_enable(decoder->output[0], output_callback)))
goto fail;
if ((status = mmal_component_enable(decoder)))
goto fail;
return 0;
fail:
ffmmal_close_decoder(avctx);
return ret < 0 ? ret : AVERROR_UNKNOWN;
}
MMAL_STATUS_T set_camera_iso(MMAL_COMPONENT_T *camera, uint32_t value){
if (!camera)
return MMAL_ENOTREADY;
return mmal_port_parameter_set_uint32(camera->control, MMAL_PARAMETER_ISO, value);
}
