// Fetch a decoded buffer and place it into the frame parameter.
static int ffmmal_read_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame)
{
MMALDecodeContext *ctx = avctx->priv_data;
MMAL_BUFFER_HEADER_T *buffer = NULL;
MMAL_STATUS_T status = 0;
int ret = 0;
if (ctx->eos_received)
goto done;
while (1) {
// To ensure decoding in lockstep with a constant delay between fed packets
// and output frames, we always wait until an output buffer is available.
// Except during start we don't know after how many input packets the decoder
// is going to return the first buffer, and we can't distinguish decoder
// being busy from decoder waiting for input. So just poll at the start and
// keep feeding new data to the buffer.
// We are pretty sure the decoder will produce output if we sent more input
// frames than what a h264 decoder could logically delay. This avoids too
// excessive buffering.
// We also wait if we sent eos, but didn't receive it yet (think of decoding
// stream with a very low number of frames).
if (avpriv_atomic_int_get(&ctx->packets_buffered) > MAX_DELAYED_FRAMES ||
(ctx->packets_sent && ctx->eos_sent)) {
// MMAL will ignore broken input packets, which means the frame we
// expect here may never arrive. Dealing with this correctly is
// complicated, so here's a hack to avoid that it freezes forever
// in this unlikely situation.
buffer = mmal_queue_timedwait(ctx->queue_decoded_frames, 100);
if (!buffer) {
av_log(avctx, AV_LOG_ERROR, "Did not get output frame from MMAL.\n");
ret = AVERROR_UNKNOWN;
goto done;
}
} else {
buffer = mmal_queue_get(ctx->queue_decoded_frames);
if (!buffer)
goto done;
}
ctx->eos_received |= !!(buffer->flags & MMAL_BUFFER_HEADER_FLAG_EOS);
if (ctx->eos_received)
goto done;
if (buffer->cmd == MMAL_EVENT_FORMAT_CHANGED) {
MMAL_COMPONENT_T *decoder = ctx->decoder;
MMAL_EVENT_FORMAT_CHANGED_T *ev = mmal_event_format_changed_get(buffer);
MMAL_BUFFER_HEADER_T *stale_buffer;
av_log(avctx, AV_LOG_INFO, "Changing output format.\n");
if ((status = mmal_port_disable(decoder->output[0])))
goto done;
while ((stale_buffer = mmal_queue_get(ctx->queue_decoded_frames)))
mmal_buffer_header_release(stale_buffer);
mmal_format_copy(decoder->output[0]->format, ev->format);
if ((ret = ffmal_update_format(avctx)) < 0)
goto done;
if ((status = mmal_port_enable(decoder->output[0], output_callback)))
goto done;
if ((ret = ffmmal_fill_output_port(avctx)) < 0)
goto done;
if ((ret = ffmmal_fill_input_port(avctx)) < 0)
goto done;
mmal_buffer_header_release(buffer);
continue;
} else if (buffer->cmd) {
char s[20];
av_get_codec_tag_string(s, sizeof(s), buffer->cmd);
av_log(avctx, AV_LOG_WARNING, "Unknown MMAL event %s on output port\n", s);
goto done;
} else if (buffer->length == 0) {
// Unused output buffer that got drained after format change.
mmal_buffer_header_release(buffer);
continue;
}
ctx->frames_output++;
if ((ret = ffmal_copy_frame(avctx, frame, buffer)) < 0)
goto done;
*got_frame = 1;
break;
}
done:
if (buffer)
mmal_buffer_header_release(buffer);
if (status && ret >= 0)
ret = AVERROR_UNKNOWN;
return ret;
}
/**
* 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_STATUS_T create_encoder_component(RASPIVID_STATE *state)
{
MMAL_COMPONENT_T *encoder = 0;
MMAL_PORT_T *encoder_input = NULL, *encoder_output = NULL;
MMAL_STATUS_T status;
MMAL_POOL_T *pool;
//printf("point1\n");
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_ENCODER, &encoder);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to create video encoder component");
goto error;
}
if (!encoder->input_num || !encoder->output_num)
{
status = MMAL_ENOSYS;
vcos_log_error("Video 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);
// Only supporting H264 at the moment
encoder_output->format->encoding = MMAL_ENCODING_H264;
encoder_output->format->bitrate = state->bitrate;
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;
// We need to set the frame rate on output to 0, to ensure it gets
// updated correctly from the input framerate when port connected
encoder_output->format->es->video.frame_rate.num = 0;
encoder_output->format->es->video.frame_rate.den = 1;
// Commit the port changes to the output port
status = mmal_port_format_commit(encoder_output);
//printf("point2\n");
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set format on video encoder output port");
goto error;
}
// Set the rate control parameter
if (0)
{
MMAL_PARAMETER_VIDEO_RATECONTROL_T param = {{ MMAL_PARAMETER_RATECONTROL, sizeof(param)}, MMAL_VIDEO_RATECONTROL_DEFAULT};
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set ratecontrol");
goto error;
}
}
if (state->intraperiod)
{
MMAL_PARAMETER_UINT32_T param = {{ MMAL_PARAMETER_INTRAPERIOD, sizeof(param)}, state->intraperiod};
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set intraperiod");
goto error;
}
}
if (state->quantisationParameter)
{
MMAL_PARAMETER_UINT32_T param = {{ MMAL_PARAMETER_VIDEO_ENCODE_INITIAL_QUANT, sizeof(param)}, state->quantisationParameter};
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set initial QP");
goto error;
}
MMAL_PARAMETER_UINT32_T param2 = {{ MMAL_PARAMETER_VIDEO_ENCODE_MIN_QUANT, sizeof(param)}, state->quantisationParameter};
status = mmal_port_parameter_set(encoder_output, ¶m2.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set min QP");
goto error;
}
MMAL_PARAMETER_UINT32_T param3 = {{ MMAL_PARAMETER_VIDEO_ENCODE_MAX_QUANT, sizeof(param)}, state->quantisationParameter};
status = mmal_port_parameter_set(encoder_output, ¶m3.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set max QP");
goto error;
}
}
{
MMAL_PARAMETER_VIDEO_PROFILE_T param;
param.hdr.id = MMAL_PARAMETER_PROFILE;
param.hdr.size = sizeof(param);
//param.profile[0].profile = state->profile;
param.profile[0].profile = MMAL_VIDEO_PROFILE_H264_HIGH;
param.profile[0].level = MMAL_VIDEO_LEVEL_H264_4; // This is the only value supported
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set H264 profile");
goto error;
}
}
if (mmal_port_parameter_set_boolean(encoder_input, MMAL_PARAMETER_VIDEO_IMMUTABLE_INPUT, state->immutableInput) != MMAL_SUCCESS)
{
vcos_log_error("Unable to set immutable input flag");
// Continue rather than abort..
}
//set INLINE HEADER flag to generate SPS and PPS for every IDR if requested
if (mmal_port_parameter_set_boolean(encoder_output, MMAL_PARAMETER_VIDEO_ENCODE_INLINE_HEADER, state->bInlineHeaders) != MMAL_SUCCESS)
{
vcos_log_error("failed to set INLINE HEADER FLAG parameters");
// Continue rather than abort..
}
//set INLINE VECTORS flag to request motion vector estimates
if (mmal_port_parameter_set_boolean(encoder_output, MMAL_PARAMETER_VIDEO_ENCODE_INLINE_VECTORS, state->inlineMotionVectors) != MMAL_SUCCESS)
{
vcos_log_error("failed to set INLINE VECTORS parameters");
// Continue rather than abort..
}
// 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);
goto error;
}
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);
state->encoder_component = NULL;
return status;
}
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;
}
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;
}
static BRCMIMAGE_STATUS_T brcmimage_decode(BRCMIMAGE_T *ctx,
BRCMIMAGE_REQUEST_T *jd)
{
BRCMIMAGE_STATUS_T err;
MMAL_STATUS_T status;
MMAL_BUFFER_HEADER_T *in, *out;
MMAL_BOOL_T eos = MMAL_FALSE;
const uint8_t *inBuf = jd->input;
unsigned int slices = 0, inBufSize = jd->input_size;
MMAL_PORT_T *port_in = ctx->mmal->input[0];
MMAL_PORT_T *port_out = ctx->mmal->output[0];
LOG_DEBUG("decode %i bytes\n", jd->input_size);
jd->output_size = 0;
err = brcmimage_configure_decoder(ctx, jd);
if (err != BRCMIMAGE_SUCCESS)
return err;
while (!eos)
{
/* Send as many chunks of data to decode as we can */
while (inBufSize)
{
status = mmal_wrapper_buffer_get_empty(port_in, &in, 0);
if (status == MMAL_EAGAIN)
break;
CHECK_MMAL_STATUS(status, EXECUTE, "failed to get empty buffer (%i)", status);
in->data = (uint8_t *)inBuf;
in->length = MMAL_MIN(port_in->buffer_size, inBufSize);
in->alloc_size = in->length;
inBufSize -= in->length;
inBuf += in->length;
in->flags = inBufSize ? 0 : MMAL_BUFFER_HEADER_FLAG_EOS;
LOG_DEBUG("send decode in (%i bytes)\n", in->length);
status = mmal_port_send_buffer(port_in, in);
CHECK_MMAL_STATUS(status, EXECUTE, "failed to send input buffer");
}
/* Check for decoded data */
status = mmal_wrapper_buffer_get_full(port_out, &out, 0);
if (status == MMAL_EAGAIN)
{
WAIT(ctx);
continue;
}
CHECK_MMAL_STATUS(status, EXECUTE, "error decoding");
/* Check if a new format has been auto-detected by the decoder */
if (out->cmd == MMAL_EVENT_FORMAT_CHANGED)
{
MMAL_EVENT_FORMAT_CHANGED_T *event = mmal_event_format_changed_get(out);
if (event)
mmal_format_copy(port_out->format, event->format);
mmal_buffer_header_release(out);
if (!event)
status = MMAL_EINVAL;
CHECK_MMAL_STATUS(status, EXECUTE, "invalid format change event");
LOG_DEBUG("new format (%4.4s:%ux%u|%ux%u)\n", (char *)&event->format->encoding,
event->format->es->video.crop.width, event->format->es->video.crop.height,
event->format->es->video.width, event->format->es->video.height);
/* re-setup the output port for the new format */
status = mmal_wrapper_port_disable(port_out);
CHECK_MMAL_STATUS(status, EXECUTE, "failed to disable output port");
ctx->slice_height = event->format->es->video.height;
if (ENABLE_SLICE_MODE && !jd->output_handle)
{
/* setup slice mode */
if (port_out->format->encoding == MMAL_ENCODING_I420 ||
port_out->format->encoding == MMAL_ENCODING_I422)
{
if (port_out->format->encoding == MMAL_ENCODING_I420)
port_out->format->encoding = MMAL_ENCODING_I420_SLICE;
if (port_out->format->encoding == MMAL_ENCODING_I422)
port_out->format->encoding = MMAL_ENCODING_I422_SLICE;
ctx->slice_height = 16;
port_out->buffer_num = 3;
}
}
LOG_DEBUG("using slice size %u\n", ctx->slice_height);
status = mmal_port_format_commit(port_out);
CHECK_MMAL_STATUS(status, EXECUTE, "invalid format change event");
port_out->buffer_size = port_out->buffer_size_min;
if (jd->output_handle)
status = mmal_wrapper_port_enable(port_out, MMAL_WRAPPER_FLAG_PAYLOAD_USE_SHARED_MEMORY);
else
status = mmal_wrapper_port_enable(port_out, MMAL_WRAPPER_FLAG_PAYLOAD_ALLOCATE);
CHECK_MMAL_STATUS(status, EXECUTE, "failed to enable output port");
/* send all our output buffers to the decoder */
while (mmal_wrapper_buffer_get_empty(port_out, &out, 0) == MMAL_SUCCESS)
{
if (jd->output_handle)
{
out->data = (uint8_t*)jd->output_handle;
out->alloc_size = jd->output_alloc_size;
}
status = mmal_port_send_buffer(port_out, out);
CHECK_MMAL_STATUS(status, EXECUTE, "failed to send output buffer");
}
continue;
}
/* We have part of our output frame */
jd->width = port_out->format->es->video.crop.width;
if (!jd->width)
jd->width = port_out->format->es->video.width;
if (jd->output_handle)
jd->buffer_width = port_out->format->es->video.width;
if (!jd->buffer_width)
jd->buffer_width = jd->width;
jd->height = port_out->format->es->video.crop.height;
if (!jd->height)
jd->height = port_out->format->es->video.height;
if (jd->output_handle)
jd->buffer_height = port_out->format->es->video.height;
if (!jd->buffer_height)
jd->buffer_height = jd->height;
if (jd->output_handle)
{
jd->output_size += out->length;
}
else
{
jd->output_size = brcmimage_copy_pixels(jd->output, jd->output_alloc_size,
out->data, out->length, jd->pixel_format,
jd->buffer_width, jd->buffer_height,
port_out->format->es->video.width,
ctx->slice_height, slices * ctx->slice_height, 0);
slices++;
}
eos = out->flags & MMAL_BUFFER_HEADER_FLAG_EOS;
out->length = 0;
if (eos)
{
mmal_buffer_header_release(out);
}
else
{
status = mmal_port_send_buffer(port_out, out);
CHECK_MMAL_STATUS(status, EXECUTE, "failed to send output buffer");
}
if (!jd->output_size)
status = MMAL_EINVAL;
CHECK_MMAL_STATUS(status, OUTPUT_BUFFER, "invalid output buffer");
}
LOG_DEBUG("decoded W:%ixH%i:(W%ixH%i):%i in %i slices\n",
jd->width, jd->height, jd->buffer_width, jd->buffer_height,
jd->pixel_format, slices);
mmal_port_flush(port_in);
return BRCMIMAGE_SUCCESS;
error:
mmal_port_flush(port_in);
return err;
}
/**
* 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;
}
/**
* 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;
}
/**
* Create the encoder component, set up its ports
*
* @param state Pointer to state control struct
*
* @return MMAL_SUCCESS if all OK, something else otherwise
*
*/
static MMAL_STATUS_T create_encoder_component(RASPIVID_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_VIDEO_ENCODER, &encoder);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to create video encoder component");
goto error;
}
if (!encoder->input_num || !encoder->output_num)
{
status = MMAL_ENOSYS;
vcos_log_error("Video 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);
// Only supporting H264 at the moment
encoder_output->format->encoding = MMAL_ENCODING_H264;
encoder_output->format->bitrate = state->bitrate;
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 rate control parameter
if (0)
{
MMAL_PARAMETER_VIDEO_RATECONTROL_T param = {{ MMAL_PARAMETER_RATECONTROL, sizeof(param)}, MMAL_VIDEO_RATECONTROL_DEFAULT};
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set ratecontrol");
goto error;
}
}
if (state->intraperiod)
{
MMAL_PARAMETER_UINT32_T param = {{ MMAL_PARAMETER_INTRAPERIOD, sizeof(param)}, state->intraperiod};
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set intraperiod");
goto error;
}
}
{
MMAL_PARAMETER_VIDEO_PROFILE_T param;
param.hdr.id = MMAL_PARAMETER_PROFILE;
param.hdr.size = sizeof(param);
param.profile[0].profile = state->profile;
param.profile[0].level = MMAL_VIDEO_LEVEL_H264_4; // This is the only value supported
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set H264 profile");
goto error;
}
}
if (mmal_port_parameter_set_boolean(encoder_input, MMAL_PARAMETER_VIDEO_IMMUTABLE_INPUT, state->immutableInput) != MMAL_SUCCESS)
{
vcos_log_error("Unable to set immutable input flag");
// Continue rather than abort..
}
// 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;
}
int setup_encoder(PORT_USERDATA *userdata) {
MMAL_STATUS_T status;
MMAL_COMPONENT_T *encoder = 0;
MMAL_PORT_T *preview_input_port = NULL;
MMAL_PORT_T *encoder_input_port = NULL, *encoder_output_port = NULL;
MMAL_POOL_T *encoder_input_port_pool;
MMAL_POOL_T *encoder_output_port_pool;
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_IMAGE_ENCODER, &encoder);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: unable to create preview (%u)\n", status);
return -1;
}
encoder_input_port = encoder->input[0];
encoder_output_port = encoder->output[0];
userdata->encoder_input_port = encoder_input_port;
userdata->encoder_output_port = encoder_input_port;
mmal_format_copy(encoder_input_port->format, userdata->camera_video_port->format);
encoder_input_port->buffer_size = encoder_input_port->buffer_size_recommended;
encoder_input_port->buffer_num = 2;
mmal_format_copy(encoder_output_port->format, encoder_input_port->format);
encoder_output_port->buffer_size = encoder_output_port->buffer_size_recommended;
encoder_output_port->buffer_num = 2;
// Commit the port changes to the input port
status = mmal_port_format_commit(encoder_input_port);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: unable to commit encoder input port format (%u)\n", status);
return -1;
}
encoder_output_port->format->encoding = MMAL_ENCODING_JPEG;
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) {
fprintf(stderr, "Error: unable to commit encoder output port format (%u)\n", status);
return -1;
}
//fprintf(stderr, " encoder input buffer_size = %d\n", encoder_input_port->buffer_size);
//fprintf(stderr, " encoder input buffer_num = %d\n", encoder_input_port->buffer_num);
//fprintf(stderr, " encoder output buffer_size = %d\n", encoder_output_port->buffer_size);
//fprintf(stderr, " encoder output buffer_num = %d\n", encoder_output_port->buffer_num);
encoder_input_port_pool = (MMAL_POOL_T *) mmal_port_pool_create(encoder_input_port, encoder_input_port->buffer_num, encoder_input_port->buffer_size);
userdata->encoder_input_pool = encoder_input_port_pool;
encoder_input_port->userdata = (struct MMAL_PORT_USERDATA_T *) userdata;
status = mmal_port_enable(encoder_input_port, encoder_input_buffer_callback);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: unable to enable encoder input port (%u)\n", status);
return -1;
}
//fprintf(stderr, "INFO:Encoder input pool has been created\n");
encoder_output_port_pool = (MMAL_POOL_T *) mmal_port_pool_create(encoder_output_port, encoder_output_port->buffer_num, encoder_output_port->buffer_size);
userdata->encoder_output_pool = encoder_output_port_pool;
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *) userdata;
status = mmal_port_enable(encoder_output_port, encoder_output_buffer_callback);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: unable to enable encoder output port (%u)\n", status);
return -1;
}
//fprintf(stderr, "INFO:Encoder output pool has been created\n");
fill_port_buffer(encoder_output_port, encoder_output_port_pool);
//fprintf(stderr, "INFO:Encoder has been created\n");
return 0;
}
MMAL_COMPONENT_T* CCameraOutput::CreateResizeComponentAndSetupPorts(MMAL_PORT_T* video_output_port, bool do_argb_conversion)
{
MMAL_COMPONENT_T *resizer = 0;
MMAL_ES_FORMAT_T *format;
MMAL_PORT_T *input_port = NULL, *output_port = NULL;
MMAL_STATUS_T status;
//create the camera component
status = mmal_component_create("vc.ril.resize", &resizer);
if (status != MMAL_SUCCESS)
{
printf("Failed to create reszie component\n");
goto error;
}
//check we have output ports
if (resizer->output_num != 1 || resizer->input_num != 1)
{
printf("Resizer doesn't have correct ports");
goto error;
}
//get the ports
input_port = resizer->input[0];
output_port = resizer->output[0];
mmal_format_copy(input_port->format,video_output_port->format);
input_port->buffer_num = 3;
status = mmal_port_format_commit(input_port);
if (status != MMAL_SUCCESS)
{
printf("Couldn't set resizer input port format : error %d", status);
goto error;
}
mmal_format_copy(output_port->format,input_port->format);
if(do_argb_conversion)
{
output_port->format->encoding = MMAL_ENCODING_RGBA;
output_port->format->encoding_variant = MMAL_ENCODING_RGBA;
}
output_port->format->es->video.width = Width;
output_port->format->es->video.height = Height;
output_port->format->es->video.crop.x = 0;
output_port->format->es->video.crop.y = 0;
output_port->format->es->video.crop.width = Width;
output_port->format->es->video.crop.height = Height;
status = mmal_port_format_commit(output_port);
if (status != MMAL_SUCCESS)
{
printf("Couldn't set resizer output port format : error %d", status);
goto error;
}
return resizer;
error:
if(resizer)
mmal_component_destroy(resizer);
return NULL;
}
int setup_camera(PORT_USERDATA *userdata) {
MMAL_STATUS_T status;
MMAL_COMPONENT_T *camera = 0;
MMAL_ES_FORMAT_T *format;
MMAL_PORT_T * camera_preview_port;
MMAL_PORT_T * camera_video_port;
MMAL_PORT_T * camera_still_port;
MMAL_POOL_T * camera_video_port_pool;
status = mmal_component_create(MMAL_COMPONENT_DEFAULT_CAMERA, &camera);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: create camera %x\n", status);
return -1;
}
userdata->camera = camera;
userdata->camera_preview_port = camera->output[MMAL_CAMERA_PREVIEW_PORT];
userdata->camera_video_port = camera->output[MMAL_CAMERA_VIDEO_PORT];
userdata->camera_still_port = camera->output[MMAL_CAMERA_CAPTURE_PORT];
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 = 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);
}
// Setup camera preview port format
format = camera_preview_port->format;
format->encoding = MMAL_ENCODING_OPAQUE;
format->encoding_variant = MMAL_ENCODING_I420;
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;
status = mmal_port_format_commit(camera_preview_port);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: camera viewfinder format couldn't be set\n");
return -1;
}
// Setup camera video port format
mmal_format_copy(camera_video_port->format, camera_preview_port->format);
format = camera_video_port->format;
format->encoding = MMAL_ENCODING_I420;
format->encoding_variant = MMAL_ENCODING_I420;
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 = VIDEO_FPS;
format->es->video.frame_rate.den = 1;
camera_video_port->buffer_size = format->es->video.width * format->es->video.height * 12 / 8;
camera_video_port->buffer_num = 2;
//fprintf(stderr, "INFO:camera video buffer_size = %d\n", camera_video_port->buffer_size);
//fprintf(stderr, "INFO:camera video buffer_num = %d\n", camera_video_port->buffer_num);
status = mmal_port_format_commit(camera_video_port);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: unable to commit camera video port format (%u)\n", status);
return -1;
}
camera_video_port_pool = (MMAL_POOL_T *) mmal_port_pool_create(camera_video_port, camera_video_port->buffer_num, camera_video_port->buffer_size);
userdata->camera_video_port_pool = camera_video_port_pool;
camera_video_port->userdata = (struct MMAL_PORT_USERDATA_T *) userdata;
status = mmal_port_enable(camera_video_port, camera_video_buffer_callback);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: unable to enable camera video port (%u)\n", status);
return -1;
}
status = mmal_component_enable(camera);
if (status != MMAL_SUCCESS) {
fprintf(stderr, "Error: unable to enable camera (%u)\n", status);
return -1;
}
fill_port_buffer(userdata->camera_video_port, userdata->camera_video_port_pool);
if (mmal_port_parameter_set_boolean(camera_video_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS) {
printf("%s: Failed to start capture\n", __func__);
}
//fprintf(stderr, "INFO: camera created\n");
return 0;
}
/**
* Reset the encoder 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_encoder_component(RASPIVID_STATE *state)
{
MMAL_COMPONENT_T *encoder = 0;
MMAL_PORT_T *encoder_input = NULL, *encoder_output = NULL;
MMAL_STATUS_T status;
MMAL_POOL_T *pool;
// Get the encoder component
if( state->encoder_component == NULL ) {
vcos_log_error("Unable to get video encoder component");
goto error;
}
else {
encoder = state->encoder_component;
}
#ifdef __NOT_REQURED__
if (!encoder->input_num || !encoder->output_num)
{
status = MMAL_ENOSYS;
vcos_log_error("Video 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);
// Only supporting H264 at the moment
encoder_output->format->encoding = state->encoding;
encoder_output->format->bitrate = state->bitrate;
if (state->encoding == MMAL_ENCODING_H264)
encoder_output->buffer_size = encoder_output->buffer_size_recommended;
else
encoder_output->buffer_size = 256<<10;
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;
// We need to set the frame rate on output to 0, to ensure it gets
// updated correctly from the input framerate when port connected
encoder_output->format->es->video.frame_rate.num = 0;
encoder_output->format->es->video.frame_rate.den = 1;
// 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;
}
if (state->encoding == MMAL_ENCODING_H264 &&
state->intraperiod != -1)
{
MMAL_PARAMETER_UINT32_T param = {{ MMAL_PARAMETER_INTRAPERIOD, sizeof(param)}, state->intraperiod};
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set intraperiod");
goto error;
}
}
if (state->encoding == MMAL_ENCODING_H264 && state->quantisationParameter)
{
MMAL_PARAMETER_UINT32_T param =
{{ MMAL_PARAMETER_VIDEO_ENCODE_INITIAL_QUANT, sizeof(param)}, state->quantisationInitialParameter};
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set initial QP");
goto error;
}
MMAL_PARAMETER_UINT32_T param2 =
{{ MMAL_PARAMETER_VIDEO_ENCODE_MIN_QUANT, sizeof(param)}, state->quantisationMinParameter};
status = mmal_port_parameter_set(encoder_output, ¶m2.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set min QP");
goto error;
}
MMAL_PARAMETER_UINT32_T param3 =
{{ MMAL_PARAMETER_VIDEO_ENCODE_MAX_QUANT, sizeof(param)}, state->quantisationMaxParameter};
status = mmal_port_parameter_set(encoder_output, ¶m3.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set max QP");
goto error;
}
}
if (state->encoding == MMAL_ENCODING_H264)
{
MMAL_PARAMETER_VIDEO_PROFILE_T param;
param.hdr.id = MMAL_PARAMETER_PROFILE;
param.hdr.size = sizeof(param);
param.profile[0].profile = state->profile;
param.profile[0].level = MMAL_VIDEO_LEVEL_H264_4; // This is the only value supported
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set H264 profile");
goto error;
}
}
if (mmal_port_parameter_set_boolean(encoder_input,
MMAL_PARAMETER_VIDEO_IMMUTABLE_INPUT, state->immutableInput) != MMAL_SUCCESS)
{
vcos_log_error("Unable to set immutable input flag");
// Continue rather than abort..
}
//set INLINE HEADER flag to generate SPS and PPS for every IDR if requested
if (mmal_port_parameter_set_boolean(encoder_output,
MMAL_PARAMETER_VIDEO_ENCODE_INLINE_HEADER, state->bInlineHeaders) != MMAL_SUCCESS)
{
vcos_log_error("failed to set INLINE HEADER FLAG parameters");
// Continue rather than abort..
}
//set Encode SPS Timing
if (mmal_port_parameter_set_boolean(encoder_output,
MMAL_PARAMETER_VIDEO_ENCODE_SPS_TIMING, MMAL_TRUE) != MMAL_SUCCESS)
{
vcos_log_error("failed to set SPS TIMING HEADER FLAG parameters");
// Continue rather than abort..
}
// set Minimise Fragmentation
if (mmal_port_parameter_set_boolean(encoder_output,
MMAL_PARAMETER_MINIMISE_FRAGMENTATION, MMAL_FALSE) != MMAL_SUCCESS)
{
vcos_log_error("failed to set SPS TIMING HEADER FLAG parameters");
// Continue rather than abort..
}
// Adaptive intra refresh settings
if (state->encoding == MMAL_ENCODING_H264 &&
state->intra_refresh_type != -1)
{
MMAL_PARAMETER_VIDEO_INTRA_REFRESH_T param;
param.hdr.id = MMAL_PARAMETER_VIDEO_INTRA_REFRESH;
param.hdr.size = sizeof(param);
// Get first so we don't overwrite anything unexpectedly
status = mmal_port_parameter_get(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_warn("Unable to get existing H264 intra-refresh values. Please update your firmware");
// Set some defaults, don't just pass random stack data
param.air_mbs = param.air_ref = param.cir_mbs = param.pir_mbs = 0;
}
param.refresh_mode = state->intra_refresh_type;
//if (state->intra_refresh_type == MMAL_VIDEO_INTRA_REFRESH_CYCLIC_MROWS)
// param.cir_mbs = 10;
status = mmal_port_parameter_set(encoder_output, ¶m.hdr);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to set H264 intra-refresh values");
goto error;
}
}
#endif /* NOT_REQUIRED */
// Enable component
status = mmal_component_enable(encoder);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Unable to enable video encoder component");
goto error;
}
#ifdef __NOT_REQURED__
/* 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;
#endif /* NOT_REQUIRED */
return status;
error:
if (encoder)
mmal_component_destroy(encoder);
state->encoder_component = NULL;
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";
}
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");
}
}
static MMAL_BOOL_T sdl_do_processing(MMAL_COMPONENT_T *component)
{
MMAL_PORT_T *port = component->input[0];
MMAL_COMPONENT_MODULE_T *module = component->priv->module;
unsigned int width = port->format->es->video.width;
unsigned int height = port->format->es->video.height;
MMAL_BUFFER_HEADER_T *buffer;
uint8_t *src_plane[3];
uint32_t *src_pitch;
unsigned int i, line;
MMAL_BOOL_T eos;
SDL_Rect rect;
buffer = mmal_queue_get(module->queue);
if (!buffer)
return 0;
eos = buffer->flags & MMAL_BUFFER_HEADER_FLAG_EOS;
/* Handle event buffers */
if (buffer->cmd)
{
MMAL_EVENT_FORMAT_CHANGED_T *event = mmal_event_format_changed_get(buffer);
if (event)
{
mmal_format_copy(port->format, event->format);
module->status = port->priv->pf_set_format(port);
if (module->status != MMAL_SUCCESS)
{
LOG_ERROR("format not set on port %p", port);
if (mmal_event_error_send(port->component, module->status) != MMAL_SUCCESS)
LOG_ERROR("unable to send an error event buffer");
}
}
else
{
LOG_ERROR("discarding event %i on port %p", (int)buffer->cmd, port);
}
buffer->length = 0;
mmal_port_buffer_header_callback(port, buffer);
return 1;
}
if (module->status != MMAL_SUCCESS)
return 1;
/* Ignore empty buffers */
if (!buffer->length)
goto end;
// FIXME: sanity check the size of the buffer
/* Blit the buffer onto the overlay. */
src_pitch = buffer->type->video.pitch;
src_plane[0] = buffer->data + buffer->type->video.offset[0];
src_plane[1] = buffer->data + buffer->type->video.offset[2];
src_plane[2] = buffer->data + buffer->type->video.offset[1];
SDL_LockYUVOverlay(module->sdl_overlay);
for (i=0; i<3; i++)
{
uint8_t *src = src_plane[i];
uint8_t *dst = module->sdl_overlay->pixels[i];
if(i == 1) {width /= 2; height /= 2;}
for(line = 0; line < height; line++)
{
memcpy(dst, src, width);
src += src_pitch[i];
dst += module->sdl_overlay->pitches[i];
}
}
SDL_UnlockYUVOverlay(module->sdl_overlay);
width = port->format->es->video.width;
height = port->format->es->video.height;
rect.x = module->display_region.x;
rect.w = module->display_region.width;
height = rect.w * height / width;
rect.y = module->display_region.y + (module->display_region.height - height) / 2;
rect.h = height;
SDL_DisplayYUVOverlay(module->sdl_overlay, &rect);
end:
buffer->offset = buffer->length = 0;
mmal_port_buffer_header_callback(port, buffer);
/* Generate EOS events */
if (eos)
mmal_event_eos_send(port);
return 1;
}
