static OMX_ERRORTYPE
prepare_port_auto_detection (mp4dmuxflt_prc_t * ap_prc)
{
OMX_PARAM_PORTDEFINITIONTYPE port_def;
assert (ap_prc);
/* Prepare audio port */
TIZ_INIT_OMX_PORT_STRUCT (port_def, ARATELIA_MP4_DEMUXER_FILTER_PORT_1_INDEX);
tiz_check_omx (
tiz_api_GetParameter (tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamPortDefinition, &port_def));
ap_prc->audio_coding_type_ = port_def.format.audio.eEncoding;
ap_prc->audio_auto_detect_on_
= (OMX_AUDIO_CodingAutoDetect == ap_prc->audio_coding_type_) ? true : false;
/* Prepare video port */
TIZ_INIT_OMX_PORT_STRUCT (port_def, ARATELIA_MP4_DEMUXER_FILTER_PORT_2_INDEX);
tiz_check_omx (
tiz_api_GetParameter (tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamPortDefinition, &port_def));
ap_prc->video_coding_type_ = port_def.format.video.eCompressionFormat;
ap_prc->video_auto_detect_on_
= (OMX_VIDEO_CodingAutoDetect == ap_prc->video_coding_type_) ? true : false;
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
alloc_data_stores (oggdmux_prc_t * ap_prc)
{
OMX_PARAM_PORTDEFINITIONTYPE port_def;
assert (ap_prc);
port_def.nSize = (OMX_U32) sizeof (OMX_PARAM_PORTDEFINITIONTYPE);
port_def.nVersion.nVersion = OMX_VERSION;
port_def.nPortIndex = ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX;
tiz_check_omx (
tiz_api_GetParameter (tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamPortDefinition, &port_def));
ap_prc->aud_buf_size_ = port_def.nBufferSize;
assert (ap_prc->p_aud_store_ == NULL);
ap_prc->aud_store_size_ = port_def.nBufferSize;
tiz_check_null_ret_oom (
(ap_prc->p_aud_store_ = tiz_mem_alloc (ap_prc->aud_store_size_)));
port_def.nPortIndex = ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX;
tiz_check_omx (
tiz_api_GetParameter (tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamPortDefinition, &port_def));
ap_prc->vid_buf_size_ = port_def.nBufferSize;
assert (ap_prc->p_vid_store_ == NULL);
ap_prc->vid_store_size_ = port_def.nBufferSize;
tiz_check_null_ret_oom (
(ap_prc->p_vid_store_ = tiz_mem_alloc (ap_prc->vid_store_size_)));
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
mp3d_proc_prepare_to_transfer (void * ap_obj, OMX_U32 a_pid)
{
mp3d_prc_t * p_prc = ap_obj;
OMX_AUDIO_PARAM_MP3TYPE mp3type;
assert (p_prc);
/* NOTE: init the decoder here, as it might have been de-inited in a
transition Exe->Idle */
init_mad_decoder (ap_obj);
TIZ_INIT_OMX_PORT_STRUCT (mp3type, ARATELIA_MP3_DECODER_INPUT_PORT_INDEX);
tiz_check_omx (tiz_api_GetParameter (tiz_get_krn (handleOf (p_prc)),
handleOf (p_prc), OMX_IndexParamAudioMp3,
&mp3type));
TIZ_INIT_OMX_PORT_STRUCT (p_prc->pcmmode_,
ARATELIA_MP3_DECODER_OUTPUT_PORT_INDEX);
tiz_check_omx (tiz_api_GetParameter (tiz_get_krn (handleOf (p_prc)),
handleOf (p_prc), OMX_IndexParamAudioPcm,
&(p_prc->pcmmode_)));
TIZ_TRACE (handleOf (p_prc),
"sample rate decoder = [%d] channels decoder = [%d]",
mp3type.nSampleRate, mp3type.nChannels);
TIZ_TRACE (handleOf (p_prc),
"sample rate renderer = [%d] channels renderer = [%d]",
p_prc->pcmmode_.nSamplingRate, p_prc->pcmmode_.nChannels);
reset_stream_parameters (ap_obj);
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
obtain_url (cc_http_prc_t * ap_prc)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
const long pathname_max = PATH_MAX + NAME_MAX;
assert (ap_prc);
assert (!ap_prc->p_content_uri_);
ap_prc->p_content_uri_
= tiz_mem_calloc (1, sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1);
tiz_check_null_ret_oom (ap_prc->p_content_uri_);
ap_prc->p_content_uri_->nSize
= sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1;
ap_prc->p_content_uri_->nVersion.nVersion = OMX_VERSION;
tiz_check_omx (
tiz_api_GetParameter (tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamContentURI, ap_prc->p_content_uri_));
TIZ_NOTICE (handleOf (ap_prc), "URI [%s]",
ap_prc->p_content_uri_->contentURI);
/* Verify we are getting an http scheme */
if (strncasecmp ((const char *) ap_prc->p_content_uri_->contentURI, "http://",
7)
&& strncasecmp ((const char *) ap_prc->p_content_uri_->contentURI,
"https://", 8))
{
rc = OMX_ErrorContentURIError;
}
return rc;
}
static OMX_ERRORTYPE
retrieve_playlist (dirble_prc_t * ap_prc)
{
return tiz_api_GetParameter (
tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_TizoniaIndexParamAudioDirblePlaylist, &(ap_prc->playlist_));
}
static OMX_ERRORTYPE
retrieve_session_configuration (dirble_prc_t * ap_prc)
{
return tiz_api_GetParameter (
tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_TizoniaIndexParamAudioDirbleSession, &(ap_prc->session_));
}
static OMX_ERRORTYPE
retrieve_buffer_size (scloud_prc_t * ap_prc)
{
TIZ_INIT_OMX_PORT_STRUCT (ap_prc->buffer_size_, ARATELIA_HTTP_SOURCE_PORT_INDEX);
return tiz_api_GetParameter (
tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_TizoniaIndexParamStreamingBuffer, &(ap_prc->buffer_size_));
}
static OMX_ERRORTYPE
sdlivr_proc_prepare_to_transfer (void *ap_obj, OMX_U32 a_pid)
{
sdlivr_prc_t *p_prc = ap_obj;
OMX_ERRORTYPE rc = OMX_ErrorNone;
OMX_PARAM_PORTDEFINITIONTYPE portdef;
TIZ_INIT_OMX_PORT_STRUCT (portdef, ARATELIA_YUV_RENDERER_PORT_INDEX);
TIZ_TRACE (handleOf (p_prc), "pid [%d]", a_pid);
assert (NULL != p_prc);
/* Retrieve port def from port */
if (OMX_ErrorNone != (rc = tiz_api_GetParameter
(tiz_get_krn (handleOf (p_prc)),
handleOf (p_prc),
OMX_IndexParamPortDefinition, &portdef)))
{
TIZ_ERROR (handleOf (p_prc),
"[%s] : retrieving the port definition", tiz_err_to_str (rc));
return rc;
}
p_prc->vportdef_ = portdef.format.video;
TIZ_TRACE (handleOf (p_prc),
"nFrameWidth = [%d] nFrameHeight = [%d] ",
/* "nStride = [%d] nSliceHeight = [%d] nBitrate = [%d] " */
/* "xFramerate = [%s] eCompressionFormat = [%d] eColorFormat = [%d]", */
p_prc->vportdef_.nFrameWidth, p_prc->vportdef_.nFrameHeight);
/* p_prc->vportdef_.nStride, */
/* p_prc->vportdef_.nSliceHeight, */
/* p_prc->vportdef_.nBitrate, */
/* p_prc->vportdef_.xFramerate, */
/* p_prc->vportdef_.eCompressionFormat, */
/* p_prc->vportdef_.eColorFormat); */
SDL_WM_SetCaption ("Tizonia OpenMAX IL YUV renderer", "YUV");
p_prc->p_surface = SDL_SetVideoMode
(p_prc->vportdef_.nFrameWidth, p_prc->vportdef_.nFrameHeight, 0,
SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL | SDL_RESIZABLE);
p_prc->p_overlay = SDL_CreateYUVOverlay
(p_prc->vportdef_.nFrameWidth, p_prc->vportdef_.nFrameHeight,
SDL_YV12_OVERLAY, p_prc->p_surface);
return OMX_ErrorNone;
}
static inline OMX_ERRORTYPE
retrieve_mountpoint_settings (const void * ap_prc,
OMX_TIZONIA_ICECASTMOUNTPOINTTYPE * ap_mountpoint)
{
const httpr_prc_t * p_prc = ap_prc;
assert (p_prc);
assert (ap_mountpoint);
/* Retrieve the mountpoint settings from the input port */
TIZ_INIT_OMX_PORT_STRUCT (*ap_mountpoint, ARATELIA_HTTP_RENDERER_PORT_INDEX);
tiz_check_omx (tiz_api_GetParameter (
tiz_get_krn (handleOf (p_prc)), handleOf (p_prc),
OMX_TizoniaIndexParamIcecastMountpoint, ap_mountpoint));
return OMX_ErrorNone;
}
static inline OMX_ERRORTYPE
retrieve_mp3_settings (const void * ap_prc,
OMX_AUDIO_PARAM_MP3TYPE * ap_mp3type)
{
const httpr_prc_t * p_prc = ap_prc;
assert (ap_prc);
assert (ap_mp3type);
/* Retrieve the mp3 settings from the input port */
TIZ_INIT_OMX_PORT_STRUCT (*ap_mp3type, ARATELIA_HTTP_RENDERER_PORT_INDEX);
tiz_check_omx (tiz_api_GetParameter (tiz_get_krn (handleOf (p_prc)),
handleOf (p_prc),
OMX_IndexParamAudioMp3, ap_mp3type));
return OMX_ErrorNone;
}
static OMX_ERRORTYPE h264d_prc_prepare_to_transfer(void *ap_obj, OMX_U32 a_pid)
{
vid_dec_PrivateType*priv = ap_obj;
assert(priv);
TIZ_INIT_OMX_PORT_STRUCT(priv->out_port_def_,
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX);
tiz_check_omx(
tiz_api_GetParameter(tiz_get_krn(handleOf(priv)), handleOf(priv),
OMX_IndexParamPortDefinition, &(priv->out_port_def_)));
priv->first_buf_in_frame = true;
priv->eos_ = false;
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
fr_proc_allocate_resources (void *ap_obj, OMX_U32 a_pid)
{
fr_prc_t *p_obj = ap_obj;
const tiz_srv_t *p_parent = ap_obj;
OMX_ERRORTYPE ret_val = OMX_ErrorNone;
void *p_krn = tiz_get_krn (p_parent->p_hdl_);
assert (ap_obj);
if (!(p_obj->p_uri_param_))
{
p_obj->p_uri_param_ = tiz_mem_calloc
(1, sizeof (OMX_PARAM_CONTENTURITYPE) + OMX_MAX_STRINGNAME_SIZE);
if (NULL == p_obj->p_uri_param_)
{
TIZ_LOG (TIZ_ERROR, "Error allocating memory "
"for the content uri struct");
return OMX_ErrorInsufficientResources;
}
p_obj->p_uri_param_->nSize = sizeof (OMX_PARAM_CONTENTURITYPE)
+ OMX_MAX_STRINGNAME_SIZE - 1;
p_obj->p_uri_param_->nVersion.nVersion = OMX_VERSION;
}
if (OMX_ErrorNone != (ret_val = tiz_api_GetParameter
(p_krn,
p_parent->p_hdl_,
OMX_IndexParamContentURI, p_obj->p_uri_param_)))
{
TIZ_LOG (TIZ_ERROR, "Error retrieving URI param from port");
return ret_val;
}
TIZ_LOG (TIZ_NOTICE, "Retrieved URI [%s]",
p_obj->p_uri_param_->contentURI);
if ((p_obj->p_file_
= fopen ((const char *) p_obj->p_uri_param_->contentURI, "r")) == 0)
{
TIZ_LOG (TIZ_ERROR, "Error opening file from URI string");
return OMX_ErrorInsufficientResources;
}
return OMX_ErrorNone;
}
static void reset_stream_parameters(vid_dec_PrivateType* apriv)
{
assert(apriv);
TIZ_INIT_OMX_PORT_STRUCT(apriv->out_port_def_,
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX);
tiz_api_GetParameter (tiz_get_krn (handleOf (apriv)), handleOf (apriv),
OMX_IndexParamPortDefinition, &(apriv->out_port_def_));
apriv->p_inhdr_ = 0;
apriv->num_in_buffers = 0;
apriv->first_buf_in_frame = true;
apriv->eos_ = false;
apriv->frame_finished = false;
apriv->frame_started = false;
apriv->picture.h264.field_order_cnt[0] = apriv->picture.h264.field_order_cnt[1] = INT_MAX;
apriv->slice = NULL;
}
static OMX_ERRORTYPE
set_auto_detect_on_port (dirble_prc_t * ap_prc)
{
OMX_PARAM_PORTDEFINITIONTYPE port_def;
assert (ap_prc);
TIZ_INIT_OMX_PORT_STRUCT (port_def, ARATELIA_HTTP_SOURCE_PORT_INDEX);
tiz_check_omx (
tiz_api_GetParameter (tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamPortDefinition, &port_def));
/* Set the new value */
port_def.format.audio.eEncoding = OMX_AUDIO_CodingAutoDetect;
tiz_check_omx (tiz_krn_SetParameter_internal (
tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamPortDefinition, &port_def));
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
prepare_for_port_auto_detection (dirble_prc_t * ap_prc)
{
OMX_PARAM_PORTDEFINITIONTYPE port_def;
assert (ap_prc);
TIZ_INIT_OMX_PORT_STRUCT (port_def, ARATELIA_HTTP_SOURCE_PORT_INDEX);
tiz_check_omx (
tiz_api_GetParameter (tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamPortDefinition, &port_def));
ap_prc->audio_coding_type_ = port_def.format.audio.eEncoding;
ap_prc->auto_detect_on_
= (OMX_AUDIO_CodingAutoDetect == ap_prc->audio_coding_type_) ? true : false;
TIZ_TRACE (
handleOf (ap_prc), "auto_detect_on_ [%s]...audio_coding_type_ [%d]",
ap_prc->auto_detect_on_ ? "true" : "false", ap_prc->audio_coding_type_);
return OMX_ErrorNone;
}
static OMX_ERRORTYPE alloc_temp_data_store (vorbisd_prc_t *ap_prc)
{
OMX_PARAM_PORTDEFINITIONTYPE port_def;
assert (NULL != ap_prc);
port_def.nSize = (OMX_U32)sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
port_def.nVersion.nVersion = OMX_VERSION;
port_def.nPortIndex = ARATELIA_VORBIS_DECODER_INPUT_PORT_INDEX;
tiz_check_omx_err (
tiz_api_GetParameter (tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamPortDefinition, &port_def));
assert (ap_prc->p_store_ == NULL);
ap_prc->store_size_ = port_def.nBufferSize;
tiz_check_null_ret_oom (
(ap_prc->p_store_ = tiz_mem_alloc (ap_prc->store_size_)));
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
sdlivr_prc_prepare_to_transfer (void * ap_obj, OMX_U32 a_pid)
{
sdlivr_prc_t * p_prc = ap_obj;
OMX_PARAM_PORTDEFINITIONTYPE portdef;
TIZ_INIT_OMX_PORT_STRUCT (portdef, ARATELIA_YUV_RENDERER_PORT_INDEX);
assert (p_prc);
/* Retrieve port def from port */
tiz_check_omx (tiz_api_GetParameter (tiz_get_krn (handleOf (p_prc)),
handleOf (p_prc),
OMX_IndexParamPortDefinition, &portdef));
p_prc->port_def_ = portdef.format.video;
TIZ_TRACE (
handleOf (p_prc),
"nFrameWidth = [%u] nFrameHeight = [%u] "
"nStride = [%d] nSliceHeight = [%u] nBitrate = [%u] "
"xFramerate = [%u] eCompressionFormat = [%0x] eColorFormat = [%0x]",
p_prc->port_def_.nFrameWidth, p_prc->port_def_.nFrameHeight,
p_prc->port_def_.nStride, p_prc->port_def_.nSliceHeight,
p_prc->port_def_.nBitrate, p_prc->port_def_.xFramerate,
p_prc->port_def_.eCompressionFormat, p_prc->port_def_.eColorFormat);
SDL_WM_SetCaption ("Tizonia YUV renderer", "YUV");
p_prc->p_surface = SDL_SetVideoMode (
p_prc->port_def_.nFrameWidth, p_prc->port_def_.nFrameHeight, 0,
SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL | SDL_RESIZABLE);
assert (!p_prc->p_overlay);
p_prc->p_overlay = SDL_CreateYUVOverlay (p_prc->port_def_.nFrameWidth,
p_prc->port_def_.nFrameHeight,
SDL_YV12_OVERLAY, p_prc->p_surface);
return p_prc->p_overlay ? OMX_ErrorNone : OMX_ErrorInsufficientResources;
}
static OMX_ERRORTYPE
httpr_prc_allocate_resources (void * ap_prc, OMX_U32 a_pid)
{
httpr_prc_t * p_prc = ap_prc;
assert (p_prc);
/* Retrieve http server configuration from the component's config port */
TIZ_INIT_OMX_STRUCT (p_prc->server_info_);
tiz_check_omx (tiz_api_GetParameter (
tiz_get_krn (handleOf (p_prc)), handleOf (p_prc),
OMX_TizoniaIndexParamHttpServer, &p_prc->server_info_));
return httpr_srv_init (
&(p_prc->p_server_), p_prc, p_prc->server_info_.cBindAddress, /* if this is
* null, the
* server will
* listen on
* all
* interfaces. */
p_prc->server_info_.nListeningPort, p_prc->server_info_.nMaxClients,
buffer_emptied, buffer_needed, p_prc);
}
static OMX_ERRORTYPE
binaryport_GetParameter (const void * ap_obj, OMX_HANDLETYPE ap_hdl,
OMX_INDEXTYPE a_index, OMX_PTR ap_struct)
{
const tiz_binaryport_t * p_obj = ap_obj;
OMX_ERRORTYPE rc = OMX_ErrorNone;
TIZ_TRACE (ap_hdl, "PORT [%d] GetParameter [%s]...", tiz_port_index (ap_obj),
tiz_idx_to_str (a_index));
assert (p_obj);
switch (a_index)
{
case OMX_IndexParamAudioPortFormat:
case OMX_IndexParamVideoPortFormat:
case OMX_IndexParamImagePortFormat:
case OMX_IndexParamOtherPortFormat:
{
/* Delegate to the domain-specific port */
if (OMX_ErrorUnsupportedIndex
!= (rc = tiz_api_GetParameter (p_obj->p_port_, ap_hdl, a_index,
ap_struct)))
{
return rc;
}
}
/* NOTE: Fall through if GetParameter returned
* OMX_ErrorUnsupportedIndex. So that we delegate to the parent */
/*@fallthrough@*/
default:
{
/* Delegate to the base port */
rc = super_GetParameter (typeOf (ap_obj, "tizbinaryport"), ap_obj,
ap_hdl, a_index, ap_struct);
}
};
return rc;
}
static OMX_ERRORTYPE
alloc_uri (oggdmux_prc_t * ap_prc)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
const long pathname_max = PATH_MAX + NAME_MAX;
assert (ap_prc);
assert (!ap_prc->p_uri_);
if (!(ap_prc->p_uri_ = tiz_mem_calloc (
1, sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1)))
{
TIZ_ERROR (handleOf (ap_prc),
"Error allocating memory for the content uri struct");
rc = OMX_ErrorInsufficientResources;
}
else
{
ap_prc->p_uri_->nSize
= sizeof (OMX_PARAM_CONTENTURITYPE) + pathname_max + 1;
ap_prc->p_uri_->nVersion.nVersion = OMX_VERSION;
if (OMX_ErrorNone
!= (rc = tiz_api_GetParameter (
tiz_get_krn (handleOf (ap_prc)), handleOf (ap_prc),
OMX_IndexParamContentURI, ap_prc->p_uri_)))
{
TIZ_ERROR (handleOf (ap_prc),
"[%s] : Error retrieving the URI param from port",
tiz_err_to_str (rc));
}
else
{
TIZ_NOTICE (handleOf (ap_prc), "URI [%s]",
ap_prc->p_uri_->contentURI);
}
}
return rc;
}
