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; }