/*
* Copyright (c) 2019 Amlogic, Inc. All rights reserved.
*
* This source code is subject to the terms and conditions defined in below
* which is part of this source code package.
*
* Description:
*/

// Copyright (C) 2019 Amlogic, Inc. All rights reserved.
//
// All information contained herein is Amlogic confidential.
//
// This software is provided to you pursuant to Software License
// Agreement (SLA) with Amlogic Inc ("Amlogic"). This software may be
// used only in accordance with the terms of this agreement.
//
// Redistribution and use in source and binary forms, with or without
// modification is strictly prohibited without prior written permission
// from Amlogic.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define LOG_TAG "vpuapi"
#include "vpuapifunc.h"
#include "product.h"
#include "enc_regdefine.h"
#include "enc_driver.h"
#include "debug.h"
#include "vdi_osal.h"
#include "vpuapi.h"
#include "chagall.h"

#define INVALID_CORE_INDEX_RETURN_ERROR(_coreIdx)  \
    if (_coreIdx >= MAX_NUM_VPU_CORE) \
    return -1;

static const Uint16* s_pusBitCode[MAX_NUM_VPU_CORE] = {NULL,};
static int s_bitCodeSize[MAX_NUM_VPU_CORE] = {0,};
struct vpudrv_inst_param_t stInstParam[MAX_NUM_VPU_CORE * MAX_NUM_INSTANCE];

Uint32 __VPU_BUSY_TIMEOUT = VPU_BUSY_CHECK_TIMEOUT;

Int32 VPU_IsInit(Uint32 coreIdx)
{
    Int32 pc;

    INVALID_CORE_INDEX_RETURN_ERROR(coreIdx);

    pc = ProductVpuIsInit(coreIdx);

    return pc;
}

Int32 VPU_WaitInterrupt(Uint32 coreIdx, int timeout)
{
    Int32 ret;
    CodecInst* instance;

    INVALID_CORE_INDEX_RETURN_ERROR(coreIdx);

    if ((instance=GetPendingInst(coreIdx)) != NULL) {
        ret = ProductVpuWaitInterrupt(instance, timeout);
    }
    else {
        ret = -1;
    }

    return ret;
}

Int32 VPU_WaitInterruptEx(VpuHandle handle, int timeout)
{
    Int32 ret;
    CodecInst *pCodecInst;

    pCodecInst  = handle;

    INVALID_CORE_INDEX_RETURN_ERROR(pCodecInst->coreIdx);

    ret = ProductVpuWaitInterrupt(pCodecInst, timeout);

    return ret;
}

void VPU_ClearInterrupt(Uint32 coreIdx)
{
    /* clear all interrupt flags */
    ProductVpuClearInterrupt(coreIdx, 0xffff);
}

void VPU_ClearInterruptEx(VpuHandle handle, Int32 intrFlag)
{
    CodecInst *pCodecInst;

    pCodecInst  = handle;

    ProductVpuClearInterrupt(pCodecInst->coreIdx, intrFlag);
}

void VPU_CheckInterrupt(VpuHandle handle, Uint32 *result_clr)
{
    CodecInst *pCodecInst;
    pCodecInst  = handle;
    EnterLock(pCodecInst->coreIdx);
    Vp5VpuCheckInterrupt(pCodecInst->coreIdx, pCodecInst->instIndex, result_clr);
    LeaveLock(pCodecInst->coreIdx);
}

int VPU_GetFrameBufSize(VpuHandle handle, int coreIdx, int stride, int height, int mapType, int format, int interleave, DRAMConfig *pDramCfg)
{
    int productId;
    CodecInst *pCodecInst;

    pCodecInst  = handle;
    UNREFERENCED_PARAMETER(interleave);             /*!<< for backward compatiblity */

    if (coreIdx < 0 || coreIdx >= MAX_NUM_VPU_CORE)
        return -1;

    productId = ProductVpuGetId(coreIdx);

    return ProductCalculateFrameBufSize(pCodecInst, productId, stride, height, (TiledMapType)mapType, (FrameBufferFormat)format, (BOOL)interleave, pDramCfg);
}


int VPU_GetProductId(int coreIdx)
{
    Int32 productId;

    INVALID_CORE_INDEX_RETURN_ERROR(coreIdx);

    if ((productId=ProductVpuGetId(coreIdx)) != PRODUCT_ID_NONE) {
        return productId;
    }

    if (vdi_init(coreIdx) < 0)
        return -1;

    EnterLock(coreIdx);
    if (ProductVpuScan(coreIdx) == FALSE)
        productId = -1;
    else
        productId = ProductVpuGetId(coreIdx);
    LeaveLock((coreIdx));

    vdi_release(coreIdx);

    return productId;
}

int VPU_GetOpenInstanceNum(Uint32 coreIdx)
{
    INVALID_CORE_INDEX_RETURN_ERROR(coreIdx);

    return vdi_get_instance_num(coreIdx);
}

static RetCode InitializeVPU(Uint32 coreIdx, const Uint16* code, Uint32 size)
{
    RetCode     ret;

    if (vdi_init(coreIdx) < 0)
        return RETCODE_FAILURE;

    EnterLock(coreIdx);

    if (vdi_get_instance_num(coreIdx) > 0) {
        if (ProductVpuScan(coreIdx) == 0) {
            LeaveLock(coreIdx);
            return RETCODE_NOT_FOUND_VPU_DEVICE;
        }
    }

    if (VPU_IsInit(coreIdx) != 0) {
        ProductVpuReInit(coreIdx, (void *)code, size);
        LeaveLock(coreIdx);
        return RETCODE_CALLED_BEFORE;
    }

    InitCodecInstancePool(coreIdx);

    ret = ProductVpuReset(coreIdx, SW_RESET_ON_BOOT);
    if (ret != RETCODE_SUCCESS) {
        LeaveLock(coreIdx);
        return ret;
    }

#if defined(SUPPORT_SW_UART) || defined(SUPPORT_SW_UART_V2)
    create_sw_uart_thread(coreIdx);
    usleep(500*1000);
#endif
    ret = ProductVpuInit(coreIdx, (void*)code, size);
    if (ret != RETCODE_SUCCESS) {
        LeaveLock(coreIdx);
        return ret;
    }

    LeaveLock(coreIdx);
    return RETCODE_SUCCESS;
}

RetCode VPU_Init(Uint32 coreIdx)
{

    if (coreIdx >= MAX_NUM_VPU_CORE)
        return RETCODE_INVALID_PARAM;
#if 0
    if (s_bitCodeSize[coreIdx] == 0)
        return RETCODE_NOT_FOUND_BITCODE_PATH;
#else
    if (s_bitCodeSize[coreIdx] == 0) {
        s_bitCodeSize[coreIdx] = (sizeof(bit_code) + 1)/2;
        s_pusBitCode[coreIdx] = bit_code;
    }
#endif

    return InitializeVPU(coreIdx, s_pusBitCode[coreIdx], s_bitCodeSize[coreIdx]);
}

RetCode VPU_InitWithBitcode(Uint32 coreIdx, const Uint16* code, Uint32 size)
{
    if (coreIdx >= MAX_NUM_VPU_CORE)
        return RETCODE_INVALID_PARAM;
    if (code == NULL || size == 0)
        return RETCODE_INVALID_PARAM;

    s_pusBitCode[coreIdx] = NULL;
    s_pusBitCode[coreIdx] = (Uint16 *)osal_malloc(size*sizeof(Uint16));
    if (!s_pusBitCode[coreIdx])
        return RETCODE_INSUFFICIENT_RESOURCE;
    osal_memcpy((void *)s_pusBitCode[coreIdx], (const void *)code, size*sizeof(Uint16));
    s_bitCodeSize[coreIdx] = size;

    return InitializeVPU(coreIdx, code, size);
}

RetCode VPU_DeInit(Uint32 coreIdx)
{
    int ret;

    if (coreIdx >= MAX_NUM_VPU_CORE)
        return RETCODE_INVALID_PARAM;

    EnterLock(coreIdx);
    if (s_pusBitCode[coreIdx] && s_pusBitCode[coreIdx] != bit_code) {
        osal_free((void *)s_pusBitCode[coreIdx]);
    }

    s_pusBitCode[coreIdx] = NULL;
    s_bitCodeSize[coreIdx] = 0;
    LeaveLock(coreIdx);

#if defined(SUPPORT_SW_UART) || defined(SUPPORT_SW_UART_V2)
    destory_sw_uart_thread();
#endif
    ret = vdi_release(coreIdx);
    if (ret != 0)
        return RETCODE_FAILURE;

    return RETCODE_SUCCESS;
}

RetCode VPU_GetVersionInfo(Uint32 coreIdx, Uint32 *versionInfo, Uint32 *revision, Uint32 *productId)
{
    RetCode  ret;

    if (coreIdx >= MAX_NUM_VPU_CORE)
        return RETCODE_INVALID_PARAM;

    EnterLock(coreIdx);

    if (ProductVpuIsInit(coreIdx) == 0) {
        LeaveLock(coreIdx);
        return RETCODE_NOT_INITIALIZED;
    }

    if (GetPendingInst(coreIdx)) {
        LeaveLock(coreIdx);
        return RETCODE_FRAME_NOT_COMPLETE;
    }

    if (productId != NULL) {
        *productId = ProductVpuGetId(coreIdx);
    }
    ret = ProductVpuGetVersion(coreIdx, versionInfo, revision);

    LeaveLock(coreIdx);

    return ret;
}

RetCode VPU_GetProductInfo(Uint32 coreIdx, VpuAttr *productInfo)
{
    RetCode  ret;

    if (coreIdx >= MAX_NUM_VPU_CORE)
        return RETCODE_INVALID_PARAM;

    EnterLock(coreIdx);

    if (ProductVpuIsInit(coreIdx) == 0) {
        LeaveLock(coreIdx);
        return RETCODE_NOT_INITIALIZED;
    }

    if (GetPendingInst(coreIdx)) {
        LeaveLock(coreIdx);
        return RETCODE_FRAME_NOT_COMPLETE;
    }
    productInfo->productId = ProductVpuGetId(coreIdx);
    ret = ProductVpuGetProductInfo(coreIdx, productInfo);

    LeaveLock(coreIdx);

    return ret;
}

RetCode VPU_HWReset(Uint32 coreIdx)
{
    if (vdi_hw_reset(coreIdx) < 0 )
        return RETCODE_FAILURE;

    if (GetPendingInst(coreIdx))
    {
        SetPendingInst(coreIdx, 0);
        LeaveLock(coreIdx);    //if vpu is in a lock state. release the state;
    }
    return RETCODE_SUCCESS;
}

/**
* VPU_SWReset
* IN
*    forcedReset : 1 if there is no need to waiting for BUS transaction,
*                  0 for otherwise
* OUT
*    RetCode : RETCODE_FAILURE if failed to reset,
*              RETCODE_SUCCESS for otherwise
*/
RetCode VPU_SWReset(Uint32 coreIdx, SWResetMode resetMode, void *pendingInst)
{
    CodecInst *pCodecInst = (CodecInst *)pendingInst;
    RetCode    ret = RETCODE_SUCCESS;
    VpuAttr*   attr = &g_VpuCoreAttributes[coreIdx];

    if (attr->supportCommandQueue == TRUE) {
        if (pCodecInst && pCodecInst->loggingEnable) {
            vdi_log(pCodecInst->coreIdx, 0x10000, 1);
        }

        EnterLock(coreIdx);
        ret = ProductVpuReset(coreIdx, resetMode);
        LeaveLock(coreIdx);

        if (pCodecInst && pCodecInst->loggingEnable) {
            vdi_log(pCodecInst->coreIdx, 0x10000, 0);
        }
    }
    else {
        if (pCodecInst) {
            if (pCodecInst->loggingEnable) {
                vdi_log(pCodecInst->coreIdx, (pCodecInst->productId == PRODUCT_ID_960 || pCodecInst->productId == PRODUCT_ID_980)?0x10:0x10000, 1);
            }
        }
        else {
            EnterLock(coreIdx);
        }

        ret = ProductVpuReset(coreIdx, resetMode);

        if (pCodecInst) {
            if (pCodecInst->loggingEnable) {
                vdi_log(pCodecInst->coreIdx, (pCodecInst->productId == PRODUCT_ID_960 || pCodecInst->productId == PRODUCT_ID_980)?0x10:0x10000, 0);
            }
            SetPendingInst(pCodecInst->coreIdx, 0);
            LeaveLock(coreIdx);
        }
        else {
            LeaveLock(coreIdx);
        }
    }

    return ret;
}

//---- VPU_SLEEP/WAKE
RetCode VPU_SleepWake(Uint32 coreIdx, int iSleepWake)
{
    RetCode ret;

    EnterLock(coreIdx);
    ret = ProductVpuSleepWake(coreIdx, iSleepWake, s_pusBitCode[coreIdx], s_bitCodeSize[coreIdx]);
    LeaveLock(coreIdx);

    return ret;
}


RetCode VPU_EncSetWrPtr(EncHandle handle, PhysicalAddress addr, int updateRdPtr)
{
    CodecInst* pCodecInst;
    CodecInst* pPendingInst;
    EncInfo * pEncInfo;
    RetCode ret;

    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS)
        return ret;
    pCodecInst = (CodecInst*)handle;

    if (pCodecInst->productId == PRODUCT_ID_960 || pCodecInst->productId == PRODUCT_ID_980) {
        return RETCODE_NOT_SUPPORTED_FEATURE;
    }

    pEncInfo = &handle->CodecInfo->encInfo;
    pPendingInst = GetPendingInst(pCodecInst->coreIdx);
    if (pCodecInst == pPendingInst) {
        VpuWriteReg(pCodecInst->coreIdx, pEncInfo->streamWrPtrRegAddr, addr);
    }
    else {
        EnterLock(pCodecInst->coreIdx);
        VpuWriteReg(pCodecInst->coreIdx, pEncInfo->streamWrPtrRegAddr, addr);
        LeaveLock(pCodecInst->coreIdx);
    }
    pEncInfo->streamWrPtr = addr;
    if (updateRdPtr)
        pEncInfo->streamRdPtr = addr;

    return RETCODE_SUCCESS;
}

RetCode VPU_EncOpen(EncHandle* pHandle, EncOpenParam * pop)
{
    CodecInst*  pCodecInst;
    EncInfo*    pEncInfo;
    RetCode     ret;

    if ((ret=ProductCheckEncOpenParam(pop)) != RETCODE_SUCCESS)
        return ret;

    EnterLock(pop->coreIdx);

    if (VPU_IsInit(pop->coreIdx) == 0) {
        LeaveLock(pop->coreIdx);
        return RETCODE_NOT_INITIALIZED;
    }

    ret = GetCodecInstance(pop->coreIdx, &pCodecInst);
    if (ret == RETCODE_FAILURE) {
        *pHandle = 0;
        LeaveLock(pop->coreIdx);
        return RETCODE_FAILURE;
    }

    pCodecInst->isDecoder = FALSE;
    *pHandle = pCodecInst;
    pEncInfo = &pCodecInst->CodecInfo->encInfo;

    osal_memset(pEncInfo, 0x00, sizeof(EncInfo));
    pEncInfo->openParam = *pop;

    if ((ret=ProductVpuEncBuildUpOpenParam(pCodecInst, pop)) != RETCODE_SUCCESS) {
        *pHandle = 0;
    }

    LeaveLock(pCodecInst->coreIdx);

    return ret;
}

RetCode VPU_EncClose(EncHandle handle)
{
    CodecInst*  pCodecInst;
    EncInfo*    pEncInfo;
    RetCode     ret;

    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS) {
        return ret;
    }

    pCodecInst = handle;
    pEncInfo = &pCodecInst->CodecInfo->encInfo;

    EnterLock(pCodecInst->coreIdx);

    if (pEncInfo->initialInfoObtained) {
        VpuWriteReg(pCodecInst->coreIdx, pEncInfo->streamWrPtrRegAddr, pEncInfo->streamWrPtr);
        VpuWriteReg(pCodecInst->coreIdx, pEncInfo->streamRdPtrRegAddr, pEncInfo->streamRdPtr);

        if ((ret=ProductVpuEncFiniSeq(pCodecInst)) != RETCODE_SUCCESS) {
            if (pCodecInst->loggingEnable)
                vdi_log(pCodecInst->coreIdx, ENC_SEQ_END, 2);

            if (ret == RETCODE_VPU_STILL_RUNNING) {
                LeaveLock(pCodecInst->coreIdx);
                return ret;
            }
        }
        if (pCodecInst->loggingEnable)
            vdi_log(pCodecInst->coreIdx, ENC_SEQ_END, 0);
        pEncInfo->streamWrPtr = VpuReadReg(pCodecInst->coreIdx, pEncInfo->streamWrPtrRegAddr);
    }

    if (pEncInfo->vbScratch.size) {
        vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbScratch, ENC_ETC, pCodecInst->instIndex);
    }

    if (pEncInfo->vbWork.size) {
        vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbWork, ENC_WORK, pCodecInst->instIndex);
    }

    if (pEncInfo->vbFrame.size) {
        if (pEncInfo->frameAllocExt == 0)
            vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbFrame, ENC_ETC, pCodecInst->instIndex);
    }

    if (pCodecInst->codecMode == W_HEVC_ENC || pCodecInst->codecMode == W_SVAC_ENC || pCodecInst->codecMode == W_AVC_ENC) {
        if (pEncInfo->vbSubSamBuf.size)
            vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbSubSamBuf, ENC_SUBSAMBUF, pCodecInst->instIndex);

        if (pEncInfo->vbMV.size)
            vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbMV, ENC_MV, pCodecInst->instIndex);

        if (pEncInfo->vbFbcYTbl.size)
            vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbFbcYTbl, ENC_FBCY_TBL, pCodecInst->instIndex);

        if (pEncInfo->vbFbcCTbl.size)
            vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbFbcCTbl, ENC_FBCC_TBL, pCodecInst->instIndex);

        if (pEncInfo->vbTemp.size)
            vdi_dettach_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbTemp);
    }

    if (pEncInfo->vbPPU.size) {
        if (pEncInfo->ppuAllocExt == 0)
            vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbPPU, ENC_ETC, pCodecInst->instIndex);
    }
    if (pEncInfo->vbSubSampFrame.size)
        vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbSubSampFrame, ENC_ETC, pCodecInst->instIndex);
    if (pEncInfo->vbMvcSubSampFrame.size)
        vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbMvcSubSampFrame, ENC_ETC, pCodecInst->instIndex);

    if (pEncInfo->vbTask.size)
        vdi_free_dma_memory(pCodecInst->coreIdx, &pEncInfo->vbTask, ENC_TASK, pCodecInst->instIndex);

    LeaveLock(pCodecInst->coreIdx);

    FreeCodecInstance(pCodecInst);

    return ret;
}

RetCode VPU_EncGetInitialInfo(EncHandle handle, EncInitialInfo * info)
{
    CodecInst*  pCodecInst;
    EncInfo*    pEncInfo;
    RetCode     ret;

    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS)
        return ret;

    if (info == 0) {
        return RETCODE_INVALID_PARAM;
    }

    pCodecInst = handle;
    pEncInfo = &pCodecInst->CodecInfo->encInfo;

    EnterLock(pCodecInst->coreIdx);

    if (GetPendingInst(pCodecInst->coreIdx)) {
        LeaveLock(pCodecInst->coreIdx);
        return RETCODE_FRAME_NOT_COMPLETE;
    }

    if ((ret=ProductVpuEncSetup(pCodecInst)) != RETCODE_SUCCESS) {
        LeaveLock(pCodecInst->coreIdx);
        return ret;
    }

    if (pCodecInst->codecMode == AVC_ENC && pCodecInst->codecModeAux == AVC_AUX_MVC)
        info->minFrameBufferCount = 3; // reconstructed frame + 2 reference frame
    else if(pCodecInst->codecMode == W_HEVC_ENC || pCodecInst->codecMode == W_SVAC_ENC || pCodecInst->codecMode == W_AVC_ENC) {
        info->minFrameBufferCount   = pEncInfo->initialInfo.minFrameBufferCount;
        info->minSrcFrameCount      = pEncInfo->initialInfo.minSrcFrameCount;
    }
    else
        info->minFrameBufferCount = 2; // reconstructed frame + reference frame

    pEncInfo->initialInfo         = *info;
    pEncInfo->initialInfoObtained = TRUE;

    LeaveLock(pCodecInst->coreIdx);

    return RETCODE_SUCCESS;
}

RetCode VPU_EncRegisterFrameBuffer(EncHandle handle, FrameBuffer* bufArray, int num, int stride, int height, TiledMapType mapType)
{
    CodecInst*      pCodecInst;
    EncInfo*        pEncInfo;
    Int32           i;
    RetCode         ret;
    EncOpenParam*   openParam;
    FrameBuffer*    fb;

    ret = CheckEncInstanceValidity(handle);
    // FIXME temp
    if (ret != RETCODE_SUCCESS)
        return ret;

    pCodecInst = handle;
    pEncInfo = &pCodecInst->CodecInfo->encInfo;
    openParam = &pEncInfo->openParam;

    if (pEncInfo->stride)
        return RETCODE_CALLED_BEFORE;

    if (!pEncInfo->initialInfoObtained)
        return RETCODE_WRONG_CALL_SEQUENCE;

    if (num < pEncInfo->initialInfo.minFrameBufferCount)
        return RETCODE_INSUFFICIENT_FRAME_BUFFERS;

    if (stride == 0 || (stride % 8 != 0) || stride < 0)
        return RETCODE_INVALID_STRIDE;

    if (height == 0 || height < 0)
        return RETCODE_INVALID_PARAM;

    if (openParam->bitstreamFormat == STD_HEVC) {
        if (stride % 32 != 0)
            return RETCODE_INVALID_STRIDE;
    }

    EnterLock(pCodecInst->coreIdx);

    if (GetPendingInst(pCodecInst->coreIdx)) {
        LeaveLock(pCodecInst->coreIdx);
        return RETCODE_FRAME_NOT_COMPLETE;
    }

    pEncInfo->numFrameBuffers   = num;
    pEncInfo->stride            = stride;
    pEncInfo->frameBufferHeight = height;
    pEncInfo->mapType           = mapType;
    pEncInfo->mapCfg.productId  = pCodecInst->productId;

    if (bufArray) {
        for(i=0; i<num; i++) {
            pEncInfo->frameBufPool[i] = bufArray[i];
        }

        if (openParam->EncStdParam.vpParam.svcEnable == TRUE) {
            for(i=num; i<num*2; i++) {
                pEncInfo->frameBufPool[i] = bufArray[i];
            }
        }
    }

    if (pEncInfo->frameAllocExt == FALSE) {
        fb = pEncInfo->frameBufPool;
        if (bufArray) {
            if (bufArray[0].bufCb == (PhysicalAddress)-1 && bufArray[0].bufCr == (PhysicalAddress)-1) {
                Uint32 size;
                pEncInfo->frameAllocExt = TRUE;
                size = ProductCalculateFrameBufSize(pCodecInst, pCodecInst->productId, stride, height,
                                                    (TiledMapType)mapType, (FrameBufferFormat)openParam->srcFormat,
                                                    (BOOL)openParam->cbcrInterleave, NULL);
                if (mapType == LINEAR_FRAME_MAP) {
                    pEncInfo->vbFrame.phys_addr = bufArray[0].bufY;
                    pEncInfo->vbFrame.size      = size * num;
                }
            }
        }
        ret = ProductVpuAllocateFramebuffer(
            pCodecInst, fb, (TiledMapType)mapType, num, stride, height, (FrameBufferFormat)openParam->srcFormat,
            openParam->cbcrInterleave, FALSE, openParam->frameEndian, &pEncInfo->vbFrame, 0, FB_TYPE_CODEC);
        if (ret != RETCODE_SUCCESS) {
            SetPendingInst(pCodecInst->coreIdx, 0);
            LeaveLock(pCodecInst->coreIdx);
            return ret;
        }
    }

    ret = ProductVpuRegisterFramebuffer(pCodecInst);

    SetPendingInst(pCodecInst->coreIdx, 0);

    LeaveLock(pCodecInst->coreIdx);

    return ret;
}


RetCode VPU_EncGetBitstreamBuffer( EncHandle handle,
    PhysicalAddress * prdPrt,
    PhysicalAddress * pwrPtr,
    int * size)
{
    CodecInst * pCodecInst;
    EncInfo * pEncInfo;
    PhysicalAddress rdPtr;
    PhysicalAddress wrPtr;
    Uint32 room;
    RetCode ret;

    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS)
        return ret;

    if ( prdPrt == 0 || pwrPtr == 0 || size == 0) {
        return RETCODE_INVALID_PARAM;
    }

    pCodecInst = handle;
    pEncInfo = &pCodecInst->CodecInfo->encInfo;

    rdPtr = pEncInfo->streamRdPtr;

    if (GetPendingInst(pCodecInst->coreIdx) == pCodecInst)
        wrPtr = VpuReadReg(pCodecInst->coreIdx, pEncInfo->streamWrPtrRegAddr);
    else {
        if (handle->productId == PRODUCT_ID_521) {
            EnterLock(pCodecInst->coreIdx);
            ProductVpuEncGetRdWrPtr(pCodecInst, &rdPtr, &wrPtr);
            LeaveLock(pCodecInst->coreIdx);
        }
        else
            wrPtr = pEncInfo->streamWrPtr;
    }

    if(pEncInfo->ringBufferEnable == 1 || pEncInfo->lineBufIntEn == 1) {
        if (wrPtr >= rdPtr) {
            room = wrPtr - rdPtr;
        }
        else {
            room = (pEncInfo->streamBufEndAddr - rdPtr) + (wrPtr - pEncInfo->streamBufStartAddr);
        }
    }
    else {
        if(wrPtr >= rdPtr)
            room = wrPtr - rdPtr;
        else
            return RETCODE_INVALID_PARAM;
    }

    *prdPrt = rdPtr;
    *pwrPtr = wrPtr;
    *size = room;

    return RETCODE_SUCCESS;
}

RetCode VPU_EncUpdateBitstreamBuffer(
    EncHandle handle,
    int size)
{
    CodecInst * pCodecInst;
    EncInfo * pEncInfo;
    PhysicalAddress wrPtr;
    PhysicalAddress rdPtr;
    RetCode ret;
    int        room = 0;
    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS)
        return ret;

    pCodecInst = handle;
    pEncInfo = &pCodecInst->CodecInfo->encInfo;

    rdPtr = pEncInfo->streamRdPtr;

    if (GetPendingInst(pCodecInst->coreIdx) == pCodecInst)
        wrPtr = VpuReadReg(pCodecInst->coreIdx, pEncInfo->streamWrPtrRegAddr);
    else
        wrPtr = pEncInfo->streamWrPtr;

    if (wrPtr == (unsigned int)-1) {
        return RETCODE_INVALID_PARAM;
    }

    if ( rdPtr < wrPtr ) {
        if ( rdPtr + size  > wrPtr ) {
            return RETCODE_INVALID_PARAM;
        }
    }


    //************** for VP5 *********************/
    if (size > 0) {
        if (pEncInfo->ringBufferEnable == TRUE) {
            rdPtr += size;
            if (pEncInfo->ringBufferWrapEnable == TRUE) {
                //======== [case1]. ring=1 & wrap=1 ===================

                if (rdPtr > pEncInfo->streamBufEndAddr) {
                    if (pEncInfo->lineBufIntEn == TRUE) {
                        return RETCODE_INVALID_PARAM;
                    }
                    room = rdPtr - pEncInfo->streamBufEndAddr;
                    rdPtr = pEncInfo->streamBufStartAddr;
                    rdPtr += room;
                }

                pEncInfo->streamRdPtr = rdPtr;
                EnterLock(pCodecInst->coreIdx);
                ProductVpuEncUpdateBitstreamBuffer(pCodecInst, size);
                LeaveLock(pCodecInst->coreIdx);
                if (rdPtr == pEncInfo->streamBufEndAddr) {
                    //set EndAddr to FW and set StartAddr to API
                    rdPtr = pEncInfo->streamBufStartAddr;   // wrap-around
                }
            }
            else {
                //========= [case2]. ring=1 & wrap=0 ===================
                pEncInfo->streamRdPtr = rdPtr;
                EnterLock(pCodecInst->coreIdx);
                ProductVpuEncUpdateBitstreamBuffer(pCodecInst, size);
                LeaveLock(pCodecInst->coreIdx);
                if (rdPtr == pEncInfo->streamBufEndAddr) {
                        //set EndAddr to FW and set StartAddr to API
                    rdPtr = pEncInfo->streamBufStartAddr;   // start? end? [FIX ME]
                }
            }
        }
        else {
            //========= [case3]. Line buffer mode  ===================
            if (VPU_ALIGN16(wrPtr) >= pEncInfo->streamRdPtr + pEncInfo->streamBufSize) {  // linebuffer full detected. already host read whole bistream in bitstreamBuffer.
                EnterLock(pCodecInst->coreIdx);
                ProductVpuEncUpdateBitstreamBuffer(pCodecInst, size);
                LeaveLock(pCodecInst->coreIdx);
            }
       }
    }
    else {
            //************ update new CPB buffer addr/size ***************/
        if (size == UPDATE_NEW_BS_BUF) {
            pEncInfo->streamRdPtr                   = pEncInfo->streamBufStartAddr;
            pEncInfo->streamBufTobeReadStartAddr    = pEncInfo->streamBufStartAddr;
            pEncInfo->streamBufTobeReadSize         = pEncInfo->streamBufSize;
            pEncInfo->streamBufTobeReadEndAddr      = pEncInfo->streamBufStartAddr + pEncInfo->streamBufSize;
            EnterLock(pCodecInst->coreIdx);
            ProductVpuEncUpdateBitstreamBuffer(pCodecInst, size);
            LeaveLock(pCodecInst->coreIdx);

            rdPtr = pEncInfo->streamBufStartAddr;
        }
    }

    pEncInfo->streamRdPtr = rdPtr;
    pEncInfo->streamWrPtr = wrPtr;
    if (GetPendingInst(pCodecInst->coreIdx) == pCodecInst)
        VpuWriteReg(pCodecInst->coreIdx, pEncInfo->streamRdPtrRegAddr, rdPtr);

    if (pEncInfo->ringBufferEnable == FALSE && pEncInfo->lineBufIntEn == TRUE) {
        pEncInfo->streamRdPtr = pEncInfo->streamBufStartAddr;
    }

    return RETCODE_SUCCESS;
}

RetCode VPU_EncStartOneFrame(
    EncHandle handle,
    EncParam * param
    )
{
    CodecInst*          pCodecInst;
    EncInfo*            pEncInfo;
    RetCode             ret;
    VpuAttr*            pAttr   = NULL;
    vpu_instance_pool_t* vip;
    FrameBuffer*        pSrcFrame;

    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS)
        return ret;

    pCodecInst = handle;
    pEncInfo   = &pCodecInst->CodecInfo->encInfo;
    vip        = (vpu_instance_pool_t *)vdi_get_instance_pool(pCodecInst->coreIdx);
    if (!vip) {
        return RETCODE_INVALID_HANDLE;
    }

    if (pEncInfo->stride == 0) { // This means frame buffers have not been registered.
        return RETCODE_WRONG_CALL_SEQUENCE;
    }

    if (param->srcIdx >= MAX_SRC_FRAME) {
        VLOG(ERR,"source frame index over range index %d \n", param->srcIdx);
        return RETCODE_INVALID_PARAM;
    }
    if (pEncInfo->srcBufUseIndex[param->srcIdx] == 1
        && param->srcEndFlag == 0) {
        VLOG(ERR,"source frame was already in encoding index %d \n",
                param->srcIdx);
        return RETCODE_INVALID_PARAM;
    }
    pSrcFrame = param -> sourceFrame;
    if (pSrcFrame && pSrcFrame->dma_buf_planes && (param->srcEndFlag == 0)) { // use dma_buf
        vpu_dma_buf_info_t dma_info;
        int i;
        if (pSrcFrame->dma_buf_planes > 3)
            return RETCODE_INVALID_FRAME_BUFFER;
        osal_memset(&dma_info, 0x00, sizeof(vpu_dma_buf_info_t));
        dma_info.num_planes = pSrcFrame->dma_buf_planes;
        for (i = 0; i < pSrcFrame->dma_buf_planes; i ++)
                dma_info.fd[i] = pSrcFrame->dma_shared_fd[i];
        VLOG(INFO,"DMA source fd[%d, %d, %d] planes %d\n",
                dma_info.fd[0],dma_info.fd[1],dma_info.fd[2],
                pSrcFrame->dma_buf_planes);
        if (vdi_config_dma(pCodecInst->coreIdx, &dma_info) !=0)
                return RETCODE_INVALID_FRAME_BUFFER;
        pSrcFrame -> bufY = dma_info.phys_addr[0];
        if (dma_info.num_planes == 1 && pEncInfo->openParam.packedFormat == 0)
        { // only one buffer plane cb/cr from the same buffer  but no packed
              pSrcFrame -> bufCb = (PhysicalAddress) (pSrcFrame -> bufY +
                        pSrcFrame -> height*pSrcFrame -> stride);
              if (pSrcFrame->cbcrInterleave == 0) { //
                  pSrcFrame->bufCr = (PhysicalAddress) (pSrcFrame -> bufCb +
                            pSrcFrame -> height*pSrcFrame -> stride/4);
              }
        }
        if (dma_info.num_planes >1 )
                pSrcFrame -> bufCb = dma_info.phys_addr[1];
        if (dma_info.num_planes > 2)
               pSrcFrame->bufCr = dma_info.phys_addr[2];
        VLOG(INFO,"DMA frame physical bufY 0x%x Cb 0x%x Cr 0x%x planes %d \n",
                pSrcFrame->bufY, pSrcFrame->bufCb, pSrcFrame->bufCr,
                dma_info.num_planes);
    }

#if 1
    //hoan add for canvas
    if (param->canvas > 0 && pSrcFrame && (pSrcFrame->canvas_index != 0xffffffff) && (param->srcEndFlag == 0))
    {
        vpu_dma_buf_canvas_info_t dma_info_canvas;

        dma_info_canvas.canvas_index = param->canvas;
        if (vdi_config_dma_canvas(pCodecInst->coreIdx, &dma_info_canvas) !=0)
                return RETCODE_INVALID_FRAME_BUFFER;
        pSrcFrame->bufY  = dma_info_canvas.phys_addr[0];
        pSrcFrame->bufCb = dma_info_canvas.phys_addr[1];
        pSrcFrame->bufCr = dma_info_canvas.phys_addr[2];
        VLOG(NONE,"[canvas_u] >> VPU_EncStartOneFrame DMA frame physical bufY 0x%x Cb 0x%x Cr 0x%x. \n",
                pSrcFrame->bufY, pSrcFrame->bufCb, pSrcFrame->bufCr);
    }
    //end
#endif

    ret = CheckEncParam(handle, param);

    if (ret != RETCODE_SUCCESS) {
        return ret;
    }

    pAttr = &g_VpuCoreAttributes[pCodecInst->coreIdx];

    EnterLock(pCodecInst->coreIdx);

    pEncInfo->ptsMap[param->srcIdx] = (pEncInfo->openParam.enablePTS == TRUE) ? GetTimestamp(handle) : param->pts;

    if (GetPendingInst(pCodecInst->coreIdx)) {
        LeaveLock(pCodecInst->coreIdx);
        return RETCODE_FRAME_NOT_COMPLETE;
    }

    ret = ProductVpuEncode(pCodecInst, param);

    if (ret == RETCODE_SUCCESS) {
        /* record the used source frame */
        pEncInfo->srcBufUseIndex[param->srcIdx] = 1;
        pEncInfo->srcBufMap[param->srcIdx] = *pSrcFrame;
    }

    if (pAttr->supportCommandQueue == TRUE) {
        SetPendingInst(pCodecInst->coreIdx, NULL);
        LeaveLock_noclk(pCodecInst->coreIdx);
    }
    else {
        SetPendingInst(pCodecInst->coreIdx, pCodecInst);
    }

    return ret;
}

RetCode VPU_EncGetOutputInfo(
    EncHandle       handle,
    EncOutputInfo*  info
    )
{
    CodecInst*  pCodecInst;
    EncInfo*    pEncInfo;
    RetCode     ret;
    VpuAttr*    pAttr;
    FrameBuffer*  pSrcFrame = NULL;

    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS) {
        return ret;
    }

    if (info == 0) {
        return RETCODE_INVALID_PARAM;
    }

    pCodecInst = handle;
    pEncInfo   = &pCodecInst->CodecInfo->encInfo;
    pAttr      = &g_VpuCoreAttributes[pCodecInst->coreIdx];

    if (pAttr->supportCommandQueue == TRUE) {
        EnterLock_noclk(pCodecInst->coreIdx);
    }
    else {
        if (pCodecInst != GetPendingInst(pCodecInst->coreIdx)) {
            SetPendingInst(pCodecInst->coreIdx, 0);
            LeaveLock(pCodecInst->coreIdx);
            return RETCODE_WRONG_CALL_SEQUENCE;
        }
    }

    ret = ProductVpuEncGetResult(pCodecInst, info);

    if (ret == RETCODE_SUCCESS) {
        if (info->encSrcIdx >= 0 && info->reconFrameIndex >= 0 )
        {

            info->pts = pEncInfo->ptsMap[info->encSrcIdx];
             /* return the used soure frame */
            if (pEncInfo->srcBufUseIndex[info->encSrcIdx] == 1) {
                pSrcFrame = &(pEncInfo->srcBufMap[info->encSrcIdx]);
                info -> encSrcFrame = *pSrcFrame;
                pEncInfo->srcBufUseIndex[info->encSrcIdx] = 0;
             } else
               VLOG(ERR, "Soure Frame already retired index= %d use %d\n",
                        info->encSrcIdx,
                        pEncInfo->srcBufUseIndex[info->encSrcIdx]);
        }
    }
    else {
        info->pts = 0LL;
    }

    SetPendingInst(pCodecInst->coreIdx, 0);
    LeaveLock(pCodecInst->coreIdx);

    /*unmap the dma buf if it has retired*/
    if (pSrcFrame && pSrcFrame->dma_buf_planes) { // use dma_buf
        vpu_dma_buf_info_t dma_info;
        int i;
        osal_memset(&dma_info, 0x00, sizeof(vpu_dma_buf_info_t));
        dma_info.num_planes = pSrcFrame->dma_buf_planes;
        for (i = 0; i < pSrcFrame->dma_buf_planes; i ++)
                dma_info.fd[i] = pSrcFrame->dma_shared_fd[i];
        dma_info.phys_addr[0] = pSrcFrame -> bufY;
        if (dma_info.num_planes > 1)
            dma_info.phys_addr[1]= pSrcFrame -> bufCb;
        if (dma_info.num_planes > 2)
            dma_info.phys_addr[2] = pSrcFrame -> bufCr;
        if (vdi_unmap_dma(pCodecInst->coreIdx, &dma_info) !=0) {
            VLOG(ERR,"Failed to de-reference DMA buffer \n");
            ret = RETCODE_FAILURE;
        }
    }

    return ret;
}

RetCode VPU_EncGiveCommand(
    EncHandle       handle,
    CodecCommand    cmd,
    void*           param
    )
{
    CodecInst*  pCodecInst;
    EncInfo*    pEncInfo;
    RetCode     ret;

    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS) {
        return ret;
    }

    pCodecInst = handle;
    pEncInfo = &pCodecInst->CodecInfo->encInfo;
    switch (cmd)
    {
    case ENABLE_ROTATION :
        {
            pEncInfo->rotationEnable = 1;
        }
        break;
    case DISABLE_ROTATION :
        {
            pEncInfo->rotationEnable = 0;
        }
        break;
    case ENABLE_MIRRORING :
        {
            pEncInfo->mirrorEnable = 1;
        }
        break;
    case DISABLE_MIRRORING :
        {
            pEncInfo->mirrorEnable = 0;
        }
        break;
    case SET_MIRROR_DIRECTION :
        {
            MirrorDirection mirDir;

            if (param == 0) {
                return RETCODE_INVALID_PARAM;
            }
            mirDir = *(MirrorDirection *)param;
            if ( !(mirDir == MIRDIR_NONE) && !(mirDir==MIRDIR_HOR) && !(mirDir==MIRDIR_VER) && !(mirDir==MIRDIR_HOR_VER)) {
                return RETCODE_INVALID_PARAM;
            }
            pEncInfo->mirrorDirection = mirDir;
        }
        break;
    case SET_ROTATION_ANGLE :
        {
            int angle;

            if (param == 0) {
                return RETCODE_INVALID_PARAM;
            }
            angle = *(int *)param;
            if (angle != 0 && angle != 90 &&
                angle != 180 && angle != 270) {
                    return RETCODE_INVALID_PARAM;
            }
            if (pEncInfo->initialInfoObtained && (angle == 90 || angle ==270)) {
                return RETCODE_INVALID_PARAM;
            }
            pEncInfo->rotationAngle = angle;
        }
        break;
    case SET_CACHE_CONFIG:
        {
            MaverickCacheConfig *mcCacheConfig;
            if (param == 0) {
                return RETCODE_INVALID_PARAM;
            }
            mcCacheConfig = (MaverickCacheConfig *)param;
            pEncInfo->cacheConfig = *mcCacheConfig;
        }
        break;
    case ENC_PUT_VIDEO_HEADER:
        {
            EncHeaderParam *encHeaderParam;

            if (param == 0) {
                return RETCODE_INVALID_PARAM;
            }
            encHeaderParam = (EncHeaderParam *)param;
            if (pCodecInst->codecMode == MP4_ENC ) {
                if (!( VOL_HEADER<=encHeaderParam->headerType && encHeaderParam->headerType <= VIS_HEADER)) {
                    return RETCODE_INVALID_PARAM;
                }
            }
            else if  (pCodecInst->codecMode == AVC_ENC) {
                if (!( SPS_RBSP<=encHeaderParam->headerType && encHeaderParam->headerType <= PPS_RBSP_MVC)) {
                    return RETCODE_INVALID_PARAM;
                }
            }
            else if (pCodecInst->codecMode == W_HEVC_ENC || pCodecInst->codecMode == W_SVAC_ENC || pCodecInst->codecMode == W_AVC_ENC) {
                if (!( CODEOPT_ENC_VPS<=encHeaderParam->headerType && encHeaderParam->headerType <= (CODEOPT_ENC_VPS|CODEOPT_ENC_SPS|CODEOPT_ENC_PPS))) {
                    return RETCODE_INVALID_PARAM;
                }
                if (pEncInfo->ringBufferEnable == 0 ) {
                    if (encHeaderParam->buf % 16 || encHeaderParam->size == 0)
                        return RETCODE_INVALID_PARAM;
                }
                if (encHeaderParam->headerType & CODEOPT_ENC_VCL)   // ENC_PUT_VIDEO_HEADER encode only non-vcl header.
                    return RETCODE_INVALID_PARAM;

            }
            else
                return RETCODE_INVALID_PARAM;

            if (pEncInfo->ringBufferEnable == 0 ) {
                if (encHeaderParam->buf % 8 || encHeaderParam->size == 0) {
                    return RETCODE_INVALID_PARAM;
                }
            }
            if (pCodecInst->codecMode == W_HEVC_ENC || pCodecInst->codecMode == W_SVAC_ENC || pCodecInst->codecMode == W_AVC_ENC) {
                if (handle->productId == PRODUCT_ID_521)
                    return Vp5VpuEncGetHeader(handle, encHeaderParam);
                else
                    return RETCODE_INVALID_PARAM;
            }
        }
        break;
    case ENC_SET_PARAM:
        {
            if (param == 0) {
                return RETCODE_INVALID_PARAM;
            }
            return RETCODE_INVALID_COMMAND;
        }
    case ENC_SET_GOP_NUMBER:
        {
            return RETCODE_INVALID_COMMAND;
        }
        break;
    case ENC_SET_INTRA_QP:
        {
            return RETCODE_INVALID_COMMAND;
        }
        break;
    case ENC_SET_BITRATE:
        {
            return RETCODE_INVALID_COMMAND;
        }
        break;
    case ENC_SET_FRAME_RATE:
        {
            return RETCODE_INVALID_COMMAND;
        }
        break;
    case ENC_SET_INTRA_MB_REFRESH_NUMBER:
        {
            return RETCODE_INVALID_COMMAND;
        }
        break;

    case ENC_SET_SLICE_INFO:
        {
            return RETCODE_INVALID_COMMAND;
        }
        break;
    case ENC_ENABLE_HEC:
        {
            return RETCODE_INVALID_COMMAND;
        }
        break;
    case ENC_DISABLE_HEC:
        {
            return RETCODE_INVALID_COMMAND;
        }
        break;
    case SET_SEC_AXI:
        {
            SecAxiUse secAxiUse;
            if (param == 0) {
                return RETCODE_INVALID_PARAM;
            }
            secAxiUse = *(SecAxiUse *)param;
            if (handle->productId == PRODUCT_ID_521) {
                pEncInfo->secAxiInfo.u.vp.useEncRdoEnable = secAxiUse.u.vp.useEncRdoEnable;
                pEncInfo->secAxiInfo.u.vp.useEncLfEnable  = secAxiUse.u.vp.useEncLfEnable;
            }
        }
        break;
    case GET_TILEDMAP_CONFIG:
        {
            TiledMapConfig *pMapCfg = (TiledMapConfig *)param;
            if (!pMapCfg) {
                return RETCODE_INVALID_PARAM;
            }
            *pMapCfg = pEncInfo->mapCfg;
            break;
        }
    case SET_DRAM_CONFIG:
        {
            DRAMConfig *cfg = (DRAMConfig *)param;

            if (!cfg) {
                return RETCODE_INVALID_PARAM;
            }

            pEncInfo->dramCfg = *cfg;
            break;
        }
    case GET_DRAM_CONFIG:
        {
            DRAMConfig *cfg = (DRAMConfig *)param;

            if (!cfg) {
                return RETCODE_INVALID_PARAM;
            }

            *cfg = pEncInfo->dramCfg;

            break;
        }
    case ENABLE_LOGGING:
        {
            pCodecInst->loggingEnable = 1;
        }
        break;
    case DISABLE_LOGGING:
        {
            pCodecInst->loggingEnable = 0;
        }
        break;
    case ENC_SET_PARA_CHANGE:
        {
            EncChangeParam* option = (EncChangeParam*)param;
            if (handle->productId == PRODUCT_ID_521)
                return Vp5VpuEncParaChange(handle, option);
            else
                return RETCODE_INVALID_PARAM;
        }
    case GET_BANDWIDTH_REPORT :
        return ProductVpuGetBandwidth(pCodecInst, (VPUBWData*)param);
    case ENC_GET_QUEUE_STATUS:
        {
            QueueStatusInfo* queueInfo = (QueueStatusInfo*)param;
            queueInfo->instanceQueueCount = pEncInfo->instanceQueueCount;
            queueInfo->reportQueueCount    = pEncInfo->reportQueueCount;
            break;
        }
    case ENC_WRPTR_SEL:
        {
            pEncInfo->encWrPtrSel = *(int *)param;
        }
        break;
    case SET_CYCLE_PER_TICK:
        {
            pEncInfo->cyclePerTick = *(Uint32 *)param;
        }
        break;
    case ENC_GET_SRC_BUF_FLAG:
        return ProductVpuGetSrcBufFlag(pCodecInst, (Uint32*)param);
    case GET_DEBUG_INFORM:
        return ProductVpuGetDebugInfo(pCodecInst, (VPUDebugInfo*)param);
    default:
        return RETCODE_INVALID_COMMAND;
    }
    return RETCODE_SUCCESS;
}

RetCode VPU_EncAllocateFrameBuffer(EncHandle handle, FrameBufferAllocInfo info, FrameBuffer *frameBuffer)
{
    CodecInst*  pCodecInst;
    EncInfo*    pEncInfo;
    RetCode     ret;
    int         gdiIndex;

    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS)
        return ret;

    pCodecInst = handle;
    pEncInfo   = &pCodecInst->CodecInfo->encInfo;

    if (!frameBuffer) {
        return RETCODE_INVALID_PARAM;
    }
    if (info.num == 0 || info.num < 0)  {
        return RETCODE_INVALID_PARAM;
    }
    if (info.stride == 0 || info.stride < 0) {
        return RETCODE_INVALID_PARAM;
    }
    if (info.height == 0 || info.height < 0) {
        return RETCODE_INVALID_PARAM;
    }

    if (info.type == FB_TYPE_PPU) {
        if (pEncInfo->numFrameBuffers == 0) {
            return RETCODE_WRONG_CALL_SEQUENCE;
        }
        pEncInfo->ppuAllocExt = frameBuffer[0].updateFbInfo;
        gdiIndex = pEncInfo->numFrameBuffers;
        ret = ProductVpuAllocateFramebuffer(pCodecInst, frameBuffer, (TiledMapType)info.mapType, (Int32)info.num,
                                            info.stride, info.height, info.format, info.cbcrInterleave, info.nv21,
                                            info.endian, &pEncInfo->vbPPU, gdiIndex, (FramebufferAllocType)info.type);
    }
    else if (info.type == FB_TYPE_CODEC) {
        gdiIndex = 0;
        pEncInfo->frameAllocExt = frameBuffer[0].updateFbInfo;
        ret = ProductVpuAllocateFramebuffer(pCodecInst, frameBuffer, (TiledMapType)info.mapType, (Int32)info.num,
                                            info.stride, info.height, info.format, info.cbcrInterleave, FALSE,
                                            info.endian, &pEncInfo->vbFrame, gdiIndex, (FramebufferAllocType)info.type);
    }
    else {
        ret = RETCODE_INVALID_PARAM;
    }

    return ret;
}

RetCode VPU_EncIssueSeqInit(EncHandle handle)
{
    CodecInst*  pCodecInst;
    RetCode     ret;
    VpuAttr*    pAttr;

    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS)
        return ret;

    pCodecInst = handle;

    EnterLock(pCodecInst->coreIdx);

    pAttr = &g_VpuCoreAttributes[pCodecInst->coreIdx];

    if (GetPendingInst(pCodecInst->coreIdx)) {
        LeaveLock(pCodecInst->coreIdx);
        return RETCODE_FRAME_NOT_COMPLETE;
    }

    ret = ProductVpuEncInitSeq(handle);
    if (ret == RETCODE_SUCCESS) {
        SetPendingInst(pCodecInst->coreIdx, pCodecInst);
    }

    if (pAttr->supportCommandQueue == TRUE) {
        SetPendingInst(pCodecInst->coreIdx, NULL);
        LeaveLock_noclk(pCodecInst->coreIdx);
    }

    return ret;
}

RetCode VPU_EncCompleteSeqInit(EncHandle handle, EncInitialInfo * info)
{
    CodecInst*  pCodecInst;
    EncInfo*    pEncInfo;
    RetCode     ret;
    VpuAttr*    pAttr;

    ret = CheckEncInstanceValidity(handle);
    if (ret != RETCODE_SUCCESS) {
        return ret;
    }

    if (info == 0) {
        return RETCODE_INVALID_PARAM;
    }

    pCodecInst = handle;
    pEncInfo = &pCodecInst->CodecInfo->encInfo;

    pAttr = &g_VpuCoreAttributes[pCodecInst->coreIdx];

    if (pAttr->supportCommandQueue == TRUE) {
        EnterLock_noclk(pCodecInst->coreIdx);
    }
    else {
        if (pCodecInst != GetPendingInst(pCodecInst->coreIdx)) {
            SetPendingInst(pCodecInst->coreIdx, 0);
            LeaveLock(pCodecInst->coreIdx);
            return RETCODE_WRONG_CALL_SEQUENCE;
        }
    }

    ret = ProductVpuEncGetSeqInfo(handle, info);
    if (ret == RETCODE_SUCCESS) {
        pEncInfo->initialInfoObtained = 1;
    }

    //info->rdPtr = VpuReadReg(pCodecInst->coreIdx, pEncInfo->streamRdPtrRegAddr);
    //info->wrPtr = VpuReadReg(pCodecInst->coreIdx, pEncInfo->streamWrPtrRegAddr);

    //pEncInfo->prevFrameEndPos = info->rdPtr;

    pEncInfo->initialInfo = *info;
    VLOG(INFO," INFO vlcBufSize %d  paramBufSize %d \n",
                info->vlcBufSize, info->paramBufSize);

    SetPendingInst(pCodecInst->coreIdx, NULL);

    LeaveLock(pCodecInst->coreIdx);

    return ret;
}

RetCode VPU_EncInstParamSync(EncHandle handle,int gopOption, int cust_qp_delta, EncChangeParam* pcp)
{
    CodecInst*  pCodecInst;
    EncInfo*    pEncInfo;
    Uint32      paramIndex;
    RetCode     ret = RETCODE_SUCCESS;

    pCodecInst = (CodecInst*)handle;
    pEncInfo = VPU_HANDLE_TO_ENCINFO(handle);
    if (pCodecInst->coreIdx >= MAX_NUM_VPU_CORE    ||
        pCodecInst->coreIdx < 0                    ||
        pCodecInst->instIndex >= MAX_NUM_INSTANCE  ||
        pCodecInst->instIndex < 0
    ) {
        VLOG(ERR,"Invalid parameter coreIdx[%d] or instIndex[%d]\n",pCodecInst->coreIdx,pCodecInst->instIndex);
        return RETCODE_FAILURE;
    }

    EnterLock(pCodecInst->coreIdx);

    paramIndex = pCodecInst->instIndex + pCodecInst->coreIdx * MAX_NUM_INSTANCE;
    if (pcp == NULL) {
        /*sync with open param*/
        osal_memset(&stInstParam[paramIndex],0,sizeof(struct vpudrv_inst_param_t));
        stInstParam[paramIndex].core_idx = pCodecInst->coreIdx;
        stInstParam[paramIndex].inst_idx = pCodecInst->instIndex;
        stInstParam[paramIndex].picWidth = pEncInfo->openParam.picWidth;
        stInstParam[paramIndex].picHeight = pEncInfo->openParam.picHeight;
        stInstParam[paramIndex].frameRateInfo = pEncInfo->openParam.frameRateInfo;
        stInstParam[paramIndex].streamBufSize = pEncInfo->openParam.streamBufSize;
        stInstParam[paramIndex].profile = pEncInfo->openParam.EncStdParam.vpParam.profile;

        stInstParam[paramIndex].intraPeriod = pEncInfo->openParam.EncStdParam.vpParam.intraPeriod;
        stInstParam[paramIndex].gopOption = gopOption;
        stInstParam[paramIndex].bitRate = pEncInfo->openParam.bitRate;
        stInstParam[paramIndex].minQpI = pEncInfo->openParam.EncStdParam.vpParam.minQpI;
        stInstParam[paramIndex].maxQpI = pEncInfo->openParam.EncStdParam.vpParam.maxQpI;
        stInstParam[paramIndex].minQpP = pEncInfo->openParam.EncStdParam.vpParam.minQpP;
        stInstParam[paramIndex].maxQpP = pEncInfo->openParam.EncStdParam.vpParam.maxQpP;
        stInstParam[paramIndex].minQpB = pEncInfo->openParam.EncStdParam.vpParam.minQpB;
        stInstParam[paramIndex].maxQpB = pEncInfo->openParam.EncStdParam.vpParam.maxQpB;
        stInstParam[paramIndex].maxDeltaQp = pEncInfo->openParam.EncStdParam.vpParam.hvsMaxDeltaQp;

        if (pEncInfo->openParam.bitstreamFormat == STD_AVC) {
            stInstParam[paramIndex].stream_type = 264;
            stInstParam[paramIndex].independSliceMode = pEncInfo->openParam.EncStdParam.vpParam.avcSliceMode;
            stInstParam[paramIndex].independSliceModeArg = pEncInfo->openParam.EncStdParam.vpParam.avcSliceArg;
            stInstParam[paramIndex].intraRefreshMode = pEncInfo->openParam.EncStdParam.vpParam.intraMbRefreshMode;
            stInstParam[paramIndex].IntraRefreshArg= pEncInfo->openParam.EncStdParam.vpParam.intraMbRefreshArg;
        }
        else if (pEncInfo->openParam.bitstreamFormat == STD_HEVC) {
            stInstParam[paramIndex].stream_type = 265;
            stInstParam[paramIndex].independSliceMode = pEncInfo->openParam.EncStdParam.vpParam.independSliceMode;
            stInstParam[paramIndex].independSliceModeArg = pEncInfo->openParam.EncStdParam.vpParam.independSliceModeArg;
            stInstParam[paramIndex].dependSliceMode = pEncInfo->openParam.EncStdParam.vpParam.dependSliceMode;
            stInstParam[paramIndex].dependSliceModeArg = pEncInfo->openParam.EncStdParam.vpParam.dependSliceModeArg;
            stInstParam[paramIndex].intraRefreshMode = pEncInfo->openParam.EncStdParam.vpParam.intraRefreshMode;
            stInstParam[paramIndex].IntraRefreshArg= pEncInfo->openParam.EncStdParam.vpParam.intraRefreshArg;
        }
        else {
            stInstParam[paramIndex].stream_type = 0;
        }
        stInstParam[paramIndex].custQpDelta = cust_qp_delta;

    }else {
        /*sync with change param*/
        if (pcp->enable_option & ENC_SET_CHANGE_PARAM_RC_TARGET_RATE) {
            stInstParam[paramIndex].bitRate = pcp->bitRate;
        }

        if (pcp->enable_option & ENC_SET_CHANGE_PARAM_RC_MIN_MAX_QP) {
            stInstParam[paramIndex].minQpI = pcp->minQpI;
            stInstParam[paramIndex].maxQpI = pcp->maxQpI;
            stInstParam[paramIndex].maxDeltaQp = pcp->hvsMaxDeltaQp;
        }

        if (pcp->enable_option & ENC_SET_CHANGE_PARAM_RC_INTER_MIN_MAX_QP) {
                stInstParam[paramIndex].minQpP = pcp->minQpP;
                stInstParam[paramIndex].maxQpP = pcp->maxQpP;
                stInstParam[paramIndex].minQpB = pcp->minQpB;
                stInstParam[paramIndex].maxQpB = pcp->maxQpB;
        }

        if (pcp->enable_option & ENC_SET_CHANGE_PARAM_INTRA_PARAM) {
            stInstParam[paramIndex].intraPeriod = pcp->intraPeriod;
        }

        if (pcp->enable_option & ENC_SET_CHANGE_PARAM_INDEPEND_SLICE) {
            if (pEncInfo->openParam.bitstreamFormat == STD_AVC) {
                stInstParam[paramIndex].independSliceMode = pcp->avcSliceMode;
                stInstParam[paramIndex].independSliceModeArg = pcp->avcSliceArg;
            }
            else if (pEncInfo->openParam.bitstreamFormat == STD_HEVC) {
                stInstParam[paramIndex].independSliceMode = pcp->independSliceMode;
                stInstParam[paramIndex].independSliceModeArg = pcp->independSliceModeArg;
            }
        }
        if (pcp->enable_option & ENC_SET_CHANGE_PARAM_DEPEND_SLICE) {
            if (pEncInfo->openParam.bitstreamFormat == STD_HEVC) {
                stInstParam[paramIndex].independSliceMode = pcp->independSliceMode;
                stInstParam[paramIndex].independSliceModeArg = pcp->independSliceModeArg;
            }
        }
    }

    if (stInstParam[paramIndex].minQpI == 0 &&
        stInstParam[paramIndex].maxQpI == 51 &&
        stInstParam[paramIndex].minQpP == 0  &&
        stInstParam[paramIndex].maxQpP == 51) {
        stInstParam[paramIndex].rcMode =  0;
    }else {
        stInstParam[paramIndex].rcMode =  1;
    }

    if (vdi_sys_sync_inst_param(&stInstParam[paramIndex]) != RETCODE_SUCCESS) {
        ret = RETCODE_FAILURE;
    }

    LeaveLock(pCodecInst->coreIdx);

    return ret;
}