//#define LOG_NDEBUG 0
#define LOG_TAG "AMLVenc"
#include <utils/Log.h>

#include<stdio.h>
#include <media/hardware/VideoAPI.h>
#include <Codec2Mapper.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/foundation/AUtils.h>
#include <ui/GraphicBuffer.h>
#include <C2AllocatorGralloc.h>
#include "AmlVencInstIntf.h"
#include "AmlVencInst.h"


namespace android {

static unsigned int gloglevel = 1;

#define CODEC2_LOG_ERR 0
#define CODEC2_LOG_INFO 1
#define CODEC2_LOG_TAG_BUFFER 2
#define CODEC2_LOG_DEBUG_LEVEL1 4
#define CODEC2_LOG_DEBUG_LEVEL2 8
#define CODEC2_LOG_TRACE 16

#define CODEC2_VENC_LOG_ERR    CODEC2_LOG_ERR
#define CODEC2_VENC_LOG_INFO   CODEC2_LOG_INFO
#define CODEC2_VENC_LOG_DEBUG   CODEC2_LOG_DEBUG_LEVEL1
#define CODEC2_VENC_LOG_TAG_BUFFER  CODEC2_LOG_TAG_BUFFER
#define CODEC2_VENC_LOG_TRACE  CODEC2_LOG_TRACE

#define CODEC2_LOG(level, f, s...) \
do { \
    if (level & gloglevel) { \
        if (level == CODEC2_LOG_INFO) \
            ALOGI(f, ##s); \
        else if (level == CODEC2_LOG_DEBUG_LEVEL1 || level == CODEC2_LOG_DEBUG_LEVEL2) \
            ALOGD(f, ##s); \
        else if (level == CODEC2_LOG_TAG_BUFFER) \
            ALOGD(f, ##s); \
    } else { \
        if (level == CODEC2_LOG_ERR) \
            ALOGE(f, ##s); \
    } \
} while(0)


#define AMLVenc_LOG(level, fmt, str...) CODEC2_LOG(level, fmt, ##str)


#define USE_CONTINUES_PHYBUFF(h) (am_gralloc_get_usage(h) & GRALLOC_USAGE_HW_VIDEO_ENCODER)
#define align_32(x)  ((((x)+31)>>5)<<5)


#define kMetadataBufferTypeCanvasSource 3
#define kMetadataBufferTypeANWBuffer 2

#define CANVAS_MODE_ENABLE  1


AmlVencInst::AmlVencInst()
            :mVencParamInst(NULL),
             mHelper(NULL),
             mVencHandle(0),
             mRequestSync(false),
             mIsChangeResolutionInternal(false) {
    ALOGD("AmlVencInst constructor!");
    gloglevel = 255;
    mHelper = new AmlVencInstHelper;
}

AmlVencInst::~AmlVencInst() {
    ALOGD("~AmlVencInst destructor!");
    Destroy();
    if (mHelper) {
        delete mHelper;
        mHelper = NULL;
    }
}


amvenc_img_format_t AmlVencInst::PixelFormatConvert(int FormatIn) {
    amvenc_img_format_t FormatOut;
    ALOGE("FORMAT input:%d",FormatIn);
    switch (FormatIn) {
        case HAL_PIXEL_FORMAT_YCbCr_420_888:
        case HAL_PIXEL_FORMAT_YCrCb_420_SP: {
            FormatOut = AML_IMG_FMT_NV21;
            ALOGE("AML_IMG_FMT_NV21");
            break;
        }
        case HAL_PIXEL_FORMAT_RGBA_8888:
        case HAL_PIXEL_FORMAT_RGB_888:
            FormatOut = AML_IMG_FMT_RGBA8888;
            ALOGE("AML_IMG_FMT_RGBA8888");
            break;
        case HAL_PIXEL_FORMAT_YV12:
            FormatOut = AML_IMG_FMT_YUV420P;
            ALOGE("AML_IMG_FMT_YUV420P");
            break;
        default: {
            ALOGE("cannot support colorformat:%x,use default nv21",FormatIn);
            FormatOut = AML_IMG_FMT_NV21;
            break;
        }
    }
    return FormatOut;
}


c2_status_t AmlVencInst::genVuiParam(stVencParam VencParam,int32_t *primaries,int32_t *transfer,int32_t *matrixCoeffs,bool *range)
{
    ColorAspects sfAspects;
    if (!C2Mapper::map(VencParam.ColorAspect.primaries, &sfAspects.mPrimaries)) {
        sfAspects.mPrimaries = android::ColorAspects::PrimariesUnspecified;
    }
    if (!C2Mapper::map(VencParam.ColorAspect.range, &sfAspects.mRange)) {
        sfAspects.mRange = android::ColorAspects::RangeUnspecified;
    }
    if (!C2Mapper::map(VencParam.ColorAspect.matrix, &sfAspects.mMatrixCoeffs)) {
        sfAspects.mMatrixCoeffs = android::ColorAspects::MatrixUnspecified;
    }
    if (!C2Mapper::map(VencParam.ColorAspect.transfer, &sfAspects.mTransfer)) {
        sfAspects.mTransfer = android::ColorAspects::TransferUnspecified;
    }
    ColorUtils::convertCodecColorAspectsToIsoAspects(sfAspects,primaries,transfer,matrixCoeffs,range);
    ALOGI("vui info:primaries:%d,transfer:%d,matrixCoeffs:%d,range:%d",*primaries,*transfer,*matrixCoeffs,(int)(*range));
    return C2_OK;
}


bool AmlVencInst::InitEncoder() {
    stVencParam VencParam;
    amvenc_codec_id_t CodecId = AML_CODEC_ID_NONE;
    amvenc_info_t VencInfo;
    amvenc_qp_param_t QpParam;

    memset(&VencParam,0,sizeof(VencParam));
    memset(&QpParam,0,sizeof(QpParam));

    mVencParamInst->GetVencParam(VencParam);
    CodecId = (mVencParamInst->GetCodecType() == H265) ? AML_CODEC_ID_H265 : AML_CODEC_ID_H264;

    VencInfo.width = VencParam.Width;
    VencInfo.height = VencParam.Height;
    VencInfo.frame_rate = VencParam.FrameRate;
    VencInfo.bit_rate = VencParam.Bitrate;
    VencInfo.img_format = PixelFormatConvert(VencParam.PixFormat);

    mBitRate = VencParam.Bitrate;

    if (C2_OK == genVuiParam(VencParam,(int32_t *)&VencInfo.colour_primaries,(int32_t *)&VencInfo.transfer_characteristics,(int32_t *)&VencInfo.matrix_coefficients,(bool *)&VencInfo.video_full_range_flag)) {
        VencInfo.vui_parameters_present_flag = 1;
        VencInfo.video_signal_type_present_flag = 1;
        VencInfo.colour_description_present_flag = 1;
        ALOGD("enable vui info");
    }

    ExtraInit(VencInfo,QpParam); //extra init action for each ip core

    ALOGE("CodecId:%d",CodecId);
    AMLVenc_LOG(CODEC2_VENC_LOG_INFO,"init param width:%d,height:%d,frame_rate:%d,bit_rate:%d,img_format:%d,qp_mode:%d",
                                     VencInfo.width,VencInfo.height,VencInfo.frame_rate,VencInfo.bit_rate,VencInfo.img_format,VencInfo.qp_mode);
    AMLVenc_LOG(CODEC2_VENC_LOG_INFO,"qp info min_qp:%d,max_qp:%d,imin:%d,imax:%d,pmin:%d,pmax:%d",
                                     QpParam.qp_min,QpParam.qp_max,QpParam.qp_I_min,QpParam.qp_I_max,QpParam.qp_P_min,QpParam.qp_P_max);
    mVencHandle = amvenc_init(CodecId,VencInfo,&QpParam);
    if (!mVencHandle) {
        ALOGE("init amlvenc failed!!!");
        return false;
    }
    ALOGE("init amvenc success!!");
    mHelper->SetCodecType(mVencParamInst->GetCodecType());
    mHelper->SetCodecHandle(mVencHandle);
    mHelper->OpenFile(DUMP_RAW);
    mHelper->OpenFile(DUMP_ES);
    return true;
}


bool AmlVencInst::init() {
    return InitEncoder();
}


void AmlVencInst::ExtraInit(amvenc_info_t &VencInfo,amvenc_qp_param_t &QpParam) {
    return;
}



bool AmlVencInst::IsYUV420(const C2GraphicView &view) {
    const C2PlanarLayout &layout = view.layout();
    return (layout.numPlanes == 3
            && layout.type == C2PlanarLayout::TYPE_YUV
            && layout.planes[layout.PLANE_Y].channel == C2PlaneInfo::CHANNEL_Y
            && layout.planes[layout.PLANE_Y].allocatedDepth == 8
            && layout.planes[layout.PLANE_Y].bitDepth == 8
            && layout.planes[layout.PLANE_Y].rightShift == 0
            && layout.planes[layout.PLANE_Y].colSampling == 1
            && layout.planes[layout.PLANE_Y].rowSampling == 1
            && layout.planes[layout.PLANE_U].channel == C2PlaneInfo::CHANNEL_CB
            && layout.planes[layout.PLANE_U].allocatedDepth == 8
            && layout.planes[layout.PLANE_U].bitDepth == 8
            && layout.planes[layout.PLANE_U].rightShift == 0
            && layout.planes[layout.PLANE_U].colSampling == 2
            && layout.planes[layout.PLANE_U].rowSampling == 2
            && layout.planes[layout.PLANE_V].channel == C2PlaneInfo::CHANNEL_CR
            && layout.planes[layout.PLANE_V].allocatedDepth == 8
            && layout.planes[layout.PLANE_V].bitDepth == 8
            && layout.planes[layout.PLANE_V].rightShift == 0
            && layout.planes[layout.PLANE_V].colSampling == 2
            && layout.planes[layout.PLANE_V].rowSampling == 2);
}

bool AmlVencInst::IsNV12(const C2GraphicView &view) {
    if (!IsYUV420(view)) {
        return false;
    }
    const C2PlanarLayout &layout = view.layout();
    return (layout.rootPlanes == 2
            && layout.planes[layout.PLANE_U].colInc == 2
            && layout.planes[layout.PLANE_U].rootIx == layout.PLANE_U
            && layout.planes[layout.PLANE_U].offset == 0
            && layout.planes[layout.PLANE_V].colInc == 2
            && layout.planes[layout.PLANE_V].rootIx == layout.PLANE_U
            && layout.planes[layout.PLANE_V].offset == 1);
}

bool AmlVencInst::IsNV21(const C2GraphicView &view) {
    if (!IsYUV420(view)) {
        return false;
    }
    const C2PlanarLayout &layout = view.layout();
    return (layout.rootPlanes == 2
            && layout.planes[layout.PLANE_U].colInc == 2
            && layout.planes[layout.PLANE_U].rootIx == layout.PLANE_V
            && layout.planes[layout.PLANE_U].offset == 1
            && layout.planes[layout.PLANE_V].colInc == 2
            && layout.planes[layout.PLANE_V].rootIx == layout.PLANE_V
            && layout.planes[layout.PLANE_V].offset == 0);
}

bool AmlVencInst::IsI420(const C2GraphicView &view) {
    if (!IsYUV420(view)) {
        return false;
    }
    const C2PlanarLayout &layout = view.layout();
    return (layout.rootPlanes == 3
            && layout.planes[layout.PLANE_U].colInc == 1
            && layout.planes[layout.PLANE_U].rootIx == layout.PLANE_U
            && layout.planes[layout.PLANE_U].offset == 0
            && layout.planes[layout.PLANE_V].colInc == 1
            && layout.planes[layout.PLANE_V].rootIx == layout.PLANE_V
            && layout.planes[layout.PLANE_V].offset == 0);
}



c2_status_t AmlVencInst::LinearDataProc(std::shared_ptr<const C2ReadView> view,stInputFrameInfo *pFrameInfo) {
    //private_handle_t *priv_handle = NULL;
//    uint32_t dumpFileSize = 0;
    stVencParam VencParam;

    if ( nullptr == pFrameInfo) {
        return C2_BAD_VALUE;
    }

    ALOGE("datalen:%d",view->capacity());
    DataModeInfo_t *pDataMode = (DataModeInfo_t *)(view->data());
    AMLVenc_LOG(CODEC2_VENC_LOG_INFO,"type:%lx",pDataMode->type);

    if (kMetadataBufferTypeCanvasSource == pDataMode->type && sizeof(DataModeInfo_t) == view->capacity()) {
        return CanvasDataProc(pDataMode,pFrameInfo);
    }
    else if(kMetadataBufferTypeANWBuffer == pDataMode->type && sizeof(DataModeInfo_t) == view->capacity()) {
        #if 0
        ALOGE("111111,pDataMode:%p",pDataMode);
        ANativeWindowBuffer *pNativeWindow = (ANativeWindowBuffer *)pDataMode->pAddr;
        int fence_id = pDataMode->canvas;
        ALOGE("111111,pNativeWindow:%p,fence_id:%d",pNativeWindow,fence_id);
        priv_handle = (private_handle_t *)pNativeWindow->handle;
        C2Venc_LOG(CODEC2_VENC_LOG_INFO,"native window source,handle:%p",priv_handle);
        //int share_fd = priv_handle->share_fd;
        //C2Venc_LOG(CODEC2_VENC_LOG_INFO,"share_fd:%d",priv_handle->share_fd);
        if (priv_handle && priv_handle->share_fd && USE_CONTINUES_PHYBUFF(priv_handle) && isSupportDMA()) {
            //const C2PlanarLayout &layout = view->layout();

            c2_status_t err = intf()->query_vb({&PicSize,&InputFmt},{},C2_DONT_BLOCK,nullptr);
            if (err == C2_BAD_INDEX) {
                if (!PicSize || !InputFmt) {
                    C2Venc_LOG(CODEC2_VENC_LOG_ERR,"get PicSize or InputFmt failed!!");
                    return C2_BAD_VALUE;
                }
            } else if (err != C2_OK) {
                C2Venc_LOG(CODEC2_VENC_LOG_ERR,"get subclass param failed!!");
                return C2_BAD_VALUE;
            }
            pFrameInfo->bufType = DMA;
            pFrameInfo->shareFd[0] = priv_handle->share_fd;
            pFrameInfo->shareFd[1] = -1;
            pFrameInfo->shareFd[2] = -1;
            pFrameInfo->planeNum = 1;
            pFrameInfo->yStride = priv_handle->plane_info[0].byte_stride;
            pFrameInfo->uStride = priv_handle->plane_info[1].byte_stride;
            pFrameInfo->vStride = priv_handle->plane_info[2].byte_stride;
            int format = priv_handle->format;
            switch (format) {
                case HAL_PIXEL_FORMAT_RGBA_8888:
                case HAL_PIXEL_FORMAT_RGB_888:
                    pFrameInfo->colorFmt = C2_ENC_FMT_RGBA8888;
                    dumpFileSize = pFrameInfo->yStride * PicSize.height;
                    break;
                case HAL_PIXEL_FORMAT_YCbCr_420_888:
                case HAL_PIXEL_FORMAT_YCrCb_420_SP:
                    pFrameInfo->colorFmt = C2_ENC_FMT_NV21;
                    dumpFileSize = pFrameInfo->yStride * PicSize.height * 3 / 2;
                    break;
                case HAL_PIXEL_FORMAT_YV12:
                    pFrameInfo->colorFmt = C2_ENC_FMT_YV12;
                    dumpFileSize = pFrameInfo->yStride * PicSize.height * 3 / 2;
                    break;
                default:
                    pFrameInfo->colorFmt = C2_ENC_FMT_NV21;
                    dumpFileSize = pFrameInfo->yStride * PicSize.height * 3 / 2;
                    C2Venc_LOG(CODEC2_VENC_LOG_ERR,"cannot find support fmt,default:%d",pFrameInfo->colorFmt);
                    break;
            }
            C2Venc_LOG(CODEC2_VENC_LOG_DEBUG,"native window source:yStride:%d,uStride:%d,vStride:%d,view->width():%d,view->height():%d,plane num:%d",
                pFrameInfo->yStride,pFrameInfo->uStride,pFrameInfo->vStride,PicSize.width,PicSize.height,pFrameInfo->planeNum);
        }
        #endif
    }
    else {  //linear picture buffer
        memset(&VencParam,0,sizeof(VencParam));
        mVencParamInst->GetVencParam(VencParam);

        AMLVenc_LOG(CODEC2_VENC_LOG_INFO,"get width:%d,height:%d,colorfmt:%d,ptr:%p",VencParam.Width,VencParam.Height,VencParam.PixFormat,const_cast<uint8_t *>(view->data()));
        pFrameInfo->bufType = VMALLOC;
        pFrameInfo->colorFmt = PixelFormatConvert(VencParam.PixFormat);
        pFrameInfo->yPlane = const_cast<uint8_t *>(view->data());
        pFrameInfo->uPlane = pFrameInfo->yPlane + VencParam.Width * VencParam.Height;
        pFrameInfo->vPlane = pFrameInfo->uPlane;
        pFrameInfo->yStride = VencParam.Width;
        pFrameInfo->uStride = VencParam.Width;
        pFrameInfo->vStride = VencParam.Width;
    }
    return C2_OK;
}


c2_status_t AmlVencInst::DMAProc(const native_handle_t *priv_handle,stInputFrameInfo *pFrameInfo,uint32_t *dumpFileSize) {
    stVencParam VencParam;

    if (NULL == priv_handle || NULL == pFrameInfo || NULL == dumpFileSize) {
        return C2_BAD_VALUE;
    }
    memset(&VencParam,0,sizeof(VencParam));
    mVencParamInst->GetVencParam(VencParam);

    pFrameInfo->bufType = DMA;
    pFrameInfo->shareFd[0] = am_gralloc_get_buffer_fd(priv_handle);
    pFrameInfo->shareFd[1] = -1;
    pFrameInfo->shareFd[2] = -1;
    pFrameInfo->planeNum = 1;
    pFrameInfo->yStride = am_gralloc_get_stride_in_byte(priv_handle);
    pFrameInfo->uStride = am_gralloc_get_stride_in_byte(priv_handle);
    pFrameInfo->vStride = am_gralloc_get_stride_in_byte(priv_handle);
    pFrameInfo->HStride = am_gralloc_get_aligned_height(priv_handle);
    AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"actual height:%d",pFrameInfo->HStride);
    int format = am_gralloc_get_format(priv_handle);
    pFrameInfo->colorFmt = PixelFormatConvert(format);
    if (AML_IMG_FMT_RGBA8888 == pFrameInfo->colorFmt) {
        pFrameInfo->yStride = am_gralloc_get_stride_in_byte(priv_handle) / 4;
        (*dumpFileSize) = pFrameInfo->yStride * pFrameInfo->HStride * 4;
    }
    else {
        (*dumpFileSize) = pFrameInfo->yStride * pFrameInfo->HStride * 3 / 2;
    }
    AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"yStride:%d,uStride:%d,vStride:%d,view->width():%d,view->height():%d,plane num:%d",
    pFrameInfo->yStride,pFrameInfo->uStride,pFrameInfo->vStride,VencParam.Width,pFrameInfo->HStride,pFrameInfo->planeNum);

    return C2_OK;
}


c2_status_t AmlVencInst::GraphicDataProc(std::shared_ptr<C2Buffer> inputBuffer,stInputFrameInfo *pFrameInfo) {
    std::shared_ptr<const C2GraphicView> view;
    uint32_t dumpFileSize = 0;
    c2_status_t res = C2_OK;
    stVencParam VencParam;

    if (nullptr == inputBuffer.get() || nullptr == pFrameInfo ) {
        AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"GraphicDataProc bad parameter!!");
        return C2_BAD_VALUE;
    }

    const native_handle_t* c2Handle = inputBuffer->data().graphicBlocks().front().handle();
    native_handle_t *handle = UnwrapNativeCodec2GrallocHandle(c2Handle);

    if (handle && am_gralloc_get_buffer_fd(handle) && USE_CONTINUES_PHYBUFF(handle) && mVencParamInst->GetIsSupportDMAMode()/*isSupportDMA()*/) {
        res = DMAProc(handle,pFrameInfo,&dumpFileSize);
        if (C2_OK != res) {
            goto fail_process;
        }
    }
    else {
        view = std::make_shared<const C2GraphicView>(inputBuffer->data().graphicBlocks().front().map().get());
        if (C2_OK != view->error() || nullptr == view.get()) {
            AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"graphic view map err = %d or view is null", view->error());
            res = C2_BAD_VALUE;
            goto fail_process;
        }

        memset(&VencParam,0,sizeof(VencParam));
        mVencParamInst->GetVencParam(VencParam);
        if (VencParam.canvas_mode == CANVAS_MODE_ENABLE) {
            DataModeInfo_t *pDataMode = (DataModeInfo_t *)(view->data()[C2PlanarLayout::PLANE_Y]);
            if (kMetadataBufferTypeCanvasSource == pDataMode->type) {
                AMLVenc_LOG(CODEC2_VENC_LOG_INFO,"enter canvas mode!!");
                res = CanvasDataProc(pDataMode,pFrameInfo);
                if (C2_OK != res) {
                    AMLVenc_LOG(CODEC2_VENC_LOG_INFO,"CanvasDataProc failed!!!");
                    goto fail_process;
                }
            }
            else {
                AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"canvas mode,but the data is not right!!!,type:%lx,canvas:%lx",pDataMode->type,pDataMode->canvas);
                res = C2_BAD_VALUE;
                goto fail_process;
            }
        }
        else {
            res = ViewDataProc(view,pFrameInfo,&dumpFileSize);
            if (C2_OK != res) {
                AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"ViewDataProc failed!!!");
                goto fail_process;
            }
        }
    }

    if (pFrameInfo->bufType == DMA) {
        uint8_t *pVirAddr = NULL;
        pVirAddr = (uint8_t *)mmap( NULL, dumpFileSize,PROT_READ | PROT_WRITE, MAP_SHARED, pFrameInfo->shareFd[0], 0);
        if (pVirAddr) {
            AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"dma mode,viraddr: %p", pVirAddr);
            mHelper->dumpDataToFile(DUMP_RAW,pVirAddr,dumpFileSize);
            munmap(pVirAddr, dumpFileSize);
        }
    }
    else {
        mHelper->dumpDataToFile(DUMP_RAW,pFrameInfo->yPlane,dumpFileSize);
    }
    return C2_OK;

fail_process:
    if (handle) {
        native_handle_delete(handle);
    }
    return res;
}


c2_status_t AmlVencInst::CheckPicSize(std::shared_ptr<const C2GraphicView> view,uint64_t frameIndex) {
    stVencParam VencParam;

    memset(&VencParam,0,sizeof(stVencParam));
    mVencParamInst->GetVencParam(VencParam);

    if (VencParam.Width != view->width() || VencParam.Height != view->height()) {
        if (0 == frameIndex) {  //first frame is normally
            AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"pic size :%d x %d,this buffer is:%d x %d,change pic size...",VencParam.Width,VencParam.Height,view->width(),view->height());
            mVencParamInst->UpdatePicSize(view->width(), view->height());
        }
        else {
            AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"buffer is not valid,pic size :%d x %d,but this buffer is:%d x %d",VencParam.Width,VencParam.Height,view->width(),view->height());
            return C2_BAD_VALUE;
        }
    }

    return C2_OK;
}


c2_status_t AmlVencInst::ViewDataProc(std::shared_ptr<const C2GraphicView> view,stInputFrameInfo *pFrameInfo,uint32_t *dumpFileSize) {
    if (NULL == view || NULL == pFrameInfo || NULL == dumpFileSize) {
        return C2_BAD_VALUE;
    }
    const C2PlanarLayout &layout = view->layout();
    pFrameInfo->bufType = VMALLOC;
    pFrameInfo->yPlane = const_cast<uint8_t *>(view->data()[C2PlanarLayout::PLANE_Y]);
    pFrameInfo->uPlane = const_cast<uint8_t *>(view->data()[C2PlanarLayout::PLANE_U]);
    pFrameInfo->vPlane = const_cast<uint8_t *>(view->data()[C2PlanarLayout::PLANE_V]);
    pFrameInfo->yStride = layout.planes[C2PlanarLayout::PLANE_Y].rowInc;
    pFrameInfo->uStride = layout.planes[C2PlanarLayout::PLANE_U].rowInc;
    pFrameInfo->vStride = layout.planes[C2PlanarLayout::PLANE_V].rowInc;
    (*dumpFileSize) = view->width() * view->height() * 3 / 2;

    if (C2_OK != CheckPicSize(view,pFrameInfo->frameIndex)) {
        return C2_BAD_VALUE;
    }

    AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"yStride:%d,uStride:%d,vStride:%d,view->width():%d,view->height():%d,root plane num:%d,component plan num:%d",
        pFrameInfo->yStride,pFrameInfo->uStride,pFrameInfo->vStride,view->width(),view->height(),layout.rootPlanes,layout.numPlanes);
    switch (layout.type) {
        case C2PlanarLayout::TYPE_RGB:
        case C2PlanarLayout::TYPE_RGBA: {
            AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"TYPE_RGBA or TYPE_RGB");
            pFrameInfo->yPlane = const_cast<uint8_t *>(view->data()[C2PlanarLayout::PLANE_R]);
            pFrameInfo->uPlane = const_cast<uint8_t *>(view->data()[C2PlanarLayout::PLANE_G]);
            pFrameInfo->vPlane = const_cast<uint8_t *>(view->data()[C2PlanarLayout::PLANE_B]);
            pFrameInfo->yStride = layout.planes[C2PlanarLayout::PLANE_R].rowInc / 4;
            pFrameInfo->uStride = layout.planes[C2PlanarLayout::PLANE_G].rowInc;
            pFrameInfo->vStride = layout.planes[C2PlanarLayout::PLANE_B].rowInc;
            (*dumpFileSize) = view->width() * view->height() * 4;
            pFrameInfo->colorFmt = AML_IMG_FMT_RGBA8888;
            break;
        }
        case C2PlanarLayout::TYPE_YUV: {
            AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"TYPE_YUV");
            if (IsNV12(*view.get())) {
                pFrameInfo->colorFmt = AML_IMG_FMT_NV12;
                AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"InputFrameInfo colorfmt :AML_IMG_FMT_NV12");
            }
            else if (IsNV21(*view.get())) {
                pFrameInfo->colorFmt = AML_IMG_FMT_NV21;
                AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"InputFrameInfo colorfmt :AML_IMG_FMT_NV21");
            }
            else if (IsI420(*view.get())) {
                pFrameInfo->colorFmt = AML_IMG_FMT_YUV420P;
                AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"InputFrameInfo colorfmt :AML_IMG_FMT_YUV420P");
            }
            else {
                AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"type yuv,but not support fmt!!!");
            }
            (*dumpFileSize) = pFrameInfo->yStride * view->height() * 3 / 2;
            break;
        }
        case C2PlanarLayout::TYPE_YUVA: {
            AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"TYPE_YUVA not support!!");
            break;
        }
        default:
            AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"layout.type:%d",layout.type);
            break;
    }

    //pFrameInfo->colorFmt = AML_IMG_FMT_YUV420P;
    return C2_OK;
}



c2_status_t AmlVencInst::CanvasDataProc(DataModeInfo_t *pDataMode,stInputFrameInfo *pFrameInfo) {
    if (pFrameInfo == nullptr) {
        return C2_BAD_VALUE;
    }

    pFrameInfo->bufType = CANVAS;
    pFrameInfo->canvas = pDataMode->canvas;
    pFrameInfo->yPlane = (uint8_t *)pDataMode->pAddr;
    pFrameInfo->uPlane = 0;
    pFrameInfo->vPlane = 0;
    AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"canvas mode,canvas id:%" PRId64"",pFrameInfo->canvas);
    return C2_OK;
}


bool AmlVencInst::GenerateHeader(char *pHeader,unsigned int &Length) {
    amvenc_metadata_t ret;

    memset(&ret,0,sizeof(ret));
    if (NULL == pHeader) {
        return false;
    }
    ret = amvenc_generate_header(mVencHandle,(unsigned char *)pHeader,&Length);
    if (!ret.is_valid) {
        return false;
    }
    mHelper->dumpDataToFile(DUMP_ES,(uint8_t *)pHeader,Length);
    AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"header len:%d",Length);
    return true;
}



eResult AmlVencInst::PreProcess(std::shared_ptr<C2Buffer> inputBuffer,stInputFrameInfo &InputFrameInfo) {
    std::shared_ptr<const C2ReadView> Linearview;

    int type = inputBuffer->data().type();

    AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"inputbuffer type:%d",type);

    if (C2BufferData::GRAPHIC == type) {
        if (C2_OK != GraphicDataProc(inputBuffer,&InputFrameInfo)) {
            AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"graphic buffer proc failed!!");
            return WORK_IS_VALID;
        }
    }
    else if(C2BufferData::LINEAR == type) {
        Linearview = std::make_shared<const C2ReadView>(inputBuffer->data().linearBlocks().front().map().get());
        if (C2_OK != Linearview->error() || nullptr == Linearview.get()) {
            AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"linear view map err = %d or view is null", Linearview->error());
            return FAIL;
        }
        if (C2_OK != LinearDataProc(Linearview,&InputFrameInfo)) {
            AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"linear buffer proc failed!!");
            return WORK_IS_VALID;
        }
    }
    else {
        AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"invalid data type:%d!!",type);
        return FAIL;
    }
    ExtraPreProcess(InputFrameInfo);
    return SUCCESS;
}



void AmlVencInst::ExtraPreProcess(stInputFrameInfo &InputFrameInfo) {
    return;
}


void AmlVencInst::ExtraProcess() {
    return;
}



c2_status_t AmlVencInst::ProcessOneFrame(stInputFrameInfo InputFrameInfo,stOutputFrame &OutFrame) {
    AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"ProcessOneFrame! yPlane:%p,uPlane:%p,vPlane:%p",InputFrameInfo.yPlane,InputFrameInfo.uPlane,InputFrameInfo.vPlane);

    amvenc_metadata_t ret;
    amvenc_frame_info_t InputInfo;
    amvenc_buffer_info_t BufferInfo;
    amvenc_buffer_info_t retbuf;
    stVencParam VencParam;
    amvenc_frame_type_t FrameType = AML_FRAME_TYPE_AUTO;
//    int32_t avg_qp = 0;
    if (!OutFrame.Data) {
        AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"ProcessOneFrame parameter bad value,pls check!");
        return C2_BAD_VALUE;
    }

    memset(&ret,0,sizeof(ret));
    memset(&InputInfo,0,sizeof(InputInfo));
    memset(&VencParam,0,sizeof(VencParam));
    memset(&BufferInfo,0,sizeof(BufferInfo));
    memset(&retbuf,0,sizeof(retbuf));

    mVencParamInst->GetVencParam(VencParam);

    FrameType = AML_FRAME_TYPE_P;
    if (VencParam.SyncFrameRequest != mRequestSync) {
        // we can handle IDR immediately
        if (VencParam.SyncFrameRequest) {
            // unset request
            FrameType = AML_FRAME_TYPE_IDR;
            mVencParamInst->UpdateSyncFrameReq(false);
            AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"Got dynamic IDR request");
        }
        mRequestSync = false;
    }

    // codec2TypeTrans(InputFrameInfo.colorFmt,&inputInfo.buf_fmt);
    BufferInfo.buf_fmt = (amvenc_img_format_t)InputFrameInfo.colorFmt;
    //BufferInfo.buf_fmt = AML_IMG_FMT_YUV420P;
    if (DMA == InputFrameInfo.bufType) {
        BufferInfo.buf_type = AML_DMA_TYPE;
        BufferInfo.buf_stride = InputFrameInfo.yStride;
        BufferInfo.buf_info.dma_info.shared_fd[0] = InputFrameInfo.shareFd[0];
        BufferInfo.buf_info.dma_info.shared_fd[1] = 0;//InputFrameInfo.shareFd[1];
        BufferInfo.buf_info.dma_info.shared_fd[2] = 0;//InputFrameInfo.shareFd[2];
        BufferInfo.buf_info.dma_info.num_planes = InputFrameInfo.planeNum;
        AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"dma mode,plan num:%d,fd[%d %d %d]",InputFrameInfo.planeNum,InputFrameInfo.shareFd[0],
                                                  InputFrameInfo.shareFd[1],
                                                  InputFrameInfo.shareFd[2]);
    }
    else if (CANVAS == InputFrameInfo.bufType) {
        BufferInfo.buf_type = AML_CANVAS_TYPE;
        BufferInfo.buf_info.canvas = InputFrameInfo.canvas;
    }
    else {
        BufferInfo.buf_type = AML_VMALLOC_TYPE;
        if (AML_IMG_FMT_RGBA8888 == BufferInfo.buf_fmt) {
            BufferInfo.buf_info.in_ptr[0] = (unsigned long)InputFrameInfo.yPlane;
            BufferInfo.buf_info.in_ptr[1] = (unsigned long)InputFrameInfo.uPlane;
            BufferInfo.buf_info.in_ptr[2] = (unsigned long)InputFrameInfo.vPlane;
        }
        else {
            BufferInfo.buf_info.in_ptr[0] = (unsigned long)InputFrameInfo.yPlane;
            BufferInfo.buf_info.in_ptr[1] = (unsigned long)InputFrameInfo.vPlane;//inputInfo.YCbCr[0] + mSize->width * mSize->height;//(unsigned long)uPlane;
            BufferInfo.buf_info.in_ptr[2] = (unsigned long)InputFrameInfo.vPlane;//(unsigned long)vPlane;
        }
        BufferInfo.buf_stride = InputFrameInfo.yStride;
    }

    ExtraProcess();  //extra process action for each ip core

    //C2MULTI_LOG(CODEC2_VENC_LOG_DEBUG,"mPixelFormat->value:0x%x,InputFrameInfo.colorFmt:%x",mPixelFormat->value,InputFrameInfo.colorFmt);

    if (mBitRate != VencParam.Bitrate) {
        AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"bitrate change to %d",VencParam.Bitrate);
        amvenc_change_bitrate(mVencHandle,VencParam.Bitrate);
        mBitRate = VencParam.Bitrate;
    }

    AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"Debug input info:yAddr:0x%lx,uAddr:0x%lx,vAddr:0x%lx,frame_type:%d,fmt:%d,pitch:%d,bitrate:%d",BufferInfo.buf_info.in_ptr[0],
         BufferInfo.buf_info.in_ptr[1],BufferInfo.buf_info.in_ptr[2],BufferInfo.buf_type,BufferInfo.buf_fmt,BufferInfo.buf_stride,VencParam.Bitrate);

    ret = amvenc_encode(mVencHandle, InputInfo, FrameType, (unsigned char*)OutFrame.Data, &BufferInfo, &retbuf);
    OutFrame.Length = ret.encoded_data_length_in_bytes;
    AMLVenc_LOG(CODEC2_VENC_LOG_DEBUG,"encode finish,output len:%d",ret.encoded_data_length_in_bytes);
    if (!ret.is_valid) {
        AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"multi encode frame failed,errcode:%d",ret.err_cod);
        return C2_CORRUPTED;
    }
#if 0 //need add this function
    int re = 0;
    re = mEncFrameQpFunc(mCodecHandle,&avg_qp);
    if (re != 1) {
        C2MULTI_LOG(CODEC2_VENC_LOG_ERR,"get avg_qp failed,re:%d",re);
    }
    C2MULTI_LOG(CODEC2_VENC_LOG_DEBUG,"per frame avg_qp=%d",avg_qp);
#endif
    mHelper->dumpDataToFile(DUMP_ES,OutFrame.Data,OutFrame.Length);
    OutFrame.FrameType = P_FRAME;
    if (ret.is_key_frame) {
        OutFrame.FrameType = IDR_FRAME;
        mVencParamInst->UpdateFrameType(IDR_FRAME/*C2Config::SYNC_FRAME*/);
    }
    else {
        mVencParamInst->UpdateFrameType(P_FRAME/*C2Config::P_FRAME*/);
    }
#if 0 //need add this function
    mIntfImpl->setAverageQp(avg_qp);
#endif
    return C2_OK;
}



bool AmlVencInst::Destroy() {
    AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"destroy venc instance,mVencHandle:%lx",mVencHandle);
    if (mVencHandle) {
        amvenc_destroy(mVencHandle);
        mVencHandle = 0;
    }
    else {
        AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"venc instance have been destroyed already!!");
    }
    AMLVenc_LOG(CODEC2_VENC_LOG_ERR,"mVencHandle:%lx",mVencHandle);
    mHelper->CloseFile(DUMP_RAW);
    mHelper->CloseFile(DUMP_ES);
    return true;
}


void AmlVencInst::SetVencParamInst(IAmlVencParam *pVencParamInst) {
    if (NULL != pVencParamInst)
        mVencParamInst = pVencParamInst;
}


}