/*
 * portbase.cpp, base port class
 *
 * Copyright (c) 2009-2010 Wind River Systems, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <errno.h>
#include <stdlib.h>
#include <string.h>

#include <OMX_Core.h>
#include <OMX_Component.h>

#include <portbase.h>
#include <componentbase.h>
//#define LOG_NDEBUG 0

#define LOG_TAG "portbase"
#include <log.h>

/*
 * constructor & destructor
 */
void PortBase::__PortBase(void)
{
    buffer_hdrs = NULL;
    nr_buffer_hdrs = 0;
    buffer_hdrs_completion = false;

    custom_mem_alloc = NULL;
    custom_mem_free = NULL;
    custom_mem_userdata = NULL;

    mem_alignment = 0;

    pthread_mutex_init(&hdrs_lock, NULL);
    pthread_cond_init(&hdrs_wait, NULL);

    __queue_init(&bufferq);
    pthread_mutex_init(&bufferq_lock, NULL);

    __queue_init(&retainedbufferq);
    pthread_mutex_init(&retainedbufferq_lock, NULL);

    __queue_init(&markq);
    pthread_mutex_init(&markq_lock, NULL);

    state = OMX_PortEnabled;
    pthread_mutex_init(&state_lock, NULL);

    memset(&portdefinition, 0, sizeof(portdefinition));
    ComponentBase::SetTypeHeader(&portdefinition, sizeof(portdefinition));
    memset(definition_format_mimetype, 0, OMX_MAX_STRINGNAME_SIZE);
    portdefinition.format.audio.cMIMEType = &definition_format_mimetype[0];
    portdefinition.format.video.cMIMEType = &definition_format_mimetype[0];
    portdefinition.format.image.cMIMEType = &definition_format_mimetype[0];

    memset(&audioparam, 0, sizeof(audioparam));

    owner = NULL;
    appdata = NULL;
    callbacks = NULL;

    cbase = NULL;
}

PortBase::PortBase()
{
    __PortBase();
}

PortBase::PortBase(const OMX_PARAM_PORTDEFINITIONTYPE *portdefinition)
{
    __PortBase();
    SetPortDefinition(portdefinition, true);
}

PortBase::~PortBase()
{
    struct list *entry, *temp;

    /* should've been already freed at FreeBuffer() */
    list_foreach_safe(buffer_hdrs, entry, temp) {
        free(entry->data); /* OMX_BUFFERHEADERTYPE */
        __list_delete(buffer_hdrs, entry);
    }

    pthread_cond_destroy(&hdrs_wait);
    pthread_mutex_destroy(&hdrs_lock);

    /* should've been already freed at buffer processing */
    queue_free_all(&bufferq);
    pthread_mutex_destroy(&bufferq_lock);

    /* should've been already freed at buffer processing */
    queue_free_all(&retainedbufferq);
    pthread_mutex_destroy(&retainedbufferq_lock);

    /* should've been already empty in PushThisBuffer () */
    queue_free_all(&markq);
    pthread_mutex_destroy(&markq_lock);

    pthread_mutex_destroy(&state_lock);
}

/* end of constructor & destructor */

/*
 * accessor
 */
/* owner */
void PortBase::SetOwner(OMX_COMPONENTTYPE *handle)
{
    owner = handle;
    cbase = static_cast<ComponentBase *>(handle->pComponentPrivate);
}

OMX_COMPONENTTYPE *PortBase::GetOwner(void)
{
    return owner;
}

OMX_ERRORTYPE PortBase::SetCallbacks(OMX_HANDLETYPE hComponent,
                                     OMX_CALLBACKTYPE *pCallbacks,
                                     OMX_PTR pAppData)
{
    if (owner != hComponent)
        return OMX_ErrorBadParameter;

    appdata = pAppData;
    callbacks = pCallbacks;

    return OMX_ErrorNone;
}

OMX_ERRORTYPE PortBase::SetMemAllocator(CustomMemAlloc *pMemAlloc, CustomMemFree *pMemFree, OMX_PTR pUserData)
{
    custom_mem_alloc = pMemAlloc;
    custom_mem_free = pMemFree;
    custom_mem_userdata = pUserData;
    return OMX_ErrorNone;
}

OMX_ERRORTYPE PortBase::SetMemAlignment(OMX_U32 nAlignment)
{
    mem_alignment = nAlignment;
    return OMX_ErrorNone;
}

OMX_U32 PortBase::getFrameBufSize(OMX_COLOR_FORMATTYPE colorFormat, OMX_U32 width, OMX_U32 height)
{
    switch (colorFormat) {
    case OMX_COLOR_FormatYCbYCr:
    case OMX_COLOR_FormatCbYCrY:
        return width * height * 2;
    case OMX_COLOR_FormatYUV420Planar:
    case OMX_COLOR_FormatYUV420SemiPlanar:
        return (width * height * 3) >> 1;

    default:
        LOGV("unsupport color format !");
        return -1;
    }
}

/* end of accessor */

/*
 * component methods & helpers
 */
/* Get/SetParameter */
OMX_ERRORTYPE PortBase::SetPortDefinition(
    const OMX_PARAM_PORTDEFINITIONTYPE *p, bool overwrite_readonly)
{
    OMX_PARAM_PORTDEFINITIONTYPE temp;

    memcpy(&temp, &portdefinition, sizeof(temp));

    if (!overwrite_readonly) {
        if (temp.nPortIndex != p->nPortIndex)
            return OMX_ErrorBadParameter;
        if (temp.eDir != p->eDir)
            return OMX_ErrorBadParameter;
        if (temp.eDomain != p->eDomain)
            return OMX_ErrorBadParameter;
        if (temp.nBufferCountActual != p->nBufferCountActual) {
            if (temp.nBufferCountMin > p->nBufferCountActual)
                return OMX_ErrorBadParameter;
            temp.nBufferCountActual = p->nBufferCountActual;
        }
        if ((p->nBufferSize > temp.nBufferSize) && (temp.eDir == OMX_DirInput)) {
            if (p->nBufferSize <= MAX_INPUT_PORT_SIZE) {
                LOGW("Input port size has been changed!");
                temp.nBufferSize = p->nBufferSize;
            } else {
                LOGE("Invalid input port size!");
                return OMX_ErrorBadParameter;
            }
        }
    }
    else {
        temp.nPortIndex = p->nPortIndex;
        temp.eDir = p->eDir;
        temp.nBufferCountActual = p->nBufferCountActual;
        temp.nBufferCountMin = p->nBufferCountMin;
        temp.nBufferSize = p->nBufferSize;
        temp.bEnabled = p->bEnabled;
        temp.bPopulated = p->bPopulated;
        temp.eDomain = p->eDomain;
        temp.bBuffersContiguous = p->bBuffersContiguous;
        temp.nBufferAlignment = p->nBufferAlignment;
    }

    switch (p->eDomain) {
    case OMX_PortDomainAudio: {
        OMX_AUDIO_PORTDEFINITIONTYPE *format = &temp.format.audio;
        const OMX_AUDIO_PORTDEFINITIONTYPE *pformat = &p->format.audio;
        OMX_U32 mimetype_len = strlen(pformat->cMIMEType);

        mimetype_len = OMX_MAX_STRINGNAME_SIZE-1 > mimetype_len ?
                       mimetype_len : OMX_MAX_STRINGNAME_SIZE-1;

        strncpy(format->cMIMEType, pformat->cMIMEType,
                mimetype_len);
        format->cMIMEType[mimetype_len+1] = '\0';
        format->pNativeRender = pformat->pNativeRender;
        format->bFlagErrorConcealment = pformat->bFlagErrorConcealment;
        format->eEncoding = pformat->eEncoding;

        break;
    }
    case OMX_PortDomainVideo: {
        OMX_VIDEO_PORTDEFINITIONTYPE *format = &temp.format.video;
        const OMX_VIDEO_PORTDEFINITIONTYPE *pformat = &p->format.video;
        OMX_U32 mimetype_len = strlen(pformat->cMIMEType);

        mimetype_len = OMX_MAX_STRINGNAME_SIZE-1 > mimetype_len ?
                       mimetype_len : OMX_MAX_STRINGNAME_SIZE-1;

        strncpy(format->cMIMEType, pformat->cMIMEType,
                mimetype_len);
        format->cMIMEType[mimetype_len+1] = '\0';
        format->pNativeRender = pformat->pNativeRender;
        format->nFrameWidth = pformat->nFrameWidth;
        format->nFrameHeight = pformat->nFrameHeight;
        format->nBitrate = pformat->nBitrate;
        format->xFramerate = pformat->xFramerate;
        format->bFlagErrorConcealment = pformat->bFlagErrorConcealment;
        format->eCompressionFormat = pformat->eCompressionFormat;
        format->eColorFormat = pformat->eColorFormat;
        format->pNativeWindow = pformat->pNativeWindow;
        OMX_S32 nFrameSize = getFrameBufSize(format->eColorFormat,format->nFrameWidth,format->nFrameHeight);
        if(nFrameSize!=-1)
            temp.nBufferSize = nFrameSize;
        if (overwrite_readonly) {
            format->nStride = pformat->nStride;
            format->nSliceHeight = pformat->nSliceHeight;
        } else {
            format->nStride = pformat->nFrameWidth;
            format->nSliceHeight = pformat->nFrameHeight;
        }

        break;
    }
    case OMX_PortDomainImage: {
        OMX_IMAGE_PORTDEFINITIONTYPE *format = &temp.format.image;
        const OMX_IMAGE_PORTDEFINITIONTYPE *pformat = &p->format.image;
        OMX_U32 mimetype_len = strlen(pformat->cMIMEType);

        mimetype_len = OMX_MAX_STRINGNAME_SIZE-1 > mimetype_len ?
                       mimetype_len : OMX_MAX_STRINGNAME_SIZE-1;

        strncpy(format->cMIMEType, pformat->cMIMEType,
                mimetype_len+1);
        format->cMIMEType[mimetype_len+1] = '\0';
        format->nFrameWidth = pformat->nFrameWidth;
        format->nFrameHeight = pformat->nFrameHeight;
        format->nStride = pformat->nStride;
        format->bFlagErrorConcealment = pformat->bFlagErrorConcealment;
        format->eCompressionFormat = pformat->eCompressionFormat;
        format->eColorFormat = pformat->eColorFormat;
        format->pNativeWindow = pformat->pNativeWindow;

        if (overwrite_readonly)
            format->nSliceHeight = pformat->nSliceHeight;

        break;
    }
    case OMX_PortDomainOther: {
        OMX_OTHER_PORTDEFINITIONTYPE *format = &temp.format.other;
        const OMX_OTHER_PORTDEFINITIONTYPE *pformat = &p->format.other;

        format->eFormat = pformat->eFormat;
        break;
    }
    default:
        LOGE("cannot find 0x%08x port domain\n", p->eDomain);
        return OMX_ErrorBadParameter;
    }

    memcpy(&portdefinition, &temp, sizeof(temp));
    return OMX_ErrorNone;
}

const OMX_PARAM_PORTDEFINITIONTYPE *PortBase::GetPortDefinition(void)
{
    return &portdefinition;
}

/* Use/Allocate/FreeBuffer */
OMX_ERRORTYPE PortBase::UseBuffer(OMX_BUFFERHEADERTYPE **ppBufferHdr,
                                  OMX_U32 nPortIndex,
                                  OMX_PTR pAppPrivate,
                                  OMX_U32 nSizeBytes,
                                  OMX_U8 *pBuffer)
{
    OMX_BUFFERHEADERTYPE *buffer_hdr;
    struct list *entry;

    LOGV("%s(): %s:%s:PortIndex %u: enter, nSizeBytes=%u\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), nPortIndex, nSizeBytes);

    pthread_mutex_lock(&hdrs_lock);

    if (portdefinition.bPopulated == OMX_TRUE) {
        pthread_mutex_unlock(&hdrs_lock);
        LOGV("%s(): %s:%s:PortIndex %u: exit done, already populated\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             nPortIndex);
        return OMX_ErrorNone;
    }

    buffer_hdr = (OMX_BUFFERHEADERTYPE *)calloc(1, sizeof(*buffer_hdr));
    if (!buffer_hdr) {
        pthread_mutex_unlock(&hdrs_lock);
        LOGE("%s(): %s:%s:PortIndex %u: exit failure, "
             "connot allocate buffer header\n", __FUNCTION__,
             cbase->GetName(), cbase->GetWorkingRole(), nPortIndex);
        return OMX_ErrorInsufficientResources;
    }

    entry = list_alloc(buffer_hdr);
    if (!entry) {
        free(buffer_hdr);
        pthread_mutex_unlock(&hdrs_lock);
        LOGE("%s(): %s:%s:PortIndex %u: exit failure, "
             "cannot allocate list entry\n", __FUNCTION__,
             cbase->GetName(), cbase->GetWorkingRole(), nPortIndex);
        return OMX_ErrorInsufficientResources;
    }

    ComponentBase::SetTypeHeader(buffer_hdr, sizeof(*buffer_hdr));
    buffer_hdr->pBuffer = pBuffer;
    buffer_hdr->nAllocLen = nSizeBytes;
    buffer_hdr->pAppPrivate = pAppPrivate;
    buffer_hdr->pInputPortPrivate = NULL;
    buffer_hdr->pOutputPortPrivate = NULL;
    if (portdefinition.eDir == OMX_DirInput) {
        buffer_hdr->nInputPortIndex = nPortIndex;
        buffer_hdr->nOutputPortIndex = 0x7fffffff;
    }
    else {
        buffer_hdr->nOutputPortIndex = nPortIndex;
        buffer_hdr->nInputPortIndex = 0x7fffffff;
    }

    buffer_hdrs = __list_add_tail(buffer_hdrs, entry);
    nr_buffer_hdrs++;

    LOGV("%s(): %s:%s:PortIndex %u: a buffer allocated (%p:%u/%u)\n",
         __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), nPortIndex,
         buffer_hdr, nr_buffer_hdrs, portdefinition.nBufferCountActual);

    if (nr_buffer_hdrs >= portdefinition.nBufferCountActual) {
        portdefinition.bPopulated = OMX_TRUE;
        buffer_hdrs_completion = true;
        pthread_cond_signal(&hdrs_wait);
        LOGV("%s(): %s:%s:PortIndex %u: allocate all buffers (%u)\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             nPortIndex, portdefinition.nBufferCountActual);
    }

    *ppBufferHdr = buffer_hdr;

    pthread_mutex_unlock(&hdrs_lock);

    LOGV("%s(): %s:%s:PortIndex %u: exit done\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), nPortIndex);
    return OMX_ErrorNone;
}

OMX_ERRORTYPE PortBase:: AllocateBuffer(OMX_BUFFERHEADERTYPE **ppBuffer,
                                       OMX_U32 nPortIndex,
                                       OMX_PTR pAppPrivate,
                                       OMX_U32 nSizeBytes)
{
    OMX_BUFFERHEADERTYPE *buffer_hdr;
    struct list *entry;

    LOGV("%s(): %s:%s:PortIndex %u: enter, nSizeBytes=%u\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), nPortIndex, nSizeBytes);

    pthread_mutex_lock(&hdrs_lock);
    if (portdefinition.bPopulated == OMX_TRUE) {
        pthread_mutex_unlock(&hdrs_lock);
        LOGV("%s(): %s:%s:PortIndex %u: exit done, already populated\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             nPortIndex);
        return OMX_ErrorNone;
    }

    if (custom_mem_alloc) {
        buffer_hdr = (OMX_BUFFERHEADERTYPE *) calloc(1, sizeof(*buffer_hdr));
    } else {
        if (mem_alignment > 0)
            buffer_hdr = (OMX_BUFFERHEADERTYPE *) calloc(1, sizeof(*buffer_hdr) + nSizeBytes + mem_alignment);
        else
            buffer_hdr = (OMX_BUFFERHEADERTYPE *) calloc(1, sizeof(*buffer_hdr) + nSizeBytes);
    }

    if (!buffer_hdr) {
        pthread_mutex_unlock(&hdrs_lock);
        LOGE("%s(): %s:%s:PortIndex %u: exit failure, "
             "connot allocate buffer header\n", __FUNCTION__,
             cbase->GetName(), cbase->GetWorkingRole(), nPortIndex);
        return OMX_ErrorInsufficientResources;
    }

    entry = list_alloc(buffer_hdr);
    if (!entry) {
        free(buffer_hdr);
        pthread_mutex_unlock(&hdrs_lock);
        LOGE("%s(): %s:%s:PortIndex %u: exit failure, "
             "connot allocate list entry\n", __FUNCTION__,
             cbase->GetName(), cbase->GetWorkingRole(), nPortIndex);
        return OMX_ErrorInsufficientResources;
    }

    ComponentBase::SetTypeHeader(buffer_hdr, sizeof(*buffer_hdr));
    if (custom_mem_alloc) {
        buffer_hdr->pBuffer = (*custom_mem_alloc)(nSizeBytes, custom_mem_userdata);
    } else {
        if (mem_alignment > 0)
            buffer_hdr->pBuffer = (OMX_U8 *)(((OMX_U32)((OMX_U8 *)buffer_hdr + sizeof(*buffer_hdr)) / mem_alignment + 1) * mem_alignment);
        else
            buffer_hdr->pBuffer = (OMX_U8 *)buffer_hdr + sizeof(*buffer_hdr);
    }
    if (buffer_hdr->pBuffer == NULL) {
        return OMX_ErrorInsufficientResources;
    }

    buffer_hdr->nAllocLen = nSizeBytes;
    buffer_hdr->pAppPrivate = pAppPrivate;
    buffer_hdr->pInputPortPrivate = NULL;
    buffer_hdr->pOutputPortPrivate = NULL;
    if (portdefinition.eDir == OMX_DirInput) {
        buffer_hdr->nInputPortIndex = nPortIndex;
        buffer_hdr->nOutputPortIndex = (OMX_U32)-1;
    }
    else {
        buffer_hdr->nOutputPortIndex = nPortIndex;
        buffer_hdr->nInputPortIndex = (OMX_U32)-1;
    }

    buffer_hdrs = __list_add_tail(buffer_hdrs, entry);
    nr_buffer_hdrs++;

    LOGV("%s(): %s:%s:PortIndex %u: a buffer allocated (%p:%u/%u)\n",
         __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), nPortIndex,
         buffer_hdr, nr_buffer_hdrs, portdefinition.nBufferCountActual);

    if (nr_buffer_hdrs == portdefinition.nBufferCountActual) {
        portdefinition.bPopulated = OMX_TRUE;
        buffer_hdrs_completion = true;
        pthread_cond_signal(&hdrs_wait);
        LOGV("%s(): %s:%s:PortIndex %u: allocate all buffers (%u)\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             nPortIndex, portdefinition.nBufferCountActual);
    }

    *ppBuffer = buffer_hdr;

    pthread_mutex_unlock(&hdrs_lock);

    LOGV("%s(): %s:%s:PortIndex %u: exit done\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), nPortIndex);
    return OMX_ErrorNone;
}

OMX_ERRORTYPE PortBase::FreeBuffer(OMX_U32 nPortIndex,
                                   OMX_BUFFERHEADERTYPE *pBuffer)
{
    struct list *entry;
    OMX_ERRORTYPE ret;

    LOGV("%s(): %s:%s:PortIndex %u:pBuffer %p: enter\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), nPortIndex, pBuffer);

    pthread_mutex_lock(&hdrs_lock);
    entry = list_find(buffer_hdrs, pBuffer);

    if (!entry) {
        pthread_mutex_unlock(&hdrs_lock);
        LOGE("%s(): %s:%s:PortIndex %u:pBuffer %p: exit failure, "
             "cannot find list entry for pBuffer\n", __FUNCTION__,
             cbase->GetName(), cbase->GetWorkingRole(), nPortIndex, pBuffer);
        return OMX_ErrorBadParameter;
    }

    if (entry->data != pBuffer) {
        pthread_mutex_unlock(&hdrs_lock);
        LOGE("%s(): %s:%s:PortIndex %u:pBuffer %p: exit failure,"
             "mismatch list entry\n" , __FUNCTION__,
             cbase->GetName(), cbase->GetWorkingRole(), nPortIndex, pBuffer);
        return OMX_ErrorBadParameter;
    }

    ret = ComponentBase::CheckTypeHeader(pBuffer, sizeof(*pBuffer));
    if (ret != OMX_ErrorNone) {
        pthread_mutex_unlock(&hdrs_lock);
        LOGE("%s(): %s:%s:PortIndex %u:pBuffer %p: exit failure,"
             "invalid type header\n", __FUNCTION__,
             cbase->GetName(), cbase->GetWorkingRole(), nPortIndex, pBuffer);
        return ret;
    }

    buffer_hdrs = __list_delete(buffer_hdrs, entry);
    nr_buffer_hdrs--;

    LOGV("%s(): %s:%s:PortIndex %u:pBuffer %p: free a buffer (%u/%u)\n",
         __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(), nPortIndex,
         pBuffer, nr_buffer_hdrs, portdefinition.nBufferCountActual);
    if (custom_mem_free) {
        (*custom_mem_free)(pBuffer->pBuffer, custom_mem_userdata);
        pBuffer->pBuffer = NULL;
    }
    free(pBuffer);

    portdefinition.bPopulated = OMX_FALSE;
    if (!nr_buffer_hdrs) {
        buffer_hdrs_completion = true;
        pthread_cond_signal(&hdrs_wait);
        LOGV("%s(): %s:%s:PortIndex %u: free all allocated buffers (%u)\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             nPortIndex, portdefinition.nBufferCountActual);
    }

    pthread_mutex_unlock(&hdrs_lock);

    LOGV("%s(): %s:%s:PortIndex %u: exit done\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), nPortIndex);
    return OMX_ErrorNone;
}

void PortBase::WaitPortBufferCompletion(void)
{
    pthread_mutex_lock(&hdrs_lock);
    if (!buffer_hdrs_completion) {
        LOGV("%s(): %s:%s:PortIndex %u: wait for buffer header completion\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex);
        pthread_cond_wait(&hdrs_wait, &hdrs_lock);
        LOGV("%s(): %s:%s:PortIndex %u: wokeup (buffer header completion)\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex);
    }
    buffer_hdrs_completion = !buffer_hdrs_completion;
    pthread_mutex_unlock(&hdrs_lock);
}

OMX_ERRORTYPE PortBase::WaitPortBufferCompletionTimeout(int64_t milliseconds)
{
    int rc = 0;
    OMX_ERRORTYPE ret = OMX_ErrorNone;
    pthread_mutex_lock(&hdrs_lock);
    if (!buffer_hdrs_completion) {
        LOGV("%s(): %s:%s:PortIndex %u: wait for buffer header completion\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex);
        struct timespec tv;
        clock_gettime(CLOCK_REALTIME, &tv);
        tv.tv_sec += milliseconds/1000;
        tv.tv_nsec+= (milliseconds%1000) * 1000000;
        if (tv.tv_nsec >= 1000000000) {
            tv.tv_sec += 1;
            tv.tv_nsec -= 1000000000;
        }

        rc = pthread_cond_timedwait(&hdrs_wait, &hdrs_lock, &tv);
    }
    if (rc == ETIMEDOUT) {
        LOGE("%s(): %s:%s:PortIndex %u: wokeup (buffer header timeout)\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex);
        ret = OMX_ErrorTimeout;
    }
    buffer_hdrs_completion = !buffer_hdrs_completion;
    pthread_mutex_unlock(&hdrs_lock);
    return ret;
}

/* Empty/FillThisBuffer */
OMX_ERRORTYPE PortBase::PushThisBuffer(OMX_BUFFERHEADERTYPE *pBuffer)
{
    int ret;
    LOGV_IF(pBuffer != NULL, "%s(): %s:%s:PortIndex %u:pBuffer %p:\n",
            __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
           portdefinition.nPortIndex, pBuffer);
    pthread_mutex_lock(&bufferq_lock);
    ret = queue_push_tail(&bufferq, pBuffer);
    pthread_mutex_unlock(&bufferq_lock);

    if (ret)
        return OMX_ErrorInsufficientResources;

    return OMX_ErrorNone;
}

OMX_BUFFERHEADERTYPE *PortBase::PopBuffer(void)
{
    OMX_BUFFERHEADERTYPE *buffer;

    pthread_mutex_lock(&bufferq_lock);
    buffer = (OMX_BUFFERHEADERTYPE *)queue_pop_head(&bufferq);
    pthread_mutex_unlock(&bufferq_lock);
    LOGV_IF((buffer != NULL || RetainedBufferQueueLength() > 0), "%s(): %s:%s:PortIndex %u:pBuffer %p:\n",
            __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
            portdefinition.nPortIndex, buffer);
    return buffer;
}

OMX_U32 PortBase::BufferQueueLength(void)
{
    OMX_U32 length;

    pthread_mutex_lock(&bufferq_lock);
    length = queue_length(&bufferq);
    pthread_mutex_unlock(&bufferq_lock);

    return length;
}

OMX_U32 PortBase::RetainedBufferQueueLength(void)
{
    OMX_U32 length;

    pthread_mutex_lock(&retainedbufferq_lock);
    length = queue_length(&retainedbufferq);
    pthread_mutex_unlock(&retainedbufferq_lock);

    return length;
}

OMX_ERRORTYPE PortBase::ReturnThisBuffer(OMX_BUFFERHEADERTYPE *pBuffer)
{
    OMX_DIRTYPE direction = portdefinition.eDir;
    OMX_U32 port_index;
    OMX_ERRORTYPE (*bufferdone_callback)(OMX_HANDLETYPE,
                                         OMX_PTR,
                                         OMX_BUFFERHEADERTYPE *);
    OMX_ERRORTYPE ret;

    LOGV("%s(): %s:%s:PortIndex %u:pBuffer %p: enter\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), portdefinition.nPortIndex,
         pBuffer);

    if (!pBuffer) {
        LOGE("%s(): %s:%s:PortIndex %u:pBuffer %p: exit failure, "
             "invalid buffer pointer\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex, pBuffer);
        return OMX_ErrorBadParameter;
    }

    if (direction == OMX_DirInput) {
        port_index = pBuffer->nInputPortIndex;
        bufferdone_callback = callbacks->EmptyBufferDone;
    }
    else if (direction == OMX_DirOutput) {
        port_index = pBuffer->nOutputPortIndex;
        bufferdone_callback = callbacks->FillBufferDone;
    }
    else {
        LOGE("%s(): %s:%s:PortIndex %u:pBuffer %p: exit failure, "
             "invalid direction (%d)\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex, pBuffer,
             direction);
        return OMX_ErrorBadParameter;
    }

    if (port_index != portdefinition.nPortIndex) {
        LOGE("%s(): %s:%s:PortIndex %u:pBuffer %p: exit failure, "
             "invalid port index (%u)\n", __FUNCTION__,
             cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex, pBuffer, port_index);
        return OMX_ErrorBadParameter;
    }

    if (pBuffer->nFlags & OMX_BUFFERFLAG_EOS) {
        LOGV("%s(): %s:%s:PortIndex %u:pBuffer %p: "
             "Report OMX_EventBufferFlag (OMX_BUFFERFLAG_EOS)\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex, pBuffer);

        callbacks->EventHandler(owner, appdata,
                                OMX_EventBufferFlag,
                                port_index, pBuffer->nFlags, NULL);
    }

    if (pBuffer->hMarkTargetComponent == owner) {
        LOGV("%s(): %s:%s:PortIndex %u:pBuffer %p: "
             "Report OMX_EventMark\n",
             __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex, pBuffer);

        callbacks->EventHandler(owner, appdata, OMX_EventMark,
                                0, 0, pBuffer->pMarkData);
        pBuffer->hMarkTargetComponent = NULL;
        pBuffer->pMarkData = NULL;
    }

    ret = bufferdone_callback(owner, appdata, pBuffer);

    LOGV("%s(): %s:%s:PortIndex %u: exit done, "
         "callback returned (0x%08x)\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), portdefinition.nPortIndex,
         ret);

    return OMX_ErrorNone;
}

OMX_ERRORTYPE PortBase::RetainAndReturnBuffer( OMX_BUFFERHEADERTYPE *pRetain, OMX_BUFFERHEADERTYPE *pReturn)
{
    OMX_ERRORTYPE ret;
    OMX_U32 length;
    if (pReturn == pRetain) {
        return ReturnThisBuffer(pReturn);
    }
    ret = RetainThisBuffer(pRetain, false);
    if (ret != OMX_ErrorNone) {
        return ret;
    }

    pthread_mutex_lock(&bufferq_lock);
    length = queue_length(&bufferq);
    OMX_BUFFERHEADERTYPE *p;
    /* remove returned buffer from the queue */
    OMX_U32 i = 0;
    for (i = 0; i < length; i++) {
        p = (OMX_BUFFERHEADERTYPE *)queue_pop_head(&bufferq);
        if (p == pReturn) {
            break;
        }
        queue_push_tail(&bufferq, p);
    }
    pthread_mutex_unlock(&bufferq_lock);

    if (i == length) {
        return OMX_ErrorNone;
    }

    return ReturnThisBuffer(pReturn);
}

/* retain buffer */
OMX_ERRORTYPE PortBase::RetainThisBuffer(OMX_BUFFERHEADERTYPE *pBuffer,
        bool accumulate)
{
    int ret;

    LOGV("%s(): %s:%s:PortIndex %u:pBuffer %p: enter, %s\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), portdefinition.nPortIndex,
         pBuffer, (accumulate == true) ? "accumulate" : "getagain");

    /* push at tail of retainedbufferq */
    if (accumulate == true) {

        if (cbase->GetWorkingRole() == NULL || (strncmp((char*)cbase->GetWorkingRole(), "video_encoder", 13) != 0)) {
            /* do not accumulate a buffer set EOS flag if not video encoder*/
            if (pBuffer->nFlags & OMX_BUFFERFLAG_EOS) {
                LOGE("%s(): %s:%s:PortIndex %u:pBuffer %p: exit failure, "
                     "cannot accumulate EOS buffer\n", __FUNCTION__,
                     cbase->GetName(), cbase->GetWorkingRole(),
                     portdefinition.nPortIndex, pBuffer);
                return OMX_ErrorBadParameter;
            }
        }

        pthread_mutex_lock(&retainedbufferq_lock);
        if ((OMX_U32)queue_length(&retainedbufferq) <
                portdefinition.nBufferCountActual)
            ret = queue_push_tail(&retainedbufferq, pBuffer);
        else {
            ret = OMX_ErrorInsufficientResources;
            LOGE("%s(): %s:%s:PortIndex %u:pBuffer %p: exit failure, "
                 "retained bufferq length (%d) exceeds port's actual count "
                 "(%u)\n", __FUNCTION__,
                 cbase->GetName(), cbase->GetWorkingRole(),
                 portdefinition.nPortIndex, pBuffer,
                 queue_length(&retainedbufferq),
                 portdefinition.nBufferCountActual);
        }
        pthread_mutex_unlock(&retainedbufferq_lock);
    }
    /*
     * just push at head of bufferq to get this buffer again in
     * ComponentBase::ProcessorProcess()
     */
    else {
        pthread_mutex_lock(&bufferq_lock);
        ret = queue_push_head(&bufferq, pBuffer);
        pthread_mutex_unlock(&bufferq_lock);
    }

    if (ret)
        return OMX_ErrorInsufficientResources;

    LOGV("%s(): %s:%s:PortIndex %u:pBuffer %p: exit done\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(),
         portdefinition.nPortIndex, pBuffer);
    return OMX_ErrorNone;
}

void PortBase::ReturnAllRetainedBuffers(void)
{
    OMX_BUFFERHEADERTYPE *buffer;
    OMX_ERRORTYPE ret;
    int i = 0;

    pthread_mutex_lock(&retainedbufferq_lock);

    do {
        buffer = (OMX_BUFFERHEADERTYPE *)queue_pop_head(&retainedbufferq);

        if (buffer) {
            LOGV("%s(): %s:%s:PortIndex %u: returns a retained buffer "
                 "(%p:%d/%d)\n", __FUNCTION__, cbase->GetName(),
                 cbase->GetWorkingRole(), portdefinition.nPortIndex,
                 buffer, i++, queue_length(&retainedbufferq));

            ret = ReturnThisBuffer(buffer);
            if (ret != OMX_ErrorNone)
                LOGE("%s(): %s:%s:PortIndex %u: failed (ret : 0x%x08x)\n",
                     __FUNCTION__,
                     cbase->GetName(), cbase->GetWorkingRole(),
                     portdefinition.nPortIndex, ret);
        }
    } while (buffer);

    pthread_mutex_unlock(&retainedbufferq_lock);
    LOGV_IF(i != 0,
            "%s(): %s:%s:PortIndex %u: returned all retained buffers (%d)\n",
            __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
            portdefinition.nPortIndex, i);
}

void PortBase::ReturnOneRetainedBuffer(void)
{
    OMX_BUFFERHEADERTYPE *buffer;
    OMX_ERRORTYPE ret;
    int i =0;

    pthread_mutex_lock(&retainedbufferq_lock);

    buffer = (OMX_BUFFERHEADERTYPE *)queue_pop_head(&retainedbufferq);

    if (buffer) {
        LOGV("%s(): %s:%s:PortIndex %u: returns a retained buffer "
             "(%p:%d/%d)\n", __FUNCTION__, cbase->GetName(),
             cbase->GetWorkingRole(), portdefinition.nPortIndex,
             buffer, i++, queue_length(&retainedbufferq));

        ret = ReturnThisBuffer(buffer);
        if (ret != OMX_ErrorNone)
            LOGE("%s(): %s:%s:PortIndex %u: failed (ret : 0x%x08x)\n",
                 __FUNCTION__,
                 cbase->GetName(), cbase->GetWorkingRole(),
                 portdefinition.nPortIndex, ret);
    }

    pthread_mutex_unlock(&retainedbufferq_lock);

}

/* SendCommand:Flush/PortEnable/Disable */
/* must be held ComponentBase::ports_block */
OMX_ERRORTYPE PortBase::FlushPort(void)
{
    OMX_BUFFERHEADERTYPE *buffer;

    LOGV("%s(): %s:%s:PortIndex %u: enter\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(),
         portdefinition.nPortIndex);

    ReturnAllRetainedBuffers();

    while ((buffer = PopBuffer()))
        ReturnThisBuffer(buffer);

    LOGV("%s(): %s:%s:PortIndex %u: exit\n", __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(),
         portdefinition.nPortIndex);

    return OMX_ErrorNone;
}

OMX_STATETYPE PortBase::GetOwnerState(void)
{
    OMX_STATETYPE state = OMX_StateInvalid;

    if (owner) {
        ComponentBase *cbase;
        cbase = static_cast<ComponentBase *>(owner->pComponentPrivate);
        if (!cbase)
            return state;

        cbase->CBaseGetState((void *)owner, &state);
    }

    return state;
}

bool PortBase::IsEnabled(void)
{
    bool enabled;
    bool unlock = true;

    if (pthread_mutex_trylock(&state_lock))
        unlock = false;

    enabled = (state == OMX_PortEnabled) ? true : false;

    if (unlock)
        pthread_mutex_unlock(&state_lock);

    return enabled;
}

OMX_DIRTYPE PortBase::GetPortDirection(void)
{
    return portdefinition.eDir;
}

OMX_U32 PortBase::GetPortBufferCount(void)
{
    return nr_buffer_hdrs;
}

OMX_ERRORTYPE PortBase::PushMark(OMX_MARKTYPE *mark)
{
    int ret;

    pthread_mutex_lock(&markq_lock);
    ret = queue_push_tail(&markq, mark);
    pthread_mutex_unlock(&markq_lock);

    if (ret)
        return OMX_ErrorInsufficientResources;

    return OMX_ErrorNone;
}

OMX_MARKTYPE *PortBase::PopMark(void)
{
    OMX_MARKTYPE *mark;

    pthread_mutex_lock(&markq_lock);
    mark = (OMX_MARKTYPE *)queue_pop_head(&markq);
    pthread_mutex_unlock(&markq_lock);

    return mark;
}

static const char *state_name[PortBase::OMX_PortEnabled+2] = {
    "OMX_PortDisabled",
    "OMX_PortEnabled",
    "UnKnown Port State",
};

const char *GetPortStateName(OMX_U8 state)
{
    if (state > PortBase::OMX_PortEnabled)
        state = PortBase::OMX_PortEnabled+1;

    return state_name[state];
}

OMX_ERRORTYPE PortBase::TransState(OMX_U8 transition)
{
    OMX_U8 current;
    OMX_ERRORTYPE ret = OMX_ErrorNone;

    LOGV("%s(): %s:%s:PortIndex %u: enter, transition from %s to %s\n",
         __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), portdefinition.nPortIndex,
         GetPortStateName(state), GetPortStateName(transition));

    pthread_mutex_lock(&state_lock);

    current = state;

    if (current == transition) {
        ret = OMX_ErrorSameState;
        LOGE("%s(): %s:%s:PortIndex %u: exit failure, same state (%s)\n",
             __FUNCTION__,
             cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex, GetPortStateName(current));
        goto unlock;
    }

    if (transition == OMX_PortEnabled) {
        if (cbase->GetWorkingRole() != NULL &&
                !strncmp (cbase->GetWorkingRole(),"video_decoder", 13 )) {
            ret = WaitPortBufferCompletionTimeout(800); //0.8s timeout
            if (!nr_buffer_hdrs) {
                // event is trigger by freeing buffer instead of allocating buffer
                ret = OMX_ErrorBadParameter;
            }
            if (ret != OMX_ErrorNone) {
                goto unlock;
            }
        } else {
            WaitPortBufferCompletion();
        }
        portdefinition.bEnabled = OMX_TRUE;
    }
    else if(transition == OMX_PortDisabled) {
        /*need to flush only if port is not empty*/
        if (nr_buffer_hdrs)
        {
            FlushPort();
            WaitPortBufferCompletion();
        }
        portdefinition.bEnabled = OMX_FALSE;
    }
    else {
        ret = OMX_ErrorBadParameter;
        LOGE("%s(): %s:%s:PortIndex %u: exit failure, invalid transition "
             "(%s)\n", __FUNCTION__,
             cbase->GetName(), cbase->GetWorkingRole(),
             portdefinition.nPortIndex, GetPortStateName(transition));
        goto unlock;
    }

    state = transition;

    LOGV("%s(): %s:%s:PortIndex %u: transition from %s to %s complete\n",
         __FUNCTION__,
         cbase->GetName(), cbase->GetWorkingRole(), portdefinition.nPortIndex,
         GetPortStateName(current), GetPortStateName(state));

unlock:
    pthread_mutex_unlock(&state_lock);
    return ret;
}

OMX_ERRORTYPE PortBase::ReportPortSettingsChanged(void)
{
    OMX_ERRORTYPE ret;

    ret = callbacks->EventHandler(owner, appdata,
                                  OMX_EventPortSettingsChanged,
                                  portdefinition.nPortIndex,OMX_IndexParamPortDefinition, NULL);

    FlushPort();

    return ret;
}

OMX_ERRORTYPE PortBase::ReportOutputCrop(void)
{
    OMX_ERRORTYPE ret;

    ret = callbacks->EventHandler(owner, appdata,
                                  OMX_EventPortSettingsChanged,
                                  portdefinition.nPortIndex,OMX_IndexConfigCommonOutputCrop, NULL);

    return ret;
}


/* end of component methods & helpers */

/* end of PortBase */