static int
read_page_first_pass (OGGZ * ap_oggz, const ogg_page * ap_og, long a_serialno,
void * ap_user_data)
{
int rc = OGGZ_CONTINUE;
oggdmux_prc_t * p_prc = ap_user_data;
assert (p_prc);
assert (ap_oggz);
if (oggz_get_bos (ap_oggz, a_serialno) > 0)
{
TIZ_TRACE (handleOf (p_prc), "serialno = [%d]", a_serialno);
if (!oggz_table_insert (
p_prc->p_tracks_, a_serialno,
&read_page_first_pass)) /* NULL makes it barf, needs
* something */
{
TIZ_ERROR (handleOf (p_prc),
"serialno = [%d] - "
"Could not insert serialno in oggz table",
a_serialno);
rc = OGGZ_STOP_ERR;
}
}
if (oggz_get_bos (ap_oggz, ALL_OGG_STREAMS) == 0)
{
TIZ_TRACE (handleOf (p_prc), "Number of tracks [%d]",
oggz_get_numtracks (ap_oggz));
return OGGZ_STOP_OK;
}
return rc;
}
static OMX_ERRORTYPE httpr_mp3port_SetParameter (const void *ap_obj,
OMX_HANDLETYPE ap_hdl,
OMX_INDEXTYPE a_index,
OMX_PTR ap_struct)
{
httpr_mp3port_t *p_obj = (httpr_mp3port_t *)ap_obj;
OMX_ERRORTYPE rc = OMX_ErrorNone;
TIZ_TRACE (ap_hdl, "[%s]...", tiz_idx_to_str (a_index));
assert (NULL != p_obj);
if (OMX_TizoniaIndexParamIcecastMountpoint == a_index)
{
memcpy (&(p_obj->mountpoint_), ap_struct,
sizeof(OMX_TIZONIA_ICECASTMOUNTPOINTTYPE));
p_obj->mountpoint_.cStationName[OMX_MAX_STRINGNAME_SIZE - 1] = '\000';
p_obj->mountpoint_.cStationDescription[OMX_MAX_STRINGNAME_SIZE - 1]
= '\000';
p_obj->mountpoint_.cStationGenre[OMX_MAX_STRINGNAME_SIZE - 1] = '\000';
p_obj->mountpoint_.cStationUrl[OMX_MAX_STRINGNAME_SIZE - 1] = '\000';
TIZ_TRACE (ap_hdl, "Station Name [%s]...",
p_obj->mountpoint_.cStationName);
}
else
{
/* Try the parent's indexes */
rc = super_SetParameter (typeOf (ap_obj, "httprmp3port"), ap_obj, ap_hdl,
a_index, ap_struct);
}
return rc;
}
static bool
claim_input_buffer (mp3d_prc_t * ap_prc)
{
bool rc = false;
assert (ap_prc);
if (!ap_prc->in_port_disabled_)
{
if (OMX_ErrorNone
== tiz_krn_claim_buffer (tiz_get_krn (handleOf (ap_prc)), 0, 0,
&ap_prc->p_inhdr_))
{
if (ap_prc->p_inhdr_)
{
TIZ_TRACE (handleOf (ap_prc),
"Claimed INPUT HEADER [%p]...nFilledLen [%d] "
"OUTPUT HEADER [%p]...nFilledLen [%d]",
ap_prc->p_inhdr_, ap_prc->p_inhdr_->nFilledLen,
ap_prc->p_outhdr_,
ap_prc->p_outhdr_ ? ap_prc->p_outhdr_->nFilledLen : 0);
rc = true;
}
else
{
TIZ_TRACE (handleOf (ap_prc), "No INPUT headers available");
}
}
}
return rc;
}
static bool
claim_output_buffer (mp3d_prc_t * ap_prc)
{
bool rc = false;
assert (ap_prc);
if (!ap_prc->out_port_disabled_)
{
if (OMX_ErrorNone
== tiz_krn_claim_buffer (tiz_get_krn (handleOf (ap_prc)), 1, 0,
&ap_prc->p_outhdr_))
{
if (ap_prc->p_outhdr_)
{
TIZ_TRACE (handleOf (ap_prc),
"Claimed OUTPUT HEADER [%p] BUFFER [%p] "
"nFilledLen [%d]...",
ap_prc->p_outhdr_, ap_prc->p_outhdr_->pBuffer,
ap_prc->p_outhdr_->nFilledLen);
rc = true;
}
else
{
TIZ_TRACE (handleOf (ap_prc), "No OUTPUT headers available");
}
}
}
return rc;
}
static void
buffer_emptied (OMX_BUFFERHEADERTYPE * ap_hdr, void * ap_arg)
{
httpr_prc_t * p_prc = ap_arg;
assert (p_prc);
assert (ap_hdr);
assert (p_prc->p_inhdr_ == ap_hdr);
assert (ap_hdr->nFilledLen == 0);
ap_hdr->nOffset = 0;
TIZ_TRACE (handleOf (p_prc), "HEADER [%p]", ap_hdr);
if ((ap_hdr->nFlags & OMX_BUFFERFLAG_EOS) != 0)
{
TIZ_TRACE (handleOf (p_prc), "OMX_BUFFERFLAG_EOS in HEADER [%p]", ap_hdr);
tiz_srv_issue_event ((OMX_PTR) p_prc, OMX_EventBufferFlag,
ARATELIA_HTTP_RENDERER_PORT_INDEX, ap_hdr->nFlags,
NULL);
}
tiz_krn_release_buffer (tiz_get_krn (handleOf (p_prc)),
ARATELIA_HTTP_RENDERER_PORT_INDEX, ap_hdr);
p_prc->p_inhdr_ = NULL;
}
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 int
read_packet (OGGZ * ap_oggz, oggz_packet * ap_zp, long serialno,
void * ap_user_data, const OMX_U32 a_pid)
{
oggdmux_prc_t * p_prc = ap_user_data;
OMX_U32 op_offset = 0;
bool * p_eos = NULL;
ogg_packet * p_op = NULL;
int rc = OGGZ_CONTINUE;
assert (ap_oggz);
assert (ap_zp);
assert (p_prc);
assert (a_pid <= ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX);
p_op = &(ap_zp->op);
p_eos = get_eos_ptr (p_prc, a_pid);
TIZ_TRACE (handleOf (p_prc), "%010lu: pid [%d] reading bytes [%d]", serialno,
a_pid, p_op->bytes);
#ifdef _DEBUG
if (a_pid == ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX)
{
g_total_read += p_op->bytes;
g_last_read = p_op->bytes;
}
#endif
if (oggz_get_eos (ap_oggz, serialno) == 1)
{
TIZ_TRACE (handleOf (p_prc), "%010lu: This is EOS\n", serialno);
*p_eos = true;
}
/* Try to empty the ogg packet out to an omx buffer */
op_offset = flush_ogg_packet (p_prc, a_pid, p_op->packet, p_op->bytes);
if (0 == op_offset)
{
if (*p_eos || !get_header (p_prc, a_pid)
|| (*get_store_offset_ptr (p_prc, a_pid)) > 0)
{
rc = OGGZ_STOP_OK;
}
else
{
rc = OGGZ_CONTINUE;
}
}
else /* (op_offset != 0) */
{
rc = OGGZ_STOP_ERR;
}
TIZ_TRACE (handleOf (p_prc), "%010lu: rc [%d] op_offset [%d]", serialno, rc,
op_offset);
return rc;
}
static void
obtain_audio_encoding_from_headers (scloud_prc_t * ap_prc,
const char * ap_header, const size_t a_size)
{
assert (ap_prc);
assert (ap_header);
{
const char * p_end = ap_header + a_size;
const char * p_value = (const char *) memchr (ap_header, ':', a_size);
char name[64];
if (p_value && (size_t) (p_value - ap_header) < sizeof (name))
{
memcpy (name, ap_header, p_value - ap_header);
name[p_value - ap_header] = 0;
/* skip the colon */
++p_value;
/* strip the value */
while (p_value < p_end && !is_valid_character (*p_value))
{
++p_value;
}
while (p_end > p_value && !is_valid_character (p_end[-1]))
{
--p_end;
}
{
char * p_info = tiz_mem_calloc (1, (p_end - p_value) + 1);
memcpy (p_info, p_value, p_end - p_value);
p_info[(p_end - p_value)] = '\0';
TIZ_TRACE (handleOf (ap_prc), "header name : [%s]", name);
TIZ_TRACE (handleOf (ap_prc), "header value : [%s]", p_info);
if (strncasecmp (name, "Content-Type", 12) == 0)
{
obtain_coding_type (ap_prc, p_info);
/* Now set the new coding type value on the output port */
(void) set_audio_coding_on_port (ap_prc);
}
else if (strncasecmp (name, "Content-Length", 14) == 0)
{
obtain_content_length (ap_prc, p_info);
}
tiz_mem_free (p_info);
}
}
}
}
static OMX_ERRORTYPE
release_headers (const void * ap_obj, OMX_U32 a_pid)
{
mp3d_prc_t * p_obj = (mp3d_prc_t *) ap_obj;
assert (ap_obj);
if (OMX_ALL == a_pid || ARATELIA_MP3_DECODER_INPUT_PORT_INDEX == a_pid)
{
if (p_obj->p_inhdr_)
{
if ((p_obj->p_inhdr_->nFlags & OMX_BUFFERFLAG_EOS) != 0)
{
TIZ_TRACE (handleOf (ap_obj), "EOS received");
p_obj->eos_ = true;
}
p_obj->p_inhdr_->nOffset = 0;
tiz_check_omx (tiz_krn_release_buffer (
tiz_get_krn (handleOf (ap_obj)),
ARATELIA_MP3_DECODER_INPUT_PORT_INDEX, p_obj->p_inhdr_));
p_obj->p_inhdr_ = NULL;
p_obj->remaining_ = 0;
}
}
if (OMX_ALL == a_pid || ARATELIA_MP3_DECODER_OUTPUT_PORT_INDEX == a_pid)
{
if (p_obj->p_outhdr_)
{
if (p_obj->eos_)
{
/* EOS has been received and all the input data has been consumed
* already, so its time to propagate the EOS flag */
p_obj->p_outhdr_->nFlags |= OMX_BUFFERFLAG_EOS;
p_obj->eos_ = false;
}
TIZ_TRACE (
handleOf (p_obj),
"Releasing output HEADER [%p] nFilledLen [%d] nAllocLen [%d]",
p_obj->p_outhdr_, p_obj->p_outhdr_->nFilledLen,
p_obj->p_outhdr_->nAllocLen);
tiz_check_omx (tiz_krn_release_buffer (
tiz_get_krn (handleOf (ap_obj)),
ARATELIA_MP3_DECODER_OUTPUT_PORT_INDEX, p_obj->p_outhdr_));
p_obj->p_outhdr_ = NULL;
}
}
return OMX_ErrorNone;
}
static OMX_ERRORTYPE httpr_mp3port_SetConfig (const void *ap_obj,
OMX_HANDLETYPE ap_hdl,
OMX_INDEXTYPE a_index,
OMX_PTR ap_struct)
{
httpr_mp3port_t *p_obj = (httpr_mp3port_t *)ap_obj;
OMX_ERRORTYPE rc = OMX_ErrorNone;
TIZ_TRACE (ap_hdl, "[%s]...", tiz_idx_to_str (a_index));
assert (NULL != p_obj);
if (OMX_TizoniaIndexConfigIcecastMetadata == a_index)
{
OMX_TIZONIA_ICECASTMETADATATYPE *p_metadata
= (OMX_TIZONIA_ICECASTMETADATATYPE *)ap_struct;
OMX_U32 stream_title_len
= strnlen ((char *)p_metadata->cStreamTitle,
OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE + 1);
if (stream_title_len > OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE)
{
rc = OMX_ErrorBadParameter;
}
else
{
TIZ_TRACE (ap_hdl, "stream_title_len [%d] Stream title [%s]...",
stream_title_len, p_metadata->cStreamTitle);
tiz_mem_free (p_obj->p_stream_title_);
p_obj->p_stream_title_ = tiz_mem_calloc (1, stream_title_len + 1);
if (NULL != p_obj->p_stream_title_)
{
strncpy (p_obj->p_stream_title_, (char *)p_metadata->cStreamTitle,
stream_title_len);
p_obj->p_stream_title_[stream_title_len] = '\000';
}
TIZ_TRACE (ap_hdl, "stream_title_len [%d] Stream title [%s]...",
stream_title_len, p_obj->p_stream_title_);
}
}
else
{
/* Delegate to the base port */
rc = super_SetConfig (typeOf (ap_obj, "httprmp3port"), ap_obj, ap_hdl,
a_index, ap_struct);
}
return rc;
}
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 int
store_data (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid, const OMX_U8 * ap_data,
OMX_U32 a_nbytes)
{
OMX_U8 ** pp_store = NULL;
OMX_U32 * p_offset = NULL;
OMX_U32 * p_size = NULL;
OMX_U32 nbytes_to_copy = 0;
OMX_U32 nbytes_avail = 0;
assert (ap_prc);
assert (a_pid <= ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX);
assert (ap_data);
pp_store = get_store_ptr (ap_prc, a_pid);
p_size = get_store_size_ptr (ap_prc, a_pid);
p_offset = get_store_offset_ptr (ap_prc, a_pid);
assert (pp_store && *pp_store);
assert (p_size);
assert (p_offset);
nbytes_avail = *p_size - *p_offset;
if (a_nbytes > nbytes_avail)
{
/* need to re-alloc */
OMX_U8 * p_new_store = NULL;
p_new_store = tiz_mem_realloc (*pp_store, *p_offset + a_nbytes);
if (p_new_store)
{
*pp_store = p_new_store;
*p_size = *p_offset + a_nbytes;
nbytes_avail = *p_size - *p_offset;
TIZ_TRACE (handleOf (ap_prc),
"pid [%d] : Realloc'd data store "
"to new size [%d]",
a_pid, *p_size);
}
}
nbytes_to_copy = MIN (nbytes_avail, a_nbytes);
memcpy (*pp_store + *p_offset, ap_data, nbytes_to_copy);
*p_offset += nbytes_to_copy;
TIZ_TRACE (handleOf (ap_prc), "pid [%d]: bytes currently stored [%d]", a_pid,
*p_offset);
return a_nbytes - nbytes_to_copy;
}
static int
flush_ogg_packet (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid,
const OMX_U8 * ap_ogg_data, const OMX_U32 nbytes)
{
OMX_BUFFERHEADERTYPE * p_hdr = NULL;
OMX_U32 nbytes_remaining = nbytes;
OMX_U32 nbytes_copied = 0;
OMX_U32 op_offset = 0;
while ((p_hdr = get_header (ap_prc, a_pid)))
{
nbytes_copied = dump_ogg_data (ap_prc, a_pid, ap_ogg_data + op_offset,
nbytes_remaining, p_hdr);
nbytes_remaining -= nbytes_copied;
op_offset += nbytes_copied;
#ifdef _DEBUG
if (a_pid == ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX)
{
g_total_released += p_hdr->nFilledLen;
OMX_U32 * p_offset = get_store_offset_ptr (ap_prc, a_pid);
TIZ_TRACE (handleOf (ap_prc),
"total released [%d] "
"total read [%d] store [%d] last read [%d] "
"remaining [%d] diff [%d]",
g_total_released, g_total_read, *p_offset, g_last_read,
nbytes_remaining,
g_total_read - (g_total_released + nbytes_remaining));
}
#endif
release_header (ap_prc, a_pid);
p_hdr = 0;
if (0 == nbytes_remaining)
{
break;
}
}
if (nbytes_remaining > 0)
{
/* Need_more_buffers. Temporarily store the data until an omx buffer is
* available */
TIZ_TRACE (handleOf (ap_prc), "Need to store [%d] bytes - pid [%d]",
nbytes_remaining, a_pid);
nbytes_remaining
= store_data (ap_prc, a_pid, ap_ogg_data + op_offset, nbytes_remaining);
}
return nbytes_remaining;
}
static bool
ivrport_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] : Video domain not found, instead found domain [%d]",
p_obj->pid_, ap_other_def->eDomain);
return false;
}
/* TODO : Review these compatibility checks */
TIZ_TRACE (handleOf (ap_obj), "PORT [%d] check_tunnel_compat [OK]",
p_obj->pid_);
return true;
}
static OMX_BUFFERHEADERTYPE *
buffer_needed (void * ap_arg)
{
httpr_prc_t * p_prc = ap_arg;
OMX_BUFFERHEADERTYPE * p_hdr = NULL;
assert (p_prc);
if (!p_prc->port_disabled_)
{
if (!p_prc->p_inhdr_)
{
(void) tiz_krn_claim_buffer (tiz_get_krn (handleOf (p_prc)),
ARATELIA_HTTP_RENDERER_PORT_INDEX, 0,
&p_prc->p_inhdr_);
if (p_prc->p_inhdr_)
{
TIZ_TRACE (handleOf (p_prc),
"Claimed HEADER [%p]...nFilledLen [%d]",
p_prc->p_inhdr_, p_prc->p_inhdr_->nFilledLen);
}
}
p_hdr = p_prc->p_inhdr_;
}
/* p_prc->awaiting_buffers_ = p_hdr ? false : true; */
return p_hdr;
}
static OMX_ERRORTYPE
oggdmux_prc_buffers_ready (const void * ap_obj)
{
oggdmux_prc_t * p_prc = (oggdmux_prc_t *) ap_obj;
OMX_ERRORTYPE rc = OMX_ErrorNone;
assert (p_prc);
TIZ_TRACE (handleOf (p_prc),
"awaiting_buffers [%s] aud eos [%s] "
"vid eos [%s]",
p_prc->awaiting_buffers_ ? "YES" : "NO",
p_prc->aud_eos_ ? "YES" : "NO", p_prc->vid_eos_ ? "YES" : "NO");
if (p_prc->awaiting_buffers_ && (!p_prc->aud_eos_ || !p_prc->vid_eos_))
{
/* Make sure we have flushed the temp buffers before reading any more
* data from file */
if (flush_stores (p_prc) == 0)
{
p_prc->awaiting_buffers_ = true;
rc = demux_file (p_prc);
}
}
return rc;
}
static OMX_ERRORTYPE
oggdmux_prc_port_disable (const void * ap_obj, OMX_U32 a_pid)
{
oggdmux_prc_t * p_prc = (oggdmux_prc_t *) ap_obj;
bool * p_port_disabled = NULL;
assert (p_prc);
assert (a_pid <= ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX);
if (OMX_ALL == a_pid)
{
p_port_disabled = get_port_disabled_ptr (
p_prc, ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX);
*p_port_disabled = true;
p_port_disabled = get_port_disabled_ptr (
p_prc, ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX);
*p_port_disabled = true;
}
else
{
p_port_disabled = get_port_disabled_ptr (p_prc, a_pid);
*p_port_disabled = true;
}
/* Release any buffers held */
TIZ_TRACE (handleOf (p_prc), "port_disable");
return release_all_buffers (p_prc, a_pid);
}
static size_t
read_from_omx_buffer (const mp3d_prc_t * ap_prc, void * ap_dst, size_t bytes,
OMX_BUFFERHEADERTYPE * ap_hdr)
{
size_t to_read = bytes;
assert (ap_dst);
assert (ap_hdr);
if (bytes > 0)
{
if (ap_hdr->nFilledLen < bytes)
{
to_read = ap_hdr->nFilledLen;
}
if (to_read > 0)
{
memcpy (ap_dst, ap_hdr->pBuffer + ap_hdr->nOffset, to_read);
TIZ_TRACE (handleOf (ap_prc),
"bytes [%d] to_read [%d] nOffset [%d] nFilledLen [%d] "
"nAllocLen [%d]",
bytes, to_read, ap_hdr->nOffset, ap_hdr->nFilledLen,
ap_hdr->nAllocLen);
}
ap_hdr->nFilledLen -= to_read;
ap_hdr->nOffset += to_read;
}
return to_read;
}
static OMX_ERRORTYPE
sdlivr_proc_buffers_ready (const void *ap_obj)
{
OMX_BUFFERHEADERTYPE *p_hdr = NULL;
if (OMX_ErrorNone == tiz_krn_claim_buffer
(tiz_get_krn (handleOf (ap_obj)), 0, 0, &p_hdr))
{
if (NULL != p_hdr)
{
tiz_check_omx_err (sdlivr_proc_render_buffer (ap_obj, p_hdr));
if (p_hdr->nFlags & OMX_BUFFERFLAG_EOS)
{
TIZ_TRACE (handleOf (ap_obj),
"OMX_BUFFERFLAG_EOS in HEADER [%p]", p_hdr);
tiz_srv_issue_event ((OMX_PTR) ap_obj,
OMX_EventBufferFlag,
0, p_hdr->nFlags, NULL);
}
tiz_check_omx_err
(tiz_krn_release_buffer (tiz_get_krn (handleOf (ap_obj)), 0, p_hdr));
}
}
return OMX_ErrorNone;
}
static int
mp4_write_cback (void * handle, const void * buffer, int64_t size, int64_t * nout,
int64_t maxChunkSize)
{
TIZ_TRACE(handleOf(gp_prc), "");
return 0;
}
OMX_ERRORTYPE
tiz_os_init (tiz_os_t ** app_os, const OMX_HANDLETYPE ap_hdl,
tiz_soa_t * ap_soa)
{
tiz_os_t * p_os = NULL;
assert (app_os);
assert (ap_hdl);
TIZ_TRACE (ap_hdl, "Init");
if (NULL == (p_os = (tiz_os_t *) os_calloc (ap_soa, sizeof (tiz_os_t))))
{
return OMX_ErrorInsufficientResources;
}
assert (p_os);
if (OMX_ErrorNone != tiz_map_init (&(p_os->p_map), os_map_compare_func,
os_map_free_func, NULL))
{
os_free (ap_soa, p_os);
p_os = NULL;
return OMX_ErrorInsufficientResources;
}
p_os->p_hdl = ap_hdl;
p_os->p_soa = ap_soa;
*app_os = p_os;
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
sdlivr_prc_buffers_ready (const void * ap_obj)
{
sdlivr_prc_t * p_prc = (sdlivr_prc_t *) ap_obj;
OMX_BUFFERHEADERTYPE * p_hdr = NULL;
void * p_krn = tiz_get_krn (handleOf (ap_obj));
assert (p_prc);
if (!p_prc->port_disabled_)
{
tiz_check_omx (tiz_krn_claim_buffer (
p_krn, ARATELIA_YUV_RENDERER_PORT_INDEX, 0, &p_hdr));
while (!p_prc->port_disabled_ && p_hdr)
{
if (p_hdr)
{
tiz_check_omx (sdlivr_prc_render_buffer (ap_obj, p_hdr));
if (p_hdr->nFlags & OMX_BUFFERFLAG_EOS)
{
TIZ_TRACE (handleOf (ap_obj),
"OMX_BUFFERFLAG_EOS in HEADER [%p]", p_hdr);
tiz_srv_issue_event ((OMX_PTR) ap_obj, OMX_EventBufferFlag, 0,
p_hdr->nFlags, NULL);
}
tiz_check_omx (tiz_krn_release_buffer (
p_krn, ARATELIA_YUV_RENDERER_PORT_INDEX, p_hdr));
tiz_check_omx (tiz_krn_claim_buffer (
p_krn, ARATELIA_YUV_RENDERER_PORT_INDEX, 0, &p_hdr));
}
}
}
return OMX_ErrorNone;
}
static OMX_U32
dump_ogg_data (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid,
const OMX_U8 * ap_ogg_data, const OMX_U32 a_nbytes,
OMX_BUFFERHEADERTYPE * ap_hdr)
{
OMX_U32 nbytes_copied = 0;
OMX_U32 nbytes_avail = 0;
assert (ap_prc);
assert (a_pid <= ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX);
assert (ap_ogg_data);
assert (ap_hdr);
assert (ap_hdr->nAllocLen >= ap_hdr->nFilledLen);
nbytes_avail = ap_hdr->nAllocLen - ap_hdr->nFilledLen;
nbytes_copied = MIN (a_nbytes, nbytes_avail);
if (nbytes_copied > 0)
{
memcpy (ap_hdr->pBuffer + ap_hdr->nFilledLen, ap_ogg_data, nbytes_copied);
ap_hdr->nFilledLen += nbytes_copied;
}
TIZ_TRACE (handleOf (ap_prc),
"HEADER [%p] pid [%d] nbytes [%d] "
"nbytes_copied [%d] nFilledLen [%d]",
ap_hdr, a_pid, a_nbytes, nbytes_copied, ap_hdr->nFilledLen);
return nbytes_copied;
}
static OMX_BUFFERHEADERTYPE *
get_header (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid)
{
OMX_BUFFERHEADERTYPE * p_hdr = NULL;
bool port_disabled = *(get_port_disabled_ptr (ap_prc, a_pid));
if (!port_disabled)
{
OMX_BUFFERHEADERTYPE ** pp_hdr = get_header_ptr (ap_prc, a_pid);
p_hdr = *pp_hdr;
if (!p_hdr)
{
if (OMX_ErrorNone
== tiz_krn_claim_buffer (tiz_get_krn (handleOf (ap_prc)), a_pid,
0, pp_hdr))
{
p_hdr = *pp_hdr;
if (p_hdr)
{
TIZ_TRACE (handleOf (ap_prc),
"Claimed HEADER [%p] pid [%d] nFilledLen [%d]",
p_hdr, a_pid, p_hdr->nFilledLen);
}
}
}
if (!p_hdr)
{
ap_prc->awaiting_buffers_ = true;
}
}
return p_hdr;
}
static OMX_ERRORTYPE
cc_youtube_cfgport_GetParameter (const void * ap_obj, OMX_HANDLETYPE ap_hdl,
OMX_INDEXTYPE a_index, OMX_PTR ap_struct)
{
const cc_youtube_cfgport_t * p_obj = ap_obj;
OMX_ERRORTYPE rc = OMX_ErrorNone;
assert (p_obj);
TIZ_TRACE (ap_hdl, "PORT [%d] GetParameter [%s]...", tiz_port_index (ap_obj),
tiz_idx_to_str (a_index));
if (OMX_TizoniaIndexParamAudioYoutubeSession == a_index)
{
memcpy (ap_struct, &(p_obj->session_),
sizeof (OMX_TIZONIA_AUDIO_PARAM_YOUTUBESESSIONTYPE));
}
else if (OMX_TizoniaIndexParamAudioYoutubePlaylist == a_index)
{
memcpy (ap_struct, &(p_obj->playlist_),
sizeof (OMX_TIZONIA_AUDIO_PARAM_YOUTUBEPLAYLISTTYPE));
}
else
{
/* Delegate to the base port */
rc = super_GetParameter (typeOf (ap_obj, "cc_youtubecfgport"), ap_obj,
ap_hdl, a_index, ap_struct);
}
return rc;
}
static OMX_ERRORTYPE
os_register_type (tiz_os_t * ap_os, const tiz_os_type_init_f a_type_init_f,
const char * a_type_name, const OMX_S32 a_type_id)
{
OMX_ERRORTYPE rc = OMX_ErrorInsufficientResources;
void * p_obj = NULL;
assert (ap_os);
assert (ap_os->p_map);
assert (a_type_init_f);
assert (a_type_name);
assert (strnlen (a_type_name, OMX_MAX_STRINGNAME_SIZE)
< OMX_MAX_STRINGNAME_SIZE);
assert (a_type_id >= 0);
/* Call the type init function */
p_obj = a_type_init_f (ap_os, ap_os->p_hdl);
if (p_obj)
{
/* Register the class or object type */
TIZ_TRACE (ap_os->p_hdl,
"Registering type #[%d] : [%s] -> [%p] "
"nameOf [%s]",
a_type_id, a_type_name, p_obj, nameOf (p_obj));
rc = tiz_map_insert (ap_os->p_map, os_strndup (ap_os->p_soa, a_type_name,
OMX_MAX_STRINGNAME_SIZE),
p_obj, (OMX_U32 *) (&a_type_id));
}
/* print_types (ap_os); */
return rc;
}
static OMX_ERRORTYPE
pausetoidle_tunneled_ports_status_update (void *ap_obj)
{
tiz_state_t *p_base = (tiz_state_t *) ap_obj;
assert (NULL != ap_obj);
{
OMX_HANDLETYPE p_hdl = handleOf(p_base->p_fsm_);
void *p_krn = tiz_get_krn (p_hdl);
if (TIZ_KRN_MAY_INIT_EXE_TO_IDLE (p_krn))
{
/* OK, at this point all the tunneled non-supplier neighboring ports
are ready to receive ETB/FTB calls. NOTE: This will call the
* 'tiz_state_state_set' function of the tiz_state_t base class (note
* we are passing 'tizidle' as 1st parameter */
TIZ_TRACE (p_hdl, "kernel may initiate pause to idle");
return tiz_state_super_state_set (typeOf (ap_obj, "tizidle"), ap_obj, p_hdl,
OMX_CommandStateSet,
OMX_StateIdle, NULL);
}
}
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
pausetoidle_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_obj),
"Trans complete to state [%s]...",
tiz_fsm_state_to_str (a_new_state));
assert (OMX_StateIdle == a_new_state);
assert (NULL != ap_obj);
assert (NULL != ap_servant);
assert (OMX_StateIdle == a_new_state);
if (2 == p_base->servants_count_ + 1)
{
/* Reset the OMX_TIZONIA_PORTSTATUS_AWAITBUFFERSRETURN flag in all ports
where this has been set */
tiz_krn_reset_tunneled_ports_status
(tiz_get_krn (handleOf(ap_servant)),
OMX_TIZONIA_PORTSTATUS_AWAITBUFFERSRETURN);
}
return tiz_state_super_trans_complete (typeOf (ap_obj, "tizpausetoidle"), ap_obj, ap_servant,
a_new_state);
}
static OMX_ERRORTYPE httpr_mp3port_GetParameter (const void *ap_obj,
OMX_HANDLETYPE ap_hdl,
OMX_INDEXTYPE a_index,
OMX_PTR ap_struct)
{
const httpr_mp3port_t *p_obj = ap_obj;
OMX_ERRORTYPE rc = OMX_ErrorNone;
TIZ_TRACE (ap_hdl, "[%s]...", tiz_idx_to_str (a_index));
assert (NULL != p_obj);
if (OMX_TizoniaIndexParamIcecastMountpoint == a_index)
{
memcpy (ap_struct, &(p_obj->mountpoint_),
sizeof(OMX_TIZONIA_ICECASTMOUNTPOINTTYPE));
}
else
{
/* Delegate to the base port */
rc = super_GetParameter (typeOf (ap_obj, "httprmp3port"), ap_obj, ap_hdl,
a_index, ap_struct);
}
return rc;
}
static int
convert_str_to_int (scloud_prc_t * ap_prc, const char * ap_start,
char ** ap_end)
{
long val = -1;
assert (ap_prc);
assert (ap_start);
assert (ap_end);
errno = 0;
val = strtol (ap_start, ap_end, 0);
if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN))
|| (errno != 0 && val == 0))
{
TIZ_ERROR (handleOf (ap_prc),
"Error retrieving the number of channels : [%s]",
strerror (errno));
}
else if (*ap_end == ap_start)
{
TIZ_ERROR (handleOf (ap_prc),
"Error retrieving the number of channels : "
"[No digits were found]");
}
TIZ_TRACE (handleOf (ap_prc), "Value : [%d]", val);
return val;
}
