/*
**
** Copyright 2017, Samsung Electronics Co. LTD
**
** 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.
*/

/* #define LOG_NDEBUG 0 */
#define LOG_TAG "ExynosCameraFrame"
#include <log/log.h>

#include "ExynosCameraFrame.h"

namespace android {

#ifdef DEBUG_FRAME_MEMORY_LEAK
unsigned long long ExynosCameraFrame::m_checkLeakCount;
unsigned long long ExynosCameraFrame::m_checkLeakFrameCount;
Mutex ExynosCameraFrame::m_countLock;
#endif

ExynosCameraFrame::ExynosCameraFrame(
        int cameraId,
        ExynosCameraParameters *obj_param,
        uint32_t frameCount,
        uint32_t frameType)
{
    m_cameraId = cameraId;
    m_parameters = obj_param;
    m_frameCount = frameCount;
    m_frameType = frameType;
    memset(m_name, 0x00, sizeof(m_name));

    CLOGV(" create frame type(%d), frameCount(%d)", frameType, frameCount);

    m_init();
}

ExynosCameraFrame::ExynosCameraFrame(int cameraId)
{
    m_cameraId = cameraId;
    m_parameters = NULL;
    m_frameCount = 0;
    m_frameType = FRAME_TYPE_OTHERS;
    memset(m_name, 0x00, sizeof(m_name));

    m_init();
}

ExynosCameraFrame::~ExynosCameraFrame()
{
    m_deinit();
}

#ifdef DEBUG_FRAME_MEMORY_LEAK
long long int ExynosCameraFrame::getCheckLeakCount()
{
    return m_privateCheckLeakCount;
}
#endif

status_t ExynosCameraFrame::addSiblingEntity(
        __unused ExynosCameraFrameEntity *curEntity,
        ExynosCameraFrameEntity *newEntity)
{
    Mutex::Autolock l(m_linkageLock);
    m_linkageList.push_back(newEntity);

    return NO_ERROR;
}

status_t ExynosCameraFrame::addChildEntity(
        ExynosCameraFrameEntity *parentEntity,
        ExynosCameraFrameEntity *newEntity)
{
    status_t ret = NO_ERROR;

    if (parentEntity == NULL) {
        CLOGE("parentEntity is NULL");
        return BAD_VALUE;
    }

    /* TODO: This is not suit in case of newEntity->next != NULL */
    ExynosCameraFrameEntity *tmpEntity;

    tmpEntity = parentEntity->getNextEntity();
    ret = parentEntity->setNextEntity(newEntity);
    if (ret != NO_ERROR) {
        CLOGE("setNextEntity fail, ret(%d)", ret);
        return ret;
    }
    newEntity->setNextEntity(tmpEntity);

    return ret;
}

status_t ExynosCameraFrame::addChildEntity(
        ExynosCameraFrameEntity *parentEntity,
        ExynosCameraFrameEntity *newEntity,
        int parentPipeId)
{
    status_t ret = NO_ERROR;

    if (parentEntity == NULL) {
        CLOGE("parentEntity is NULL");
        return BAD_VALUE;
    }

    /* TODO: This is not suit in case of newEntity->next != NULL */
    ExynosCameraFrameEntity *tmpEntity;

    tmpEntity = parentEntity->getNextEntity();
    ret = parentEntity->setNextEntity(newEntity);
    if (ret != NO_ERROR) {
        CLOGE("setNextEntity fail, ret(%d)", ret);
        return ret;
    }

    if (0 <= parentPipeId) {
        ret = newEntity->setParentPipeId((enum pipeline)parentPipeId);
        if (ret != NO_ERROR) {
            CLOGE("setParentPipeId(%d) fail, ret(%d)", parentPipeId, ret);
            return ret;
        }
    } else {
        CLOGW("parentPipeId(%d) < 0. you may set parentPipeId which connect between parent(%d) and child(%d)",
             parentPipeId, parentEntity->getPipeId(), newEntity->getPipeId());
    }

    newEntity->setNextEntity(tmpEntity);
    return ret;
}

ExynosCameraFrameEntity *ExynosCameraFrame::getFirstEntity(void)
{
    List<ExynosCameraFrameEntity *>::iterator r;
    ExynosCameraFrameEntity *firstEntity = NULL;

    Mutex::Autolock l(m_linkageLock);
    if (m_linkageList.empty()) {
        CLOGE("m_linkageList is empty");
        firstEntity = NULL;
        return firstEntity;
    }

    r = m_linkageList.begin()++;
    m_currentEntity = r;
    firstEntity = *r;

    return firstEntity;
}

ExynosCameraFrameEntity *ExynosCameraFrame::getNextEntity(void)
{
    ExynosCameraFrameEntity *nextEntity = NULL;

    Mutex::Autolock l(m_linkageLock);
    m_currentEntity++;

    if (m_currentEntity == m_linkageList.end()) {
        return nextEntity;
    }

    nextEntity = *m_currentEntity;

    return nextEntity;
}
/* Unused, but useful */
/*
ExynosCameraFrameEntity *ExynosCameraFrame::getChildEntity(ExynosCameraFrameEntity *parentEntity)
{
    ExynosCameraFrameEntity *childEntity = NULL;

    if (parentEntity == NULL) {
        CLOGE("parentEntity is NULL");
        return childEntity;
    }

    childEntity = parentEntity->getNextEntity();

    return childEntity;
}
*/

ExynosCameraFrameEntity *ExynosCameraFrame::searchEntityByPipeId(uint32_t pipeId)
{
    List<ExynosCameraFrameEntity *>::iterator r;
    ExynosCameraFrameEntity *curEntity = NULL;
    int listSize = 0;

    Mutex::Autolock l(m_linkageLock);
    if (m_linkageList.empty()) {
        CLOGE("m_linkageList is empty");
        return NULL;
    }

    listSize = m_linkageList.size();
    r = m_linkageList.begin();

    for (int i = 0; i < listSize; i++) {
        curEntity = *r;
        if (curEntity == NULL) {
            CLOGE("curEntity is NULL, index(%d), linkageList size(%d)",
                 i, listSize);
            return NULL;
        }

        while (curEntity != NULL) {
            if (curEntity->getPipeId() == pipeId)
                return curEntity;
            curEntity = curEntity->getNextEntity();
        }
        r++;
    }

    CLOGD("Cannot find matched entity, frameCount(%d), pipeId(%d)", getFrameCount(), pipeId);

    return NULL;
}

status_t ExynosCameraFrame::setSrcBuffer(uint32_t pipeId,
                                         ExynosCameraBuffer srcBuf,
                                         uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;

    if (nodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->setSrcBuf(srcBuf, nodeIndex);
    if (ret != NO_ERROR) {
        CLOGE("Could not set src buffer, ret(%d)", ret);
        return ret;
    }

    return ret;
}

status_t ExynosCameraFrame::setDstBuffer(uint32_t pipeId,
                                         ExynosCameraBuffer dstBuf,
                                         uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;

    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->setDstBuf(dstBuf, nodeIndex);
    if (ret != NO_ERROR) {
        CLOGE("Could not set dst buffer, ret(%d)", ret);
        return ret;
    }

    /* TODO: set buffer to child node's source */
    entity = entity->getNextEntity();
    if (entity != NULL) {
        ret = entity->setSrcBuf(dstBuf);
        if (ret != NO_ERROR) {
            CLOGE("Could not set dst buffer, ret(%d)", ret);
            return ret;
        }
    }

    return ret;
}

status_t ExynosCameraFrame::setDstBuffer(uint32_t pipeId,
                                         ExynosCameraBuffer dstBuf,
                                         uint32_t nodeIndex,
                                         int      parentPipeId)
{
    status_t ret = NO_ERROR;

    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->setDstBuf(dstBuf, nodeIndex);
    if (ret != NO_ERROR) {
        CLOGE("Could not set dst buffer, ret(%d)", ret);
        return ret;
    }

    /* TODO: set buffer to child node's source */
    entity = entity->getNextEntity();
    if (entity != NULL) {
        bool flagSetChildEntity = false;

        /*
         * it  will set child's source buffer
         * when no specific parent set. (for backward compatibility)
         * when specific parent only. (for MCPipe)
         */
        if (entity->flagSpecficParent() == true) {
            if (parentPipeId == entity->getParentPipeId()) {
                flagSetChildEntity = true;
            } else {
                CLOGV("parentPipeId(%d) != entity->getParentPipeId()(%d). so skip setting child src Buf",
                     parentPipeId, entity->getParentPipeId());
            }
        } else {
            /* this is for backward compatiblity */
            flagSetChildEntity = true;
        }

        /* child mode need to setting next */
        if (flagSetChildEntity == true) {
            ret = entity->setSrcBuf(dstBuf);
            if (ret != NO_ERROR) {
                CLOGE("Could not set dst buffer, ret(%d)", ret);
                return ret;
            }
        }
    }

    return ret;
}

status_t ExynosCameraFrame::getSrcBuffer(uint32_t pipeId,
                                         ExynosCameraBuffer *srcBuf,
                                         uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;

    if (nodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->getSrcBuf(srcBuf, nodeIndex);
    if (ret != NO_ERROR) {
        CLOGE("Could not get src buffer, ret(%d)", ret);
        return ret;
    }

    return ret;
}

status_t ExynosCameraFrame::getDstBuffer(uint32_t pipeId,
                                         ExynosCameraBuffer *dstBuf,
                                         uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;

    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->getDstBuf(dstBuf, nodeIndex);
    if (ret != NO_ERROR) {
        CLOGE("Could not get dst buffer, ret(%d)", ret);
        return ret;
    }

    return ret;
}

status_t ExynosCameraFrame::setSrcRect(uint32_t pipeId, ExynosRect srcRect, uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->setSrcRect(srcRect, nodeIndex);
    if (ret != NO_ERROR) {
        CLOGE("Could not set src rect, ret(%d)", ret);
        return ret;
    }

    return ret;
}

status_t ExynosCameraFrame::setDstRect(uint32_t pipeId, ExynosRect dstRect, uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->setDstRect(dstRect);
    if (ret != NO_ERROR) {
        CLOGE("Could not set dst rect, ret(%d)", ret);
        return ret;
    }

    /* TODO: set buffer to child node's source */
    entity = entity->getNextEntity();
    if (entity != NULL) {
        ret = entity->setSrcRect(dstRect, nodeIndex);
        if (ret != NO_ERROR) {
            CLOGE("Could not set dst rect, ret(%d)", ret);
            return ret;
        }
    }

    return ret;
}

status_t ExynosCameraFrame::getSrcRect(uint32_t pipeId, ExynosRect *srcRect, uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->getSrcRect(srcRect, nodeIndex);
    if (ret != NO_ERROR) {
        CLOGE("Could not get src rect, ret(%d)", ret);
        return ret;
    }

    return ret;
}

status_t ExynosCameraFrame::getDstRect(uint32_t pipeId, ExynosRect *dstRect, uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->getDstRect(dstRect, nodeIndex);
    if (ret != NO_ERROR) {
        CLOGE("Could not get dst rect, ret(%d)", ret);
        return ret;
    }

    return ret;
}

status_t ExynosCameraFrame::getSrcBufferState(uint32_t pipeId,
                                         entity_buffer_state_t *state,
                                         uint32_t nodeIndex)
{
    if (nodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    *state = entity->getSrcBufState(nodeIndex);

    return NO_ERROR;
}

status_t ExynosCameraFrame::getDstBufferState(uint32_t pipeId,
                                         entity_buffer_state_t *state,
                                         uint32_t nodeIndex)
{
    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    *state = entity->getDstBufState(nodeIndex);

    return NO_ERROR;
}

status_t ExynosCameraFrame::setSrcBufferState(uint32_t pipeId,
                                         entity_buffer_state_t state,
                                         uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;

    if (nodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->setSrcBufState(state, nodeIndex);

    return ret;
}

status_t ExynosCameraFrame::setDstBufferState(uint32_t pipeId,
                                         entity_buffer_state_t state,
                                         uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;

    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->setDstBufState(state, nodeIndex);
    if (ret != NO_ERROR) {
        CLOGE("Could not set dst buffer, ret(%d)", ret);
        return ret;
    }

    /* Set buffer to child node's source */
    entity = entity->getNextEntity();
    if (entity != NULL) {
        ret = entity->setSrcBufState(state);
        if (ret != NO_ERROR) {
            CLOGE("Could not set src buffer, ret(%d)", ret);
            return ret;
        }
    }

    return ret;
}

status_t ExynosCameraFrame::ensureSrcBufferState(uint32_t pipeId,
                                         entity_buffer_state_t state)
{
    status_t ret = NO_ERROR;
    int retry = 0;
    entity_buffer_state_t curState;

    do {
        ret = getSrcBufferState(pipeId, &curState);
        if (ret != NO_ERROR)
            continue;

        if (state == curState) {
            ret = OK;
            break;
        } else {
            ret = BAD_VALUE;
            usleep(100);
        }

        retry++;
        if (retry == 10)
            ret = TIMED_OUT;
    } while (ret != OK && retry < 100);

    CLOGV(" retry count %d", retry);

    return ret;
}

status_t ExynosCameraFrame::ensureDstBufferState(uint32_t pipeId,
                                         entity_buffer_state_t state)
{
    status_t ret = NO_ERROR;
    int retry = 0;
    entity_buffer_state_t curState;

    do {
        ret = getDstBufferState(pipeId, &curState);
        if (ret != NO_ERROR)
            continue;

        if (state == curState) {
            ret = OK;
            break;
        } else {
            ret = BAD_VALUE;
            usleep(100);
        }

        retry++;
        if (retry == 10)
            ret = TIMED_OUT;
    } while (ret != OK && retry < 100);

    CLOGV(" retry count %d", retry);

    return ret;
}

status_t ExynosCameraFrame::setEntityState(uint32_t pipeId,
                                           entity_state_t state)
{
    Mutex::Autolock lock(m_entityLock);
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    if (entity->getEntityState() == ENTITY_STATE_COMPLETE &&
        state != ENTITY_STATE_REWORK) {
        return NO_ERROR;
    }

    if (state == ENTITY_STATE_COMPLETE) {
        m_numCompletePipe++;
        if (m_numCompletePipe >= m_numRequestPipe)
            setFrameState(FRAME_STATE_COMPLETE);
    }

    entity->setEntityState(state);

    return NO_ERROR;
}

status_t ExynosCameraFrame::getEntityState(uint32_t pipeId,
                                           entity_state_t *state)
{
    Mutex::Autolock lock(m_entityLock);
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    *state = entity->getEntityState();
    return NO_ERROR;
}

status_t ExynosCameraFrame::getEntityBufferType(uint32_t pipeId,
                                                entity_buffer_type_t *type)
{
    Mutex::Autolock lock(m_entityLock);
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    *type = entity->getBufType();
    return NO_ERROR;
}

uint32_t ExynosCameraFrame::getFrameCount(void)
{
    return m_frameCount;
}

int32_t ExynosCameraFrame::getMetaFrameCount(uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return 0;
    }

    return getMetaDmRequestFrameCount(&m_metaData[srcNodeIndex]);
}

status_t ExynosCameraFrame::setNumRequestPipe(uint32_t num)
{
    m_numRequestPipe = num;
    return NO_ERROR;
}

uint32_t ExynosCameraFrame::getNumRequestPipe(void)
{
    return m_numRequestPipe;
}

uint32_t ExynosCameraFrame::getNumRemainPipe(void)
{
    int numRemainPipe = m_numRequestPipe - m_numCompletePipe;
    
    return (numRemainPipe > 0) ? numRemainPipe : 0;
}

bool ExynosCameraFrame::isComplete(void)
{
    return checkFrameState(FRAME_STATE_COMPLETE);
}

ExynosCameraFrameEntity *ExynosCameraFrame::getFrameDoneEntity(void)
{
    List<ExynosCameraFrameEntity *>::iterator r;
    ExynosCameraFrameEntity *curEntity = NULL;

    Mutex::Autolock l(m_linkageLock);
    if (m_linkageList.empty()) {
        CLOGE("m_linkageList is empty");
        return NULL;
    }

    r = m_linkageList.begin()++;
    curEntity = *r;

    while (r != m_linkageList.end()) {
        if (curEntity != NULL) {
            switch (curEntity->getEntityState()) {
            case ENTITY_STATE_FRAME_SKIP:
            case ENTITY_STATE_REWORK:
            case ENTITY_STATE_FRAME_DONE:
                if (curEntity->getNextEntity() != NULL) {
                    curEntity = curEntity->getNextEntity();
                    continue;
                }
                return curEntity;
                break;
            default:
                break;
            }
        }
        r++;
        curEntity = *r;
    }

    return NULL;
}

ExynosCameraFrameEntity *ExynosCameraFrame::getFrameDoneEntity(uint32_t pipeID)
{
    List<ExynosCameraFrameEntity *>::iterator r;
    ExynosCameraFrameEntity *curEntity = NULL;

    Mutex::Autolock l(m_linkageLock);
    if (m_linkageList.empty()) {
        CLOGE("m_linkageList is empty");
        return NULL;
    }

    r = m_linkageList.begin()++;
    curEntity = *r;

    while (r != m_linkageList.end()) {
        if (curEntity != NULL && pipeID == curEntity->getPipeId()) {
            switch (curEntity->getEntityState()) {
            case ENTITY_STATE_FRAME_SKIP:
            case ENTITY_STATE_REWORK:
            case ENTITY_STATE_FRAME_DONE:
                if (curEntity->getNextEntity() != NULL) {
                    curEntity = curEntity->getNextEntity();
                    continue;
                }
                return curEntity;
                break;
            default:
                break;
            }
        }
        r++;
        curEntity = *r;
    }

    return NULL;
}

ExynosCameraFrameEntity *ExynosCameraFrame::getFrameDoneFirstEntity(void)
{
    List<ExynosCameraFrameEntity *>::iterator r;
    ExynosCameraFrameEntity *curEntity = NULL;

    Mutex::Autolock l(m_linkageLock);
    if (m_linkageList.empty()) {
        CLOGE("m_linkageList is empty");
        return NULL;
    }

    r = m_linkageList.begin()++;
    curEntity = *r;

    while (r != m_linkageList.end()) {
        if (curEntity != NULL) {
            switch (curEntity->getEntityState()) {
            case ENTITY_STATE_REWORK:
                if (curEntity->getNextEntity() != NULL) {
                    curEntity = curEntity->getNextEntity();
                    continue;
                }
                return curEntity;
                break;
            case ENTITY_STATE_FRAME_DONE:
                return curEntity;
                break;
            case ENTITY_STATE_FRAME_SKIP:
            case ENTITY_STATE_COMPLETE:
                if (curEntity->getNextEntity() != NULL) {
                    curEntity = curEntity->getNextEntity();
                    continue;
                }
                break;
            default:
                break;
            }
        }
        r++;
        curEntity = *r;
    }

    return NULL;
}

ExynosCameraFrameEntity *ExynosCameraFrame::getFrameDoneFirstEntity(uint32_t pipeID)
{
    List<ExynosCameraFrameEntity *>::iterator r;
    ExynosCameraFrameEntity *curEntity = NULL;

    Mutex::Autolock l(m_linkageLock);
    if (m_linkageList.empty()) {
        CLOGE("m_linkageList is empty");
        return NULL;
    }

    r = m_linkageList.begin()++;
    curEntity = *r;

    while (r != m_linkageList.end()) {
        if (curEntity != NULL) {
            switch (curEntity->getEntityState()) {
            case ENTITY_STATE_REWORK:
                if (curEntity->getPipeId() == pipeID)
                    return curEntity;

                if (curEntity->getNextEntity() != NULL) {
                    curEntity = curEntity->getNextEntity();
                    continue;
                }
                break;
            case ENTITY_STATE_FRAME_DONE:
                if (curEntity->getPipeId() == pipeID)
                    return curEntity;

                if (curEntity->getNextEntity() != NULL) {
                    curEntity = curEntity->getNextEntity();
                    continue;
                }
                break;
            case ENTITY_STATE_FRAME_SKIP:
            case ENTITY_STATE_COMPLETE:
                if (curEntity->getNextEntity() != NULL) {
                    curEntity = curEntity->getNextEntity();
                    continue;
                }
                break;
            default:
                break;
            }
        }
        r++;
        curEntity = *r;
    }

    return NULL;
}

status_t ExynosCameraFrame::skipFrame(void)
{
    Mutex::Autolock lock(m_frameStateLock);
    m_frameState = FRAME_STATE_SKIPPED;

    return NO_ERROR;
}

void ExynosCameraFrame::setFrameState(frame_status_t state)
{
    Mutex::Autolock lock(m_frameStateLock);
    /* TODO: We need state machine */
    if (state > FRAME_STATE_INVALID)
        m_frameState = FRAME_STATE_INVALID;
    else
        m_frameState = state;
}

frame_status_t ExynosCameraFrame::getFrameState(void)
{
    Mutex::Autolock lock(m_frameStateLock);
    return m_frameState;
}

bool ExynosCameraFrame::checkFrameState(frame_status_t state)
{
    Mutex::Autolock lock(m_frameStateLock);
    return (m_frameState == state) ? true : false;
}

void ExynosCameraFrame::printEntity(void)
{
    List<ExynosCameraFrameEntity *>::iterator r;
    ExynosCameraFrameEntity *curEntity = NULL;
    int listSize = 0;

    Mutex::Autolock l(m_linkageLock);
    if (m_linkageList.empty()) {
        CLOGE("m_linkageList is empty");
        return;
    }

    listSize = m_linkageList.size();
    r = m_linkageList.begin();

    CLOGD(" FrameCount(%d), request(%d), complete(%d)", getFrameCount(), m_numRequestPipe, m_numCompletePipe);

    for (int i = 0; i < listSize; i++) {
        curEntity = *r;
        if (curEntity == NULL) {
            CLOGE("curEntity is NULL, index(%d)", i);
            return;
        }

        CLOGD("sibling id(%d), state(%d)",
             curEntity->getPipeId(), curEntity->getEntityState());

        while (curEntity != NULL) {
            CLOGD("----- Child id(%d), state(%d)",
                 curEntity->getPipeId(), curEntity->getEntityState());
            curEntity = curEntity->getNextEntity();
        }
        r++;
    }

    return;
}

void ExynosCameraFrame::printNotDoneEntity(void)
{
    List<ExynosCameraFrameEntity *>::iterator r;
    ExynosCameraFrameEntity *curEntity = NULL;
    int listSize = 0;

    Mutex::Autolock l(m_linkageLock);
    if (m_linkageList.empty()) {
        CLOGE("m_linkageList is empty");
        return;
    }

    listSize = m_linkageList.size();
    r = m_linkageList.begin();

    CLOGD(" FrameCount(%d), request(%d), complete(%d)",
             getFrameCount(), m_numRequestPipe, m_numCompletePipe);

    for (int i = 0; i < listSize; i++) {
        curEntity = *r;
        if (curEntity == NULL) {
            CLOGE("curEntity is NULL, index(%d)", i);
            return;
        }

        if (curEntity->getEntityState() != ENTITY_STATE_COMPLETE) {
            CLOGD("sibling id(%d), state(%d)",
                     curEntity->getPipeId(), curEntity->getEntityState());
        }

        while (curEntity != NULL) {
            if (curEntity->getEntityState() != ENTITY_STATE_COMPLETE) {
                CLOGD("----- Child id(%d), state(%d)",
                         curEntity->getPipeId(), curEntity->getEntityState());
            }
            curEntity = curEntity->getNextEntity();
        }
        r++;
    }

    return;
}

void ExynosCameraFrame::dump(void)
{
    printEntity();

    for (int i = 0; i < MAX_NUM_PIPES; i ++) {
        if (m_request[INDEX(i)] == true)
            CLOGI("pipeId(%d)'s request is ture", i);
    }
}

void ExynosCameraFrame::frameLock(void)
{
    m_frameLocked = true;
}

void ExynosCameraFrame::frameUnlock(void)
{
    m_frameLocked = false;
}

bool ExynosCameraFrame::getFrameLockState(void)
{
    return m_frameLocked;
}

status_t ExynosCameraFrame::initMetaData(struct camera2_shot_ext *shot, uint32_t srcNodeIndex)
{
    status_t ret = NO_ERROR;

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    if (shot != NULL) {
        CLOGV(" initialize shot_ext");
        memcpy(&m_metaData[srcNodeIndex], shot, sizeof(struct camera2_shot_ext));
    }

    ret = m_parameters->duplicateCtrlMetadata(&m_metaData[srcNodeIndex]);
    if (ret != NO_ERROR) {
        CLOGE("duplicate Ctrl metadata fail");
        return INVALID_OPERATION;
    }

    return ret;
}

status_t ExynosCameraFrame::getMetaData(struct camera2_shot_ext *shot, uint32_t srcNodeIndex)
{
    if (shot == NULL) {
        CLOGE(" buffer is NULL");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    memcpy(shot, &m_metaData[srcNodeIndex], sizeof(struct camera2_shot_ext));

    return NO_ERROR;
}

status_t ExynosCameraFrame::setMetaData(struct camera2_shot_ext *shot, uint32_t srcNodeIndex)
{
    if (shot == NULL) {
        CLOGE(" buffer is NULL");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }


    memcpy(&m_metaData[srcNodeIndex], shot, sizeof(struct camera2_shot_ext));

    return NO_ERROR;
}

status_t ExynosCameraFrame::storeDynamicMeta(struct camera2_shot_ext *shot, uint32_t srcNodeIndex)
{
    if (shot == NULL) {
        CLOGE(" buffer is NULL");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    if (getMetaDmRequestFrameCount(shot) == 0)
        CLOGW(" DM Frame count is ZERO");

    memcpy(&m_metaData[srcNodeIndex].shot.dm, &shot->shot.dm, sizeof(struct camera2_dm));

    return NO_ERROR;
}

status_t ExynosCameraFrame::storeDynamicMeta(struct camera2_dm *dm, uint32_t srcNodeIndex)
{
    if (dm == NULL) {
        CLOGE(" buffer is NULL");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    if (getMetaDmRequestFrameCount(dm) == 0)
        CLOGW(" DM Frame count is ZERO");

    memcpy(&m_metaData[srcNodeIndex].shot.dm, dm, sizeof(struct camera2_dm));

    return NO_ERROR;
}

status_t ExynosCameraFrame::storeUserDynamicMeta(struct camera2_shot_ext *shot, uint32_t srcNodeIndex)
{
    if (shot == NULL) {
        CLOGE(" buffer is NULL");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    memcpy(&m_metaData[srcNodeIndex].shot.udm, &shot->shot.udm, sizeof(struct camera2_udm));

    return NO_ERROR;
}

status_t ExynosCameraFrame::storeUserDynamicMeta(struct camera2_udm *udm, uint32_t srcNodeIndex)
{
    if (udm == NULL) {
        CLOGE(" buffer is NULL");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    memcpy(&m_metaData[srcNodeIndex].shot.udm, udm, sizeof(struct camera2_udm));

    return NO_ERROR;
}

status_t ExynosCameraFrame::getDynamicMeta(struct camera2_shot_ext *shot, uint32_t srcNodeIndex)
{
    if (shot == NULL) {
        CLOGE(" buffer is NULL");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    memcpy(&shot->shot.dm, &m_metaData[srcNodeIndex].shot.dm, sizeof(struct camera2_dm));

    return NO_ERROR;
}

status_t ExynosCameraFrame::getDynamicMeta(struct camera2_dm *dm, uint32_t srcNodeIndex)
{
    if (dm == NULL) {
        CLOGE(" buffer is NULL");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    memcpy(dm, &m_metaData[srcNodeIndex].shot.dm, sizeof(struct camera2_dm));

    return NO_ERROR;
}

status_t ExynosCameraFrame::getUserDynamicMeta(struct camera2_shot_ext *shot, uint32_t srcNodeIndex)
{
    if (shot == NULL) {
        CLOGE(" buffer is NULL");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    memcpy(&shot->shot.udm, &m_metaData[srcNodeIndex].shot.udm, sizeof(struct camera2_udm));

    return NO_ERROR;
}

status_t ExynosCameraFrame::getUserDynamicMeta(struct camera2_udm *udm, uint32_t srcNodeIndex)
{
    if (udm == NULL) {
        CLOGE(" buffer is NULL");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    memcpy(udm, &m_metaData[srcNodeIndex].shot.udm, sizeof(struct camera2_udm));

    return NO_ERROR;
}

status_t ExynosCameraFrame::setMetaDataEnable(bool flag, uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    m_metaDataEnable[srcNodeIndex] = flag;
    return NO_ERROR;
}

bool ExynosCameraFrame::getMetaDataEnable(uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return false;
    }

    long count = 0;

    while (count < DM_WAITING_COUNT) {
        if (m_metaDataEnable[srcNodeIndex] == true) {
            if (0 < count)
                CLOGD(" metadata enable count(%ld) ", count);

            break;
        }

        count++;
        usleep(WAITING_TIME);
    }

    return m_metaDataEnable[srcNodeIndex];
}

int ExynosCameraFrame::getZoom(uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    return m_zoom[srcNodeIndex];
}

status_t ExynosCameraFrame::setZoom(int zoom, uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    m_zoom[srcNodeIndex] = zoom;

    return NO_ERROR;
}

float ExynosCameraFrame::getZoomRatio(uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    return m_zoomRatio[srcNodeIndex];
}

status_t ExynosCameraFrame::setZoomRatio(float zoomRatio, uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    m_zoomRatio[srcNodeIndex] = zoomRatio;

    return NO_ERROR;
}

status_t ExynosCameraFrame::getNodeGroupInfo(struct camera2_node_group *node_group, int index, uint32_t srcNodeIndex)
{
    if (node_group == NULL) {
        CLOGE(" node_group is NULL");
        return BAD_VALUE;
    }

    if (index >= PERFRAME_NODE_GROUP_MAX) {
        CLOGE(" index is bigger than PERFRAME_NODE_GROUP_MAX");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    memcpy(node_group, &m_node_gorup[srcNodeIndex][index], sizeof(struct camera2_node_group));

    return NO_ERROR;
}

status_t ExynosCameraFrame::getNodeGroupInfo(struct camera2_node_group *node_group, int index, int *zoom, uint32_t srcNodeIndex)
{
    getNodeGroupInfo(node_group, index, srcNodeIndex);
    *zoom = m_zoom[srcNodeIndex];

    return NO_ERROR;
}

status_t ExynosCameraFrame::getNodeGroupInfo(struct camera2_node_group *node_group, int index, float *zoomRatio, uint32_t srcNodeIndex)
{
    getNodeGroupInfo(node_group, index, srcNodeIndex);
    *zoomRatio = m_zoomRatio[srcNodeIndex];

    return NO_ERROR;
}

status_t ExynosCameraFrame::storeNodeGroupInfo(struct camera2_node_group *node_group, int index, uint32_t srcNodeIndex)
{
    if (node_group == NULL) {
        CLOGE(" node_group is NULL");
        return BAD_VALUE;
    }

    if (index >= PERFRAME_NODE_GROUP_MAX) {
        CLOGE(" index is bigger than PERFRAME_NODE_GROUP_MAX");
        return BAD_VALUE;
    }

    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    memcpy(&m_node_gorup[srcNodeIndex][index], node_group, sizeof(struct camera2_node_group));

    return NO_ERROR;
}
status_t ExynosCameraFrame::storeNodeGroupInfo(struct camera2_node_group *node_group, int index, int zoom, uint32_t srcNodeIndex)
{
    storeNodeGroupInfo(node_group, index, srcNodeIndex);
    m_zoom[srcNodeIndex] = zoom;

    return NO_ERROR;
}

status_t ExynosCameraFrame::storeNodeGroupInfo(struct camera2_node_group *node_group, int index, float zoomRatio, uint32_t srcNodeIndex)
{
    storeNodeGroupInfo(node_group, index, srcNodeIndex);
    m_zoomRatio[srcNodeIndex] = zoomRatio;

    return NO_ERROR;
}


void ExynosCameraFrame::dumpNodeGroupInfo(const char *name, uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return;
    }

    if (name != NULL)
        CLOGD("(%s)++++++++++++++++++++ frameCount(%d)", name, m_frameCount);
    else
        CLOGD("()++++++++++++++++++++ frameCount(%d)", m_frameCount);

    for (int i = 0; i < PERFRAME_NODE_GROUP_MAX; i ++) {
        CLOGI("Leader[%d] (%d, %d, %d, %d)(%d, %d, %d, %d)(%d %d)",
            i,
            m_node_gorup[srcNodeIndex][i].leader.input.cropRegion[0],
            m_node_gorup[srcNodeIndex][i].leader.input.cropRegion[1],
            m_node_gorup[srcNodeIndex][i].leader.input.cropRegion[2],
            m_node_gorup[srcNodeIndex][i].leader.input.cropRegion[3],
            m_node_gorup[srcNodeIndex][i].leader.output.cropRegion[0],
            m_node_gorup[srcNodeIndex][i].leader.output.cropRegion[1],
            m_node_gorup[srcNodeIndex][i].leader.output.cropRegion[2],
            m_node_gorup[srcNodeIndex][i].leader.output.cropRegion[3],
            m_node_gorup[srcNodeIndex][i].leader.request,
            m_node_gorup[srcNodeIndex][i].leader.vid);

        for (int j = 0; j < CAPTURE_NODE_MAX; j ++) {
            CLOGI("Capture[%d][%d] (%d, %d, %d, %d)(%d, %d, %d, %d)(%d, %d)",
                i,
                j,
                m_node_gorup[srcNodeIndex][i].capture[j].input.cropRegion[0],
                m_node_gorup[srcNodeIndex][i].capture[j].input.cropRegion[1],
                m_node_gorup[srcNodeIndex][i].capture[j].input.cropRegion[2],
                m_node_gorup[srcNodeIndex][i].capture[j].input.cropRegion[3],
                m_node_gorup[srcNodeIndex][i].capture[j].output.cropRegion[0],
                m_node_gorup[srcNodeIndex][i].capture[j].output.cropRegion[1],
                m_node_gorup[srcNodeIndex][i].capture[j].output.cropRegion[2],
                m_node_gorup[srcNodeIndex][i].capture[j].output.cropRegion[3],
                m_node_gorup[srcNodeIndex][i].capture[j].request,
                m_node_gorup[srcNodeIndex][i].capture[j].vid);
        }

        if (name != NULL)
            CLOGD("(%s)------------------------ ", name);
        else
            CLOGD("()------------------------ ");
    }

    if (name != NULL)
        CLOGD("(%s)++++++++++++++++++++", name);
    else
        CLOGD("()++++++++++++++++++++");

    return;
}

sync_type_t ExynosCameraFrame::getSyncType(void)
{
    return m_syncType;
}

status_t ExynosCameraFrame::setSyncType(sync_type_t type)
{
    m_syncType = type;

    return NO_ERROR;
}

int ExynosCameraFrame::getCameraId(void)
{
    return m_cameraId;
}

/* backup for reprocessing */
void ExynosCameraFrame::setReprocessingFrameType(frame_type_t frameType)
{
    m_reprocessingFrameType = frameType;
}

uint32_t ExynosCameraFrame::getReprocessingFrameType()
{
    return m_reprocessingFrameType;
}

int ExynosCameraFrame::getReprocessingZoom(void)
{
    return m_reprocessingZoom;
}

status_t ExynosCameraFrame::setReprocessingZoom(int zoom)
{
    m_reprocessingZoom = zoom;

    return NO_ERROR;
}

sync_type_t ExynosCameraFrame::getReprocessingSyncType(void)
{
    return m_reprocessingSyncType;
}

status_t ExynosCameraFrame::setReprocessingSyncType(sync_type_t type)
{
    m_reprocessingSyncType = type;

    return NO_ERROR;
}

void ExynosCameraFrame::setJpegSize(int size)
{
    m_jpegSize = size;
}

int ExynosCameraFrame::getJpegSize(void)
{
    return m_jpegSize;
}

int64_t ExynosCameraFrame::getTimeStamp(uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    return (int64_t)getMetaDmSensorTimeStamp(&m_metaData[srcNodeIndex]);
}

#ifdef SAMSUNG_TIMESTAMP_BOOT
int64_t ExynosCameraFrame::getTimeStampBoot(uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return BAD_VALUE;
    }

    return (int64_t)getMetaUdmSensorTimeStampBoot(&m_metaData[srcNodeIndex]);
}
#endif

void ExynosCameraFrame::getFpsRange(uint32_t *min, uint32_t *max, uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return;
    }

    getMetaCtlAeTargetFpsRange(&m_metaData[srcNodeIndex], min, max);
}

void ExynosCameraFrame::setFpsRange(uint32_t min, uint32_t max, uint32_t srcNodeIndex)
{
    if (srcNodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE("Invalid srcNodeIndex index, max(%d) index(%d)", SRC_BUFFER_COUNT_MAX, srcNodeIndex);
        return;
    }

    setMetaCtlAeTargetFpsRange(&m_metaData[srcNodeIndex], min, max);
    setMetaCtlSensorFrameDuration(&m_metaData[srcNodeIndex], (uint64_t)((1000 * 1000 * 1000) / (uint64_t)max));
}

void ExynosCameraFrame::setRequest(uint32_t pipeId, bool val)
{
    if ((pipeId % 100) >= MAX_NUM_PIPES) {
        CLOGE("[F%d]Invalid pipeId(%d)", m_frameCount, pipeId);
    } else {
        m_request[INDEX(pipeId)] = val;
    }
}

bool ExynosCameraFrame::getRequest(uint32_t pipeId)
{
    bool request = false;

    if ((pipeId % 100) >= MAX_NUM_PIPES) {
        CLOGE("[F%d]Invalid pipeId(%d)", m_frameCount, pipeId);
    } else {
        request = m_request[INDEX(pipeId)];
    }

    return request;
}

bool ExynosCameraFrame::getIspDone(void)
{
    return m_ispDoneFlag;
}

void ExynosCameraFrame::setIspDone(bool done)
{
    m_ispDoneFlag = done;
}

bool ExynosCameraFrame::get3aaDrop(void)
{
    return m_3aaDropFlag;
}

void ExynosCameraFrame::set3aaDrop(bool flag)
{
    m_3aaDropFlag = flag;
}

void ExynosCameraFrame::setIspcDrop(bool flag)
{
    m_ispcDropFlag = flag;
}

bool ExynosCameraFrame::getIspcDrop(void)
{
    return m_ispcDropFlag;
}

void ExynosCameraFrame::setDisDrop(bool flag)
{
    m_disDropFlag = flag;
}

bool ExynosCameraFrame::getDisDrop(void)
{
    return m_disDropFlag;
}

bool ExynosCameraFrame::getScpDrop(void)
{
    return m_scpDropFlag;
}

void ExynosCameraFrame::setScpDrop(bool flag)
{
    m_scpDropFlag = flag;
}

bool ExynosCameraFrame::getSccDrop(void)
{
    return m_sccDropFlag;
}

void ExynosCameraFrame::setSccDrop(bool flag)
{
    m_sccDropFlag = flag;
}

uint32_t ExynosCameraFrame::getUniqueKey(void)
{
    return m_uniqueKey;
}

status_t ExynosCameraFrame::setUniqueKey(uint32_t uniqueKey)
{
    m_uniqueKey = uniqueKey;
    return NO_ERROR;
}

status_t ExynosCameraFrame::setFrameInfo(ExynosCameraParameters *obj_param, uint32_t frameCount, uint32_t frameType)
{
    status_t ret = NO_ERROR;

    m_parameters = obj_param;
    m_frameCount = frameCount;
    m_frameType = frameType;
    return ret;
}

status_t ExynosCameraFrame::setFrameMgrInfo(frame_key_queue_t *queue)
{
    status_t ret = NO_ERROR;

    m_frameQueue = queue;

    return ret;
}

void ExynosCameraFrame::setFrameType(frame_type_t frameType)
{
    m_frameType = frameType;
}

uint32_t ExynosCameraFrame::getFrameType()
{
    return m_frameType;
}

status_t ExynosCameraFrame::m_init()
{
    m_numRequestPipe = 0;
    m_numCompletePipe = 0;
    m_frameState = FRAME_STATE_READY;
    m_frameLocked = false;

    for (int i = 0; i < SRC_BUFFER_COUNT_MAX; i++) {
        m_metaDataEnable[i] = false;
        m_zoom[i] = 0;
        m_zoomRatio[i] = 1.0f;

        memset(&m_metaData[i], 0x0, sizeof(struct camera2_shot_ext));

        for (int j = 0; j < PERFRAME_NODE_GROUP_MAX; j++)
            memset(&m_node_gorup[i][j], 0x0, sizeof(struct camera2_node_group));
    }

    m_jpegSize = 0;
    m_ispDoneFlag = false;
    m_3aaDropFlag = false;
    m_ispcDropFlag = false;
    m_disDropFlag = false;
    m_scpDropFlag = false;
    m_sccDropFlag = false;

    for (int i = 0; i < MAX_NUM_PIPES; i++)
        m_request[i] = false;

    m_uniqueKey = 0;
    m_yuvStallPortEnable = false;

    for (int i = 0; i < STREAM_TYPE_MAX; i++) {
        m_stream[i] = false;
    }

    m_refCount = 1;
    CLOGV(" Generate frame type(%d), frameCount(%d)", m_frameType, m_frameCount);

#ifdef DEBUG_FRAME_MEMORY_LEAK
    m_privateCheckLeakCount = 0;
    m_countLock.lock();
    m_checkLeakCount++;
    m_checkLeakFrameCount++;
    m_privateCheckLeakCount = m_checkLeakCount;
    CLOGI("[HalFrmCnt:F%d][LeakFrmCnt:F%lld] CONSTRUCTOR (%lld)",
           m_frameCount, m_privateCheckLeakFrameCount, m_checkLeakCount);
    m_countLock.unlock();
#endif

    m_dupBufferInfo.streamID = 0;
    m_dupBufferInfo.extScalerPipeID = 0;

    m_frameQueue = NULL;
    m_syncType = SYNC_TYPE_BASE;

    m_reprocessingFrameType = m_frameType;
    m_reprocessingZoom = 0;
    m_reprocessingSyncType = m_syncType;

#ifdef CORRECT_TIMESTAMP_FOR_SENSORFUSION
    m_adjustedTimestampFlag = false;
#endif

    m_specialCaptureStep = 0;
    m_hasRequest = false;
    m_updateResult = false;

#ifdef SAMSUNG_TN_FEATURE
    for (int i = 0; i < MAX_PIPE_UNI_NUM; i++) {
        m_scenario[i] = -1;
    }
#endif

    return NO_ERROR;
}

status_t ExynosCameraFrame::m_deinit()
{
    CLOGV(" Delete frame type(%d), frameCount(%d)", m_frameType, m_frameCount);
#ifdef DEBUG_FRAME_MEMORY_LEAK
    m_countLock.lock();
    m_checkLeakCount --;
    CLOGI("[HalFrmCnt:F%d][LeakFrmCnt:F%lld] DESTRUCTOR (%lld)",
           m_frameCount, m_privateCheckLeakCount, m_checkLeakCount);
    m_countLock.unlock();
#endif

    if (m_frameQueue != NULL)
        m_frameQueue->pushProcessQ(&m_uniqueKey);

    List<ExynosCameraFrameEntity *>::iterator r;
    ExynosCameraFrameEntity *curEntity = NULL;
    ExynosCameraFrameEntity *tmpEntity = NULL;

    Mutex::Autolock l(m_linkageLock);
    while (!m_linkageList.empty()) {
        r = m_linkageList.begin()++;
        if (*r) {
            curEntity = *r;

            while (curEntity != NULL) {
                tmpEntity = curEntity->getNextEntity();
                CLOGV("PipeId:%d", curEntity->getPipeId());

                delete curEntity;
                curEntity = tmpEntity;
            }

        }
        m_linkageList.erase(r);
    }

    return NO_ERROR;
}

status_t ExynosCameraFrame::setRotation(uint32_t pipeId, int rotation)
{
    status_t ret = NO_ERROR;
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->setRotation(rotation);
    if (ret != NO_ERROR) {
        CLOGE("pipeId(%d)->setRotation(%d) fail", pipeId, rotation);
        return ret;
    }

    return ret;
}

status_t ExynosCameraFrame::getRotation(uint32_t pipeId)
{
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    return entity->getRotation();
}

status_t ExynosCameraFrame::setFlipHorizontal(uint32_t pipeId, int flipHorizontal)
{
    status_t ret = NO_ERROR;
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->setFlipHorizontal(flipHorizontal);
    if (ret != NO_ERROR) {
        CLOGE("pipeId(%d)->setRotation(%d) fail", pipeId, flipHorizontal);
        return ret;
    }

    return ret;
}

status_t ExynosCameraFrame::getFlipHorizontal(uint32_t pipeId)
{
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    return entity->getFlipHorizontal();
}

status_t ExynosCameraFrame::setFlipVertical(uint32_t pipeId, int flipVertical)
{
    status_t ret = NO_ERROR;
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    ret = entity->setFlipVertical(flipVertical);
    if (ret != NO_ERROR) {
        CLOGE("pipeId(%d)->setRotation(%d) fail", pipeId, flipVertical);
        return ret;
    }

    return ret;
}

status_t ExynosCameraFrame::getFlipVertical(uint32_t pipeId)
{
    ExynosCameraFrameEntity *entity = searchEntityByPipeId(pipeId);
    if (entity == NULL) {
        CLOGE("Could not find entity, pipeID(%d)", pipeId);
        return BAD_VALUE;
    }

    return entity->getFlipVertical();
}

#ifdef SAMSUNG_TN_FEATURE
void ExynosCameraFrame::setScenario(int index, int scenario)
{
    if (index < MAX_PIPE_UNI_NUM) {
        m_scenario[index] = scenario;
    }
}

int32_t ExynosCameraFrame::getScenario(int pipeId)
{
    switch (pipeId) {
    case PIPE_PP_UNI_REPROCESSING:
    case PIPE_PP_UNI_REPROCESSING2:
        return m_scenario[pipeId - PIPE_PP_UNI_REPROCESSING];
        break;
    case PIPE_PP_UNI:
    case PIPE_PP_UNI2:
        return m_scenario[pipeId - PIPE_PP_UNI];
        break;
    default:
        return -1;
        break;
    }
}

int32_t ExynosCameraFrame::getScenarioIndex(int scenario)
{
    int index = -1;
    for (int i = 0; i < MAX_PIPE_UNI_NUM; i++) {
        if (m_scenario[i] == scenario) {
            index = i;
            break;
        }
    }

    return index;
}

bool ExynosCameraFrame::hasScenario(int scenario)
{
    int ret = false;
    for (int i = 0; i < MAX_PIPE_UNI_NUM; i++) {
        if (m_scenario[i] == scenario) {
            ret = true;
            break;
        }
    }

    return ret;
}
#endif

void ExynosCameraFrame::setStreamRequested(int stream, bool flag)
{
    if (stream < STREAM_TYPE_MAX) {
        m_stream[stream] = flag;
    }
}

bool ExynosCameraFrame::getStreamRequested(int stream)
{
    if (stream < STREAM_TYPE_MAX) {
        return m_stream[stream];
    } else {
        return false;
    }
}

void ExynosCameraFrame::setUpdateResult(bool flag)
{
    m_updateResult = flag;
}

bool ExynosCameraFrame::getUpdateResult(void)
{
    return m_updateResult;
}

/*
 * ExynosCameraFrameEntity class
 */

ExynosCameraFrameEntity::ExynosCameraFrameEntity(
        uint32_t pipeId,
        entity_type_t type,
        entity_buffer_type_t bufType)
{
    m_pipeId = pipeId;

    if (m_setEntityType(type) != NO_ERROR)
        CLOGE2("setEntityType fail, pipeId(%d), type(%d)", pipeId, type);

    m_bufferType = bufType;
    m_entityState = ENTITY_STATE_READY;

    m_prevEntity = NULL;
    m_nextEntity = NULL;

    m_flagSpecificParent = false;
    m_parentPipeId = -1;

    m_rotation = 0;

    m_flipHorizontal = 0;
    m_flipVertical = 0;
}

status_t ExynosCameraFrameEntity::m_setEntityType(entity_type_t type)
{
    status_t ret = NO_ERROR;

    m_EntityType = type;

    /* for src */
    for(int i = SRC_BUFFER_DEFAULT; i < SRC_BUFFER_COUNT_MAX; i++) {
        switch (type) {
        case ENTITY_TYPE_INPUT_ONLY:
            m_srcBufState[i] = ENTITY_BUFFER_STATE_REQUESTED;
            break;
        case ENTITY_TYPE_OUTPUT_ONLY:
            m_srcBufState[i] = ENTITY_BUFFER_STATE_NOREQ;
            break;
        case ENTITY_TYPE_INPUT_OUTPUT:
            m_srcBufState[i] = ENTITY_BUFFER_STATE_REQUESTED;
            break;
        default:
            m_srcBufState[i] = ENTITY_BUFFER_STATE_NOREQ;
            m_EntityType = ENTITY_TYPE_INVALID;
            ret = BAD_VALUE;
            break;
        }
    }

    /* for dst */
    for(int i = DST_BUFFER_DEFAULT; i < DST_BUFFER_COUNT_MAX; i++) {
        switch (type) {
        case ENTITY_TYPE_INPUT_ONLY:
            m_dstBufState[i] = ENTITY_BUFFER_STATE_NOREQ;
            break;
        case ENTITY_TYPE_OUTPUT_ONLY:
            m_dstBufState[i] = ENTITY_BUFFER_STATE_REQUESTED;
            break;
        case ENTITY_TYPE_INPUT_OUTPUT:
            m_dstBufState[i] = ENTITY_BUFFER_STATE_REQUESTED;
            break;
        default:
            m_dstBufState[i] = ENTITY_BUFFER_STATE_NOREQ;
            m_EntityType = ENTITY_TYPE_INVALID;
            ret = BAD_VALUE;
            break;
        }
    }

    return ret;
}

uint32_t ExynosCameraFrameEntity::getPipeId(void)
{
    return m_pipeId;
}

status_t ExynosCameraFrameEntity::setSrcBuf(ExynosCameraBuffer buf, uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;

    if (nodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    if (m_srcBufState[nodeIndex] == ENTITY_BUFFER_STATE_COMPLETE) {
        CLOGV2("Buffer completed, state(%d)", m_srcBufState[nodeIndex]);
        return NO_ERROR;
    }

    if (m_bufferType != ENTITY_BUFFER_DELIVERY &&
        m_srcBufState[nodeIndex] != ENTITY_BUFFER_STATE_REQUESTED) {
        CLOGE2("Invalid buffer state(%d)", m_srcBufState[nodeIndex]);
        return INVALID_OPERATION;
    }

    this->m_srcBuf[nodeIndex] = buf;

    ret = setSrcBufState(ENTITY_BUFFER_STATE_READY, nodeIndex);

    return ret;
}

status_t ExynosCameraFrameEntity::setDstBuf(ExynosCameraBuffer buf, uint32_t nodeIndex)
{
    status_t ret = NO_ERROR;

    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    if (m_bufferType != ENTITY_BUFFER_DELIVERY &&
        m_dstBufState[nodeIndex] != ENTITY_BUFFER_STATE_REQUESTED) {
        CLOGE2("Invalid buffer state(%d)", m_dstBufState[nodeIndex]);
        return INVALID_OPERATION;
    }

    this->m_dstBuf[nodeIndex] = buf;
    ret = setDstBufState(ENTITY_BUFFER_STATE_READY, nodeIndex);

    return ret;
}

status_t ExynosCameraFrameEntity::getSrcBuf(ExynosCameraBuffer *buf, uint32_t nodeIndex)
{
    if (nodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    *buf = this->m_srcBuf[nodeIndex];

    return NO_ERROR;
}

status_t ExynosCameraFrameEntity::getDstBuf(ExynosCameraBuffer *buf, uint32_t nodeIndex)
{
    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    /* Comment out: It was collide with ExynosCamera's dirty dynamic bayer handling routine.
     * (make error log, but no side effect)
     * This code added for block human error.
     * I will add this code after check the side effect closely.
     */
    /*
    if (this->m_dstBuf[nodeIndex].index == -1) {
        CLOGE2("Invalid buffer index(%d)", nodeIndex);
        return BAD_VALUE;
    }
    */

    *buf = this->m_dstBuf[nodeIndex];

    return NO_ERROR;
}

status_t ExynosCameraFrameEntity::setSrcRect(ExynosRect rect, uint32_t nodeIndex)
{
    if (nodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    this->m_srcRect[nodeIndex] = rect;

    return NO_ERROR;
}

status_t ExynosCameraFrameEntity::setDstRect(ExynosRect rect, uint32_t nodeIndex)
{
    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    this->m_dstRect[nodeIndex] = rect;

    return NO_ERROR;
}

status_t ExynosCameraFrameEntity::getSrcRect(ExynosRect *rect, uint32_t nodeIndex)
{
    if (nodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    *rect = this->m_srcRect[nodeIndex];

    return NO_ERROR;
}

status_t ExynosCameraFrameEntity::getDstRect(ExynosRect *rect, uint32_t nodeIndex)
{
    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    *rect = this->m_dstRect[nodeIndex];

    return NO_ERROR;
}

status_t ExynosCameraFrameEntity::setSrcBufState(entity_buffer_state_t state, uint32_t nodeIndex)
{
    if (nodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    if (m_srcBufState[nodeIndex] == ENTITY_BUFFER_STATE_COMPLETE) {
        CLOGV2("Buffer completed, state(%d)", m_srcBufState[nodeIndex]);
        return NO_ERROR;
    }

    m_srcBufState[nodeIndex] = state;
    return NO_ERROR;
}

status_t ExynosCameraFrameEntity::setDstBufState(entity_buffer_state_t state, uint32_t nodeIndex)
{
    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return BAD_VALUE;
    }

    m_dstBufState[nodeIndex] = state;

    return NO_ERROR;
}

entity_buffer_state_t ExynosCameraFrameEntity::getSrcBufState(uint32_t nodeIndex)
{
    if (nodeIndex >= SRC_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return ENTITY_BUFFER_STATE_INVALID;
    }

    return m_srcBufState[nodeIndex];
}

entity_buffer_state_t ExynosCameraFrameEntity::getDstBufState(uint32_t nodeIndex)
{
    if (nodeIndex >= DST_BUFFER_COUNT_MAX) {
        CLOGE2("Invalid buffer index, index(%d)", nodeIndex);
        return ENTITY_BUFFER_STATE_INVALID;
    }

    return m_dstBufState[nodeIndex];
}

entity_buffer_type_t ExynosCameraFrameEntity::getBufType(void)
{
    return m_bufferType;
}

status_t ExynosCameraFrameEntity::setEntityState(entity_state_t state)
{
    this->m_entityState = state;

    return NO_ERROR;
}

entity_state_t ExynosCameraFrameEntity::getEntityState(void)
{
    return this->m_entityState;
}

ExynosCameraFrameEntity *ExynosCameraFrameEntity::getPrevEntity(void)
{
    return this->m_prevEntity;
}

ExynosCameraFrameEntity *ExynosCameraFrameEntity::getNextEntity(void)
{
    return this->m_nextEntity;
}

status_t ExynosCameraFrameEntity::setPrevEntity(ExynosCameraFrameEntity *entity)
{
    this->m_prevEntity = entity;

    return NO_ERROR;
}

status_t ExynosCameraFrameEntity::setNextEntity(ExynosCameraFrameEntity *entity)
{
    this->m_nextEntity = entity;

    return NO_ERROR;
}

bool ExynosCameraFrameEntity::flagSpecficParent(void)
{
    return m_flagSpecificParent;
}

status_t ExynosCameraFrameEntity::setParentPipeId(enum pipeline parentPipeId)
{
    if (0 <= m_parentPipeId) {
        CLOGE2("m_parentPipeId(%d) is already set. parentPipeId(%d)",
             m_parentPipeId, parentPipeId);
        return BAD_VALUE;
    }

    m_flagSpecificParent = true;
    m_parentPipeId = parentPipeId;

    return NO_ERROR;
}

int ExynosCameraFrameEntity::getParentPipeId(void)
{
    return m_parentPipeId;
}

status_t ExynosCameraFrameEntity::setRotation(int rotation)
{
    m_rotation = rotation;

    return NO_ERROR;
}

int ExynosCameraFrameEntity::getRotation(void)
{
    return m_rotation;
}

status_t ExynosCameraFrameEntity::setFlipHorizontal(int flipHorizontal)
{
    m_flipHorizontal = flipHorizontal;

    return NO_ERROR;
}

int ExynosCameraFrameEntity::getFlipHorizontal(void)
{
    return m_flipHorizontal;
}

status_t ExynosCameraFrameEntity::setFlipVertical(int flipVertical)
{
    m_flipVertical = flipVertical;

    return NO_ERROR;
}

int ExynosCameraFrameEntity::getFlipVertical(void)
{
    return m_flipVertical;
}

}; /* namespace android */