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 bool
claim_output (const void *ap_obj)
{
const tiz_srv_t *p_parent = ap_obj;
struct webpdprc *p_obj = (struct webpdprc *) ap_obj;
tiz_pd_set_t ports;
void *p_krn = tiz_get_krn (p_parent->p_hdl_);
TIZ_PD_ZERO (&ports);
tiz_check_omx_err (tiz_krn_select (p_krn, 2, &ports));
/* We need one output buffers */
if (TIZ_PD_ISSET (1, &ports))
{
tiz_check_omx_err (tiz_krn_claim_buffer
(p_krn, 1, 0, &p_obj->pouthdr_));
TIZ_LOG_CNAME (TIZ_TRACE, TIZ_CNAME (p_parent->p_hdl_),
TIZ_CBUF (p_parent->p_hdl_),
"Claimed OUTPUT HEADER [%p] BUFFER [%p] "
"nFilledLen [%d]...", p_obj->pouthdr_,
p_obj->pouthdr_->pBuffer, p_obj->pouthdr_->nFilledLen);
return true;
}
return false;
}
static bool
claim_input (const void *ap_obj)
{
const tiz_srv_t *p_parent = ap_obj;
struct webpdprc *p_obj = (struct webpdprc *) ap_obj;
tiz_pd_set_t ports;
void *p_krn = tiz_get_krn (p_parent->p_hdl_);
TIZ_PD_ZERO (&ports);
tiz_check_omx_err (tiz_krn_select (p_krn, 2, &ports));
/* We need one input buffers */
if (TIZ_PD_ISSET (0, &ports))
{
tiz_check_omx_err (tiz_krn_claim_buffer
(p_krn, 0, 0, &p_obj->pinhdr_));
TIZ_LOG_CNAME (TIZ_TRACE, TIZ_CNAME (p_parent->p_hdl_),
TIZ_CBUF (p_parent->p_hdl_),
"Claimed INPUT HEADER [%p]...", p_obj->pinhdr_);
return true;
}
TIZ_LOG_CNAME (TIZ_TRACE,
TIZ_CNAME (p_parent->p_hdl_),
TIZ_CBUF (p_parent->p_hdl_),
"COULD NOT CLAIM AN INPUT HEADER...");
return false;
}
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 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 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 OMX_ERRORTYPE
fr_proc_buffers_ready (const void *ap_obj)
{
const fr_prc_t *p_obj = ap_obj;
const tiz_srv_t *p_parent = ap_obj;
tiz_pd_set_t ports;
void *p_krn = tiz_get_krn (p_parent->p_hdl_);
OMX_BUFFERHEADERTYPE *p_hdr = NULL;
if (p_obj->eos_ == false)
{
TIZ_PD_ZERO (&ports);
tiz_check_omx_err (tiz_krn_select (p_krn, 1, &ports));
if (TIZ_PD_ISSET (0, &ports))
{
tiz_check_omx_err (tiz_krn_claim_buffer (p_krn, 0, 0, &p_hdr));
TIZ_LOG (TIZ_TRACE, "Claimed HEADER [%p]...", p_hdr);
tiz_check_omx_err (fr_proc_read_buffer (ap_obj, p_hdr));
tiz_krn_release_buffer (p_krn, 0, p_hdr);
}
}
return OMX_ErrorNone;
}
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_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_BUFFERHEADERTYPE * get_output_buffer(vid_dec_PrivateType* priv) {
assert (priv);
if (priv->out_port_disabled_) {
return NULL;
}
if (!priv->p_outhdr_) {
if (OMX_ErrorNone
== tiz_krn_claim_buffer(tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX, 0,
&priv->p_outhdr_)) {
if (priv->p_outhdr_) {
/* Check pBuffer nullity to know if an eglimage has been registered. */
if (!priv->p_outhdr_->pBuffer) {
get_eglimage(priv);
}
}
}
}
return priv->p_outhdr_;
}
static OMX_ERRORTYPE
tiztc_proc_buffers_ready (const void *ap_obj)
{
const tiz_srv_t *p_parent = ap_obj;
tiz_pd_set_t ports;
void *p_ker = tiz_get_krn (p_parent->p_hdl_);
OMX_BUFFERHEADERTYPE *p_hdr = NULL;
TIZ_LOG (TIZ_TRACE, "Buffers ready...");
TIZ_PD_ZERO (&ports);
tiz_check_omx_err (tiz_krn_select (p_ker, 1, &ports));
if (TIZ_PD_ISSET (0, &ports))
{
tiz_check_omx_err (tiz_krn_claim_buffer (p_ker, 0, 0, &p_hdr));
tiz_check_omx_err (tiztc_proc_render_buffer (p_hdr));
(void) tiz_krn_release_buffer (p_ker, 0, p_hdr);
}
return OMX_ErrorNone;
}
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_BUFFERHEADERTYPE * get_input_buffer(vid_dec_PrivateType* priv) {
assert(priv);
if (priv->in_port_disabled_) {
return NULL;
}
if (priv->num_in_buffers > 1) {
/* The input buffer wasn't cleared last time. */
h264d_buffer_emptied(priv, priv->in_buffers[0]);
if (priv->in_buffers[0]) {
/* Failed to release buffer */
return NULL;
}
h264d_shift_buffers_left(priv);
}
/* Decode_frame expects new buffers each time */
assert(priv->p_inhdr_ || priv->first_buf_in_frame);
tiz_krn_claim_buffer(tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_INPUT_PORT_INDEX, 0,
&priv->p_inhdr_);
return priv->p_inhdr_;
}
