static OMX_ERRORTYPE
release_all_buffers (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid)
{
assert (ap_prc);
if ((a_pid == ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX || a_pid == OMX_ALL)
&& (ap_prc->p_aud_hdr_))
{
void * p_krn = tiz_get_krn (handleOf (ap_prc));
tiz_check_omx (tiz_krn_release_buffer (
p_krn, ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX, ap_prc->p_aud_hdr_));
ap_prc->p_aud_hdr_ = NULL;
}
if ((a_pid == ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX || a_pid == OMX_ALL)
&& (ap_prc->p_vid_hdr_))
{
void * p_krn = tiz_get_krn (handleOf (ap_prc));
tiz_check_omx (tiz_krn_release_buffer (
p_krn, ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX, ap_prc->p_vid_hdr_));
ap_prc->p_vid_hdr_ = NULL;
}
ap_prc->awaiting_buffers_ = true;
return OMX_ErrorNone;
}
static OMX_ERRORTYPE
webpd_proc_buffers_ready (const void *ap_obj)
{
struct webpdprc *p_obj = (struct webpdprc *) ap_obj;
const tiz_srv_t *p_parent = ap_obj;
void *p_krn = tiz_get_krn (p_parent->p_hdl_);
TIZ_LOG_CNAME (TIZ_TRACE,
TIZ_CNAME (p_parent->p_hdl_),
TIZ_CBUF (p_parent->p_hdl_), "Buffers ready...");
while (1)
{
if (!p_obj->pinhdr_)
{
if (!claim_input (ap_obj) || !p_obj->pinhdr_)
{
break;
}
}
if (!p_obj->pouthdr_)
{
if (!claim_output (ap_obj))
{
break;
}
}
tiz_check_omx_err (webpd_proc_transform_buffer (ap_obj));
if (p_obj->pinhdr_ && (0 == p_obj->pinhdr_->nFilledLen))
{
p_obj->pinhdr_->nOffset = 0;
tiz_krn_release_buffer (p_krn, 0, p_obj->pinhdr_);
p_obj->pinhdr_ = NULL;
}
}
if (p_obj->eos_ && p_obj->pouthdr_)
{
/* EOS has been received and all the input data has been consumed
* already, so its time to propagate the EOS flag */
TIZ_LOG_CNAME (TIZ_TRACE,
TIZ_CNAME (p_parent->p_hdl_),
TIZ_CBUF (p_parent->p_hdl_),
"p_obj->eos OUTPUT HEADER [%p]...", p_obj->pouthdr_);
p_obj->pouthdr_->nFlags |= OMX_BUFFERFLAG_EOS;
tiz_krn_release_buffer (p_krn, 1, p_obj->pouthdr_);
p_obj->pouthdr_ = NULL;
}
return OMX_ErrorNone;
}
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
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_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 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 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
release_buffer (scloud_prc_t * ap_prc)
{
assert (ap_prc);
if (ap_prc->p_outhdr_)
{
if (ap_prc->bytes_before_eos_ > ap_prc->p_outhdr_->nFilledLen)
{
ap_prc->bytes_before_eos_ -= ap_prc->p_outhdr_->nFilledLen;
}
else
{
ap_prc->bytes_before_eos_ = 0;
ap_prc->eos_ = true;
}
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 void release_output_header(vid_dec_PrivateType* priv) {
if (priv->p_outhdr_) {
assert(!priv->out_port_disabled_);
(void) tiz_krn_release_buffer (tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX,
priv->p_outhdr_);
priv->p_outhdr_ = NULL;
}
}
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 void get_eglimage(vid_dec_PrivateType* priv) {
OMX_PTR p_eglimage = NULL;
OMX_NATIVE_WINDOWTYPE * p_egldisplay = NULL;
const tiz_port_t * p_port = NULL;
struct pipe_video_buffer templat = {};
struct pipe_video_buffer *video_buffer = NULL;
struct pipe_resource * p_res = NULL;
struct pipe_resource *resources[VL_NUM_COMPONENTS];
if (OMX_ErrorNone ==
tiz_krn_claim_eglimage(tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX,
priv->p_outhdr_, &p_eglimage)) {
priv->use_eglimage = true;
p_port = tiz_krn_get_port(tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX);
p_egldisplay = p_port->portdef_.format.video.pNativeWindow;
if (!util_hash_table_get(priv->video_buffer_map, priv->p_outhdr_)) {
p_res = st_omx_pipe_texture_from_eglimage(p_egldisplay, p_eglimage);
assert(p_res);
memset(&templat, 0, sizeof(templat));
templat.buffer_format = p_res->format;
templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_NONE;
templat.width = p_res->width0;
templat.height = p_res->height0;
templat.interlaced = 0;
memset(resources, 0, sizeof(resources));
pipe_resource_reference(&resources[0], p_res);
video_buffer = vl_video_buffer_create_ex2(priv->pipe, &templat, resources);
assert(video_buffer);
assert(video_buffer->buffer_format == p_res->format);
util_hash_table_set(priv->video_buffer_map, priv->p_outhdr_, video_buffer);
}
} else {
(void) tiz_krn_release_buffer(tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX,
priv->p_outhdr_);
priv->p_outhdr_ = NULL;
}
}
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 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 void h264d_buffer_filled(vid_dec_PrivateType* priv, OMX_BUFFERHEADERTYPE * p_hdr)
{
assert(priv);
assert(p_hdr);
assert(priv->p_outhdr_ == p_hdr);
if (!priv->in_port_disabled_) {
p_hdr->nOffset = 0;
if (priv->eos_) {
/* EOS has been received and all the input data has been consumed
* already, so its time to propagate the EOS flag */
priv->p_outhdr_->nFlags |= OMX_BUFFERFLAG_EOS;
priv->eos_ = false;
}
(void) tiz_krn_release_buffer(tiz_get_krn (handleOf (priv)),
OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX,
p_hdr);
priv->p_outhdr_ = NULL;
}
}
/* 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
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;
}
