static gboolean
gst_omx_h264_enc_set_format (GstOMXVideoEnc * enc, GstOMXPort * port,
GstVideoCodecState * state)
{
GstOMXH264Enc *self = GST_OMX_H264_ENC (enc);
GstCaps *peercaps;
OMX_PARAM_PORTDEFINITIONTYPE port_def;
OMX_VIDEO_PARAM_PROFILELEVELTYPE param;
OMX_ERRORTYPE err;
const gchar *profile_string, *level_string;
gst_omx_port_get_port_definition (GST_OMX_VIDEO_ENC (self)->enc_out_port,
&port_def);
port_def.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
err =
gst_omx_port_update_port_definition (GST_OMX_VIDEO_ENC
(self)->enc_out_port, &port_def);
if (err != OMX_ErrorNone)
return FALSE;
GST_OMX_INIT_STRUCT (¶m);
param.nPortIndex = GST_OMX_VIDEO_ENC (self)->enc_out_port->index;
err =
gst_omx_component_get_parameter (GST_OMX_VIDEO_ENC (self)->enc,
OMX_IndexParamVideoProfileLevelCurrent, ¶m);
if (err != OMX_ErrorNone) {
GST_WARNING_OBJECT (self,
"Setting profile/level not supported by component");
return TRUE;
}
peercaps = gst_pad_peer_query_caps (GST_VIDEO_ENCODER_SRC_PAD (enc),
gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SRC_PAD (enc)));
if (peercaps) {
GstStructure *s;
if (gst_caps_is_empty (peercaps)) {
gst_caps_unref (peercaps);
GST_ERROR_OBJECT (self, "Empty caps");
return FALSE;
}
s = gst_caps_get_structure (peercaps, 0);
profile_string = gst_structure_get_string (s, "profile");
if (profile_string) {
if (g_str_equal (profile_string, "baseline")) {
param.eProfile = OMX_VIDEO_AVCProfileBaseline;
} else if (g_str_equal (profile_string, "main")) {
param.eProfile = OMX_VIDEO_AVCProfileMain;
} else if (g_str_equal (profile_string, "extended")) {
param.eProfile = OMX_VIDEO_AVCProfileExtended;
} else if (g_str_equal (profile_string, "high")) {
param.eProfile = OMX_VIDEO_AVCProfileHigh;
} else if (g_str_equal (profile_string, "high-10")) {
param.eProfile = OMX_VIDEO_AVCProfileHigh10;
} else if (g_str_equal (profile_string, "high-4:2:2")) {
param.eProfile = OMX_VIDEO_AVCProfileHigh422;
} else if (g_str_equal (profile_string, "high-4:4:4")) {
param.eProfile = OMX_VIDEO_AVCProfileHigh444;
} else {
goto unsupported_profile;
}
}
level_string = gst_structure_get_string (s, "level");
if (level_string) {
if (g_str_equal (level_string, "1")) {
param.eLevel = OMX_VIDEO_AVCLevel1;
} else if (g_str_equal (level_string, "1b")) {
param.eLevel = OMX_VIDEO_AVCLevel1b;
} else if (g_str_equal (level_string, "1.1")) {
param.eLevel = OMX_VIDEO_AVCLevel11;
} else if (g_str_equal (level_string, "1.2")) {
param.eLevel = OMX_VIDEO_AVCLevel12;
} else if (g_str_equal (level_string, "1.3")) {
param.eLevel = OMX_VIDEO_AVCLevel13;
} else if (g_str_equal (level_string, "2")) {
param.eLevel = OMX_VIDEO_AVCLevel2;
} else if (g_str_equal (level_string, "2.1")) {
param.eLevel = OMX_VIDEO_AVCLevel21;
} else if (g_str_equal (level_string, "2.2")) {
param.eLevel = OMX_VIDEO_AVCLevel22;
} else if (g_str_equal (level_string, "3")) {
param.eLevel = OMX_VIDEO_AVCLevel3;
} else if (g_str_equal (level_string, "3.1")) {
param.eLevel = OMX_VIDEO_AVCLevel31;
} else if (g_str_equal (level_string, "3.2")) {
param.eLevel = OMX_VIDEO_AVCLevel32;
} else if (g_str_equal (level_string, "4")) {
param.eLevel = OMX_VIDEO_AVCLevel4;
} else if (g_str_equal (level_string, "4.1")) {
param.eLevel = OMX_VIDEO_AVCLevel41;
} else if (g_str_equal (level_string, "4.2")) {
param.eLevel = OMX_VIDEO_AVCLevel42;
} else if (g_str_equal (level_string, "5")) {
param.eLevel = OMX_VIDEO_AVCLevel5;
} else if (g_str_equal (level_string, "5.1")) {
param.eLevel = OMX_VIDEO_AVCLevel51;
} else {
goto unsupported_level;
}
}
gst_caps_unref (peercaps);
}
err =
gst_omx_component_set_parameter (GST_OMX_VIDEO_ENC (self)->enc,
OMX_IndexParamVideoProfileLevelCurrent, ¶m);
if (err == OMX_ErrorUnsupportedIndex) {
GST_WARNING_OBJECT (self,
"Setting profile/level not supported by component");
} else if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self,
"Error setting profile %u and level %u: %s (0x%08x)",
(guint) param.eProfile, (guint) param.eLevel,
gst_omx_error_to_string (err), err);
return FALSE;
}
return TRUE;
unsupported_profile:
GST_ERROR_OBJECT (self, "Unsupported profile %s", profile_string);
gst_caps_unref (peercaps);
return FALSE;
unsupported_level:
GST_ERROR_OBJECT (self, "Unsupported level %s", level_string);
gst_caps_unref (peercaps);
return FALSE;
}
static gboolean
gst_omx_h264_enc_set_format (GstOMXVideoEnc * enc, GstOMXPort * port,
GstVideoCodecState * state)
{
GstOMXH264Enc *self = GST_OMX_H264_ENC (enc);
GstCaps *peercaps;
OMX_PARAM_PORTDEFINITIONTYPE port_def;
OMX_VIDEO_PARAM_PROFILELEVELTYPE param;
OMX_VIDEO_CONFIG_AVCINTRAPERIOD config_avcintraperiod;
#ifdef USE_OMX_TARGET_RPI
OMX_CONFIG_PORTBOOLEANTYPE config_inline_header;
#endif
OMX_ERRORTYPE err;
const gchar *profile_string, *level_string;
#ifdef USE_OMX_TARGET_RPI
GST_OMX_INIT_STRUCT (&config_inline_header);
config_inline_header.nPortIndex =
GST_OMX_VIDEO_ENC (self)->enc_out_port->index;
err =
gst_omx_component_get_parameter (GST_OMX_VIDEO_ENC (self)->enc,
OMX_IndexParamBrcmVideoAVCInlineHeaderEnable, &config_inline_header);
if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self,
"can't get OMX_IndexParamBrcmVideoAVCInlineHeaderEnable %s (0x%08x)",
gst_omx_error_to_string (err), err);
return FALSE;
}
if (self->inline_sps_pps_headers) {
config_inline_header.bEnabled = OMX_TRUE;
} else {
config_inline_header.bEnabled = OMX_FALSE;
}
err =
gst_omx_component_set_parameter (GST_OMX_VIDEO_ENC (self)->enc,
OMX_IndexParamBrcmVideoAVCInlineHeaderEnable, &config_inline_header);
if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self,
"can't set OMX_IndexParamBrcmVideoAVCInlineHeaderEnable %s (0x%08x)",
gst_omx_error_to_string (err), err);
return FALSE;
}
#endif
if (self->periodicty_idr !=
GST_OMX_H264_VIDEO_ENC_PERIODICITY_OF_IDR_FRAMES_DEFAULT
|| self->interval_intraframes !=
GST_OMX_H264_VIDEO_ENC_INTERVAL_OF_CODING_INTRA_FRAMES_DEFAULT) {
GST_OMX_INIT_STRUCT (&config_avcintraperiod);
config_avcintraperiod.nPortIndex =
GST_OMX_VIDEO_ENC (self)->enc_out_port->index;
err =
gst_omx_component_get_parameter (GST_OMX_VIDEO_ENC (self)->enc,
OMX_IndexConfigVideoAVCIntraPeriod, &config_avcintraperiod);
if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self,
"can't get OMX_IndexConfigVideoAVCIntraPeriod %s (0x%08x)",
gst_omx_error_to_string (err), err);
return FALSE;
}
GST_DEBUG_OBJECT (self, "default nPFrames:%u, nIDRPeriod:%u",
(guint) config_avcintraperiod.nPFrames,
(guint) config_avcintraperiod.nIDRPeriod);
if (self->periodicty_idr !=
GST_OMX_H264_VIDEO_ENC_PERIODICITY_OF_IDR_FRAMES_DEFAULT) {
config_avcintraperiod.nIDRPeriod = self->periodicty_idr;
}
if (self->interval_intraframes !=
GST_OMX_H264_VIDEO_ENC_INTERVAL_OF_CODING_INTRA_FRAMES_DEFAULT) {
config_avcintraperiod.nPFrames = self->interval_intraframes;
}
err =
gst_omx_component_set_parameter (GST_OMX_VIDEO_ENC (self)->enc,
OMX_IndexConfigVideoAVCIntraPeriod, &config_avcintraperiod);
if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self,
"can't set OMX_IndexConfigVideoAVCIntraPeriod %s (0x%08x)",
gst_omx_error_to_string (err), err);
return FALSE;
}
}
gst_omx_port_get_port_definition (GST_OMX_VIDEO_ENC (self)->enc_out_port,
&port_def);
port_def.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
err =
gst_omx_port_update_port_definition (GST_OMX_VIDEO_ENC
(self)->enc_out_port, &port_def);
if (err != OMX_ErrorNone)
return FALSE;
GST_OMX_INIT_STRUCT (¶m);
param.nPortIndex = GST_OMX_VIDEO_ENC (self)->enc_out_port->index;
err =
gst_omx_component_get_parameter (GST_OMX_VIDEO_ENC (self)->enc,
OMX_IndexParamVideoProfileLevelCurrent, ¶m);
if (err != OMX_ErrorNone) {
GST_WARNING_OBJECT (self,
"Setting profile/level not supported by component");
return TRUE;
}
peercaps = gst_pad_peer_query_caps (GST_VIDEO_ENCODER_SRC_PAD (enc),
gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SRC_PAD (enc)));
if (peercaps) {
GstStructure *s;
if (gst_caps_is_empty (peercaps)) {
gst_caps_unref (peercaps);
GST_ERROR_OBJECT (self, "Empty caps");
return FALSE;
}
s = gst_caps_get_structure (peercaps, 0);
profile_string = gst_structure_get_string (s, "profile");
if (profile_string) {
if (g_str_equal (profile_string, "baseline")) {
param.eProfile = OMX_VIDEO_AVCProfileBaseline;
} else if (g_str_equal (profile_string, "main")) {
param.eProfile = OMX_VIDEO_AVCProfileMain;
} else if (g_str_equal (profile_string, "extended")) {
param.eProfile = OMX_VIDEO_AVCProfileExtended;
} else if (g_str_equal (profile_string, "high")) {
param.eProfile = OMX_VIDEO_AVCProfileHigh;
} else if (g_str_equal (profile_string, "high-10")) {
param.eProfile = OMX_VIDEO_AVCProfileHigh10;
} else if (g_str_equal (profile_string, "high-4:2:2")) {
param.eProfile = OMX_VIDEO_AVCProfileHigh422;
} else if (g_str_equal (profile_string, "high-4:4:4")) {
param.eProfile = OMX_VIDEO_AVCProfileHigh444;
} else {
goto unsupported_profile;
}
}
level_string = gst_structure_get_string (s, "level");
if (level_string) {
if (g_str_equal (level_string, "1")) {
param.eLevel = OMX_VIDEO_AVCLevel1;
} else if (g_str_equal (level_string, "1b")) {
param.eLevel = OMX_VIDEO_AVCLevel1b;
} else if (g_str_equal (level_string, "1.1")) {
param.eLevel = OMX_VIDEO_AVCLevel11;
} else if (g_str_equal (level_string, "1.2")) {
param.eLevel = OMX_VIDEO_AVCLevel12;
} else if (g_str_equal (level_string, "1.3")) {
param.eLevel = OMX_VIDEO_AVCLevel13;
} else if (g_str_equal (level_string, "2")) {
param.eLevel = OMX_VIDEO_AVCLevel2;
} else if (g_str_equal (level_string, "2.1")) {
param.eLevel = OMX_VIDEO_AVCLevel21;
} else if (g_str_equal (level_string, "2.2")) {
param.eLevel = OMX_VIDEO_AVCLevel22;
} else if (g_str_equal (level_string, "3")) {
param.eLevel = OMX_VIDEO_AVCLevel3;
} else if (g_str_equal (level_string, "3.1")) {
param.eLevel = OMX_VIDEO_AVCLevel31;
} else if (g_str_equal (level_string, "3.2")) {
param.eLevel = OMX_VIDEO_AVCLevel32;
} else if (g_str_equal (level_string, "4")) {
param.eLevel = OMX_VIDEO_AVCLevel4;
} else if (g_str_equal (level_string, "4.1")) {
param.eLevel = OMX_VIDEO_AVCLevel41;
} else if (g_str_equal (level_string, "4.2")) {
param.eLevel = OMX_VIDEO_AVCLevel42;
} else if (g_str_equal (level_string, "5")) {
param.eLevel = OMX_VIDEO_AVCLevel5;
} else if (g_str_equal (level_string, "5.1")) {
param.eLevel = OMX_VIDEO_AVCLevel51;
} else {
goto unsupported_level;
}
}
gst_caps_unref (peercaps);
}
err =
gst_omx_component_set_parameter (GST_OMX_VIDEO_ENC (self)->enc,
OMX_IndexParamVideoProfileLevelCurrent, ¶m);
if (err == OMX_ErrorUnsupportedIndex) {
GST_WARNING_OBJECT (self,
"Setting profile/level not supported by component");
} else if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self,
"Error setting profile %u and level %u: %s (0x%08x)",
(guint) param.eProfile, (guint) param.eLevel,
gst_omx_error_to_string (err), err);
return FALSE;
}
return TRUE;
unsupported_profile:
GST_ERROR_OBJECT (self, "Unsupported profile %s", profile_string);
gst_caps_unref (peercaps);
return FALSE;
unsupported_level:
GST_ERROR_OBJECT (self, "Unsupported level %s", level_string);
gst_caps_unref (peercaps);
return FALSE;
}
static gboolean
gst_omx_audio_enc_set_format (GstAudioEncoder * encoder, GstAudioInfo * info)
{
GstOMXAudioEnc *self;
GstOMXAudioEncClass *klass;
gboolean needs_disable = FALSE;
OMX_PARAM_PORTDEFINITIONTYPE port_def;
OMX_AUDIO_PARAM_PCMMODETYPE pcm_param;
gint i;
OMX_ERRORTYPE err;
self = GST_OMX_AUDIO_ENC (encoder);
klass = GST_OMX_AUDIO_ENC_GET_CLASS (encoder);
GST_DEBUG_OBJECT (self, "Setting new caps");
/* Set audio encoder base class properties */
gst_audio_encoder_set_frame_samples_min (encoder,
gst_util_uint64_scale_ceil (OMX_MIN_PCMPAYLOAD_MSEC,
GST_MSECOND * info->rate, GST_SECOND));
gst_audio_encoder_set_frame_samples_max (encoder, 0);
gst_omx_port_get_port_definition (self->enc_in_port, &port_def);
needs_disable =
gst_omx_component_get_state (self->enc,
GST_CLOCK_TIME_NONE) != OMX_StateLoaded;
/* If the component is not in Loaded state and a real format change happens
* we have to disable the port and re-allocate all buffers. If no real
* format change happened we can just exit here.
*/
if (needs_disable) {
GST_DEBUG_OBJECT (self, "Need to disable and drain encoder");
gst_omx_audio_enc_drain (self);
gst_omx_port_set_flushing (self->enc_out_port, 5 * GST_SECOND, TRUE);
/* Wait until the srcpad loop is finished,
* unlock GST_AUDIO_ENCODER_STREAM_LOCK to prevent deadlocks
* caused by using this lock from inside the loop function */
GST_AUDIO_ENCODER_STREAM_UNLOCK (self);
gst_pad_stop_task (GST_AUDIO_ENCODER_SRC_PAD (encoder));
GST_AUDIO_ENCODER_STREAM_LOCK (self);
if (gst_omx_port_set_enabled (self->enc_in_port, FALSE) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_set_enabled (self->enc_out_port, FALSE) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_wait_buffers_released (self->enc_in_port,
5 * GST_SECOND) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_wait_buffers_released (self->enc_out_port,
1 * GST_SECOND) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_deallocate_buffers (self->enc_in_port) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_deallocate_buffers (self->enc_out_port) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_wait_enabled (self->enc_in_port,
1 * GST_SECOND) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_wait_enabled (self->enc_out_port,
1 * GST_SECOND) != OMX_ErrorNone)
return FALSE;
GST_DEBUG_OBJECT (self, "Encoder drained and disabled");
}
port_def.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
GST_DEBUG_OBJECT (self, "Setting inport port definition");
if (gst_omx_port_update_port_definition (self->enc_in_port,
&port_def) != OMX_ErrorNone)
return FALSE;
GST_OMX_INIT_STRUCT (&pcm_param);
pcm_param.nPortIndex = self->enc_in_port->index;
pcm_param.nChannels = info->channels;
pcm_param.eNumData =
((info->finfo->flags & GST_AUDIO_FORMAT_FLAG_SIGNED) ?
OMX_NumericalDataSigned : OMX_NumericalDataUnsigned);
pcm_param.eEndian =
((info->finfo->endianness == G_LITTLE_ENDIAN) ?
OMX_EndianLittle : OMX_EndianBig);
pcm_param.bInterleaved = OMX_TRUE;
pcm_param.nBitPerSample = info->finfo->width;
pcm_param.nSamplingRate = info->rate;
pcm_param.ePCMMode = OMX_AUDIO_PCMModeLinear;
for (i = 0; i < pcm_param.nChannels; i++) {
OMX_AUDIO_CHANNELTYPE pos;
switch (info->position[i]) {
case GST_AUDIO_CHANNEL_POSITION_MONO:
case GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER:
pos = OMX_AUDIO_ChannelCF;
break;
case GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT:
pos = OMX_AUDIO_ChannelLF;
break;
case GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT:
pos = OMX_AUDIO_ChannelRF;
break;
case GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT:
pos = OMX_AUDIO_ChannelLS;
break;
case GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT:
pos = OMX_AUDIO_ChannelRS;
break;
case GST_AUDIO_CHANNEL_POSITION_LFE1:
pos = OMX_AUDIO_ChannelLFE;
break;
case GST_AUDIO_CHANNEL_POSITION_REAR_CENTER:
pos = OMX_AUDIO_ChannelCS;
break;
case GST_AUDIO_CHANNEL_POSITION_REAR_LEFT:
pos = OMX_AUDIO_ChannelLR;
break;
case GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT:
pos = OMX_AUDIO_ChannelRR;
break;
default:
pos = OMX_AUDIO_ChannelNone;
break;
}
pcm_param.eChannelMapping[i] = pos;
}
GST_DEBUG_OBJECT (self, "Setting PCM parameters");
err =
gst_omx_component_set_parameter (self->enc, OMX_IndexParamAudioPcm,
&pcm_param);
if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self, "Failed to set PCM parameters: %s (0x%08x)",
gst_omx_error_to_string (err), err);
return FALSE;
}
if (klass->set_format) {
if (!klass->set_format (self, self->enc_in_port, info)) {
GST_ERROR_OBJECT (self, "Subclass failed to set the new format");
return FALSE;
}
}
GST_DEBUG_OBJECT (self, "Updating outport port definition");
if (gst_omx_port_update_port_definition (self->enc_out_port,
NULL) != OMX_ErrorNone)
return FALSE;
GST_DEBUG_OBJECT (self, "Enabling component");
if (needs_disable) {
if (gst_omx_port_set_enabled (self->enc_in_port, TRUE) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_allocate_buffers (self->enc_in_port) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_wait_enabled (self->enc_in_port,
5 * GST_SECOND) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_mark_reconfigured (self->enc_in_port) != OMX_ErrorNone)
return FALSE;
} else {
/* Disable output port */
if (gst_omx_port_set_enabled (self->enc_out_port, FALSE) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_wait_enabled (self->enc_out_port,
1 * GST_SECOND) != OMX_ErrorNone)
return FALSE;
if (gst_omx_component_set_state (self->enc, OMX_StateIdle) != OMX_ErrorNone)
return FALSE;
/* Need to allocate buffers to reach Idle state */
if (gst_omx_port_allocate_buffers (self->enc_in_port) != OMX_ErrorNone)
return FALSE;
if (gst_omx_component_get_state (self->enc,
GST_CLOCK_TIME_NONE) != OMX_StateIdle)
return FALSE;
if (gst_omx_component_set_state (self->enc,
OMX_StateExecuting) != OMX_ErrorNone)
return FALSE;
if (gst_omx_component_get_state (self->enc,
GST_CLOCK_TIME_NONE) != OMX_StateExecuting)
return FALSE;
}
/* Unset flushing to allow ports to accept data again */
gst_omx_port_set_flushing (self->enc_in_port, 5 * GST_SECOND, FALSE);
gst_omx_port_set_flushing (self->enc_out_port, 5 * GST_SECOND, FALSE);
if (gst_omx_component_get_last_error (self->enc) != OMX_ErrorNone) {
GST_ERROR_OBJECT (self, "Component in error state: %s (0x%08x)",
gst_omx_component_get_last_error_string (self->enc),
gst_omx_component_get_last_error (self->enc));
return FALSE;
}
/* Start the srcpad loop again */
GST_DEBUG_OBJECT (self, "Starting task again");
self->downstream_flow_ret = GST_FLOW_OK;
gst_pad_start_task (GST_AUDIO_ENCODER_SRC_PAD (self),
(GstTaskFunction) gst_omx_audio_enc_loop, encoder, NULL);
return TRUE;
}
static gboolean
gst_omx_mpeg4_video_enc_set_format (GstOMXVideoEnc * enc, GstOMXPort * port,
GstVideoInfo * info)
{
GstOMXMPEG4VideoEnc *self = GST_OMX_MPEG4_VIDEO_ENC (enc);
GstCaps *peercaps, *intersection;
OMX_VIDEO_MPEG4PROFILETYPE profile = OMX_VIDEO_MPEG4ProfileSimple;
OMX_VIDEO_MPEG4LEVELTYPE level = OMX_VIDEO_MPEG4Level1;
OMX_VIDEO_PARAM_PROFILELEVELTYPE param;
OMX_ERRORTYPE err;
const gchar *profile_string, *level_string;
peercaps = gst_pad_peer_query_caps (GST_BASE_VIDEO_CODEC_SRC_PAD (enc), NULL);
if (peercaps) {
GstStructure *s;
intersection =
gst_caps_intersect (peercaps,
gst_pad_get_pad_template_caps (GST_BASE_VIDEO_CODEC_SRC_PAD (enc)));
gst_caps_unref (peercaps);
if (gst_caps_is_empty (intersection)) {
gst_caps_unref (intersection);
GST_ERROR_OBJECT (self, "Empty caps");
return FALSE;
}
s = gst_caps_get_structure (intersection, 0);
profile_string = gst_structure_get_string (s, "profile");
if (profile_string) {
if (g_str_equal (profile_string, "simple")) {
profile = OMX_VIDEO_MPEG4ProfileSimple;
} else if (g_str_equal (profile_string, "simple-scalable")) {
profile = OMX_VIDEO_MPEG4ProfileSimpleScalable;
} else if (g_str_equal (profile_string, "core")) {
profile = OMX_VIDEO_MPEG4ProfileCore;
} else if (g_str_equal (profile_string, "main")) {
profile = OMX_VIDEO_MPEG4ProfileMain;
} else if (g_str_equal (profile_string, "n-bit")) {
profile = OMX_VIDEO_MPEG4ProfileNbit;
} else if (g_str_equal (profile_string, "scalable")) {
profile = OMX_VIDEO_MPEG4ProfileScalableTexture;
} else if (g_str_equal (profile_string, "simple-face")) {
profile = OMX_VIDEO_MPEG4ProfileSimpleFace;
} else if (g_str_equal (profile_string, "simple-fba")) {
profile = OMX_VIDEO_MPEG4ProfileSimpleFBA;
} else if (g_str_equal (profile_string, "basic-animated-texture")) {
profile = OMX_VIDEO_MPEG4ProfileBasicAnimated;
} else if (g_str_equal (profile_string, "hybrid")) {
profile = OMX_VIDEO_MPEG4ProfileHybrid;
} else if (g_str_equal (profile_string, "advanced-real-time-simple")) {
profile = OMX_VIDEO_MPEG4ProfileAdvancedRealTime;
} else if (g_str_equal (profile_string, "core-scalable")) {
profile = OMX_VIDEO_MPEG4ProfileCoreScalable;
} else if (g_str_equal (profile_string, "advanced-coding-efficiency")) {
profile = OMX_VIDEO_MPEG4ProfileAdvancedCoding;
} else if (g_str_equal (profile_string, "advanced-core")) {
profile = OMX_VIDEO_MPEG4ProfileAdvancedCore;
} else if (g_str_equal (profile_string, "advanced-scalable-texture")) {
profile = OMX_VIDEO_MPEG4ProfileAdvancedScalable;
} else if (g_str_equal (profile_string, "advanced-simple")) {
profile = OMX_VIDEO_MPEG4ProfileAdvancedSimple;
} else {
goto unsupported_profile;
}
}
level_string = gst_structure_get_string (s, "level");
if (level_string) {
if (g_str_equal (level_string, "0")) {
level = OMX_VIDEO_MPEG4Level0;
} else if (g_str_equal (level_string, "0b")) {
level = OMX_VIDEO_MPEG4Level0b;
} else if (g_str_equal (level_string, "1")) {
level = OMX_VIDEO_MPEG4Level1;
} else if (g_str_equal (level_string, "2")) {
level = OMX_VIDEO_MPEG4Level2;
} else if (g_str_equal (level_string, "3")) {
level = OMX_VIDEO_MPEG4Level3;
} else if (g_str_equal (level_string, "4")) {
level = OMX_VIDEO_MPEG4Level4;
} else if (g_str_equal (level_string, "4a")) {
level = OMX_VIDEO_MPEG4Level4a;
} else if (g_str_equal (level_string, "5")) {
level = OMX_VIDEO_MPEG4Level5;
} else {
goto unsupported_level;
}
}
gst_caps_unref (intersection);
}
GST_OMX_INIT_STRUCT (¶m);
param.nPortIndex = GST_OMX_VIDEO_ENC (self)->out_port->index;
param.eProfile = profile;
param.eLevel = level;
err =
gst_omx_component_set_parameter (GST_OMX_VIDEO_ENC (self)->component,
OMX_IndexParamVideoProfileLevelCurrent, ¶m);
if (err == OMX_ErrorUnsupportedIndex) {
GST_WARNING_OBJECT (self,
"Setting profile/level not supported by component");
} else if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self,
"Error setting profile %d and level %d: %s (0x%08x)", profile, level,
gst_omx_error_to_string (err), err);
return FALSE;
}
return TRUE;
unsupported_profile:
gst_caps_unref (intersection);
GST_ERROR_OBJECT (self, "Unsupported profile %s", profile_string);
return FALSE;
unsupported_level:
gst_caps_unref (intersection);
GST_ERROR_OBJECT (self, "Unsupported level %s", level_string);
return FALSE;
}
static gboolean
gst_omx_h264_enc_set_format (GstOMXVideoEnc * enc, GstOMXPort * port,
GstVideoState * state)
{
GstOMXH264Enc *self = GST_OMX_H264_ENC (enc);
GstCaps *peercaps;
OMX_VIDEO_AVCPROFILETYPE profile = OMX_VIDEO_AVCProfileBaseline;
OMX_VIDEO_AVCLEVELTYPE level = OMX_VIDEO_AVCLevel11;
OMX_VIDEO_PARAM_PROFILELEVELTYPE param;
OMX_ERRORTYPE err;
peercaps = gst_pad_peer_get_caps (GST_BASE_VIDEO_CODEC_SRC_PAD (enc));
if (peercaps) {
GstStructure *s;
GstCaps *intersection;
const gchar *profile_string, *level_string;
intersection =
gst_caps_intersect (peercaps,
gst_pad_get_pad_template_caps (GST_BASE_VIDEO_CODEC_SRC_PAD (enc)));
gst_caps_unref (peercaps);
if (gst_caps_is_empty (intersection)) {
gst_caps_unref (intersection);
GST_ERROR_OBJECT (self, "Empty caps");
return FALSE;
}
s = gst_caps_get_structure (intersection, 0);
profile_string = gst_structure_get_string (s, "profile");
if (profile_string) {
if (g_str_equal (profile_string, "baseline")) {
profile = OMX_VIDEO_AVCProfileBaseline;
} else if (g_str_equal (profile_string, "main")) {
profile = OMX_VIDEO_AVCProfileMain;
} else if (g_str_equal (profile_string, "extended")) {
profile = OMX_VIDEO_AVCProfileExtended;
} else if (g_str_equal (profile_string, "high")) {
profile = OMX_VIDEO_AVCProfileHigh;
} else if (g_str_equal (profile_string, "high-10")) {
profile = OMX_VIDEO_AVCProfileHigh10;
} else if (g_str_equal (profile_string, "high-4:2:2")) {
profile = OMX_VIDEO_AVCProfileHigh422;
} else if (g_str_equal (profile_string, "high-4:4:4")) {
profile = OMX_VIDEO_AVCProfileHigh444;
} else {
GST_ERROR_OBJECT (self, "Unsupported profile %s", profile_string);
return FALSE;
}
}
level_string = gst_structure_get_string (s, "level");
if (level_string) {
if (g_str_equal (level_string, "1")) {
level = OMX_VIDEO_AVCLevel1;
} else if (g_str_equal (level_string, "1b")) {
level = OMX_VIDEO_AVCLevel1b;
} else if (g_str_equal (level_string, "1.1")) {
level = OMX_VIDEO_AVCLevel11;
} else if (g_str_equal (level_string, "1.2")) {
level = OMX_VIDEO_AVCLevel12;
} else if (g_str_equal (level_string, "1.3")) {
level = OMX_VIDEO_AVCLevel13;
} else if (g_str_equal (level_string, "2")) {
level = OMX_VIDEO_AVCLevel2;
} else if (g_str_equal (level_string, "2.1")) {
level = OMX_VIDEO_AVCLevel21;
} else if (g_str_equal (level_string, "2.2")) {
level = OMX_VIDEO_AVCLevel22;
} else if (g_str_equal (level_string, "3")) {
level = OMX_VIDEO_AVCLevel3;
} else if (g_str_equal (level_string, "3.1")) {
level = OMX_VIDEO_AVCLevel31;
} else if (g_str_equal (level_string, "3.2")) {
level = OMX_VIDEO_AVCLevel32;
} else if (g_str_equal (level_string, "4")) {
level = OMX_VIDEO_AVCLevel4;
} else if (g_str_equal (level_string, "4.1")) {
level = OMX_VIDEO_AVCLevel41;
} else if (g_str_equal (level_string, "4.2")) {
level = OMX_VIDEO_AVCLevel42;
} else if (g_str_equal (level_string, "5")) {
level = OMX_VIDEO_AVCLevel5;
} else if (g_str_equal (level_string, "5.1")) {
level = OMX_VIDEO_AVCLevel51;
} else {
GST_ERROR_OBJECT (self, "Unsupported level %s", level_string);
return FALSE;
}
}
}
GST_OMX_INIT_STRUCT (¶m);
param.nPortIndex = GST_OMX_VIDEO_ENC (self)->out_port->index;
param.eProfile = profile;
param.eLevel = level;
err =
gst_omx_component_set_parameter (GST_OMX_VIDEO_ENC (self)->component,
OMX_IndexParamVideoProfileLevelCurrent, ¶m);
if (err == OMX_ErrorUnsupportedIndex) {
GST_WARNING_OBJECT (self,
"Setting profile/level not supported by component");
} else if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self,
"Error setting profile %d and level %d: %s (0x%08x)", profile, level,
gst_omx_error_to_string (err), err);
return FALSE;
}
return TRUE;
}
static gboolean
gst_omx_aac_dec_set_format (GstOMXAudioDec * dec, GstOMXPort * port,
GstCaps * caps)
{
GstOMXAACDec *self = GST_OMX_AAC_DEC (dec);
OMX_PARAM_PORTDEFINITIONTYPE port_def;
OMX_AUDIO_PARAM_AACPROFILETYPE aac_param;
OMX_ERRORTYPE err;
GstStructure *s;
gint rate, channels, mpegversion;
const gchar *stream_format;
gst_omx_port_get_port_definition (port, &port_def);
port_def.format.audio.eEncoding = OMX_AUDIO_CodingAAC;
err = gst_omx_port_update_port_definition (port, &port_def);
if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self,
"Failed to set AAC format on component: %s (0x%08x)",
gst_omx_error_to_string (err), err);
return FALSE;
}
GST_OMX_INIT_STRUCT (&aac_param);
aac_param.nPortIndex = port->index;
err =
gst_omx_component_get_parameter (dec->dec, OMX_IndexParamAudioAac,
&aac_param);
if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self,
"Failed to get AAC parameters from component: %s (0x%08x)",
gst_omx_error_to_string (err), err);
return FALSE;
}
s = gst_caps_get_structure (caps, 0);
if (!gst_structure_get_int (s, "mpegversion", &mpegversion) ||
!gst_structure_get_int (s, "rate", &rate) ||
!gst_structure_get_int (s, "channels", &channels)) {
GST_ERROR_OBJECT (self, "Incomplete caps");
return FALSE;
}
stream_format = gst_structure_get_string (s, "stream-format");
if (!stream_format) {
GST_ERROR_OBJECT (self, "Incomplete caps");
return FALSE;
}
aac_param.nChannels = channels;
aac_param.nSampleRate = rate;
aac_param.nBitRate = 0; /* unknown */
aac_param.nAudioBandWidth = 0; /* decoder decision */
aac_param.eChannelMode = 0; /* FIXME */
if (mpegversion == 2)
aac_param.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP2ADTS;
else if (strcmp (stream_format, "adts") == 0)
aac_param.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4ADTS;
else if (strcmp (stream_format, "loas") == 0)
aac_param.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4LOAS;
else if (strcmp (stream_format, "adif") == 0)
aac_param.eAACStreamFormat = OMX_AUDIO_AACStreamFormatADIF;
else if (strcmp (stream_format, "raw") == 0)
aac_param.eAACStreamFormat = OMX_AUDIO_AACStreamFormatRAW;
else /* fallback instead of failing */
aac_param.eAACStreamFormat = OMX_AUDIO_AACStreamFormatRAW;
err =
gst_omx_component_set_parameter (dec->dec, OMX_IndexParamAudioAac,
&aac_param);
if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self, "Error setting AAC parameters: %s (0x%08x)",
gst_omx_error_to_string (err), err);
return FALSE;
}
return TRUE;
}
