/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
*************************************************************************
* @file   VideoEditorVideoEncoder.cpp
* @brief  StageFright shell video encoder
*************************************************************************
*/
#define LOG_NDEBUG 1
#define LOG_TAG "VIDEOEDITOR_VIDEOENCODER"

/*******************
 *     HEADERS     *
 *******************/
#include "M4OSA_Debug.h"
#include "M4SYS_AccessUnit.h"
#include "VideoEditorVideoEncoder.h"
#include "MediaBufferPuller.h"
#include <I420ColorConverter.h>

#include <unistd.h>
#include "utils/Log.h"
#include "utils/Vector.h"
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/MediaSource.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/OMXClient.h>
#include <media/stagefright/OMXCodec.h>
#include <media/MediaProfiles.h>
#include "OMX_Video.h"

#include "IntelVideoEditorEncoderSource.h"
#include "IntelVideoEditorAVCEncoder.h"
#include "IntelVideoEditorH263Encoder.h"
#include "IntelVideoEditorUtils.h"

/********************
 *   DEFINITIONS    *
 ********************/

// Force using hardware encoder
#define VIDEOEDITOR_FORCECODEC kHardwareCodecsOnly

#if !defined(VIDEOEDITOR_FORCECODEC)
    #error "Cannot force DSI retrieval if codec type is not fixed"
#endif

/********************
 *   SOURCE CLASS   *
 ********************/

namespace android {

struct VideoEditorVideoEncoderSource : public MediaSource {
    public:
        static sp<VideoEditorVideoEncoderSource> Create(
            const sp<MetaData> &format);
        virtual status_t start(MetaData *params = NULL);
        virtual status_t stop();
        virtual sp<MetaData> getFormat();
        virtual status_t read(MediaBuffer **buffer,
            const ReadOptions *options = NULL);
        virtual int32_t storeBuffer(MediaBuffer *buffer);
        virtual int32_t getNumberOfBuffersInQueue();

    protected:
        virtual ~VideoEditorVideoEncoderSource();

    private:
        struct MediaBufferChain {
            MediaBuffer* buffer;
            MediaBufferChain* nextLink;
        };
        enum State {
            CREATED,
            STARTED,
            ERROR
        };
        VideoEditorVideoEncoderSource(const sp<MetaData> &format);

        // Don't call me
        VideoEditorVideoEncoderSource(const VideoEditorVideoEncoderSource &);
        VideoEditorVideoEncoderSource &operator=(
                const VideoEditorVideoEncoderSource &);

        MediaBufferChain* mFirstBufferLink;
        MediaBufferChain* mLastBufferLink;
        int32_t           mNbBuffer;
        bool              mIsEOS;
        State             mState;
        sp<MetaData>      mEncFormat;
        Mutex             mLock;
        Condition         mBufferCond;
};

sp<VideoEditorVideoEncoderSource> VideoEditorVideoEncoderSource::Create(
    const sp<MetaData> &format) {

    sp<VideoEditorVideoEncoderSource> aSource =
        new VideoEditorVideoEncoderSource(format);
    return aSource;
}

VideoEditorVideoEncoderSource::VideoEditorVideoEncoderSource(
    const sp<MetaData> &format):
        mFirstBufferLink(NULL),
        mLastBufferLink(NULL),
        mNbBuffer(0),
        mIsEOS(false),
        mState(CREATED),
        mEncFormat(format) {
    ALOGV("VideoEditorVideoEncoderSource::VideoEditorVideoEncoderSource");
}

VideoEditorVideoEncoderSource::~VideoEditorVideoEncoderSource() {

    // Safety clean up
    if( STARTED == mState ) {
        stop();
    }
}

status_t VideoEditorVideoEncoderSource::start(MetaData *meta) {
    status_t err = OK;

    ALOGV("VideoEditorVideoEncoderSource::start() begin");

    if( CREATED != mState ) {
        ALOGV("VideoEditorVideoEncoderSource::start: invalid state %d", mState);
        return UNKNOWN_ERROR;
    }
    mState = STARTED;

    ALOGV("VideoEditorVideoEncoderSource::start() END (0x%x)", err);
    return err;
}

status_t VideoEditorVideoEncoderSource::stop() {
    status_t err = OK;

    ALOGV("VideoEditorVideoEncoderSource::stop() begin");

    if( STARTED != mState ) {
        ALOGV("VideoEditorVideoEncoderSource::stop: invalid state %d", mState);
        return UNKNOWN_ERROR;
    }

    // Release the buffer chain
    int32_t i = 0;
    MediaBufferChain* tmpLink = NULL;
    while( mFirstBufferLink ) {
        i++;
        tmpLink = mFirstBufferLink;
        mFirstBufferLink = mFirstBufferLink->nextLink;
        delete tmpLink;
    }
    ALOGV("VideoEditorVideoEncoderSource::stop : %d buffer remained", i);
    mFirstBufferLink = NULL;
    mLastBufferLink = NULL;

    mState = CREATED;

    ALOGV("VideoEditorVideoEncoderSource::stop() END (0x%x)", err);
    return err;
}

sp<MetaData> VideoEditorVideoEncoderSource::getFormat() {

    ALOGV("VideoEditorVideoEncoderSource::getFormat");
    return mEncFormat;
}

status_t VideoEditorVideoEncoderSource::read(MediaBuffer **buffer,
        const ReadOptions *options) {
    Mutex::Autolock autolock(mLock);
    MediaSource::ReadOptions readOptions;
    status_t err = OK;
    MediaBufferChain* tmpLink = NULL;

    ALOGV("VideoEditorVideoEncoderSource::read() begin");

    if ( STARTED != mState ) {
        ALOGV("VideoEditorVideoEncoderSource::read: invalid state %d", mState);
        return UNKNOWN_ERROR;
    }

    while (mFirstBufferLink == NULL && !mIsEOS) {
        mBufferCond.wait(mLock);
    }

    // End of stream?
    if (mFirstBufferLink == NULL) {
        *buffer = NULL;
        ALOGV("VideoEditorVideoEncoderSource::read : EOS");
        return ERROR_END_OF_STREAM;
    }

    // Get a buffer from the chain
    *buffer = mFirstBufferLink->buffer;
    tmpLink = mFirstBufferLink;
    mFirstBufferLink = mFirstBufferLink->nextLink;

    if ( NULL == mFirstBufferLink ) {
        mLastBufferLink = NULL;
    }
    delete tmpLink;
    mNbBuffer--;

    ALOGV("VideoEditorVideoEncoderSource::read() END (0x%x)", err);
    return err;
}

int32_t VideoEditorVideoEncoderSource::storeBuffer(MediaBuffer *buffer) {
    Mutex::Autolock autolock(mLock);
    status_t err = OK;

    ALOGV("VideoEditorVideoEncoderSource::storeBuffer() begin");

    if( NULL == buffer ) {
        ALOGV("VideoEditorVideoEncoderSource::storeBuffer : reached EOS");
        mIsEOS = true;
    } else {
        MediaBufferChain* newLink = new MediaBufferChain;
        newLink->buffer = buffer;
        newLink->nextLink = NULL;
        if( NULL != mLastBufferLink ) {
            mLastBufferLink->nextLink = newLink;
        } else {
            mFirstBufferLink = newLink;
        }
        mLastBufferLink = newLink;
        mNbBuffer++;
    }
    mBufferCond.signal();
    ALOGV("VideoEditorVideoEncoderSource::storeBuffer() end");
    return mNbBuffer;
}

int32_t VideoEditorVideoEncoderSource::getNumberOfBuffersInQueue() {
    Mutex::Autolock autolock(mLock);
    return mNbBuffer;
}

/**
 ******************************************************************************
 * structure VideoEditorVideoEncoder_Context
 * @brief    This structure defines the context of the StageFright video encoder
 *           shell
 ******************************************************************************
*/
typedef enum {
    CREATED   = 0x1,
    OPENED    = 0x2,
    STARTED   = 0x4,
    BUFFERING = 0x8,
    READING   = 0x10
} VideoEditorVideoEncoder_State;

typedef struct {
    VideoEditorVideoEncoder_State     mState;
    M4ENCODER_Format                  mFormat;
    M4WRITER_DataInterface*           mWriterDataInterface;
    M4VPP_apply_fct*                  mPreProcFunction;
    M4VPP_Context                     mPreProcContext;
    M4SYS_AccessUnit*                 mAccessUnit;
    M4ENCODER_Params*                 mCodecParams;
    M4ENCODER_Header                  mHeader;
    H264MCS_ProcessEncodedNALU_fct*   mH264NALUPostProcessFct;
    M4OSA_Context                     mH264NALUPostProcessCtx;
    M4OSA_UInt32                      mLastCTS;
    sp<IntelVideoEditorEncoderSource> mEncoderSource;
    OMXClient                         mClient;
    sp<MediaSource>                   mEncoder;
    OMX_COLOR_FORMATTYPE              mEncoderColorFormat;
    MediaBufferPuller*                mPuller;
    I420ColorConverter*               mI420ColorConverter;

    uint32_t                          mNbInputFrames;
    double                            mFirstInputCts;
    double                            mLastInputCts;
    uint32_t                          mNbOutputFrames;
    int64_t                           mFirstOutputCts;
    int64_t                           mLastOutputCts;

    MediaProfiles *mVideoEditorProfile;
    int32_t mMaxPrefetchFrames;
} VideoEditorVideoEncoder_Context;

/********************
 *      TOOLS       *
 ********************/

M4OSA_ERR VideoEditorVideoEncoder_getDSI(M4ENCODER_Context pContext,
        sp<MetaData> metaData) {
    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context*  pEncoderContext = M4OSA_NULL;
    status_t result = OK;
    int32_t nbBuffer = 0;
    int32_t stride = 0;
    int32_t height = 0;
    int32_t framerate = 0;
    int32_t isCodecConfig = 0;
    size_t size = 0;
    uint32_t codecFlags = 0;
    MediaBuffer* inputBuffer = NULL;
    MediaBuffer* outputBuffer = NULL;
    sp<IntelVideoEditorEncoderSource> encoderSource = NULL;
    sp<MediaSource> encoder = NULL;;
    OMXClient client;

    ALOGV("VideoEditorVideoEncoder_getDSI begin");
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext,       M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(M4OSA_NULL != metaData.get(), M4ERR_PARAMETER);

    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;
    VIDEOEDITOR_CHECK(CREATED == pEncoderContext->mState, M4ERR_STATE);

    // Create the encoder source
    encoderSource = IntelVideoEditorEncoderSource::Create(metaData);
    VIDEOEDITOR_CHECK(NULL != encoderSource.get(), M4ERR_STATE);

    // Create Hardware encoder

    encoder = new IntelVideoEditorAVCEncoder(encoderSource,metaData);
    VIDEOEDITOR_CHECK(NULL != encoder.get(), M4ERR_STATE);

    /**
     * Send fake frames and retrieve the DSI
     */
    // Send a fake frame to the source
    metaData->findInt32(kKeyStride,     &stride);
    metaData->findInt32(kKeyHeight,     &height);
    metaData->findInt32(kKeySampleRate, &framerate);

    result = encoder->start();
    VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);

    encoderSource->requestBuffer(&inputBuffer);

    inputBuffer->meta_data()->setInt64(kKeyTime, 0);
    nbBuffer = encoderSource->storeBuffer(inputBuffer);
    encoderSource->storeBuffer(NULL); // Signal EOS

    // Call read once to get the DSI
    result = encoder->read(&outputBuffer, NULL);
    VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);
    VIDEOEDITOR_CHECK(outputBuffer->meta_data()->findInt32(
        kKeyIsCodecConfig, &isCodecConfig) && isCodecConfig, M4ERR_STATE);

    VIDEOEDITOR_CHECK(M4OSA_NULL == pEncoderContext->mHeader.pBuf, M4ERR_STATE);
    if ( M4ENCODER_kH264 == pEncoderContext->mFormat ) {
        // For H264, format the DSI
        LOGV("outputBuffer->range_offset() = %d, outputBuffer->range_length() = %d",
            outputBuffer->range_offset(), outputBuffer->range_length());
        result = buildAVCCodecSpecificData(
            (uint8_t**)(&(pEncoderContext->mHeader.pBuf)),
            (size_t*)(&(pEncoderContext->mHeader.Size)),
            (const uint8_t*)outputBuffer->data() + outputBuffer->range_offset(),
            outputBuffer->range_length(), encoder->getFormat().get());
        outputBuffer->release();
        VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);
    } else {
        // For MPEG4, just copy the DSI
        pEncoderContext->mHeader.Size =
            (M4OSA_UInt32)outputBuffer->range_length();
        SAFE_MALLOC(pEncoderContext->mHeader.pBuf, M4OSA_Int8,
            pEncoderContext->mHeader.Size, "Encoder header");
        memcpy((void *)pEncoderContext->mHeader.pBuf,
            (void *)((M4OSA_MemAddr8)(outputBuffer->data())+outputBuffer->range_offset()),
            pEncoderContext->mHeader.Size);
        outputBuffer->release();
    }

    result = encoder->stop();
    VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);

cleanUp:
    // Destroy the graph
    if ( encoder != NULL ) { encoder.clear(); }
    //client.disconnect();
    if ( encoderSource != NULL ) { encoderSource.clear(); }
    if ( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_getDSI no error");
    } else {
        ALOGV("VideoEditorVideoEncoder_getDSI ERROR 0x%X", err);
    }
    ALOGV("VideoEditorVideoEncoder_getDSI end");
    return err;
}
/********************
 * ENGINE INTERFACE *
 ********************/

M4OSA_ERR VideoEditorVideoEncoder_cleanup(M4ENCODER_Context pContext) {
    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

    ALOGV("VideoEditorVideoEncoder_cleanup begin");
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;
    VIDEOEDITOR_CHECK(CREATED == pEncoderContext->mState, M4ERR_STATE);

    // Release memory
    SAFE_FREE(pEncoderContext->mHeader.pBuf);
    SAFE_FREE(pEncoderContext);
    pContext = M4OSA_NULL;

cleanUp:
    if ( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_cleanup no error");
    } else {
        ALOGV("VideoEditorVideoEncoder_cleanup ERROR 0x%X", err);
    }
    ALOGV("VideoEditorVideoEncoder_cleanup end");
    return err;
}

M4OSA_ERR VideoEditorVideoEncoder_init(M4ENCODER_Format format,
        M4ENCODER_Context* pContext,
        M4WRITER_DataInterface* pWriterDataInterface,
        M4VPP_apply_fct* pVPPfct, M4VPP_Context pVPPctxt,
        M4OSA_Void* pExternalAPI, M4OSA_Void* pUserData) {

    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;
    int encoderInput = OMX_COLOR_FormatYUV420Planar;

    ALOGV("VideoEditorVideoEncoder_init begin: format  %d", format);
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(M4OSA_NULL != pWriterDataInterface, M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(M4OSA_NULL != pVPPfct, M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(M4OSA_NULL != pVPPctxt, M4ERR_PARAMETER);

    // Context allocation & initialization
    SAFE_MALLOC(pEncoderContext, VideoEditorVideoEncoder_Context, 1,
        "VideoEditorVideoEncoder");
    pEncoderContext->mState = CREATED;
    pEncoderContext->mFormat = format;
    pEncoderContext->mWriterDataInterface = pWriterDataInterface;
    pEncoderContext->mPreProcFunction = pVPPfct;
    pEncoderContext->mPreProcContext = pVPPctxt;
    pEncoderContext->mPuller = NULL;

    // Get color converter and determine encoder input format
    pEncoderContext->mI420ColorConverter = new I420ColorConverter;
    if (pEncoderContext->mI420ColorConverter->isLoaded()) {
        encoderInput = pEncoderContext->mI420ColorConverter->getEncoderInputFormat();
    }
    if (encoderInput == OMX_COLOR_FormatYUV420Planar) {
        delete pEncoderContext->mI420ColorConverter;
        pEncoderContext->mI420ColorConverter = NULL;
    }
    pEncoderContext->mEncoderColorFormat = (OMX_COLOR_FORMATTYPE)encoderInput;
    ALOGI("encoder input format = 0x%X\n", encoderInput);

    *pContext = pEncoderContext;

cleanUp:
    if ( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_init no error");
    } else {
        VideoEditorVideoEncoder_cleanup(pEncoderContext);
        *pContext = M4OSA_NULL;
        ALOGV("VideoEditorVideoEncoder_init ERROR 0x%X", err);
    }
    ALOGV("VideoEditorVideoEncoder_init end");
    return err;
}

M4OSA_ERR VideoEditorVideoEncoder_init_H263(M4ENCODER_Context* pContext,
        M4WRITER_DataInterface* pWriterDataInterface, M4VPP_apply_fct* pVPPfct,
        M4VPP_Context pVPPctxt, M4OSA_Void* pExternalAPI, M4OSA_Void* pUserData)
        {

    return VideoEditorVideoEncoder_init(M4ENCODER_kH263, pContext,
        pWriterDataInterface, pVPPfct, pVPPctxt, pExternalAPI, pUserData);
}


M4OSA_ERR VideoEditorVideoEncoder_init_MPEG4(M4ENCODER_Context* pContext,
        M4WRITER_DataInterface* pWriterDataInterface, M4VPP_apply_fct* pVPPfct,
        M4VPP_Context pVPPctxt, M4OSA_Void* pExternalAPI, M4OSA_Void* pUserData)
        {

    return VideoEditorVideoEncoder_init(M4ENCODER_kMPEG4, pContext,
        pWriterDataInterface, pVPPfct, pVPPctxt, pExternalAPI, pUserData);
}


M4OSA_ERR VideoEditorVideoEncoder_init_H264(M4ENCODER_Context* pContext,
        M4WRITER_DataInterface* pWriterDataInterface, M4VPP_apply_fct* pVPPfct,
        M4VPP_Context pVPPctxt, M4OSA_Void* pExternalAPI, M4OSA_Void* pUserData)
        {

    return VideoEditorVideoEncoder_init(M4ENCODER_kH264, pContext,
        pWriterDataInterface, pVPPfct, pVPPctxt, pExternalAPI, pUserData);
}

M4OSA_ERR VideoEditorVideoEncoder_close(M4ENCODER_Context pContext) {
    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

    ALOGV("VideoEditorVideoEncoder_close begin");
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;
    VIDEOEDITOR_CHECK(OPENED == pEncoderContext->mState, M4ERR_STATE);

    // Release memory
    SAFE_FREE(pEncoderContext->mCodecParams);

    // Destroy the graph
    pEncoderContext->mEncoder.clear();
   // pEncoderContext->mClient.disconnect();
    pEncoderContext->mEncoderSource.clear();

    delete pEncoderContext->mPuller;
    pEncoderContext->mPuller = NULL;

    delete pEncoderContext->mI420ColorConverter;
    pEncoderContext->mI420ColorConverter = NULL;

    // Set the new state
    pEncoderContext->mState = CREATED;

cleanUp:
    if( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_close no error");
    } else {
        ALOGV("VideoEditorVideoEncoder_close ERROR 0x%X", err);
    }
    ALOGV("VideoEditorVideoEncoder_close end");
    return err;
}


M4OSA_ERR VideoEditorVideoEncoder_open(M4ENCODER_Context pContext,
        M4SYS_AccessUnit* pAU, M4OSA_Void* pParams) {
    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;
    M4ENCODER_Params* pCodecParams = M4OSA_NULL;
    status_t result = OK;
    sp<MetaData> encoderMetadata = NULL;
    const char* mime = NULL;
    int32_t iProfile = 0;
    int32_t iLevel = 0;

    int32_t iFrameRate = 0;
    uint32_t codecFlags = 0;

    ALOGV(">>> VideoEditorVideoEncoder_open begin");
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(M4OSA_NULL != pAU,      M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(M4OSA_NULL != pParams,  M4ERR_PARAMETER);

    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;
    pCodecParams = (M4ENCODER_Params*)pParams;
    VIDEOEDITOR_CHECK(CREATED == pEncoderContext->mState, M4ERR_STATE);

    // Context initialization
    pEncoderContext->mAccessUnit = pAU;
    pEncoderContext->mVideoEditorProfile = MediaProfiles::getInstance();
    pEncoderContext->mMaxPrefetchFrames =
        pEncoderContext->mVideoEditorProfile->getVideoEditorCapParamByName(
        "maxPrefetchYUVFrames");

    // Allocate & initialize the encoding parameters
    SAFE_MALLOC(pEncoderContext->mCodecParams, M4ENCODER_Params, 1,
        "VideoEditorVideoEncoder");


    pEncoderContext->mCodecParams->InputFormat = pCodecParams->InputFormat;
    pEncoderContext->mCodecParams->InputFrameWidth =
        pCodecParams->InputFrameWidth;
    pEncoderContext->mCodecParams->InputFrameHeight =
        pCodecParams->InputFrameHeight;
    pEncoderContext->mCodecParams->FrameWidth = pCodecParams->FrameWidth;
    pEncoderContext->mCodecParams->FrameHeight = pCodecParams->FrameHeight;
    pEncoderContext->mCodecParams->Bitrate = pCodecParams->Bitrate;
    pEncoderContext->mCodecParams->FrameRate = pCodecParams->FrameRate;
    pEncoderContext->mCodecParams->Format = pCodecParams->Format;
    pEncoderContext->mCodecParams->videoProfile = pCodecParams->videoProfile;
    pEncoderContext->mCodecParams->videoLevel= pCodecParams->videoLevel;

    // Check output format consistency and resolution
    VIDEOEDITOR_CHECK(
        pEncoderContext->mCodecParams->Format == pEncoderContext->mFormat,
        M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(0 == pEncoderContext->mCodecParams->FrameWidth  % 16,
        M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(0 == pEncoderContext->mCodecParams->FrameHeight % 16,
        M4ERR_PARAMETER);

    /**
     * StageFright graph building
     */

    // Create the meta data for the encoder
    encoderMetadata = new MetaData;
    switch( pEncoderContext->mCodecParams->Format ) {
        case M4ENCODER_kH263:
            mime     = MEDIA_MIMETYPE_VIDEO_H263;
            break;
        case M4ENCODER_kMPEG4:
            mime     = MEDIA_MIMETYPE_VIDEO_MPEG4;
            break;
        case M4ENCODER_kH264:
            mime     = MEDIA_MIMETYPE_VIDEO_AVC;
            break;
        default:
            VIDEOEDITOR_CHECK(!"VideoEncoder_open : incorrect input format",
                M4ERR_PARAMETER);
            break;
    }
    iProfile = pEncoderContext->mCodecParams->videoProfile;
    iLevel = pEncoderContext->mCodecParams->videoLevel;
    ALOGV("Encoder mime %s profile %d, level %d",
        mime,iProfile, iLevel);
    ALOGV("Encoder w %d, h %d, bitrate %d, fps %d",
        pEncoderContext->mCodecParams->FrameWidth,
        pEncoderContext->mCodecParams->FrameHeight,
        pEncoderContext->mCodecParams->Bitrate,
        pEncoderContext->mCodecParams->FrameRate);
    CHECK(iProfile != 0x7fffffff);
    CHECK(iLevel != 0x7fffffff);

    encoderMetadata->setCString(kKeyMIMEType, mime);
    encoderMetadata->setInt32(kKeyVideoProfile, iProfile);
    //FIXME:
    // Temp: Do not set the level for Mpeg4 / H.263 Enc
    // as OMX.Nvidia.mp4.encoder and OMX.Nvidia.h263.encoder
    // return 0x80001019
    if (pEncoderContext->mCodecParams->Format == M4ENCODER_kH264) {
        encoderMetadata->setInt32(kKeyVideoLevel, iLevel);
    }
    encoderMetadata->setInt32(kKeyWidth,
        (int32_t)pEncoderContext->mCodecParams->FrameWidth);
    encoderMetadata->setInt32(kKeyStride,
        (int32_t)pEncoderContext->mCodecParams->FrameWidth);
    encoderMetadata->setInt32(kKeyHeight,
        (int32_t)pEncoderContext->mCodecParams->FrameHeight);
    encoderMetadata->setInt32(kKeySliceHeight,
        (int32_t)pEncoderContext->mCodecParams->FrameHeight);

    switch( pEncoderContext->mCodecParams->FrameRate ) {
        case M4ENCODER_k5_FPS:    iFrameRate = 5;  break;
        case M4ENCODER_k7_5_FPS:  iFrameRate = 8;  break;
        case M4ENCODER_k10_FPS:   iFrameRate = 10; break;
        case M4ENCODER_k12_5_FPS: iFrameRate = 13; break;
        case M4ENCODER_k15_FPS:   iFrameRate = 15; break;
        case M4ENCODER_k20_FPS:   iFrameRate = 20; break;
        case M4ENCODER_k25_FPS:   iFrameRate = 25; break;
        case M4ENCODER_k30_FPS:   iFrameRate = 30; break;
        case M4ENCODER_kVARIABLE_FPS:
            iFrameRate = 30;
            ALOGI("Frame rate set to M4ENCODER_kVARIABLE_FPS: set to 30");
          break;
        case M4ENCODER_kUSE_TIMESCALE:
            iFrameRate = 30;
            ALOGI("Frame rate set to M4ENCODER_kUSE_TIMESCALE:  set to 30");
            break;

        default:
            VIDEOEDITOR_CHECK(!"VideoEncoder_open:incorrect framerate",
                M4ERR_STATE);
            break;
    }
    encoderMetadata->setInt32(kKeyFrameRate, iFrameRate);
    encoderMetadata->setInt32(kKeyBitRate,
        (int32_t)pEncoderContext->mCodecParams->Bitrate);
    encoderMetadata->setInt32(kKeyIFramesInterval, 1);

    encoderMetadata->setInt32(kKeyColorFormat,
        pEncoderContext->mEncoderColorFormat);

    if (pEncoderContext->mCodecParams->Format != M4ENCODER_kH263) {
        // Get the encoder DSI
        err = VideoEditorVideoEncoder_getDSI(pEncoderContext, encoderMetadata);
        VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);
    }

    // Create the encoder source
    pEncoderContext->mEncoderSource = IntelVideoEditorEncoderSource::Create(
        encoderMetadata);
    VIDEOEDITOR_CHECK(
        NULL != pEncoderContext->mEncoderSource.get(), M4ERR_STATE);

    // Create the HW Encoder
    if (pEncoderContext->mCodecParams->Format == M4ENCODER_kH264) {
        pEncoderContext->mEncoder = new IntelVideoEditorAVCEncoder(
        pEncoderContext->mEncoderSource, encoderMetadata);
    } else if (pEncoderContext->mCodecParams->Format == M4ENCODER_kH263) {
        pEncoderContext->mEncoder = new IntelVideoEditorH263Encoder(
        pEncoderContext->mEncoderSource, encoderMetadata);
    }
    VIDEOEDITOR_CHECK(NULL != pEncoderContext->mEncoder.get(), M4ERR_STATE);
    ALOGV("VideoEditorVideoEncoder_open : DONE");
    pEncoderContext->mPuller = new MediaBufferPuller(
        pEncoderContext->mEncoder);

    // Set the new state
    pEncoderContext->mState = OPENED;

cleanUp:
    if( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_open no error");
    } else {
        VideoEditorVideoEncoder_close(pEncoderContext);
        ALOGV("VideoEditorVideoEncoder_open ERROR 0x%X", err);
    }
    ALOGV("VideoEditorVideoEncoder_open end");
    return err;
}

M4OSA_ERR VideoEditorVideoEncoder_processInputBuffer(
        M4ENCODER_Context pContext, M4OSA_Double Cts,
        M4OSA_Bool bReachedEOS) {
    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;
    M4VIFI_ImagePlane pOutPlane[3];
    MediaBuffer* buffer = NULL;
    int32_t nbBuffer = 0;

    ALOGV("VideoEditorVideoEncoder_processInputBuffer begin: cts  %f", Cts);
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;
    pOutPlane[0].pac_data = M4OSA_NULL;
    pOutPlane[1].pac_data = M4OSA_NULL;
    pOutPlane[2].pac_data = M4OSA_NULL;

    if ( M4OSA_FALSE == bReachedEOS ) {
        M4OSA_UInt32 sizeY = pEncoderContext->mCodecParams->FrameWidth *
            pEncoderContext->mCodecParams->FrameHeight;
        M4OSA_UInt32 sizeU = sizeY >> 2;
        M4OSA_UInt32 size  = sizeY + 2*sizeU;
        M4OSA_UInt8* pData = M4OSA_NULL;
        buffer = new MediaBuffer((size_t)size);
        pData = (M4OSA_UInt8*)buffer->data() + buffer->range_offset();

        // Prepare the output image for pre-processing
        pOutPlane[0].u_width   = pEncoderContext->mCodecParams->FrameWidth;
        pOutPlane[0].u_height  = pEncoderContext->mCodecParams->FrameHeight;
        pOutPlane[0].u_topleft = 0;
        pOutPlane[0].u_stride  = pOutPlane[0].u_width;
        pOutPlane[1].u_width   = pOutPlane[0].u_width/2;
        pOutPlane[1].u_height  = pOutPlane[0].u_height/2;
        pOutPlane[1].u_topleft = 0;
        pOutPlane[1].u_stride  = pOutPlane[0].u_stride/2;
        pOutPlane[2].u_width   = pOutPlane[1].u_width;
        pOutPlane[2].u_height  = pOutPlane[1].u_height;
        pOutPlane[2].u_topleft = 0;
        pOutPlane[2].u_stride  = pOutPlane[1].u_stride;

        pOutPlane[0].pac_data = pData;
        pOutPlane[1].pac_data = pData + sizeY;
        pOutPlane[2].pac_data = pData + sizeY + sizeU;

        // Apply pre-processing
        err = pEncoderContext->mPreProcFunction(
            pEncoderContext->mPreProcContext, M4OSA_NULL, pOutPlane);
        VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

        // Convert MediaBuffer to the encoder input format if necessary
        if (pEncoderContext->mI420ColorConverter) {
            I420ColorConverter* converter = pEncoderContext->mI420ColorConverter;
            int actualWidth = pEncoderContext->mCodecParams->FrameWidth;
            int actualHeight = pEncoderContext->mCodecParams->FrameHeight;

            int encoderWidth, encoderHeight;
            ARect encoderRect;
            int encoderBufferSize;

            if (converter->getEncoderInputBufferInfo(
                actualWidth, actualHeight,
                &encoderWidth, &encoderHeight,
                &encoderRect, &encoderBufferSize) == 0) {

                MediaBuffer* newBuffer;
                pEncoderContext->mEncoderSource->requestBuffer(&newBuffer);
                if (converter->convertI420ToEncoderInput(
                    pData,  // srcBits
                    actualWidth, actualHeight,
                    encoderWidth, encoderHeight,
                    encoderRect,
                    (uint8_t*)newBuffer->data() + newBuffer->range_offset()) < 0) {
                    ALOGE("convertI420ToEncoderInput failed");
                }

                // switch to new buffer
                buffer->release();
                buffer = newBuffer;
            }
        }

        // Set the metadata
        buffer->meta_data()->setInt64(kKeyTime, (int64_t)(Cts*1000));
    }

    // Push the buffer to the source, a NULL buffer, notifies the source of EOS
    nbBuffer = pEncoderContext->mEncoderSource->storeBuffer(buffer);

cleanUp:
    if ( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_processInputBuffer error 0x%X", err);
    } else {
        if( NULL != buffer ) {
            buffer->release();
        }
        ALOGV("VideoEditorVideoEncoder_processInputBuffer ERROR 0x%X", err);
    }
    ALOGV("VideoEditorVideoEncoder_processInputBuffer end");
    return err;
}

M4OSA_ERR VideoEditorVideoEncoder_processOutputBuffer(
        M4ENCODER_Context pContext, MediaBuffer* buffer) {
    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;
    M4OSA_UInt32 Cts = 0;
    uint8_t *data;
    uint32_t length;
    int32_t i32Tmp = 0;
    int64_t i64Tmp = 0;
    status_t result = OK;
    LOGV("VideoEditorVideoEncoder_processOutputBuffer begin");
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(M4OSA_NULL != buffer,   M4ERR_PARAMETER);

    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

    // Process the returned AU
    if ( 0 == buffer->range_length() ) {
        // Encoder has no data yet, nothing unusual
        LOGV("VideoEditorVideoEncoder_processOutputBuffer : buffer is empty");
        goto cleanUp;
    }
    VIDEOEDITOR_CHECK(0 == ((M4OSA_UInt32)buffer->data())%4, M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(buffer->meta_data().get(), M4ERR_PARAMETER);
    if ( buffer->meta_data()->findInt32(kKeyIsCodecConfig, &i32Tmp) && i32Tmp ){
        LOGV("VideoEditorVideoEncoder_processOutputBuffer DSI %d",buffer->range_length());
        removeAVCCodecSpecificData(&data,&length,(const uint8_t*) buffer->data(),buffer->range_length(),NULL);
        buffer->set_range(buffer->range_offset() + length, buffer->range_length() - length);
    }

    // Check the CTS
    VIDEOEDITOR_CHECK(buffer->meta_data()->findInt64(kKeyTime, &i64Tmp),
        M4ERR_STATE);

    pEncoderContext->mNbOutputFrames++;
    if ( 0 > pEncoderContext->mFirstOutputCts ) {
        pEncoderContext->mFirstOutputCts = i64Tmp;
    }
    pEncoderContext->mLastOutputCts = i64Tmp;

    Cts = (M4OSA_Int32)(i64Tmp/1000);
    LOGV("[TS_CHECK] VI/ENC WRITE frame %d @ %lld -> %d (last %d)",
        pEncoderContext->mNbOutputFrames, i64Tmp, Cts,
        pEncoderContext->mLastCTS);
    if ( Cts < pEncoderContext->mLastCTS ) {
        LOGV("VideoEncoder_processOutputBuffer WARNING : Cts is going "
        "backwards %d < %d", Cts, pEncoderContext->mLastCTS);
        goto cleanUp;
    }
    LOGV("VideoEditorVideoEncoder_processOutputBuffer : %d %d",
        Cts, pEncoderContext->mLastCTS);

    // Retrieve the AU container
    err = pEncoderContext->mWriterDataInterface->pStartAU(
        pEncoderContext->mWriterDataInterface->pWriterContext,
        pEncoderContext->mAccessUnit->stream->streamID,
        pEncoderContext->mAccessUnit);
    VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

    // Format the AU
    VIDEOEDITOR_CHECK(
        buffer->range_length() <= pEncoderContext->mAccessUnit->size,
        M4ERR_PARAMETER);
    // Remove H264 AU start code
    if ( M4ENCODER_kH264 == pEncoderContext->mFormat ) {
        if (!memcmp((const uint8_t *)buffer->data() + \
                buffer->range_offset(), "\x00\x00\x00\x01", 4) ) {
            buffer->set_range(buffer->range_offset() + 4,
                buffer->range_length() - 4);
        }
    }

    if ( (M4ENCODER_kH264 == pEncoderContext->mFormat) &&
        (M4OSA_NULL != pEncoderContext->mH264NALUPostProcessFct) ) {
    // H264 trimming case, NALU post processing is needed
        M4OSA_Int32 outputSize = pEncoderContext->mAccessUnit->size;
        err = pEncoderContext->mH264NALUPostProcessFct(
            pEncoderContext->mH264NALUPostProcessCtx,
            (M4OSA_UInt8*)buffer->data()+buffer->range_offset(),
            buffer->range_length(),
            (M4OSA_UInt8*)pEncoderContext->mAccessUnit->dataAddress,
            &outputSize);
        VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);
        pEncoderContext->mAccessUnit->size = (M4OSA_UInt32)outputSize;
    } else {
        // The AU can just be copied
        memcpy((void *)pEncoderContext->mAccessUnit->\
            dataAddress, (void *)((M4OSA_MemAddr8)(buffer->data())+buffer->\
            range_offset()), buffer->range_length());
        pEncoderContext->mAccessUnit->size =
            (M4OSA_UInt32)buffer->range_length();
    }

    if ( buffer->meta_data()->findInt32(kKeyIsSyncFrame,&i32Tmp) && i32Tmp){
        pEncoderContext->mAccessUnit->attribute = AU_RAP;
    } else {
        pEncoderContext->mAccessUnit->attribute = AU_P_Frame;
    }
    pEncoderContext->mLastCTS = Cts;
    pEncoderContext->mAccessUnit->CTS = Cts;
    pEncoderContext->mAccessUnit->DTS = Cts;

    LOGV("VideoEditorVideoEncoder_processOutputBuffer: AU @ 0x%X 0x%X %d %d",
        pEncoderContext->mAccessUnit->dataAddress,
        *pEncoderContext->mAccessUnit->dataAddress,
        pEncoderContext->mAccessUnit->size,
        pEncoderContext->mAccessUnit->CTS);

    // Write the AU
    err = pEncoderContext->mWriterDataInterface->pProcessAU(
        pEncoderContext->mWriterDataInterface->pWriterContext,
        pEncoderContext->mAccessUnit->stream->streamID,
        pEncoderContext->mAccessUnit);
    VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

cleanUp:
    if( M4NO_ERROR == err ) {
        LOGV("VideoEditorVideoEncoder_processOutputBuffer no error");
    } else {
        if (pEncoderContext != NULL) {
            SAFE_FREE(pEncoderContext->mHeader.pBuf);
            pEncoderContext->mHeader.Size = 0;
        }
        LOGV("VideoEditorVideoEncoder_processOutputBuffer ERROR 0x%X", err);
    }
    LOGV("VideoEditorVideoEncoder_processOutputBuffer end");
    return err;
}

M4OSA_ERR VideoEditorVideoEncoder_encode(M4ENCODER_Context pContext,
        M4VIFI_ImagePlane* pInPlane, M4OSA_Double Cts,
        M4ENCODER_FrameMode FrameMode) {
    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;
    status_t result = OK;
    MediaBuffer* outputBuffer = NULL;

    ALOGV("VideoEditorVideoEncoder_encode 0x%X %f %d", pInPlane, Cts, FrameMode);
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;
    if ( STARTED == pEncoderContext->mState ) {
        pEncoderContext->mState = BUFFERING;
    }
    VIDEOEDITOR_CHECK(
        (BUFFERING | READING) & pEncoderContext->mState, M4ERR_STATE);

    pEncoderContext->mNbInputFrames++;
    if ( 0 > pEncoderContext->mFirstInputCts ) {
        pEncoderContext->mFirstInputCts = Cts;
    }
    pEncoderContext->mLastInputCts = Cts;

    ALOGV("VideoEditorVideoEncoder_encode 0x%X %d %f (%d)", pInPlane, FrameMode,
        Cts, pEncoderContext->mLastCTS);

    // Push the input buffer to the encoder source
    err = VideoEditorVideoEncoder_processInputBuffer(pEncoderContext, Cts,
        M4OSA_FALSE);
    VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

    // Notify the source in case of EOS
    if ( M4ENCODER_kLastFrame == FrameMode ) {
        err = VideoEditorVideoEncoder_processInputBuffer(
            pEncoderContext, 0, M4OSA_TRUE);
        VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);
    }

    if ( BUFFERING == pEncoderContext->mState ) {
        // Prefetch is complete, start reading
        pEncoderContext->mState = READING;
    }
    // Read
    while (1)  {
        MediaBuffer *outputBuffer =
                pEncoderContext->mPuller->getBufferNonBlocking();

        if (outputBuffer == NULL) {
            break;
        } else {
            // Provide the encoded AU to the writer
            err = VideoEditorVideoEncoder_processOutputBuffer(pEncoderContext,
                outputBuffer);
            VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

            pEncoderContext->mPuller->putBuffer(outputBuffer);
        }
    }

cleanUp:
    if( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_encode no error");
    } else {
        ALOGV("VideoEditorVideoEncoder_encode ERROR 0x%X", err);
    }
    ALOGV("VideoEditorVideoEncoder_encode end");
    return err;
}

M4OSA_ERR VideoEditorVideoEncoder_start(M4ENCODER_Context pContext) {
    M4OSA_ERR                  err             = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;
    status_t                   result          = OK;

    ALOGV("VideoEditorVideoEncoder_start begin");
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;
    VIDEOEDITOR_CHECK(OPENED == pEncoderContext->mState, M4ERR_STATE);

    pEncoderContext->mNbInputFrames  = 0;
    pEncoderContext->mFirstInputCts  = -1.0;
    pEncoderContext->mLastInputCts   = -1.0;
    pEncoderContext->mNbOutputFrames = 0;
    pEncoderContext->mFirstOutputCts = -1;
    pEncoderContext->mLastOutputCts  = -1;

    result = pEncoderContext->mEncoder->start();
    VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);

    pEncoderContext->mPuller->start();

    // Set the new state
    pEncoderContext->mState = STARTED;

cleanUp:
    if ( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_start no error");
    } else {
        ALOGV("VideoEditorVideoEncoder_start ERROR 0x%X", err);
    }
    ALOGV("VideoEditorVideoEncoder_start end");
    return err;
}

M4OSA_ERR VideoEditorVideoEncoder_stop(M4ENCODER_Context pContext) {
    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;
    MediaBuffer* outputBuffer = NULL;
    status_t result = OK;

    ALOGV("VideoEditorVideoEncoder_stop begin");
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);
    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

    // Send EOS again to make sure the source doesn't block.
    err = VideoEditorVideoEncoder_processInputBuffer(pEncoderContext, 0,
        M4OSA_TRUE);
    VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

    // Process the remaining buffers if necessary
    if ( (BUFFERING | READING) & pEncoderContext->mState ) {
        while (1)  {
            MediaBuffer *outputBuffer =
                pEncoderContext->mPuller->getBufferBlocking();

            if (outputBuffer == NULL) break;

            err = VideoEditorVideoEncoder_processOutputBuffer(
                pEncoderContext, outputBuffer);
            VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

            pEncoderContext->mPuller->putBuffer(outputBuffer);
        }

        pEncoderContext->mState = STARTED;
    }

    // Stop the graph module if necessary
    if ( STARTED == pEncoderContext->mState ) {
        pEncoderContext->mPuller->stop();
        pEncoderContext->mEncoder->stop();
        pEncoderContext->mState = OPENED;
    }

    if (pEncoderContext->mNbInputFrames != pEncoderContext->mNbOutputFrames) {
        ALOGW("Some frames were not encoded: input(%d) != output(%d)",
            pEncoderContext->mNbInputFrames, pEncoderContext->mNbOutputFrames);
    }

cleanUp:
    if ( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_stop no error");
    } else {
        ALOGV("VideoEditorVideoEncoder_stop ERROR 0x%X", err);
    }
    ALOGV("VideoEditorVideoEncoder_stop end");
    return err;
}

M4OSA_ERR VideoEditorVideoEncoder_regulBitRate(M4ENCODER_Context pContext) {
    ALOGW("regulBitRate is not implemented");
    return M4NO_ERROR;
}

M4OSA_ERR VideoEditorVideoEncoder_setOption(M4ENCODER_Context pContext,
        M4OSA_UInt32 optionID, M4OSA_DataOption optionValue) {
    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

    ALOGV("VideoEditorVideoEncoder_setOption start optionID 0x%X", optionID);
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

    switch( optionID ) {
        case M4ENCODER_kOptionID_SetH264ProcessNALUfctsPtr:
            pEncoderContext->mH264NALUPostProcessFct =
                (H264MCS_ProcessEncodedNALU_fct*)optionValue;
            break;
        case M4ENCODER_kOptionID_H264ProcessNALUContext:
            pEncoderContext->mH264NALUPostProcessCtx =
                (M4OSA_Context)optionValue;
            break;
        default:
            ALOGV("VideoEditorVideoEncoder_setOption: unsupported optionId 0x%X",
                optionID);
            VIDEOEDITOR_CHECK(M4OSA_FALSE, M4ERR_BAD_OPTION_ID);
            break;
    }

cleanUp:
    if ( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_setOption no error");
    } else {
        ALOGV("VideoEditorVideoEncoder_setOption ERROR 0x%X", err);
    }
    ALOGV("VideoEditorVideoEncoder_setOption end");
    return err;
}

M4OSA_ERR VideoEditorVideoEncoder_getOption(M4ENCODER_Context pContext,
        M4OSA_UInt32 optionID, M4OSA_DataOption optionValue) {
    M4OSA_ERR err = M4NO_ERROR;
    VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

    ALOGV("VideoEditorVideoEncoder_getOption begin optinId 0x%X", optionID);
    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);
    pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

    switch( optionID ) {
        case M4ENCODER_kOptionID_EncoderHeader:
            VIDEOEDITOR_CHECK(
                    M4OSA_NULL != pEncoderContext->mHeader.pBuf, M4ERR_STATE);
            *(M4ENCODER_Header**)optionValue = &(pEncoderContext->mHeader);
            break;
        default:
            ALOGV("VideoEditorVideoEncoder_getOption: unsupported optionId 0x%X",
                optionID);
            VIDEOEDITOR_CHECK(M4OSA_FALSE, M4ERR_BAD_OPTION_ID);
            break;
    }

cleanUp:
    if ( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_getOption no error");
    } else {
        ALOGV("VideoEditorVideoEncoder_getOption ERROR 0x%X", err);
    }
    return err;
}

M4OSA_ERR VideoEditorVideoEncoder_getInterface(M4ENCODER_Format format,
        M4ENCODER_Format* pFormat,
        M4ENCODER_GlobalInterface** pEncoderInterface, M4ENCODER_OpenMode mode){
    M4OSA_ERR err = M4NO_ERROR;

    // Input parameters check
    VIDEOEDITOR_CHECK(M4OSA_NULL != pFormat,           M4ERR_PARAMETER);
    VIDEOEDITOR_CHECK(M4OSA_NULL != pEncoderInterface, M4ERR_PARAMETER);

    ALOGV("VideoEditorVideoEncoder_getInterface begin 0x%x 0x%x %d", pFormat,
        pEncoderInterface, mode);

    SAFE_MALLOC(*pEncoderInterface, M4ENCODER_GlobalInterface, 1,
        "VideoEditorVideoEncoder");

    *pFormat = format;

    switch( format ) {
        case M4ENCODER_kH263:
            {
                (*pEncoderInterface)->pFctInit =
                    VideoEditorVideoEncoder_init_H263;
                break;
            }
        case M4ENCODER_kMPEG4:
            {
                (*pEncoderInterface)->pFctInit =
                    VideoEditorVideoEncoder_init_MPEG4;
                break;
            }
        case M4ENCODER_kH264:
            {
                (*pEncoderInterface)->pFctInit =
                    VideoEditorVideoEncoder_init_H264;
                break;
            }
        default:
            ALOGV("VideoEditorVideoEncoder_getInterface : unsupported format %d",
                format);
            VIDEOEDITOR_CHECK(M4OSA_FALSE, M4ERR_PARAMETER);
        break;
    }
    (*pEncoderInterface)->pFctOpen         = VideoEditorVideoEncoder_open;
    (*pEncoderInterface)->pFctStart        = VideoEditorVideoEncoder_start;
    (*pEncoderInterface)->pFctStop         = VideoEditorVideoEncoder_stop;
    (*pEncoderInterface)->pFctPause        = M4OSA_NULL;
    (*pEncoderInterface)->pFctResume       = M4OSA_NULL;
    (*pEncoderInterface)->pFctClose        = VideoEditorVideoEncoder_close;
    (*pEncoderInterface)->pFctCleanup      = VideoEditorVideoEncoder_cleanup;
    (*pEncoderInterface)->pFctRegulBitRate =
        VideoEditorVideoEncoder_regulBitRate;
    (*pEncoderInterface)->pFctEncode       = VideoEditorVideoEncoder_encode;
    (*pEncoderInterface)->pFctSetOption    = VideoEditorVideoEncoder_setOption;
    (*pEncoderInterface)->pFctGetOption    = VideoEditorVideoEncoder_getOption;

cleanUp:
    if( M4NO_ERROR == err ) {
        ALOGV("VideoEditorVideoEncoder_getInterface no error");
    } else {
        *pEncoderInterface = M4OSA_NULL;
        ALOGV("VideoEditorVideoEncoder_getInterface ERROR 0x%X", err);
    }
    return err;
}

extern "C" {

M4OSA_ERR VideoEditorVideoEncoder_getInterface_H263(M4ENCODER_Format* pFormat,
        M4ENCODER_GlobalInterface** pEncoderInterface, M4ENCODER_OpenMode mode){
    LOGI("VideoEditorVideoEncoder_getInterface_H263: Intel Version");
    return VideoEditorVideoEncoder_getInterface(M4ENCODER_kH263, pFormat,
            pEncoderInterface, mode);
}

M4OSA_ERR VideoEditorVideoEncoder_getInterface_MPEG4(M4ENCODER_Format* pFormat,
        M4ENCODER_GlobalInterface** pEncoderInterface, M4ENCODER_OpenMode mode){
    LOGI("VideoEditorVideoEncoder_getInterface_MPEG4: Intel Version");
    return VideoEditorVideoEncoder_getInterface(M4ENCODER_kMPEG4, pFormat,
           pEncoderInterface, mode);
}

M4OSA_ERR VideoEditorVideoEncoder_getInterface_H264(M4ENCODER_Format* pFormat,
        M4ENCODER_GlobalInterface** pEncoderInterface, M4ENCODER_OpenMode mode){
    LOGI("VideoEditorVideoEncoder_getInterface_H264: Intel Version");
    return VideoEditorVideoEncoder_getInterface(M4ENCODER_kH264, pFormat,
           pEncoderInterface, mode);

}

}  // extern "C"

}  // namespace android