/*
 INTEL CONFIDENTIAL
 Copyright 2011 Intel Corporation All Rights Reserved.
 The source code contained or described herein and all documents related to the source code ("Material") are owned by Intel Corporation or its suppliers or licensors. Title to the Material remains with Intel Corporation or its suppliers and licensors. The Material contains trade secrets and proprietary and confidential information of Intel or its suppliers and licensors. The Material is protected by worldwide copyright and trade secret laws and treaty provisions. No part of the Material may be used, copied, reproduced, modified, published, uploaded, posted, transmitted, distributed, or disclosed in any way without Intel’s prior express written permission.

 No license under any patent, copyright, trade secret or other intellectual property right is granted to or conferred upon you by disclosure or delivery of the Materials, either expressly, by implication, inducement, estoppel or otherwise. Any license under such intellectual property rights must be express and approved by Intel in writing.
 */
#include <string.h>
#include "VideoEncoderLog.h"
#include "VideoEncoderBase.h"
#include <va/va_tpi.h>
#include <va/va_android.h>

#undef DUMP_SRC_DATA // To dump source data
// API declaration
extern "C" {
VAStatus vaLockSurface(VADisplay dpy,
    VASurfaceID surface,
    unsigned int *fourcc,
    unsigned int *luma_stride,
    unsigned int *chroma_u_stride,
    unsigned int *chroma_v_stride,
    unsigned int *luma_offset,
    unsigned int *chroma_u_offset,
    unsigned int *chroma_v_offset,
    unsigned int *buffer_name,
    void **buffer
);

VAStatus vaUnlockSurface(VADisplay dpy,
    VASurfaceID surface
);

VAStatus vaCreateSurfaceFromKBuf(
    VADisplay dpy,
    int width,
    int height,
    int format,
    VASurfaceID *surface,       /* out */
    unsigned int kbuf_handle, /* kernel buffer handle*/
    unsigned size, /* kernel buffer size */
    unsigned int kBuf_fourcc, /* expected fourcc */
    unsigned int luma_stride, /* luma stride, could be width aligned with a special value */
    unsigned int chroma_u_stride, /* chroma stride */
    unsigned int chroma_v_stride,
    unsigned int luma_offset, /* could be 0 */
    unsigned int chroma_u_offset, /* UV offset from the beginning of the memory */
    unsigned int chroma_v_offset
);
}

VideoEncoderBase::VideoEncoderBase()
    :mInitialized(false)
    ,mVADisplay(NULL)
    ,mVADecoderDisplay(NULL)
    ,mVAContext(0)
    ,mVAConfig(0)
    ,mVAEntrypoint(VAEntrypointEncSlice)
    ,mCurSegment(NULL)
    ,mOffsetInSeg(0)
    ,mTotalSize(0)
    ,mTotalSizeCopied(0)
    ,mBufferMode(BUFFER_SHARING_NONE)
    ,mUpstreamBufferList(NULL)
    ,mUpstreamBufferCnt(0)
    ,mBufAttrib(NULL)
    ,mForceKeyFrame(false)
    ,mNewHeader(false)
    ,mFirstFrame (true)
    ,mRenderMaxSliceSize(false)
    ,mRenderQP (false)
    ,mRenderAIR(false)
    ,mRenderFrameRate(false)
    ,mRenderBitRate(false)
    ,mRenderHrd(false)
    ,mLastCodedBuffer(0)
    ,mOutCodedBuffer(0)
    ,mSeqParamBuf(0)
    ,mPicParamBuf(0)
    ,mSliceParamBuf(0)
    ,mSharedSurfaces(NULL)
    ,mSurfaces(NULL)
    ,mSurfaceCnt(0)
    ,mSharedSurfacesCnt(0)
    ,mReqSurfacesCnt(0)
    ,mUsrPtr(NULL)
    ,mVideoSrcBufferList(NULL)
    ,mCurFrame(NULL)
    ,mRefFrame(NULL)
    ,mRecFrame(NULL)
    ,mLastFrame(NULL)
    ,mLastInputRawBuffer(NULL)
    ,mEncodedFrames(0)
    ,mFrameNum(0)
    ,mCodedBufSize(0)
    ,mCodedBufIndex(0)
    ,mPicSkipped(false)
    ,mIsIntra(true)
    ,mSliceSizeOverflow(false)
    ,mCodedBufferMapped(false)
    ,mDataCopiedOut(false)
    ,mKeyFrame(true) {

    VAStatus vaStatus = VA_STATUS_SUCCESS;
    // here the display can be any value, use following one
    // just for consistence purpose, so don't define it
    unsigned int display = 0x18C34078;
    int majorVersion = -1;
    int minorVersion = -1;

    setDefaultParams();
    mVACodedBuffer [0] = 0;
    mVACodedBuffer [1] = 0;

    LOG_V("vaGetDisplay \n");
    mVADisplay = vaGetDisplay(&display);
    if (mVADisplay == NULL) {
        LOG_E("vaGetDisplay failed.");
    }

    vaStatus = vaInitialize(mVADisplay, &majorVersion, &minorVersion);
    LOG_V("vaInitialize \n");
    if (vaStatus != VA_STATUS_SUCCESS) {
        LOG_E( "Failed vaInitialize, vaStatus = %d\n", vaStatus);
    }
}

VideoEncoderBase::~VideoEncoderBase() {

    VAStatus vaStatus = VA_STATUS_SUCCESS;
    vaStatus = vaTerminate(mVADisplay);
    LOG_V( "vaTerminate\n");
    if (vaStatus != VA_STATUS_SUCCESS) {
        LOG_W( "Failed vaTerminate, vaStatus = %d\n", vaStatus);
    } else {
        mVADisplay = NULL;
    }
}

Encode_Status VideoEncoderBase::start() {

    Encode_Status ret = ENCODE_SUCCESS;
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    VASurfaceID *surfaces = NULL;

    VAConfigAttrib vaAttrib[2];
    uint32_t index;
    uint32_t maxSize = 0;

    VideoEncSurfaceBuffer *videoSurfaceBuffer = NULL;
    uint32_t normalSurfacesCnt = 2;

    if (mInitialized) {
        LOG_V("Encoder has been started\n");
        return ENCODE_ALREADY_INIT;
    }

    // For upstream allocates buffer, it is mandatory to set buffer mode
    // and for other stuff, it is optional
    // Different buffer mode will have different surface handling approach

    // mSharedSurfacesCnt is for upstream buffer allocation case
    mSharedSurfacesCnt = 0;

    vaAttrib[0].type = VAConfigAttribRTFormat;
    vaAttrib[1].type = VAConfigAttribRateControl;
    vaAttrib[0].value = VA_RT_FORMAT_YUV420;
    vaAttrib[1].value = mComParams.rcMode;

    LOG_V( "======VA Configuration======\n");

    LOG_I( "profile = %d\n", mComParams.profile);
    LOG_I( "mVAEntrypoint = %d\n", mVAEntrypoint);
    LOG_I( "vaAttrib[0].type = %d\n", vaAttrib[0].type);
    LOG_I( "vaAttrib[1].type = %d\n", vaAttrib[1].type);
    LOG_I( "vaAttrib[0].value (Format) = %d\n", vaAttrib[0].value);
    LOG_I( "vaAttrib[1].value (RC mode) = %d\n", vaAttrib[1].value);

    LOG_V( "vaCreateConfig\n");

    vaStatus = vaCreateConfig(
            mVADisplay, mComParams.profile, mVAEntrypoint,
            &vaAttrib[0], 2, &(mVAConfig));
    CHECK_VA_STATUS_GOTO_CLEANUP("vaCreateConfig");

    if (mComParams.rcMode == VA_RC_VCM) {

        // Following three features are only enabled in VCM mode
        mRenderMaxSliceSize = true;
        mRenderAIR = true;
        mRenderBitRate = true;
    }

    LOG_I("mReqSurfacesCnt = %d\n", mReqSurfacesCnt);
    LOG_I("mUpstreamBufferCnt = %d\n", mUpstreamBufferCnt);

    if (mReqSurfacesCnt == 0) {
        switch (mBufferMode) {
            case BUFFER_SHARING_CI:
            case BUFFER_SHARING_V4L2:
            case BUFFER_SHARING_SURFACE:
            case BUFFER_SHARING_GFXHANDLE:
            {
                mSharedSurfacesCnt = mUpstreamBufferCnt;
                normalSurfacesCnt = VENCODER_NUMBER_EXTRA_SURFACES_SHARED_MODE;

                if (mSharedSurfacesCnt != 0) {
                    mSharedSurfaces = new VASurfaceID[mSharedSurfacesCnt];

                    if (mSharedSurfaces == NULL) {
                        LOG_E("Failed allocate shared surface\n");
                        ret = ENCODE_NO_MEMORY;
                        goto CLEAN_UP;
                    }
                } else {
                    LOG_E("Set to upstream mode, but no upstream info, something is wrong");
                    ret = ENCODE_FAIL;
                    goto CLEAN_UP;
                }
                break;
            }

            default:
            {
                mBufferMode = BUFFER_SHARING_NONE;
                normalSurfacesCnt = VENCODER_NUMBER_EXTRA_SURFACES_NON_SHARED_MODE;
                break;
            }
        }
    } else if (mReqSurfacesCnt == 1) {
        // TODO: Un-normal case,
        mBufferMode = BUFFER_SHARING_NONE;
        normalSurfacesCnt = VENCODER_NUMBER_EXTRA_SURFACES_NON_SHARED_MODE;
    } else {
        mBufferMode = BUFFER_SHARING_USRPTR;
        mUsrPtr = new uint8_t *[mReqSurfacesCnt];
        if (mUsrPtr == NULL) {
            LOG_E("Failed allocate memory\n");
            ret = ENCODE_NO_MEMORY;
            goto CLEAN_UP;
        }
    }

    LOG_I("mBufferMode = %d\n", mBufferMode);

    mSurfaceCnt = normalSurfacesCnt + mSharedSurfacesCnt + mReqSurfacesCnt;

    surfaces = new VASurfaceID[normalSurfacesCnt];
    if (surfaces == NULL) {
        LOG_E("Failed allocate surface\n");
        ret = ENCODE_NO_MEMORY;
        goto CLEAN_UP;
    }

    mSurfaces = new VASurfaceID[mSurfaceCnt] ;
    if (mSurfaces == NULL) {
        LOG_E("Failed allocate private surface\n");
        ret = ENCODE_NO_MEMORY;
        goto CLEAN_UP;
    }

    vaStatus = vaCreateSurfaces(mVADisplay, mComParams.resolution.width,
            mComParams.resolution.height, VA_RT_FORMAT_YUV420,
            normalSurfacesCnt, surfaces, NULL , 0);
    CHECK_VA_STATUS_GOTO_CLEANUP("vaCreateSurfaces");

    switch (mBufferMode) {
        case BUFFER_SHARING_CI:
            ret = surfaceMappingForCIFrameList();
            CHECK_ENCODE_STATUS_CLEANUP("surfaceMappingForCIFrameList");
            break;
        case BUFFER_SHARING_V4L2:
            // To be develped
            break;
        case BUFFER_SHARING_SURFACE:
            ret = surfaceMappingForSurfaceList();
            CHECK_ENCODE_STATUS_CLEANUP("surfaceMappingForSurfaceList");
            break;
        case BUFFER_SHARING_GFXHANDLE:
            ret = surfaceMappingForGfxHandle();
            CHECK_ENCODE_STATUS_CLEANUP("surfaceMappingForGfxHandle");
            break;
        case BUFFER_SHARING_NONE:
            break;
        case BUFFER_SHARING_USRPTR: {
            videoSurfaceBuffer = mVideoSrcBufferList;
            index = 0;
            while (videoSurfaceBuffer != NULL) {
                mSurfaces[index] = videoSurfaceBuffer->surface;
                mUsrPtr [index] = videoSurfaceBuffer->usrptr;
                videoSurfaceBuffer = videoSurfaceBuffer->next;
                index ++;
            }
        }
            break;
        default:
            break;
    }

    for (index = 0; index < normalSurfacesCnt; index++) {
        mSurfaces[mReqSurfacesCnt + mSharedSurfacesCnt + index] = surfaces[index];

        videoSurfaceBuffer = new VideoEncSurfaceBuffer;
        if (videoSurfaceBuffer == NULL) {
            LOG_E( "new VideoEncSurfaceBuffer failed\n");
            return ENCODE_NO_MEMORY;
        }

        videoSurfaceBuffer->surface = surfaces[index];
        videoSurfaceBuffer->usrptr = NULL;
        videoSurfaceBuffer->index = mReqSurfacesCnt + mSharedSurfacesCnt + index;
        videoSurfaceBuffer->bufAvailable = true;
        videoSurfaceBuffer->next = NULL;

        mVideoSrcBufferList = appendVideoSurfaceBuffer(mVideoSrcBufferList, videoSurfaceBuffer);

        videoSurfaceBuffer = NULL;
    }

    LOG_V( "assign surface Done\n");
    LOG_I( "Created %d libva surfaces\n", mSurfaceCnt);

    //Initialize and save the VA context ID
    LOG_V( "vaCreateContext\n");

    vaStatus = vaCreateContext(mVADisplay, mVAConfig,
            mComParams.resolution.width,
            mComParams.resolution.height,
            0, mSurfaces, mSurfaceCnt,
            &(mVAContext));
    CHECK_VA_STATUS_GOTO_CLEANUP("vaCreateContext");

    LOG_I("Created libva context width %d, height %d\n",
          mComParams.resolution.width, mComParams.resolution.height);

    ret = getMaxOutSize(&maxSize);
    CHECK_ENCODE_STATUS_CLEANUP("getMaxOutSize");

    // Create coded buffer for output
    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
            VAEncCodedBufferType,
            mCodedBufSize,
            1, NULL,
            &(mVACodedBuffer[0]));

    CHECK_VA_STATUS_GOTO_CLEANUP("vaCreateBuffer::VAEncCodedBufferType");

    // Create coded buffer for output
    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
            VAEncCodedBufferType,
            mCodedBufSize,
            1, NULL,
            &(mVACodedBuffer[1]));

    CHECK_VA_STATUS_GOTO_CLEANUP("vaCreateBuffer::VAEncCodedBufferType");

    mFirstFrame = true;

CLEAN_UP:

    if (ret == ENCODE_SUCCESS) {
        mInitialized = true;
    }

    if (surfaces) delete []surfaces;

    LOG_V( "end\n");
    return ret;
}

Encode_Status VideoEncoderBase::encode(VideoEncRawBuffer *inBuffer) {

    if (!mInitialized) {
        LOG_E("Encoder has not initialized yet\n");
        return ENCODE_NOT_INIT;
    }

    CHECK_NULL_RETURN_IFFAIL(inBuffer);
    if (mComParams.syncEncMode) {
        LOG_I("Sync Enocde Mode, no optimization, no one frame delay\n");
        return syncEncode(inBuffer);
    } else {
        LOG_I("Async Enocde Mode, HW/SW works in parallel, introduce one frame delay\n");
        return asyncEncode(inBuffer);
    }
}

Encode_Status VideoEncoderBase::asyncEncode(VideoEncRawBuffer *inBuffer) {

    Encode_Status ret = ENCODE_SUCCESS;
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    uint8_t *buf = NULL;

    inBuffer->bufAvailable = false;
    if (mNewHeader) mFrameNum = 0;

    // current we use one surface for source data,
    // one for reference and one for reconstructed
    decideFrameType();
    ret = manageSrcSurface(inBuffer);
    CHECK_ENCODE_STATUS_RETURN("manageSrcSurface");

    // Start encoding process
    LOG_V( "vaBeginPicture\n");
    LOG_I( "mVAContext = 0x%08x\n",(uint32_t) mVAContext);
    LOG_I( "Surface = 0x%08x\n",(uint32_t) mCurFrame->surface);
    LOG_I( "mVADisplay = 0x%08x\n",(uint32_t)mVADisplay);

#ifdef DUMP_SRC_DATA

    if (mBufferMode == BUFFER_SHARING_SURFACE && mFirstFrame){

        FILE *fp = fopen("/data/data/dump_encoder.yuv", "wb");
        VAImage image;
        uint8_t *usrptr = NULL;
        uint32_t stride = 0;
        uint32_t frameSize = 0;

        vaStatus = vaDeriveImage(mVADisplay, mCurFrame->surface, &image);
        CHECK_VA_STATUS_RETURN("vaDeriveImage");

        LOG_V( "vaDeriveImage Done\n");

        frameSize = image.data_size;
        stride = image.pitches[0];

        LOG_I("Source Surface/Image information --- start ---- :");
        LOG_I("surface = 0x%08x\n",(uint32_t)mCurFrame->surface);
        LOG_I("image->pitches[0] = %d\n", image.pitches[0]);
        LOG_I("image->pitches[1] = %d\n", image.pitches[1]);
        LOG_I("image->offsets[0] = %d\n", image.offsets[0]);
        LOG_I("image->offsets[1] = %d\n", image.offsets[1]);
        LOG_I("image->num_planes = %d\n", image.num_planes);
        LOG_I("image->width = %d\n", image.width);
        LOG_I("image->height = %d\n", image.height);
        LOG_I ("frameSize= %d\n", image.data_size);
        LOG_I("Source Surface/Image information ----end ----");

        vaStatus = vaMapBuffer(mVADisplay, image.buf, (void **) &usrptr);
        CHECK_VA_STATUS_RETURN("vaMapBuffer");

        fwrite(usrptr, frameSize, 1, fp);
        fflush(fp);
        fclose(fp);

        vaStatus = vaUnmapBuffer(mVADisplay, image.buf);
        CHECK_VA_STATUS_RETURN("vaUnmapBuffer");

        vaStatus = vaDestroyImage(mVADisplay, image.image_id);
        CHECK_VA_STATUS_RETURN("vaDestroyImage");
    }
#endif

    vaStatus = vaBeginPicture(mVADisplay, mVAContext, mCurFrame->surface);
    CHECK_VA_STATUS_RETURN("vaBeginPicture");

    ret = sendEncodeCommand();
    CHECK_ENCODE_STATUS_RETURN("sendEncodeCommand");

    if ((mComParams.rcMode == VA_RC_NONE) || mFirstFrame) {
        vaStatus = vaEndPicture(mVADisplay, mVAContext);
        CHECK_VA_STATUS_RETURN("vaEndPicture");
    }

    LOG_V( "vaEndPicture\n");

    if (mFirstFrame) {
        updateProperities();
        decideFrameType();
    }

    LOG_I ("vaSyncSurface ID = 0x%08x\n", mLastFrame->surface);
    vaStatus = vaSyncSurface(mVADisplay, mLastFrame->surface);
    if (vaStatus != VA_STATUS_SUCCESS) {
        LOG_W( "Failed vaSyncSurface\n");
    }

    mOutCodedBuffer = mLastCodedBuffer;

    // Need map buffer before calling query surface below to get
    // the right skip frame flag for current frame
    // It is a requirement of video driver
    vaStatus = vaMapBuffer (mVADisplay, mOutCodedBuffer, (void **)&buf);
    vaStatus = vaUnmapBuffer(mVADisplay, mOutCodedBuffer);

    if (!((mComParams.rcMode == VA_RC_NONE) || mFirstFrame)) {
        vaStatus = vaEndPicture(mVADisplay, mVAContext);
        CHECK_VA_STATUS_RETURN("vaEndPicture");

    }

    if (mFirstFrame) {
        vaStatus = vaBeginPicture(mVADisplay, mVAContext, mCurFrame->surface);
        CHECK_VA_STATUS_RETURN("vaBeginPicture");

        ret = sendEncodeCommand();
        CHECK_ENCODE_STATUS_RETURN("sendEncodeCommand");

        vaStatus = vaEndPicture(mVADisplay, mVAContext);
        CHECK_VA_STATUS_RETURN("vaEndPicture");

        mKeyFrame = true;
    }

    // Query the status of current surface
    VASurfaceStatus vaSurfaceStatus;
    vaStatus = vaQuerySurfaceStatus(mVADisplay, mCurFrame->surface,  &vaSurfaceStatus);
    CHECK_VA_STATUS_RETURN("vaQuerySurfaceStatus");

    mPicSkipped = vaSurfaceStatus & VASurfaceSkipped;

    if (!mFirstFrame) {
        VideoEncoderBase::appendVideoSurfaceBuffer(mVideoSrcBufferList, mLastFrame);
    }

    mLastFrame = NULL;
    updateProperities();
    mCurFrame = NULL;

    if (mLastInputRawBuffer) mLastInputRawBuffer->bufAvailable = true;

    LOG_V("ref the current inBuffer\n");

    mLastInputRawBuffer = inBuffer;
    mFirstFrame = false;

    return ENCODE_SUCCESS;
}

Encode_Status VideoEncoderBase::syncEncode(VideoEncRawBuffer *inBuffer) {

    Encode_Status ret = ENCODE_SUCCESS;
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    uint8_t *buf = NULL;
    VideoEncSurfaceBuffer *tmpFrame = NULL;

    inBuffer->bufAvailable = false;
    if (mNewHeader) mFrameNum = 0;

    // current we use one surface for source data,
    // one for reference and one for reconstructed
    decideFrameType();
    ret = manageSrcSurface(inBuffer);
    CHECK_ENCODE_STATUS_RETURN("manageSrcSurface");

    vaStatus = vaBeginPicture(mVADisplay, mVAContext, mCurFrame->surface);
    CHECK_VA_STATUS_RETURN("vaBeginPicture");

    ret = sendEncodeCommand();
    CHECK_ENCODE_STATUS_RETURN("sendEncodeCommand");

    vaStatus = vaEndPicture(mVADisplay, mVAContext);
    CHECK_VA_STATUS_RETURN("vaEndPicture");

    LOG_I ("vaSyncSurface ID = 0x%08x\n", mCurFrame->surface);
    vaStatus = vaSyncSurface(mVADisplay, mCurFrame->surface);
    if (vaStatus != VA_STATUS_SUCCESS) {
        LOG_W( "Failed vaSyncSurface\n");
    }

    mOutCodedBuffer = mVACodedBuffer[mCodedBufIndex];

    // Need map buffer before calling query surface below to get
    // the right skip frame flag for current frame
    // It is a requirement of video driver
    vaStatus = vaMapBuffer (mVADisplay, mOutCodedBuffer, (void **)&buf);
    vaStatus = vaUnmapBuffer(mVADisplay, mOutCodedBuffer);

    // Query the status of current surface
    VASurfaceStatus vaSurfaceStatus;
    vaStatus = vaQuerySurfaceStatus(mVADisplay, mCurFrame->surface,  &vaSurfaceStatus);
    CHECK_VA_STATUS_RETURN("vaQuerySurfaceStatus");

    mPicSkipped = vaSurfaceStatus & VASurfaceSkipped;

    VideoEncoderBase::appendVideoSurfaceBuffer(mVideoSrcBufferList, mCurFrame);
    mCurFrame = NULL;

    mEncodedFrames ++;
    mFrameNum ++;

    if (!mPicSkipped) {
        tmpFrame = mRecFrame;
        mRecFrame = mRefFrame;
        mRefFrame = tmpFrame;
    }

    inBuffer->bufAvailable = true;
    return ENCODE_SUCCESS;
}

void VideoEncoderBase::setKeyFrame(int32_t keyFramePeriod) {

    // For first getOutput async mode, the mFrameNum already increased to 2, and of course is key frame
    // frame 0 is already encoded and will be outputed here
    // frame 1 is encoding now, frame 2 will be sent to encoder for next encode() call
    if (!mComParams.syncEncMode) {
        if (mFrameNum > 2) {
            if (keyFramePeriod != 0 &&
                    (((mFrameNum - 2) % keyFramePeriod) == 0)) {
                mKeyFrame = true;
            } else {
                mKeyFrame = false;
            }
        } else if (mFrameNum == 2) {
            mKeyFrame = true;
        }
    } else {
        if (mFrameNum > 1) {
            if (keyFramePeriod != 0 &&
                    (((mFrameNum - 1) % keyFramePeriod) == 0)) {
                mKeyFrame = true;
            } else {
                mKeyFrame = false;
            }
        } else if (mFrameNum == 1) {
            mKeyFrame = true;
        }
    }
}

Encode_Status VideoEncoderBase::getOutput(VideoEncOutputBuffer *outBuffer) {

    Encode_Status ret = ENCODE_SUCCESS;
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    bool useLocalBuffer = false;

    CHECK_NULL_RETURN_IFFAIL(outBuffer);

    LOG_V("Begin\n");

    if (outBuffer->format != OUTPUT_EVERYTHING && outBuffer->format != OUTPUT_FRAME_DATA) {
        LOG_E("Output buffer mode not supported\n");
        goto CLEAN_UP;
    }

    setKeyFrame(mComParams.intraPeriod);

    ret = prepareForOutput(outBuffer, &useLocalBuffer);
    CHECK_ENCODE_STATUS_CLEANUP("prepareForOutput");

    ret = outputAllData(outBuffer);
    CHECK_ENCODE_STATUS_CLEANUP("outputAllData");

    LOG_I("out size for this getOutput call = %d\n", outBuffer->dataSize);

    ret = cleanupForOutput();
    CHECK_ENCODE_STATUS_CLEANUP("cleanupForOutput");

CLEAN_UP:

    if (ret < ENCODE_SUCCESS) {
        if (outBuffer->data && (useLocalBuffer == true)) {
            delete[] outBuffer->data;
            outBuffer->data = NULL;
            useLocalBuffer = false;
        }

        if (mCodedBufferMapped) {
            vaStatus = vaUnmapBuffer(mVADisplay, mOutCodedBuffer);
            mCodedBufferMapped = false;
            mCurSegment = NULL;
        }
    }

    LOG_V("End\n");
    return ret;
}


void VideoEncoderBase::flush() {

    LOG_V( "Begin\n");

    // put reconstructed surface back to list
    if (mRecFrame != NULL) {
        appendVideoSurfaceBuffer(mVideoSrcBufferList, mRecFrame);
        mRecFrame = NULL;
    }

    // put reference surface back to list
    if (mRefFrame != NULL) {
        appendVideoSurfaceBuffer(mVideoSrcBufferList, mRefFrame);
        mRefFrame = NULL;
    }

    // Here this raw buffer means the surface being encoding
    if (mLastInputRawBuffer) {
        mLastInputRawBuffer->bufAvailable = true;
        mLastInputRawBuffer = NULL;
    }

    // reset the properities
    mEncodedFrames = 0;
    mFrameNum = 0;
    mPicSkipped = false;
    mIsIntra = true;

    LOG_V( "end\n");
}

Encode_Status VideoEncoderBase::stop() {

    VAStatus vaStatus = VA_STATUS_SUCCESS;
    Encode_Status ret = ENCODE_SUCCESS;
    VideoEncSurfaceBuffer *videoSurfaceBuffer = NULL;
    VideoEncSurfaceBuffer *tmpBuffer = NULL;


    LOG_V( "Begin\n");

    if (mSharedSurfaces) {
        delete [] mSharedSurfaces;
        mSharedSurfaces = NULL;
    }

    if (mSurfaces) {
        delete [] mSurfaces;
        mSurfaces = NULL;
    }

    if (mUsrPtr) {
        delete [] mUsrPtr;
        mUsrPtr = NULL;
    }

    if (mUpstreamBufferList) {
        delete [] mUpstreamBufferList;
        mUpstreamBufferList = NULL;
    }

    if (mBufAttrib) {
        delete mBufAttrib;
        mBufAttrib = NULL;
    }

    // It is possible that above pointers have been allocated
    // before we set mInitialized to true
    if (!mInitialized) {
        LOG_V("Encoder has been stopped\n");
        return ENCODE_SUCCESS;
    }

    LOG_V( "Release frames\n");

    // put reconstructed surface back to list
    if (mRecFrame != NULL) {
        appendVideoSurfaceBuffer(mVideoSrcBufferList, mRecFrame);
        mRecFrame = NULL;
    }

    // put reference surface back to list
    if (mRefFrame != NULL) {
        appendVideoSurfaceBuffer(mVideoSrcBufferList, mRefFrame);
        mRefFrame = NULL;
    }

    // put Source surface back to list
    if (mLastFrame != NULL) {
        appendVideoSurfaceBuffer(mVideoSrcBufferList, mLastFrame);
        mLastFrame = NULL;
    }

    LOG_V( "Release surfaces\n");
    LOG_V( "vaDestroyContext\n");
    vaStatus = vaDestroyContext(mVADisplay, mVAContext);
    CHECK_VA_STATUS_GOTO_CLEANUP("vaDestroyContext");

    LOG_V( "vaDestroyConfig\n");
    vaStatus = vaDestroyConfig(mVADisplay, mVAConfig);
    CHECK_VA_STATUS_GOTO_CLEANUP("vaDestroyConfig");

    // Release Src Surface Buffer List
    LOG_V( "Rlease Src Surface Buffer \n");

    videoSurfaceBuffer = mVideoSrcBufferList;

    while (videoSurfaceBuffer != NULL) {
        tmpBuffer = videoSurfaceBuffer;
        videoSurfaceBuffer = videoSurfaceBuffer->next;
        delete tmpBuffer;
    }

CLEAN_UP:
    mInitialized = false;
    LOG_V( "end\n");
    return ret;
}

Encode_Status VideoEncoderBase::prepareForOutput(
        VideoEncOutputBuffer *outBuffer, bool *useLocalBuffer) {

    Encode_Status ret = ENCODE_SUCCESS;
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    VACodedBufferSegment *vaCodedSeg = NULL;
    uint32_t status = 0;
    uint8_t *buf = NULL;

    LOG_V( "begin\n");
    // Won't check parameters here as the caller already checked them
    // mCurSegment is NULL means it is first time to be here after finishing encoding a frame
    if (mCurSegment == NULL && !mCodedBufferMapped) {
        LOG_I ("Coded Buffer ID been mapped = 0x%08x\n", mOutCodedBuffer);
        vaStatus = vaMapBuffer (mVADisplay, mOutCodedBuffer, (void **)&buf);
        CHECK_VA_STATUS_RETURN("vaMapBuffer");
        CHECK_NULL_RETURN_IFFAIL(buf);

        mCodedBufferMapped = true;
        mTotalSize = 0;
        mOffsetInSeg = 0;
        mTotalSizeCopied = 0;
        vaCodedSeg = (VACodedBufferSegment *)buf;
        mCurSegment = (VACodedBufferSegment *)buf;

        while (1) {

            mTotalSize += vaCodedSeg->size;
            status = vaCodedSeg->status;

            if (!mSliceSizeOverflow) {
                mSliceSizeOverflow = status & VA_CODED_BUF_STATUS_SLICE_OVERFLOW_MASK;
            }

            if (vaCodedSeg->next == NULL)
                break;

            vaCodedSeg = (VACodedBufferSegment *)vaCodedSeg->next;
        }
    }

    // We will support two buffer allocation mode,
    // one is application allocates the buffer and passes to encode,
    // the other is encode allocate memory

    //means  app doesn't allocate the buffer, so _encode will allocate it.
    if (outBuffer->data == NULL) {
        *useLocalBuffer = true;
        outBuffer->data = new  uint8_t[mTotalSize - mTotalSizeCopied + 100];
        if (outBuffer->data == NULL) {
            LOG_E( "outBuffer->data == NULL\n");
            return ENCODE_NO_MEMORY;
        }
        outBuffer->bufferSize = mTotalSize + 100;
        outBuffer->dataSize = 0;
    }

    // Clear all flag for every call
    outBuffer->flag = 0;
    if (mSliceSizeOverflow) outBuffer->flag |= ENCODE_BUFFERFLAG_SLICEOVERFOLOW;

    if (mCurSegment->size < mOffsetInSeg) {
        LOG_E("mCurSegment->size < mOffsetInSeg\n");
        return ENCODE_FAIL;
    }

    // Make sure we have data in current segment
    if (mCurSegment->size == mOffsetInSeg) {
        if (mCurSegment->next != NULL) {
            mCurSegment = (VACodedBufferSegment *)mCurSegment->next;
            mOffsetInSeg = 0;
        } else {
            LOG_V("No more data available\n");
            outBuffer->flag |= ENCODE_BUFFERFLAG_DATAINVALID;
            outBuffer->dataSize = 0;
            mCurSegment = NULL;
            return ENCODE_NO_REQUEST_DATA;
        }
    }

    LOG_V( "end\n");
    return ENCODE_SUCCESS;
}

Encode_Status VideoEncoderBase::cleanupForOutput() {

    VAStatus vaStatus = VA_STATUS_SUCCESS;
    Encode_Status ret = ENCODE_SUCCESS;

    //mCurSegment is NULL means all data has been copied out
    if (mCurSegment == NULL && mCodedBufferMapped) {
        vaStatus = vaUnmapBuffer(mVADisplay, mOutCodedBuffer);
        CHECK_VA_STATUS_RETURN("vaUnmapBuffer");
        mCodedBufferMapped = false;
    }
    return ENCODE_SUCCESS;
}


Encode_Status VideoEncoderBase::outputAllData(
        VideoEncOutputBuffer *outBuffer) {

    // Data size been copied for every single call
    uint32_t sizeCopiedHere = 0;
    uint32_t sizeToBeCopied = 0;

    CHECK_NULL_RETURN_IFFAIL(outBuffer->data);

    while (1) {

        LOG_I("mCurSegment->size = %d, mOffsetInSeg = %d\n", mCurSegment->size, mOffsetInSeg);
        LOG_I("outBuffer->bufferSize = %d, sizeCopiedHere = %d, mTotalSizeCopied = %d\n",
              outBuffer->bufferSize, sizeCopiedHere, mTotalSizeCopied);

        if (mCurSegment->size < mOffsetInSeg || outBuffer->bufferSize < sizeCopiedHere) {
            LOG_E("mCurSegment->size < mOffsetInSeg  || outBuffer->bufferSize < sizeCopiedHere\n");
            return ENCODE_FAIL;
        }

        if ((mCurSegment->size - mOffsetInSeg) <= outBuffer->bufferSize - sizeCopiedHere) {
            sizeToBeCopied = mCurSegment->size - mOffsetInSeg;
            memcpy(outBuffer->data + sizeCopiedHere,
                   (uint8_t *)mCurSegment->buf + mOffsetInSeg, sizeToBeCopied);
            sizeCopiedHere += sizeToBeCopied;
            mTotalSizeCopied += sizeToBeCopied;
            mOffsetInSeg = 0;
        } else {
            sizeToBeCopied = outBuffer->bufferSize - sizeCopiedHere;
            memcpy(outBuffer->data + sizeCopiedHere,
                   (uint8_t *)mCurSegment->buf + mOffsetInSeg, outBuffer->bufferSize - sizeCopiedHere);
            mTotalSizeCopied += sizeToBeCopied;
            mOffsetInSeg += sizeToBeCopied;
            outBuffer->dataSize = outBuffer->bufferSize;
            outBuffer->remainingSize = mTotalSize - mTotalSizeCopied;
            outBuffer->flag |= ENCODE_BUFFERFLAG_PARTIALFRAME;
            if (mKeyFrame) outBuffer->flag |= ENCODE_BUFFERFLAG_SYNCFRAME;
            return ENCODE_BUFFER_TOO_SMALL;
        }

        if (mCurSegment->next == NULL) {
            outBuffer->dataSize = sizeCopiedHere;
            outBuffer->remainingSize = 0;
            outBuffer->flag |= ENCODE_BUFFERFLAG_ENDOFFRAME;
            if (mKeyFrame) outBuffer->flag |= ENCODE_BUFFERFLAG_SYNCFRAME;
            mCurSegment = NULL;
            return ENCODE_SUCCESS;
        }

        mCurSegment = (VACodedBufferSegment *)mCurSegment->next;
        mOffsetInSeg = 0;
    }
}

void VideoEncoderBase::setDefaultParams() {

    // Set default value for input parameters
    mComParams.profile = VAProfileH264Baseline;
    mComParams.level = 40;
    mComParams.rawFormat = RAW_FORMAT_NV12;
    mComParams.frameRate.frameRateNum = 30;
    mComParams.frameRate.frameRateDenom = 1;
    mComParams.resolution.width = 0;
    mComParams.resolution.height = 0;
    mComParams.intraPeriod = 30;
    mComParams.rcMode = RATE_CONTROL_NONE;
    mComParams.rcParams.initQP = 15;
    mComParams.rcParams.minQP = 1;
    mComParams.rcParams.bitRate = 640000;
    mComParams.rcParams.targetPercentage= 95;
    mComParams.rcParams.windowSize = 500;
    mComParams.rcParams.disableFrameSkip = 0;
    mComParams.rcParams.disableBitsStuffing = 1;
    mComParams.cyclicFrameInterval = 30;
    mComParams.refreshType = VIDEO_ENC_NONIR;
    mComParams.airParams.airMBs = 0;
    mComParams.airParams.airThreshold = 0;
    mComParams.airParams.airAuto = 1;
    mComParams.disableDeblocking = 2;
    mComParams.syncEncMode = false;

    mHrdParam.bufferSize = 0;
    mHrdParam.initBufferFullness = 0;
}

Encode_Status VideoEncoderBase::setParameters(
        VideoParamConfigSet *videoEncParams) {

    Encode_Status ret = ENCODE_SUCCESS;
    CHECK_NULL_RETURN_IFFAIL(videoEncParams);
    LOG_I("Config type = %d\n", (int)videoEncParams->type);

    if (mInitialized) {
        LOG_E("Encoder has been initialized, should use setConfig to change configurations\n");
        return ENCODE_ALREADY_INIT;
    }

    switch (videoEncParams->type) {
        case VideoParamsTypeCommon: {

            VideoParamsCommon *paramsCommon =
                    reinterpret_cast <VideoParamsCommon *> (videoEncParams);

            if (paramsCommon->size != sizeof (VideoParamsCommon)) {
                return ENCODE_INVALID_PARAMS;
            }
            mComParams = *paramsCommon;
            break;
        }

        case VideoParamsTypeUpSteamBuffer: {

            VideoParamsUpstreamBuffer *upStreamBuffer =
                    reinterpret_cast <VideoParamsUpstreamBuffer *> (videoEncParams);

            if (upStreamBuffer->size != sizeof (VideoParamsUpstreamBuffer)) {
                return ENCODE_INVALID_PARAMS;
            }

            ret = setUpstreamBuffer(upStreamBuffer);
            break;
        }

        case VideoParamsTypeUsrptrBuffer: {

            // usrptr only can be get
            // this case should not happen
            break;
        }

        case VideoParamsTypeHRD: {
            VideoParamsHRD *hrd =
                    reinterpret_cast <VideoParamsHRD *> (videoEncParams);

            if (hrd->size != sizeof (VideoParamsHRD)) {
                return ENCODE_INVALID_PARAMS;
            }

            mHrdParam.bufferSize = hrd->bufferSize;
            mHrdParam.initBufferFullness = hrd->initBufferFullness;
            mRenderHrd = true;

            break;
        }

        case VideoParamsTypeAVC:
        case VideoParamsTypeH263:
        case VideoParamsTypeMP4:
        case VideoParamsTypeVC1: {
            ret = derivedSetParams(videoEncParams);
            break;
        }

        default: {
            LOG_E ("Wrong ParamType here\n");
            break;
        }
    }
    return ret;
}

Encode_Status VideoEncoderBase::getParameters(
        VideoParamConfigSet *videoEncParams) {

    Encode_Status ret = ENCODE_SUCCESS;
    CHECK_NULL_RETURN_IFFAIL(videoEncParams);
    LOG_I("Config type = %d\n", (int)videoEncParams->type);

    switch (videoEncParams->type) {
        case VideoParamsTypeCommon: {

            VideoParamsCommon *paramsCommon =
                    reinterpret_cast <VideoParamsCommon *> (videoEncParams);

            if (paramsCommon->size != sizeof (VideoParamsCommon)) {
                return ENCODE_INVALID_PARAMS;
            }
            *paramsCommon = mComParams;
            break;
        }

        case VideoParamsTypeUpSteamBuffer: {

            // Get upstream buffer could happen
            // but not meaningful a lot
            break;
        }

        case VideoParamsTypeUsrptrBuffer: {
            VideoParamsUsrptrBuffer *usrptrBuffer =
                    reinterpret_cast <VideoParamsUsrptrBuffer *> (videoEncParams);

            if (usrptrBuffer->size != sizeof (VideoParamsUsrptrBuffer)) {
                return ENCODE_INVALID_PARAMS;
            }

            ret = getNewUsrptrFromSurface(
                    usrptrBuffer->width, usrptrBuffer->height, usrptrBuffer->format,
                    usrptrBuffer->expectedSize, &(usrptrBuffer->actualSize),
                    &(usrptrBuffer->stride), &(usrptrBuffer->usrPtr));

            break;
        }

        case VideoParamsTypeHRD: {
            VideoParamsHRD *hrd =
                    reinterpret_cast <VideoParamsHRD *> (videoEncParams);

            if (hrd->size != sizeof (VideoParamsHRD)) {
                return ENCODE_INVALID_PARAMS;
            }

            hrd->bufferSize = mHrdParam.bufferSize;
            hrd->initBufferFullness = mHrdParam.initBufferFullness;

            break;
        }

        case VideoParamsTypeAVC:
        case VideoParamsTypeH263:
        case VideoParamsTypeMP4:
        case VideoParamsTypeVC1: {
            derivedGetParams(videoEncParams);
            break;
        }

        default: {
            LOG_E ("Wrong ParamType here\n");
            break;
        }

    }
    return ENCODE_SUCCESS;
}

Encode_Status VideoEncoderBase::setConfig(VideoParamConfigSet *videoEncConfig) {

    Encode_Status ret = ENCODE_SUCCESS;
    CHECK_NULL_RETURN_IFFAIL(videoEncConfig);
    LOG_I("Config type = %d\n", (int)videoEncConfig->type);

   // workaround
#if 0
    if (!mInitialized) {
        LOG_E("Encoder has not initialized yet, can't call setConfig\n");
        return ENCODE_NOT_INIT;
    }
#endif

    switch (videoEncConfig->type) {
        case VideoConfigTypeFrameRate: {
            VideoConfigFrameRate *configFrameRate =
                    reinterpret_cast <VideoConfigFrameRate *> (videoEncConfig);

            if (configFrameRate->size != sizeof (VideoConfigFrameRate)) {
                return ENCODE_INVALID_PARAMS;
            }
            mComParams.frameRate = configFrameRate->frameRate;
            mRenderFrameRate = true;
            break;
        }

        case VideoConfigTypeBitRate: {
            VideoConfigBitRate *configBitRate =
                    reinterpret_cast <VideoConfigBitRate *> (videoEncConfig);

            if (configBitRate->size != sizeof (VideoConfigBitRate)) {
                return ENCODE_INVALID_PARAMS;
            }
            mComParams.rcParams = configBitRate->rcParams;
            mRenderBitRate = true;
            break;
        }
        case VideoConfigTypeResolution: {

            // Not Implemented
            break;
        }
        case VideoConfigTypeIntraRefreshType: {

            VideoConfigIntraRefreshType *configIntraRefreshType =
                    reinterpret_cast <VideoConfigIntraRefreshType *> (videoEncConfig);

            if (configIntraRefreshType->size != sizeof (VideoConfigIntraRefreshType)) {
                return ENCODE_INVALID_PARAMS;
            }
            mComParams.refreshType = configIntraRefreshType->refreshType;
            break;
        }

        case VideoConfigTypeCyclicFrameInterval: {
            VideoConfigCyclicFrameInterval *configCyclicFrameInterval =
                    reinterpret_cast <VideoConfigCyclicFrameInterval *> (videoEncConfig);
            if (configCyclicFrameInterval->size != sizeof (VideoConfigCyclicFrameInterval)) {
                return ENCODE_INVALID_PARAMS;
            }

            mComParams.cyclicFrameInterval = configCyclicFrameInterval->cyclicFrameInterval;
            break;
        }

        case VideoConfigTypeAIR: {

            VideoConfigAIR *configAIR = reinterpret_cast <VideoConfigAIR *> (videoEncConfig);

            if (configAIR->size != sizeof (VideoConfigAIR)) {
                return ENCODE_INVALID_PARAMS;
            }

            mComParams.airParams = configAIR->airParams;
            mRenderAIR = true;
            break;
        }
        case VideoConfigTypeAVCIntraPeriod:
        case VideoConfigTypeNALSize:
        case VideoConfigTypeIDRRequest:
        case VideoConfigTypeSliceNum: {

            ret = derivedSetConfig(videoEncConfig);
            break;
        }
        default: {
            LOG_E ("Wrong Config Type here\n");
            break;
        }
    }
    return ret;
}

Encode_Status VideoEncoderBase::getConfig(VideoParamConfigSet *videoEncConfig) {

    Encode_Status ret = ENCODE_SUCCESS;
    CHECK_NULL_RETURN_IFFAIL(videoEncConfig);
    LOG_I("Config type = %d\n", (int)videoEncConfig->type);

    switch (videoEncConfig->type) {
        case VideoConfigTypeFrameRate: {
            VideoConfigFrameRate *configFrameRate =
                    reinterpret_cast <VideoConfigFrameRate *> (videoEncConfig);

            if (configFrameRate->size != sizeof (VideoConfigFrameRate)) {
                return ENCODE_INVALID_PARAMS;
            }

            configFrameRate->frameRate = mComParams.frameRate;
            break;
        }

        case VideoConfigTypeBitRate: {
            VideoConfigBitRate *configBitRate =
                    reinterpret_cast <VideoConfigBitRate *> (videoEncConfig);

            if (configBitRate->size != sizeof (VideoConfigBitRate)) {
                return ENCODE_INVALID_PARAMS;
            }
            configBitRate->rcParams = mComParams.rcParams;


            break;
        }
        case VideoConfigTypeResolution: {
            // Not Implemented
            break;
        }
        case VideoConfigTypeIntraRefreshType: {

            VideoConfigIntraRefreshType *configIntraRefreshType =
                    reinterpret_cast <VideoConfigIntraRefreshType *> (videoEncConfig);

            if (configIntraRefreshType->size != sizeof (VideoConfigIntraRefreshType)) {
                return ENCODE_INVALID_PARAMS;
            }
            configIntraRefreshType->refreshType = mComParams.refreshType;
            break;
        }

        case VideoConfigTypeCyclicFrameInterval: {
            VideoConfigCyclicFrameInterval *configCyclicFrameInterval =
                    reinterpret_cast <VideoConfigCyclicFrameInterval *> (videoEncConfig);
            if (configCyclicFrameInterval->size != sizeof (VideoConfigCyclicFrameInterval)) {
                return ENCODE_INVALID_PARAMS;
            }

            configCyclicFrameInterval->cyclicFrameInterval = mComParams.cyclicFrameInterval;
            break;
        }

        case VideoConfigTypeAIR: {

            VideoConfigAIR *configAIR = reinterpret_cast <VideoConfigAIR *> (videoEncConfig);

            if (configAIR->size != sizeof (VideoConfigAIR)) {
                return ENCODE_INVALID_PARAMS;
            }

            configAIR->airParams = mComParams.airParams;
            break;
        }
        case VideoConfigTypeAVCIntraPeriod:
        case VideoConfigTypeNALSize:
        case VideoConfigTypeIDRRequest:
        case VideoConfigTypeSliceNum: {

            ret = derivedGetConfig(videoEncConfig);
            break;
        }
        default: {
            LOG_E ("Wrong ParamType here\n");
            break;
        }
    }
    return ret;
}

void VideoEncoderBase:: decideFrameType () {

    LOG_I( "mEncodedFrames = %d\n", mEncodedFrames);
    LOG_I( "mFrameNum = %d\n", mFrameNum);
    LOG_I( "mIsIntra = %d\n", mIsIntra);

    // determine the picture type
    if (mComParams.intraPeriod == 0) {
        if (mFrameNum == 0)
            mIsIntra = true;
        else
            mIsIntra = false;
    } else if ((mFrameNum % mComParams.intraPeriod) == 0) {
        mIsIntra = true;
    } else {
        mIsIntra = false;
    }

    LOG_I( "mIsIntra = %d\n",mIsIntra);
}


void VideoEncoderBase:: updateProperities () {

    VideoEncSurfaceBuffer *tmpFrame = NULL;
    LOG_V( "Begin\n");

    mEncodedFrames ++;
    mFrameNum ++;
    mLastCodedBuffer = mVACodedBuffer[mCodedBufIndex];
    mCodedBufIndex ++;
    mCodedBufIndex %=2;

    mLastFrame = mCurFrame;

    if (!mPicSkipped) {
        tmpFrame = mRecFrame;
        mRecFrame = mRefFrame;
        mRefFrame = tmpFrame;
    }

    LOG_V( "End\n");
}


Encode_Status  VideoEncoderBase::getMaxOutSize (uint32_t *maxSize) {

    uint32_t size = mComParams.resolution.width * mComParams.resolution.height;

    if (maxSize == NULL) {
        LOG_E("maxSize == NULL\n");
        return ENCODE_NULL_PTR;
    }

    LOG_V( "Begin\n");

    if (mCodedBufSize > 0) {
        *maxSize = mCodedBufSize;
        LOG_V ("Already calculate the max encoded size, get the value directly");
        return ENCODE_SUCCESS;
    }

    // base on the rate control mode to calculate the defaule encoded buffer size
    if (mComParams.rcMode == VA_RC_NONE) {
        mCodedBufSize = (size * 400) / (16 * 16);
        // set to value according to QP
    } else {
        mCodedBufSize = mComParams.rcParams.bitRate / 4;
    }

    mCodedBufSize =
        max (mCodedBufSize , (size * 400) / (16 * 16));

    // in case got a very large user input bit rate value
    mCodedBufSize =
        min(mCodedBufSize, (size * 1.5 * 8));
    mCodedBufSize =  (mCodedBufSize + 15) &(~15);

    *maxSize = mCodedBufSize;
    return ENCODE_SUCCESS;
}

Encode_Status VideoEncoderBase::getNewUsrptrFromSurface(
    uint32_t width, uint32_t height, uint32_t format,
    uint32_t expectedSize, uint32_t *outsize, uint32_t *stride, uint8_t **usrptr) {

    Encode_Status ret = ENCODE_FAIL;
    VAStatus vaStatus = VA_STATUS_SUCCESS;

    VASurfaceID surface = VA_INVALID_SURFACE;
    VAImage image;
    uint32_t index = 0;

    VideoEncSurfaceBuffer *videoSurfaceBuffer = NULL;

    LOG_V( "Begin\n");

    // If encode session has been configured, we can not request surface creation anymore
    if (mInitialized) {
        LOG_E( "Already Initialized, can not request VA surface anymore\n");
        return ENCODE_WRONG_STATE;
    }

    if (width<=0 || height<=0 ||outsize == NULL ||stride == NULL || usrptr == NULL) {
        LOG_E("width<=0 || height<=0 || outsize == NULL || stride == NULL ||usrptr == NULL\n");
        return ENCODE_NULL_PTR;
    }

    // Current only NV12 is supported in VA API
    // Through format we can get known the number of planes
    if (format != STRING_TO_FOURCC("NV12")) {

        LOG_W ("Format is not supported\n");
        return ENCODE_NOT_SUPPORTED;
    }

    vaStatus = vaCreateSurfacesForUserPtr(mVADisplay, width, height, VA_RT_FORMAT_YUV420, 1,
            &surface, expectedSize, VA_FOURCC_NV12, width, width, width,
            0, width * height, width * height);

    CHECK_VA_STATUS_RETURN("vaCreateSurfacesForUserPtr");

    vaStatus = vaDeriveImage(mVADisplay, surface, &image);
    CHECK_VA_STATUS_RETURN("vaDeriveImage");

    LOG_V( "vaDeriveImage Done\n");

    vaStatus = vaMapBuffer(mVADisplay, image.buf, (void **) usrptr);
    CHECK_VA_STATUS_RETURN("vaMapBuffer");

    // make sure the physical page been allocated
    for (index = 0; index < image.data_size; index = index + 4096) {
        unsigned char tmp =  *(*usrptr + index);
        if (tmp == 0)
            *(*usrptr + index) = 0;
    }

    *outsize = image.data_size;
    *stride = image.pitches[0];

    videoSurfaceBuffer = new VideoEncSurfaceBuffer;
    if (videoSurfaceBuffer == NULL) {
        LOG_E( "new VideoEncSurfaceBuffer failed\n");
        return ENCODE_NO_MEMORY;
    }

    videoSurfaceBuffer->surface = surface;
    videoSurfaceBuffer->usrptr = *usrptr;
    videoSurfaceBuffer->index = mReqSurfacesCnt;
    videoSurfaceBuffer->bufAvailable = true;
    videoSurfaceBuffer->next = NULL;

    mVideoSrcBufferList = appendVideoSurfaceBuffer(mVideoSrcBufferList, videoSurfaceBuffer);

    LOG_I( "surface = 0x%08x\n",(uint32_t)surface);
    LOG_I("image->pitches[0] = %d\n", image.pitches[0]);
    LOG_I("image->pitches[1] = %d\n", image.pitches[1]);
    LOG_I("image->offsets[0] = %d\n", image.offsets[0]);
    LOG_I("image->offsets[1] = %d\n", image.offsets[1]);
    LOG_I("image->num_planes = %d\n", image.num_planes);
    LOG_I("image->width = %d\n", image.width);
    LOG_I("image->height = %d\n", image.height);

    LOG_I ("data_size = %d\n", image.data_size);
    LOG_I ("usrptr = 0x%p\n", *usrptr);
    LOG_I ("mReqSurfacesCnt = %d\n", mReqSurfacesCnt);
    LOG_I ("videoSurfaceBuffer->usrptr = 0x%p\n ", videoSurfaceBuffer->usrptr);

    videoSurfaceBuffer = NULL;

    vaStatus = vaUnmapBuffer(mVADisplay, image.buf);
    CHECK_VA_STATUS_RETURN("vaUnmapBuffer");


    vaStatus = vaDestroyImage(mVADisplay, image.image_id);
    CHECK_VA_STATUS_RETURN("vaDestroyImage");

    if (*outsize < expectedSize) {
        LOG_E ("Allocated buffer size is small than the expected size, destroy the surface");
        LOG_I ("Allocated size is %d, expected size is %d\n", *outsize, expectedSize);
        vaStatus = vaDestroySurfaces(mVADisplay, &surface, 1);
        CHECK_VA_STATUS_RETURN("vaDestroySurfaces");
        return ENCODE_FAIL;
    }

    mReqSurfacesCnt ++;
    ret = ENCODE_SUCCESS;

    return ret;
}


Encode_Status VideoEncoderBase::setUpstreamBuffer(VideoParamsUpstreamBuffer *upStreamBuffer) {

    CHECK_NULL_RETURN_IFFAIL(upStreamBuffer);
    if (upStreamBuffer->bufCnt == 0) {
        LOG_E("bufCnt == 0\n");
        return ENCODE_FAIL;
    }

    if (mUpstreamBufferList) delete [] mUpstreamBufferList;
    if (mBufAttrib) delete mBufAttrib;

    mUpstreamBufferCnt = upStreamBuffer->bufCnt;
    mVADecoderDisplay = upStreamBuffer->display;
    mBufferMode = upStreamBuffer->bufferMode;
    mBufAttrib = new ExternalBufferAttrib;
    if (!mBufAttrib) {
        LOG_E ("mBufAttrib NULL\n");
        return ENCODE_NO_MEMORY;
    }

    if (upStreamBuffer->bufAttrib) {
        mBufAttrib->format = upStreamBuffer->bufAttrib->format;
        mBufAttrib->lumaStride = upStreamBuffer->bufAttrib->lumaStride;
    } else {
        LOG_E ("Buffer Attrib doesn't set by client, return error");
        return ENCODE_INVALID_PARAMS;
    }

    mUpstreamBufferList = new uint32_t [upStreamBuffer->bufCnt];
    if (!mUpstreamBufferList) {
        LOG_E ("mUpstreamBufferList NULL\n");
        return ENCODE_NO_MEMORY;
    }

    memcpy(mUpstreamBufferList, upStreamBuffer->bufList, upStreamBuffer->bufCnt * sizeof (uint32_t));
    return ENCODE_SUCCESS;
}


Encode_Status VideoEncoderBase::generateVideoBufferAndAttachToList(uint32_t index, uint8_t *usrptr) {

    VideoEncSurfaceBuffer *videoSurfaceBuffer = NULL;
    videoSurfaceBuffer = new VideoEncSurfaceBuffer;
    if (videoSurfaceBuffer == NULL) {
        LOG_E( "new VideoEncSurfaceBuffer failed\n");
        return ENCODE_NO_MEMORY;
    }

    videoSurfaceBuffer->surface = mSharedSurfaces[index];
    videoSurfaceBuffer->usrptr = NULL;
    videoSurfaceBuffer->index = index;
    videoSurfaceBuffer->bufAvailable = true;
    videoSurfaceBuffer->next = NULL;

    mVideoSrcBufferList = appendVideoSurfaceBuffer
            (mVideoSrcBufferList, videoSurfaceBuffer);
    videoSurfaceBuffer = NULL;

 return ENCODE_SUCCESS;
}

Encode_Status VideoEncoderBase::surfaceMappingForSurfaceList() {

    uint32_t index;
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    Encode_Status ret = ENCODE_SUCCESS;

    uint32_t fourCC = 0;
    uint32_t lumaStride = 0;
    uint32_t chromaUStride = 0;
    uint32_t chromaVStride = 0;
    uint32_t lumaOffset = 0;
    uint32_t chromaUOffset = 0;
    uint32_t chromaVOffset = 0;
    uint32_t kBufHandle = 0;

    for (index = 0; index < mSharedSurfacesCnt; index++) {

        vaStatus = vaLockSurface(
                mVADecoderDisplay, (VASurfaceID)mUpstreamBufferList[index],
                &fourCC, &lumaStride, &chromaUStride, &chromaVStride,
                &lumaOffset, &chromaUOffset, &chromaVOffset, &kBufHandle, NULL);

        CHECK_VA_STATUS_RETURN("vaLockSurface");
        LOG_I("Surface incoming = 0x%08x", mUpstreamBufferList[index]);
        LOG_I("lumaStride = %d", lumaStride);
        LOG_I("chromaUStride = %d", chromaUStride);
        LOG_I("chromaVStride = %d", chromaVStride);
        LOG_I("lumaOffset = %d", lumaOffset);
        LOG_I("chromaUOffset = %d", chromaUOffset);
        LOG_I("chromaVOffset = %d", chromaVOffset);
        LOG_I("kBufHandle = 0x%08x", kBufHandle);
        LOG_I("fourCC = %d", fourCC);

        vaStatus = vaUnlockSurface(mVADecoderDisplay, (VASurfaceID)mUpstreamBufferList[index]);
        CHECK_VA_STATUS_RETURN("vaUnlockSurface");

        vaStatus = vaCreateSurfaceFromKBuf(
                mVADisplay, mComParams.resolution.width, mComParams.resolution.height, VA_RT_FORMAT_YUV420,
                (VASurfaceID *)&mSharedSurfaces[index], kBufHandle, lumaStride * mComParams.resolution.height * 3 / 2,
                fourCC, lumaStride, chromaUStride, chromaVStride, lumaOffset, chromaUOffset, chromaVOffset);

        CHECK_VA_STATUS_RETURN("vaCreateSurfaceFromKbuf");

        LOG_I("Surface ID created from Kbuf = 0x%08x", mSharedSurfaces[index]);

        mSurfaces[index] = mSharedSurfaces[index];
        ret = generateVideoBufferAndAttachToList(index, NULL);
        CHECK_ENCODE_STATUS_RETURN("generateVideoBufferAndAttachToList");
    }

    return ret;
}

Encode_Status VideoEncoderBase::surfaceMappingForGfxHandle() {

    uint32_t index;
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    Encode_Status ret = ENCODE_SUCCESS;

    VASurfaceAttrib * vaSurfaceAttrib = new VASurfaceAttrib;
    if (vaSurfaceAttrib == NULL) {
        LOG_E("Failed to allocate VASurfaceAttrib\n");
        return ENCODE_NO_MEMORY;
    }

    VAExternalMemoryBuffers *vaExternalMemoryBuffers = new VAExternalMemoryBuffers;
    if (vaExternalMemoryBuffers == NULL) {
        LOG_E("Failed to allocate VAExternalMemoryBuffers\n");
        return ENCODE_NO_MEMORY;
    }

    vaExternalMemoryBuffers->buffers = new uint32_t[mSharedSurfacesCnt];
    if (vaExternalMemoryBuffers->buffers == NULL) {
        LOG_E("Failed to allocate buffers for VAExternalMemoryBuffers\n");
        return ENCODE_NO_MEMORY;
    }

    LOG_I("mSharedSurfacesCnt = %d\n", mSharedSurfacesCnt);
    LOG_I("lumaStride = %d\n", mBufAttrib->lumaStride);
    LOG_I("format = 0x%08x\n", mBufAttrib->format);
    LOG_I("width = %d\n", mComParams.resolution.width);
    LOG_I("height = %d\n", mComParams.resolution.height);

    vaExternalMemoryBuffers->count = mSharedSurfacesCnt;
    vaExternalMemoryBuffers->luma_stride = mBufAttrib->lumaStride;
    vaExternalMemoryBuffers->pixel_format = mBufAttrib->format;
    vaExternalMemoryBuffers->width = mComParams.resolution.width;
    vaExternalMemoryBuffers->height = mComParams.resolution.height;
    vaExternalMemoryBuffers->type = VAExternalMemoryAndroidGrallocBuffer;
    for(index = 0; index < mSharedSurfacesCnt; index++) {
        vaExternalMemoryBuffers->buffers[index] = (uint32_t) mUpstreamBufferList[index];
        LOG_I("NativeHandleList[%d] = 0x%08x", index, mUpstreamBufferList[index]);
    }
    vaSurfaceAttrib->flags = VA_SURFACE_ATTRIB_SETTABLE;
    vaSurfaceAttrib->type = VASurfaceAttribNativeHandle;
    vaSurfaceAttrib->value.type = VAGenericValueTypePointer;
    vaSurfaceAttrib->value.value.p_val = (void *)vaExternalMemoryBuffers;
    vaStatus = vaCreateSurfaces(
            mVADisplay,
            mComParams.resolution.width,
            mComParams.resolution.height,
            VA_RT_FORMAT_YUV420,
            mSharedSurfacesCnt,
            mSharedSurfaces,
            vaSurfaceAttrib,
            1);

    CHECK_VA_STATUS_RETURN("vaCreateSurfaces");
    LOG_V("Successfully create surfaces from native hanle");

    for(index = 0; index < mSharedSurfacesCnt; index++) {
        mSurfaces[index] = mSharedSurfaces[index];
        ret = generateVideoBufferAndAttachToList(index, NULL);
        LOG_I("mSurfaces[%d] = %08x", index, mSurfaces[index]);
        CHECK_ENCODE_STATUS_RETURN("generateVideoBufferAndAttachToList");
    }
    if(vaExternalMemoryBuffers) {
        if(vaExternalMemoryBuffers->buffers) {
            delete [] vaExternalMemoryBuffers->buffers;
            vaExternalMemoryBuffers->buffers= NULL;
        }
        delete vaExternalMemoryBuffers;
        vaExternalMemoryBuffers =  NULL;
    }

    if(vaSurfaceAttrib) {
        delete vaSurfaceAttrib;
        vaSurfaceAttrib = NULL;
    }

    LOG_V("surfaceMappingForGfxHandle: Done");
    return ret;
}

Encode_Status VideoEncoderBase::surfaceMappingForCIFrameList() {
    uint32_t index;
    VAStatus vaStatus = VA_STATUS_SUCCESS;
    Encode_Status ret = ENCODE_SUCCESS;

    for (index = 0; index < mSharedSurfacesCnt; index++) {

        vaStatus = vaCreateSurfaceFromCIFrame(
                mVADisplay, (uint32_t)mUpstreamBufferCnt, &mSharedSurfaces[index]);

        CHECK_VA_STATUS_RETURN("vaCreateSurfaceFromCIFrame");

        mSurfaces[index] = mSharedSurfaces[index];

        ret = generateVideoBufferAndAttachToList(index, NULL);
        CHECK_ENCODE_STATUS_RETURN("generateVideoBufferAndAttachToList")
    }
    return ret;
}

Encode_Status VideoEncoderBase::manageSrcSurface(VideoEncRawBuffer *inBuffer) {

    Encode_Status ret = ENCODE_SUCCESS;
    VAStatus vaStatus = VA_STATUS_SUCCESS;

    uint32_t idx = 0;
    uint32_t bufIndex = 0;
    uint32_t data = 0;

    if (mBufferMode == BUFFER_SHARING_CI) {

        memcpy(&bufIndex, inBuffer->data, sizeof(unsigned int));
        // bufIndex = *(uint32_t*)inBuffer->data;

        LOG_I("mSurfaceCnt = %d\n", mSurfaceCnt);
        LOG_I("bufIndex = %d\n", bufIndex);

        if (bufIndex > mSurfaceCnt - 2) {
            LOG_E("the CI frame idx is bigger than total CI frame count\n");
            ret = ENCODE_FAIL;
            return ret;

        }

    } else if (mBufferMode == BUFFER_SHARING_SURFACE || mBufferMode == BUFFER_SHARING_GFXHANDLE) {

        bufIndex = (uint32_t) -1;
        data = *(uint32_t*)inBuffer->data;

        LOG_I("data = 0x%08x\n", data);

        for (idx = 0; idx < mSharedSurfacesCnt; idx++) {

            LOG_I("mUpstreamBufferList[%d] = 0x%08x\n", idx, mUpstreamBufferList[idx]);
            if (data == mUpstreamBufferList[idx])
                bufIndex = idx;
        }

        LOG_I("mSurfaceCnt = %d\n", mSurfaceCnt);
        LOG_I("bufIndex = %d\n", bufIndex);

        if (bufIndex > mSurfaceCnt - 2) {
            LOG_E("Can't find the surface in our list\n");
            ret = ENCODE_FAIL;
            return ret;
        }
    }else if (mBufferMode == BUFFER_SHARING_USRPTR) {

        bufIndex = (uint32_t) -1; //fixme, temp use a big value

        LOG_I("bufin->data = 0x%p\n", inBuffer->data);

        for (idx = 0; idx < mReqSurfacesCnt; idx++) {
            LOG_I("mUsrPtr[%d] = 0x%p\n", idx, mUsrPtr[idx]);

            if (inBuffer->data == mUsrPtr[idx])
                bufIndex = idx;
        }

        LOG_I("mSurfaceCnt = %d\n", mSurfaceCnt);
        LOG_I("bufIndex = %d\n", bufIndex);

        if (bufIndex > mSurfaceCnt - 2) {
            LOG_W("the Surface idx is too big, most likely the buffer passed in is not allocated by us\n");
            ret = ENCODE_FAIL;
            goto no_share_mode;
        }
    }


    switch (mBufferMode) {

        case BUFFER_SHARING_CI:
        case BUFFER_SHARING_SURFACE:
        case BUFFER_SHARING_GFXHANDLE:
        case BUFFER_SHARING_USRPTR: {

            if (mRefFrame== NULL) {
                mRefFrame = getVideoSurfaceBufferByIndex(mVideoSrcBufferList, mSurfaceCnt -1 );
                if (mRefFrame == NULL) {
                    LOG_E ("No Surface buffer available, something should be wrong\n");
                    return ENCODE_FAIL;
                }
                mVideoSrcBufferList = removeVideoSurfaceBuffer(mVideoSrcBufferList, mRefFrame);

            }

            if (mRecFrame== NULL) {
                mRecFrame = getVideoSurfaceBufferByIndex(mVideoSrcBufferList, mSurfaceCnt - 2);
                if (mRecFrame == NULL) {
                    LOG_E ("No Surface buffer available, something should be wrong\n");
                    return ENCODE_FAIL;
                }
                mVideoSrcBufferList = removeVideoSurfaceBuffer(mVideoSrcBufferList, mRecFrame);

            }

            if (mCurFrame== NULL) {
                mCurFrame = getVideoSurfaceBufferByIndex(mVideoSrcBufferList, bufIndex);
                if (mCurFrame == NULL) {
                    LOG_E ("No Surface buffer available, something should be wrong\n");
                    return ENCODE_FAIL;
                }
                mVideoSrcBufferList = removeVideoSurfaceBuffer(mVideoSrcBufferList, mCurFrame);
            }
        }

        break;
        case BUFFER_SHARING_V4L2:
            LOG_E("Not Implemented\n");
            break;

        case BUFFER_SHARING_NONE: {
no_share_mode:

            if (mRefFrame== NULL) {
                mRefFrame = mVideoSrcBufferList;
                if (mRefFrame == NULL) {
                    LOG_E("No Surface buffer available, something should be wrong\n");
                    return ENCODE_FAIL;
                }
                mVideoSrcBufferList = removeVideoSurfaceBuffer(mVideoSrcBufferList, mRefFrame);

            }

            if (mRecFrame== NULL) {
                mRecFrame = mVideoSrcBufferList;
                if (mRecFrame == NULL) {
                    LOG_E ("No Surface buffer available, something should be wrong\n");
                    return ENCODE_FAIL;
                }
                mVideoSrcBufferList = removeVideoSurfaceBuffer(mVideoSrcBufferList, mRecFrame);

            }

            if (mCurFrame== NULL) {
                mCurFrame = mVideoSrcBufferList;
                if (mCurFrame == NULL) {
                    LOG_E ("No Surface buffer available, something should be wrong\n");
                    return ENCODE_FAIL;
                }
                mVideoSrcBufferList = removeVideoSurfaceBuffer(mVideoSrcBufferList, mCurFrame);
            }

            LOG_V( "Get Surface Done\n");
            ret = uploadDataToSurface (inBuffer);
            CHECK_ENCODE_STATUS_RETURN("uploadDataToSurface");
        }
        break;
        default:
            break;

    }

    return ENCODE_SUCCESS;
}

VideoEncSurfaceBuffer *VideoEncoderBase::appendVideoSurfaceBuffer(
        VideoEncSurfaceBuffer *head, VideoEncSurfaceBuffer *buffer) {

    if (head == NULL) {
        return buffer;
    }

    VideoEncSurfaceBuffer *node = head;
    VideoEncSurfaceBuffer *tail = NULL;

    while (node != NULL) {
        tail = node;
        node = node->next;
    }
    tail->next = buffer;

    return head;
}

VideoEncSurfaceBuffer *VideoEncoderBase::removeVideoSurfaceBuffer(
        VideoEncSurfaceBuffer *head, VideoEncSurfaceBuffer *buffer) {

    VideoEncSurfaceBuffer *node = head;
    VideoEncSurfaceBuffer *tmpNode = NULL;

    if (head == buffer) {
        tmpNode = head->next;
        buffer->next = NULL;
        return tmpNode;
    }

    while (node != NULL) {
        if (node->next == buffer)
            break;
        node = node->next;
    }

    if (node != NULL) {
        node->next = buffer->next;
    }

    buffer->next = NULL;
    return head;

}

VideoEncSurfaceBuffer *VideoEncoderBase::getVideoSurfaceBufferByIndex(
        VideoEncSurfaceBuffer *head, uint32_t index) {
    VideoEncSurfaceBuffer *node = head;

    while (node != NULL) {
        if (node->index == index)
            break;
        node = node->next;
    }

    return node;
}

Encode_Status VideoEncoderBase::uploadDataToSurface(VideoEncRawBuffer *inBuffer) {

    VAStatus vaStatus = VA_STATUS_SUCCESS;

    uint32_t width = mComParams.resolution.width;
    uint32_t height = mComParams.resolution.height;

    VAImage srcImage;
    uint8_t *pvBuffer;
    uint8_t *dstY;
    uint8_t *dstUV;
    uint32_t i,j;

    uint8_t *inBuf = inBuffer->data;
    VAImage *image = NULL;

    int uvOffset = width * height;
    uint8_t *uvBufIn = inBuf + uvOffset;
    uint32_t uvHeight = height / 2;
    uint32_t uvWidth = width;

    LOG_V("map source data to surface\n");
    LOG_I("Surface ID = 0x%08x\n", (uint32_t) mCurFrame->surface);

    vaStatus = vaDeriveImage(mVADisplay, mCurFrame->surface, &srcImage);
    CHECK_VA_STATUS_RETURN("vaDeriveImage");

    LOG_V( "vaDeriveImage Done\n");

    image = &srcImage;

    vaStatus = vaMapBuffer(mVADisplay, image->buf, (void **)&pvBuffer);
    CHECK_VA_STATUS_RETURN("vaMapBuffer");

    LOG_V("vaImage information\n");
    LOG_I("image->pitches[0] = %d\n", image->pitches[0]);
    LOG_I("image->pitches[1] = %d\n", image->pitches[1]);
    LOG_I("image->offsets[0] = %d\n", image->offsets[0]);
    LOG_I("image->offsets[1] = %d\n", image->offsets[1]);
    LOG_I("image->num_planes = %d\n", image->num_planes);
    LOG_I("image->width = %d\n", image->width);
    LOG_I("image->height = %d\n", image->height);

    LOG_I("input buf size = %d\n", inBuffer->size);

    if (mComParams.rawFormat == RAW_FORMAT_YUV420) {
        dstY = pvBuffer +image->offsets[0];

        for (i = 0; i < height; i ++) {
            memcpy(dstY, inBuf + i * width, width);
            dstY += image->pitches[0];
        }

        dstUV = pvBuffer + image->offsets[1];

        for (i = 0; i < height / 2; i ++) {
            for (j = 0; j < width; j+=2) {
                dstUV [j] = inBuf [width * height + i * width / 2 + j / 2];
                dstUV [j + 1] =
                    inBuf [width * height * 5 / 4 + i * width / 2 + j / 2];
            }
            dstUV += image->pitches[1];
        }
    }

    else if (mComParams.rawFormat == RAW_FORMAT_NV12) {

        dstY = pvBuffer + image->offsets[0];
        for (i = 0; i < height; i++) {
            memcpy(dstY, inBuf + i * width, width);
            dstY += image->pitches[0];
        }

        dstUV = pvBuffer + image->offsets[1];
        for (i = 0; i < uvHeight; i++) {
            memcpy(dstUV, uvBufIn + i * uvWidth, uvWidth);
            dstUV += image->pitches[1];
        }
    } else {
        LOG_E("Raw format not supoort\n");
        return ENCODE_FAIL;
    }

    vaStatus = vaUnmapBuffer(mVADisplay, image->buf);
    CHECK_VA_STATUS_RETURN("vaUnmapBuffer");

    vaStatus = vaDestroyImage(mVADisplay, srcImage.image_id);
    CHECK_VA_STATUS_RETURN("vaDestroyImage");

    return ENCODE_SUCCESS;
}

Encode_Status VideoEncoderBase::renderDynamicBitrate() {
    VAStatus vaStatus = VA_STATUS_SUCCESS;

    LOG_V( "Begin\n\n");
    // disable bits stuffing and skip frame apply to all rate control mode

    VAEncMiscParameterBuffer   *miscEncParamBuf;
    VAEncMiscParameterRateControl *bitrateControlParam;
    VABufferID miscParamBufferID;

    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
            VAEncMiscParameterBufferType,
            sizeof (VAEncMiscParameterBuffer) + sizeof (VAEncMiscParameterRateControl),
            1, NULL,
            &miscParamBufferID);

    CHECK_VA_STATUS_RETURN("vaCreateBuffer");

    vaStatus = vaMapBuffer(mVADisplay, miscParamBufferID, (void **)&miscEncParamBuf);
    CHECK_VA_STATUS_RETURN("vaMapBuffer");

    miscEncParamBuf->type = VAEncMiscParameterTypeRateControl;
    bitrateControlParam = (VAEncMiscParameterRateControl *)miscEncParamBuf->data;

    bitrateControlParam->bits_per_second = mComParams.rcParams.bitRate;
    bitrateControlParam->initial_qp = mComParams.rcParams.initQP;
    bitrateControlParam->min_qp = mComParams.rcParams.minQP;
    bitrateControlParam->target_percentage = mComParams.rcParams.targetPercentage;
    bitrateControlParam->window_size = mComParams.rcParams.windowSize;
    bitrateControlParam->rc_flags.bits.disable_frame_skip = mComParams.rcParams.disableFrameSkip;
    bitrateControlParam->rc_flags.bits.disable_bit_stuffing = mComParams.rcParams.disableBitsStuffing;

    LOG_I("bits_per_second = %d\n", bitrateControlParam->bits_per_second);
    LOG_I("initial_qp = %d\n", bitrateControlParam->initial_qp);
    LOG_I("min_qp = %d\n", bitrateControlParam->min_qp);
    LOG_I("target_percentage = %d\n", bitrateControlParam->target_percentage);
    LOG_I("window_size = %d\n", bitrateControlParam->window_size);
    LOG_I("disable_frame_skip = %d\n", bitrateControlParam->rc_flags.bits.disable_frame_skip);
    LOG_I("disable_bit_stuffing = %d\n", bitrateControlParam->rc_flags.bits.disable_bit_stuffing);

    vaStatus = vaUnmapBuffer(mVADisplay, miscParamBufferID);
    CHECK_VA_STATUS_RETURN("vaUnmapBuffer");


    vaStatus = vaRenderPicture(mVADisplay, mVAContext,
            &miscParamBufferID, 1);
    CHECK_VA_STATUS_RETURN("vaRenderPicture");

    return ENCODE_SUCCESS;
}


Encode_Status VideoEncoderBase::renderDynamicFrameRate() {

    VAStatus vaStatus = VA_STATUS_SUCCESS;

    if (mComParams.rcMode != RATE_CONTROL_VCM) {

        LOG_W("Not in VCM mode, but call SendDynamicFramerate\n");
        return ENCODE_SUCCESS;
    }

    VAEncMiscParameterBuffer   *miscEncParamBuf;
    VAEncMiscParameterFrameRate *frameRateParam;
    VABufferID miscParamBufferID;

    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
            VAEncMiscParameterBufferType,
            sizeof(miscEncParamBuf) + sizeof(VAEncMiscParameterFrameRate),
            1, NULL, &miscParamBufferID);
    CHECK_VA_STATUS_RETURN("vaCreateBuffer");

    vaStatus = vaMapBuffer(mVADisplay, miscParamBufferID, (void **)&miscEncParamBuf);
    CHECK_VA_STATUS_RETURN("vaMapBuffer");

    miscEncParamBuf->type = VAEncMiscParameterTypeFrameRate;
    frameRateParam = (VAEncMiscParameterFrameRate *)miscEncParamBuf->data;
    frameRateParam->framerate =
            (unsigned int) (mComParams.frameRate.frameRateNum + mComParams.frameRate.frameRateDenom/2)
            / mComParams.frameRate.frameRateDenom;

    vaStatus = vaUnmapBuffer(mVADisplay, miscParamBufferID);
    CHECK_VA_STATUS_RETURN("vaUnmapBuffer");

    vaStatus = vaRenderPicture(mVADisplay, mVAContext, &miscParamBufferID, 1);
    CHECK_VA_STATUS_RETURN("vaRenderPicture");

    LOG_I( "frame rate = %d\n", frameRateParam->framerate);
    return ENCODE_SUCCESS;
}

Encode_Status VideoEncoderBase::renderHrd() {

    VAStatus vaStatus = VA_STATUS_SUCCESS;

    VAEncMiscParameterBuffer *miscEncParamBuf;
    VAEncMiscParameterHRD *hrdParam;
    VABufferID miscParamBufferID;

    vaStatus = vaCreateBuffer(mVADisplay, mVAContext,
            VAEncMiscParameterBufferType,
            sizeof(miscEncParamBuf) + sizeof(VAEncMiscParameterHRD),
            1, NULL, &miscParamBufferID);
    CHECK_VA_STATUS_RETURN("vaCreateBuffer");

    vaStatus = vaMapBuffer(mVADisplay, miscParamBufferID, (void **)&miscEncParamBuf);
    CHECK_VA_STATUS_RETURN("vaMapBuffer");

    miscEncParamBuf->type = VAEncMiscParameterTypeHRD;
    hrdParam = (VAEncMiscParameterHRD *)miscEncParamBuf->data;

    hrdParam->buffer_size = mHrdParam.bufferSize;
    hrdParam->initial_buffer_fullness = mHrdParam.initBufferFullness;

    vaStatus = vaUnmapBuffer(mVADisplay, miscParamBufferID);
    CHECK_VA_STATUS_RETURN("vaUnmapBuffer");

    vaStatus = vaRenderPicture(mVADisplay, mVAContext, &miscParamBufferID, 1);
    CHECK_VA_STATUS_RETURN("vaRenderPicture");

    return ENCODE_SUCCESS;
}