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;
}
/* TODO: Change void to a int for OOM errors */
static void
release_header (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid)
{
OMX_BUFFERHEADERTYPE ** pp_hdr = get_header_ptr (ap_prc, a_pid);
OMX_BUFFERHEADERTYPE * p_hdr = NULL;
p_hdr = *pp_hdr;
assert (p_hdr);
TIZ_TRACE (handleOf (ap_prc),
"Releasing HEADER [%p] pid [%d] "
"nFilledLen [%d] nFlags [%d]",
p_hdr, a_pid, p_hdr->nFilledLen, p_hdr->nFlags);
/* TODO: Check for OOM error and issue Error Event */
p_hdr->nOffset = 0;
(void) tiz_krn_release_buffer (tiz_get_krn (handleOf (ap_prc)), a_pid, p_hdr);
*pp_hdr = NULL;
assert (ap_prc);
ap_prc->awaiting_buffers_ = true;
}
static OMX_ERRORTYPE
demux_file (oggdmux_prc_t * ap_prc)
{
int run_status = 0;
assert (ap_prc);
do
{
run_status
= oggz_read (ap_prc->p_oggz_, TIZ_OGG_DEMUXER_DEFAULT_READ_BLOCKSIZE);
TIZ_TRACE (handleOf (ap_prc), "run_status [%d]", run_status);
}
while (buffers_available (ap_prc) && run_status > 0);
if (0 == run_status) /* This indicates end of file */
{
int remaining = 0;
ap_prc->file_eos_ = true;
/* Try to empty the temp stores out to an omx buffer */
remaining = flush_stores (ap_prc);
TIZ_TRACE (handleOf (ap_prc),
"aud_store_offset [%d] vid_store_offset [%d] - total [%d]",
ap_prc->aud_store_offset_, ap_prc->vid_store_offset_,
remaining);
if (!ap_prc->aud_eos_)
{
ap_prc->aud_eos_ = release_header_with_eos (
ap_prc, ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX);
}
if (!ap_prc->vid_eos_)
{
ap_prc->vid_eos_ = release_header_with_eos (
ap_prc, ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX);
}
}
return OMX_ErrorNone;
}
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
sdlivr_proc_allocate_resources (void *ap_obj, OMX_U32 a_pid)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
if (-1 == SDL_Init (SDL_INIT_VIDEO))
{
rc = OMX_ErrorInsufficientResources;
TIZ_ERROR (handleOf (ap_obj),
"[%s] : while initializing SDL [%s]", tiz_err_to_str (rc),
SDL_GetError ());
}
return rc;
}
static OMX_ERRORTYPE init_vorbis_decoder (vorbisd_prc_t *ap_prc)
{
OMX_ERRORTYPE rc = OMX_ErrorInsufficientResources;
assert (NULL != ap_prc);
tiz_check_null_ret_oom (
ap_prc->p_fsnd_ = fish_sound_new (FISH_SOUND_DECODE, &(ap_prc->fsinfo_)));
if (0 != fish_sound_set_interleave (ap_prc->p_fsnd_, 1))
{
TIZ_ERROR (handleOf (ap_prc),
"[OMX_ErrorInsufficientResources] : "
"Could not set interleaved.");
goto end;
}
if (0 != fish_sound_set_decoded_float_ilv (
ap_prc->p_fsnd_, fishsound_decoded_callback, ap_prc))
{
TIZ_ERROR (handleOf (ap_prc),
"[OMX_ErrorInsufficientResources] : "
"Could not set 'decoded' callback.");
goto end;
}
rc = OMX_ErrorNone;
end:
if (OMX_ErrorInsufficientResources == rc)
{
fish_sound_delete (ap_prc->p_fsnd_);
ap_prc->p_fsnd_ = NULL;
}
return rc;
}
static OMX_ERRORTYPE
transform_buffer (fr_prc_t *ap_prc)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
OMX_BUFFERHEADERTYPE *p_in
= tiz_filter_prc_get_header (ap_prc, ARATELIA_FILE_READER_INPUT_PORT_INDEX);
OMX_BUFFERHEADERTYPE *p_out
= tiz_filter_prc_get_header (ap_prc, ARATELIA_FILE_READER_OUTPUT_PORT_INDEX);
if (NULL == p_in || NULL == p_out)
{
TIZ_TRACE (handleOf (ap_prc), "IN HEADER [%p] OUT HEADER [%p]", p_in,
p_out);
return OMX_ErrorNone;
}
assert (ap_prc);
if (0 == p_in->nFilledLen)
{
TIZ_TRACE (handleOf (ap_prc), "HEADER [%p] nFlags [%d] is empty", p_in,
p_in->nFlags);
if ((p_in->nFlags & OMX_BUFFERFLAG_EOS) > 0)
{
/* Inmediately propagate EOS flag to output */
TIZ_TRACE (handleOf (ap_prc), "Propagate EOS flag to output HEADER [%p]",
p_out);
p_out->nFlags |= OMX_BUFFERFLAG_EOS;
tiz_filter_prc_update_eos_flag (ap_prc, true);
p_in->nFlags = 0;
tiz_check_omx
(tiz_filter_prc_release_header (ap_prc, ARATELIA_FILE_READER_OUTPUT_PORT_INDEX));
}
}
return rc;
}
static OMX_ERRORTYPE
loadedtoidle_trans_complete (const void * ap_obj, OMX_PTR ap_servant,
OMX_STATETYPE a_new_state)
{
const tiz_state_t * p_base = (const tiz_state_t *) ap_obj;
TIZ_TRACE (handleOf (ap_servant), "Trans complete to state [%s]...",
tiz_fsm_state_to_str ((tiz_fsm_state_id_t) a_new_state));
assert (ap_obj);
assert (ap_servant);
assert (OMX_StateIdle == a_new_state);
if (2 == p_base->servants_count_ + 1)
{
/* Reset the OMX_PORTSTATUS_ACCEPTUSEBUFFER flag in all ports where this
* has been set */
tiz_krn_reset_tunneled_ports_status (tiz_get_krn (handleOf (ap_servant)),
OMX_PORTSTATUS_ACCEPTUSEBUFFER);
}
return tiz_state_super_trans_complete (typeOf (ap_obj, "tizloadedtoidle"),
ap_obj, ap_servant, a_new_state);
}
static bool
release_header_with_eos (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid)
{
bool eos_released = false;
OMX_BUFFERHEADERTYPE * p_hdr = get_header (ap_prc, a_pid);
if (p_hdr)
{
TIZ_TRACE (handleOf (ap_prc), "Adding EOS flag - PID [%d]", a_pid);
p_hdr->nFlags |= OMX_BUFFERFLAG_EOS;
release_header (ap_prc, a_pid);
eos_released = true;
}
return eos_released;
}
static void release_input_headers(vid_dec_PrivateType* priv) {
int i;
for (i = 0; i < priv->num_in_buffers; i++) {
assert(!priv->in_port_disabled_);
if (priv->in_buffers[i]->pInputPortPrivate) {
vid_dec_FreeInputPortPrivate(priv->in_buffers[i]);
}
(void) tiz_krn_release_buffer (tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_INPUT_PORT_INDEX,
priv->in_buffers[i]);
priv->in_buffers[i] = NULL;
}
priv->p_inhdr_ = NULL;
priv->num_in_buffers = 0;
}
static OMX_ERRORTYPE
mp3d_proc_stop_and_return (void * ap_obj)
{
mp3d_prc_t * p_obj = ap_obj;
char buffer[80];
assert (ap_obj);
mad_timer_string (p_obj->timer_, buffer, "%lu:%02lu.%03u", MAD_UNITS_MINUTES,
MAD_UNITS_MILLISECONDS, 0);
TIZ_TRACE (handleOf (p_obj), "%lu frames decoded (%s)", p_obj->frame_count_,
buffer);
/* NOTE: de-init the decoder here, as there seems to be no obvious flush
functionality that could be used instead */
deinit_mad_decoder (ap_obj);
return release_headers (p_obj, OMX_ALL);
}
static OMX_BUFFERHEADERTYPE *
buffer_emptied (OMX_PTR ap_arg)
{
dirble_prc_t * p_prc = ap_arg;
OMX_BUFFERHEADERTYPE * p_hdr = NULL;
assert (p_prc);
if (!p_prc->port_disabled_)
{
if (p_prc->p_outhdr_)
{
p_hdr = p_prc->p_outhdr_;
}
else
{
if (OMX_ErrorNone
== (tiz_krn_claim_buffer (tiz_get_krn (handleOf (p_prc)),
ARATELIA_HTTP_SOURCE_PORT_INDEX, 0,
&p_prc->p_outhdr_)))
{
if (p_prc->p_outhdr_)
{
TIZ_TRACE (handleOf (p_prc),
"Claimed HEADER [%p]...nFilledLen [%d]",
p_prc->p_outhdr_, p_prc->p_outhdr_->nFilledLen);
p_hdr = p_prc->p_outhdr_;
}
else
{
TIZ_TRACE (handleOf (p_prc), "No more headers available");
}
}
}
}
return p_hdr;
}
static OMX_ERRORTYPE
dirble_prc_config_change (void * ap_prc, OMX_U32 TIZ_UNUSED (a_pid),
OMX_INDEXTYPE a_config_idx)
{
dirble_prc_t * p_prc = ap_prc;
OMX_ERRORTYPE rc = OMX_ErrorNone;
assert (p_prc);
if (OMX_TizoniaIndexConfigPlaylistSkip == a_config_idx && p_prc->p_trans_)
{
TIZ_INIT_OMX_STRUCT (p_prc->playlist_skip_);
tiz_check_omx (tiz_api_GetConfig (
tiz_get_krn (handleOf (p_prc)), handleOf (p_prc),
OMX_TizoniaIndexConfigPlaylistSkip, &p_prc->playlist_skip_));
p_prc->playlist_skip_.nValue > 0 ? obtain_next_url (p_prc, 1)
: obtain_next_url (p_prc, -1);
/* Changing the URL has the side effect of halting the current
download */
tiz_urltrans_set_uri (p_prc->p_trans_, p_prc->p_uri_param_);
if (p_prc->port_disabled_)
{
/* Record that the URI has changed, so that when the port is
re-enabled, we restart the transfer */
p_prc->uri_changed_ = true;
}
/* Get ready to auto-detect another stream */
set_auto_detect_on_port (p_prc);
prepare_for_port_auto_detection (p_prc);
/* Re-start the transfer */
tiz_urltrans_start (p_prc->p_trans_);
}
return rc;
}
static void
send_port_auto_detect_events (scloud_prc_t * ap_prc)
{
assert (ap_prc);
if (ap_prc->audio_coding_type_ != OMX_AUDIO_CodingUnused
|| ap_prc->audio_coding_type_ != OMX_AUDIO_CodingAutoDetect)
{
TIZ_DEBUG (handleOf (ap_prc), "Issuing OMX_EventPortFormatDetected");
tiz_srv_issue_event ((OMX_PTR) ap_prc, OMX_EventPortFormatDetected, 0, 0,
NULL);
TIZ_DEBUG (handleOf (ap_prc), "Issuing OMX_EventPortSettingsChanged");
tiz_srv_issue_event ((OMX_PTR) ap_prc, OMX_EventPortSettingsChanged,
ARATELIA_HTTP_SOURCE_PORT_INDEX, /* port 0 */
OMX_IndexParamPortDefinition, /* the index of the
struct that has
been modififed */
NULL);
}
else
{
/* Oops... could not detect the stream format */
tiz_srv_issue_err_event ((OMX_PTR) ap_prc, OMX_ErrorFormatNotDetected);
}
}
static inline OMX_ERRORTYPE
set_read_packet_callback (oggdmux_prc_t * ap_prc, long serialno,
OggzReadPacket ap_read_cback)
{
assert (ap_prc);
assert (ap_read_cback);
if (oggz_set_read_callback (ap_prc->p_oggz_, serialno, ap_read_cback, ap_prc)
< 0)
{
TIZ_ERROR (handleOf (ap_prc),
"[OMX_ErrorInsufficientResources] : "
"Could not set read packet callback.");
return OMX_ErrorInsufficientResources;
}
return OMX_ErrorNone;
}
static inline OMX_ERRORTYPE
set_read_page_callback (oggdmux_prc_t * ap_prc, OggzReadPage ap_read_cback)
{
assert (ap_prc);
assert (ap_read_cback);
if (oggz_set_read_page (ap_prc->p_oggz_, ALL_OGG_STREAMS, ap_read_cback,
ap_prc)
< 0)
{
TIZ_ERROR (handleOf (ap_prc),
"[OMX_ErrorInsufficientResources] : "
"Could not set read page callback.");
return OMX_ErrorInsufficientResources;
}
return OMX_ErrorNone;
}
static OMX_ERRORTYPE vorbisd_prc_buffers_ready (const void *ap_obj)
{
vorbisd_prc_t *p_prc = (vorbisd_prc_t *)ap_obj;
OMX_ERRORTYPE rc = OMX_ErrorNone;
assert (NULL != p_prc);
TIZ_TRACE (handleOf (p_prc), "eos [%s] ",
tiz_filter_prc_is_eos (p_prc) ? "YES" : "NO");
while (tiz_filter_prc_headers_available (p_prc) && OMX_ErrorNone == rc)
{
rc = transform_buffer (p_prc);
}
return rc;
}
static OMX_ERRORTYPE
store_metadata (dirble_prc_t * ap_prc, const char * ap_header_name,
const char * ap_header_info)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
OMX_CONFIG_METADATAITEMTYPE * p_meta = NULL;
size_t metadata_len = 0;
size_t info_len = 0;
assert (ap_prc);
if (ap_header_name && ap_header_info)
{
info_len = strnlen (ap_header_info, OMX_MAX_STRINGNAME_SIZE - 1) + 1;
metadata_len = sizeof (OMX_CONFIG_METADATAITEMTYPE) + info_len;
if (NULL == (p_meta = (OMX_CONFIG_METADATAITEMTYPE *) tiz_mem_calloc (
1, metadata_len)))
{
rc = OMX_ErrorInsufficientResources;
}
else
{
const size_t name_len
= strnlen (ap_header_name, OMX_MAX_STRINGNAME_SIZE - 1) + 1;
strncpy ((char *) p_meta->nKey, ap_header_name, name_len - 1);
p_meta->nKey[name_len - 1] = '\0';
p_meta->nKeySizeUsed = name_len;
strncpy ((char *) p_meta->nValue, ap_header_info, info_len - 1);
p_meta->nValue[info_len - 1] = '\0';
p_meta->nValueMaxSize = info_len;
p_meta->nValueSizeUsed = info_len;
p_meta->nSize = metadata_len;
p_meta->nVersion.nVersion = OMX_VERSION;
p_meta->eScopeMode = OMX_MetadataScopeAllLevels;
p_meta->nScopeSpecifier = 0;
p_meta->nMetadataItemIndex = 0;
p_meta->eSearchMode = OMX_MetadataSearchValueSizeByIndex;
p_meta->eKeyCharset = OMX_MetadataCharsetASCII;
p_meta->eValueCharset = OMX_MetadataCharsetASCII;
rc = tiz_krn_store_metadata (tiz_get_krn (handleOf (ap_prc)), p_meta);
}
}
return rc;
}
static int
read_audio_packet (OGGZ * ap_oggz, oggz_packet * ap_zp, long serialno,
void * ap_user_data)
{
oggdmux_prc_t * p_prc = ap_user_data;
int rc = OGGZ_CONTINUE;
assert (ap_user_data);
if (!p_prc->aud_port_disabled_
&& is_audio_content (oggz_stream_get_content (p_prc->p_oggz_, serialno)))
{
rc = read_packet (ap_oggz, ap_zp, serialno, ap_user_data,
ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX);
}
TIZ_TRACE (handleOf (p_prc), "%010lu: rc [%d]", serialno, rc);
return rc;
}
static OMX_ERRORTYPE
mp3d_proc_buffers_ready (const void * ap_obj)
{
mp3d_prc_t * p_obj = (mp3d_prc_t *) ap_obj;
assert (ap_obj);
TIZ_TRACE (handleOf (p_obj), "buffers ready");
while (true)
{
if (!p_obj->p_inhdr_)
{
if ((!claim_input_buffer (p_obj) && p_obj->stream_.next_frame == NULL)
|| (!p_obj->p_inhdr_ && p_obj->stream_.error == MAD_ERROR_BUFLEN))
{
break;
}
}
if (!p_obj->p_outhdr_)
{
if (!claim_output_buffer (p_obj))
{
break;
}
}
tiz_check_omx (decode_buffer (ap_obj));
if (p_obj->p_inhdr_ != NULL && (0 == p_obj->p_inhdr_->nFilledLen))
{
tiz_check_omx (
release_headers (p_obj, ARATELIA_MP3_DECODER_INPUT_PORT_INDEX));
}
}
if (p_obj->eos_ && p_obj->p_outhdr_)
{
/* EOS has been received and all the input data has been consumed
* already, so its time to propagate the EOS flag */
tiz_check_omx (
release_headers (p_obj, ARATELIA_MP3_DECODER_OUTPUT_PORT_INDEX));
}
return OMX_ErrorNone;
}
static inline OMX_ERRORTYPE
seek_to_byte_offset (oggdmux_prc_t * ap_prc, const oggz_off_t a_offset)
{
assert (ap_prc);
/* Reset the internal EOS flags */
ap_prc->aud_eos_ = false;
ap_prc->vid_eos_ = false;
if (oggz_seek (ap_prc->p_oggz_, a_offset, SEEK_SET) == -1)
{
TIZ_ERROR (handleOf (ap_prc),
"[OMX_ErrorInsufficientResources] : "
"Could not seek to [%d] offset",
a_offset);
return OMX_ErrorInsufficientResources;
}
return OMX_ErrorNone;
}
static size_t
og_io_read (void * ap_user_handle, void * ap_buf, size_t n)
{
oggdmux_prc_t * p_prc = ap_user_handle;
FILE * f = NULL;
ssize_t bytes_read = 0;
assert (p_prc);
f = p_prc->p_file_;
bytes_read = read (fileno (f), ap_buf, n);
if (0 == bytes_read)
{
TIZ_TRACE (handleOf (p_prc), "Zero bytes_read buf [%p] n [%d]", ap_buf,
n);
}
return bytes_read;
}
static void h264d_buffer_emptied(vid_dec_PrivateType* priv, OMX_BUFFERHEADERTYPE * p_hdr)
{
assert(priv);
assert(priv->in_buffers[0] == p_hdr);
if (!priv->out_port_disabled_) {
assert (p_hdr->nFilledLen == 0);
p_hdr->nOffset = 0;
if ((p_hdr->nFlags & OMX_BUFFERFLAG_EOS) != 0) {
priv->eos_ = true;
}
(void) tiz_krn_release_buffer (tiz_get_krn (handleOf (priv)), 0, p_hdr);
priv->p_inhdr_ = NULL;
priv->in_buffers[0] = NULL;
}
}
static void
obtain_coding_type (scloud_prc_t * ap_prc, char * ap_info)
{
assert (ap_prc);
assert (ap_info);
TIZ_TRACE (handleOf (ap_prc), "encoding type : [%s]", ap_info);
if (strncasecmp (ap_info, "audio/mpeg", 10) == 0
|| strncasecmp (ap_info, "audio/mpg", 9) == 0
|| strncasecmp (ap_info, "audio/mp3", 9) == 0)
{
ap_prc->audio_coding_type_ = OMX_AUDIO_CodingMP3;
}
else
{
ap_prc->audio_coding_type_ = OMX_AUDIO_CodingUnused;
}
}
static OMX_ERRORTYPE
release_buffer (dirble_prc_t * ap_prc)
{
assert (ap_prc);
if (ap_prc->p_outhdr_)
{
if (ap_prc->eos_)
{
ap_prc->eos_ = false;
ap_prc->p_outhdr_->nFlags |= OMX_BUFFERFLAG_EOS;
}
tiz_check_omx (tiz_krn_release_buffer (
tiz_get_krn (handleOf (ap_prc)), ARATELIA_HTTP_SOURCE_PORT_INDEX,
ap_prc->p_outhdr_));
ap_prc->p_outhdr_ = NULL;
}
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
cc_http_prc_store_stream_metadata (const void * p_obj)
{
cc_http_prc_t * p_prc = (cc_http_prc_t *) p_obj;
cc_prc_t * p_cc_prc = (cc_prc_t *) p_obj;
assert (p_prc);
TIZ_DEBUG (handleOf (p_prc), "store_stream_metadata");
/* Station url */
{
tiz_check_omx (cc_prc_store_display_title (
p_cc_prc, "Station", (const char *) p_prc->p_content_uri_->contentURI));
tiz_check_omx (cc_prc_store_stream_metadata_item (
p_cc_prc, "Station", (const char *) p_prc->p_content_uri_->contentURI));
}
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
release_output_header (mp4dmuxflt_prc_t * ap_prc, const OMX_U32 a_pid)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
if (tiz_filter_prc_is_port_enabled (ap_prc, a_pid))
{
OMX_BUFFERHEADERTYPE * p_hdr = tiz_filter_prc_get_header (ap_prc, a_pid);
assert (ap_prc);
if (p_hdr)
{
TIZ_DEBUG (handleOf (ap_prc), "p_hdr [%p] nFilledLen [%u]", p_hdr,
p_hdr->nFilledLen);
propagate_eos_if_required (ap_prc, p_hdr);
rc = tiz_filter_prc_release_header (ap_prc, a_pid);
}
}
return rc;
}
static OMX_ERRORTYPE
update_metadata (dirble_prc_t * ap_prc)
{
assert (ap_prc);
/* Clear previous metatada items */
tiz_krn_clear_metadata (tiz_get_krn (handleOf (ap_prc)));
/* Station Name */
tiz_check_omx (
store_metadata (ap_prc, "Station",
tiz_dirble_get_current_station_name (ap_prc->p_dirble_)));
/* Country */
tiz_check_omx (store_metadata (
ap_prc, "URL", (const char *) ap_prc->p_uri_param_->contentURI));
/* Country */
tiz_check_omx (store_metadata (
ap_prc, "Country",
tiz_dirble_get_current_station_country (ap_prc->p_dirble_)));
/* Category */
tiz_check_omx (store_metadata (
ap_prc, "Categories",
tiz_dirble_get_current_station_category (ap_prc->p_dirble_)));
/* Website */
tiz_check_omx (store_metadata (
ap_prc, "Website",
tiz_dirble_get_current_station_website (ap_prc->p_dirble_)));
/* Signal that a new set of metatadata items is available */
(void) tiz_srv_issue_event ((OMX_PTR) ap_prc, OMX_EventIndexSettingChanged,
OMX_ALL, /* no particular port associated */
OMX_IndexConfigMetadataItem, /* index of the
struct that has
been modififed */
NULL);
return OMX_ErrorNone;
}
static bool
binaryport_check_tunnel_compat (const void * ap_obj,
OMX_PARAM_PORTDEFINITIONTYPE * ap_this_def,
OMX_PARAM_PORTDEFINITIONTYPE * ap_other_def)
{
tiz_port_t * p_obj = (tiz_port_t *) ap_obj;
assert (ap_this_def);
assert (ap_other_def);
if (ap_other_def->eDomain != ap_this_def->eDomain)
{
TIZ_ERROR (handleOf (ap_obj),
"port [%d] check_tunnel_compat : Different domain found [%d]",
p_obj->pid_, ap_other_def->eDomain);
return false;
}
return true;
}
/* TODO: move this functionality to tiz_filter_prc_t */
static OMX_ERRORTYPE
release_input_header (mp4dmuxflt_prc_t * ap_prc)
{
OMX_ERRORTYPE rc = OMX_ErrorNone;
OMX_BUFFERHEADERTYPE * p_hdr = get_mp4_hdr (ap_prc);
assert (ap_prc);
if (p_hdr)
{
TIZ_DEBUG (handleOf (ap_prc), "[%p] nFlags [%d]", p_hdr, p_hdr->nFlags);
if ((p_hdr->nFlags & OMX_BUFFERFLAG_EOS) > 0)
{
tiz_filter_prc_update_eos_flag (ap_prc, true);
p_hdr->nFlags &= ~(1 << OMX_BUFFERFLAG_EOS);
}
rc = tiz_filter_prc_release_header (
ap_prc, ARATELIA_MP4_DEMUXER_FILTER_PORT_0_INDEX);
}
return rc;
}
