/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * 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.
 * -------------------------------------------------------------------
 */
#ifndef PVMF_OMX_ENC_NODE_H_INCLUDED
#define PVMF_OMX_ENC_NODE_H_INCLUDED

#ifndef OSCL_BASE_H_INCLUDED
#include "oscl_base.h"
#endif

#ifndef OSCL_SCHEDULER_AO_H_INCLUDED
#include "oscl_scheduler_ao.h"
#endif

#ifndef PVMF_FORMAT_TYPE_H_INCLUDED
#include "pvmf_format_type.h"
#endif

#ifndef PVMF_NODE_INTERFACE_H_INCLUDED
#include "pvmf_node_interface.h"
#endif

#ifndef OSCL_PRIQUEUE_H_INCLUDED
#include "oscl_priqueue.h"
#endif

#ifndef PVMF_MEDIA_DATA_H_INCLUDED
#include "pvmf_media_data.h"
#endif

#ifndef OSCL_MEM_MEMPOOL_H_INCLUDED
#include "oscl_mem_mempool.h"
#endif
#ifndef PVMF_MEMPOOL_H_INCLUDED
#include "pvmf_mempool.h"
#endif

#ifndef PVMF_FIXEDSIZE_BUFFER_ALLOC_H_INCLUDED
#include "pvmf_fixedsize_buffer_alloc.h"
#endif

#ifndef PVMF_SIMPLE_MEDIA_BUFFER_H_INCLUDED
#include "pvmf_simple_media_buffer.h"
#endif

#ifndef PVMF_MEDIA_FRAG_GROUP_H_INCLUDED
#include "pvmf_media_frag_group.h"
#endif

#ifndef PVMF_POOL_BUFFER_ALLOCATOR_H_INCLUDED
#include "pvmf_pool_buffer_allocator.h"
#endif

#ifndef PVMF_VIDEO_H_INCLUDED
#include "pvmf_video.h"
#endif

#ifndef PVMF_POOL_BUFFER_ALLOCATOR_H_INCLUDED
#include "pvmf_pool_buffer_allocator.h"
#endif

#ifndef PVMF_NODE_UTILS_H_INCLUDED
#include "pvmf_node_utils.h"
#endif

#ifndef PVMF_OMX_ENC_PORT_H_INCLUDED
#include "pvmf_omx_enc_port.h"
#endif

#ifndef PVMF_OMX_ENC_NODE_EXTENSION_INTERFACE_H_INCLUDED
#include "pvmf_omx_enc_node_extension_interface.h"
#endif

#ifndef PV_MP4_H263_ENC_EXTENSION_H_INCLUDED
#include "pvmp4h263encextension.h"
#endif

#ifndef PVMF_AUDIO_ENCNODE_EXTENSION_H_INCLUDED
#include "pvmf_audio_encnode_extension.h"
#endif

// DV: NOTE - this needs to be fixed
//#ifndef __PVM4VENCODER_H
//#include "pvm4vencoder.h"
//#endif

#ifndef PVMF_META_DATA_EXTENSION_H_INCLUDED
#include "pvmf_meta_data_extension.h"
#endif

#ifndef PV_MIME_STRING_UTILS_H_INCLUDED
#include "pv_mime_string_utils.h"
#endif

#ifndef OMX_Core_h
#include "OMX_Core.h"
#endif

#ifndef OMX_Component_h
#include "OMX_Component.h"
#endif

#ifndef PVMF_OMX_ENC_CALLBACKS_H_INCLUDED
#include "pvmf_omx_enc_callbacks.h"
#endif

#ifndef PV_OMXDEFS_H_INCLUDED
#include "pv_omxdefs.h"
#endif

#ifndef OSCLCONFIG_IO_H_INCLUDED
#include "osclconfig_io.h"
#endif
#ifndef OSCL_MEM_H_INCLUDED
#include "oscl_mem.h"
#endif

#if (PVLOGGER_INST_LEVEL >= PVLOGMSG_INST_REL)
#ifndef PVMF_MEDIA_CLOCK_H_INCLUDED
#include "pvmf_media_clock.h"
#endif
#endif

#ifndef __MEDIA_CLOCK_CONVERTER_H
#include "media_clock_converter.h"
#endif

#define PVMFOMXENCNODE_NUM_CMD_IN_POOL 8
#define PVOMXENCMAXNUMDPBFRAMESPLUS1 17


typedef struct OutputBufCtrlStruct
{
    OMX_BUFFERHEADERTYPE *pBufHdr;
} OutputBufCtrlStruct;

typedef struct InputBufCtrlStruct
{
    OMX_BUFFERHEADERTYPE *pBufHdr;
    PVMFSharedMediaDataPtr pMediaData;
} InputBufCtrlStruct;


// fwd class declaration
class PVLogger;
//memory allocator type for this node.
typedef OsclMemAllocator PVMFOMXEncNodeAllocator;
typedef OsclMemAllocDestructDealloc<uint8> PVMFOMXEncNodeAllocDestructDealloc;


// CALLBACK PROTOTYPES
OMX_ERRORTYPE CallbackEventHandlerEnc(OMX_OUT OMX_HANDLETYPE aComponent,
                                      OMX_OUT OMX_PTR aAppData,
                                      OMX_OUT OMX_EVENTTYPE aEvent,
                                      OMX_OUT OMX_U32 aData1,
                                      OMX_OUT OMX_U32 aData2,
                                      OMX_OUT OMX_PTR aEventData);

OMX_ERRORTYPE CallbackEmptyBufferDoneEnc(OMX_OUT OMX_HANDLETYPE aComponent,
        OMX_OUT OMX_PTR aAppData,
        OMX_OUT OMX_BUFFERHEADERTYPE* aBuffer);

OMX_ERRORTYPE CallbackFillBufferDoneEnc(OMX_OUT OMX_HANDLETYPE aComponent,
                                        OMX_OUT OMX_PTR aAppData,
                                        OMX_OUT OMX_BUFFERHEADERTYPE* aBuffer);


//Default values for number of Input/Output buffers. If the component needs more than this, it will be
// negotiated. If the component does not need more than this number, the default is used
#define NUMBER_INPUT_BUFFER 5
#define NUMBER_OUTPUT_BUFFER 9

// for AMR encoder
#define MAX_NUM_AMR_FRAMES_PER_BUFFER 25
#define PVMF_AMRENC_DEFAULT_SAMPLING_RATE 8000
#define PVMF_AMRENC_DEFAULT_NUM_CHANNELS 1
#define PVMF_AMRENC_DEFAULT_BITSPERSAMPLE 16
// in milliseconds
#define PVMF_AMRENC_DEFAULT_FRAME_DURATION 20

////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////
/////////////////////////
/////////////////////////
// CUSTOM DEALLOCATOR FOR MEDIA DATA SHARED PTR WRAPPER:
//                      1) Deallocates the underlying output buffer
//                      2) Deallocates the pvci buffer wrapper and the rest of accompanying structures
//                    Deallocator is created as part of the wrapper, and travels with the buffer wrapper

class PVOMXEncBufferSharedPtrWrapperCombinedCleanupDA : public OsclDestructDealloc
{
    public:
        PVOMXEncBufferSharedPtrWrapperCombinedCleanupDA(Oscl_DefAlloc* allocator, void *pMempoolData) :
                buf_alloc(allocator), ptr_to_data_to_dealloc(pMempoolData) {};
        virtual ~PVOMXEncBufferSharedPtrWrapperCombinedCleanupDA() {};

        virtual void destruct_and_dealloc(OsclAny* ptr)
        {
            // call buffer deallocator
            if (buf_alloc != NULL)
            {
                buf_alloc->deallocate(ptr_to_data_to_dealloc);
            }

            // this is needed to completely free PVMFMediaDataImpl, since it allocates memory for the frag list
            ((PVMFMediaDataImpl*)ptr)->~PVMFMediaDataImpl();
            oscl_free(ptr);
        }

    private:
        Oscl_DefAlloc* buf_alloc;
        void *ptr_to_data_to_dealloc;
};


#define PVMFOMXEncNodeCommandBase PVMFGenericNodeCommand<PVMFOMXEncNodeAllocator>

class PVMFOMXEncNodeCommand: public PVMFOMXEncNodeCommandBase
{
    public:
        //constructor for Custom2 command
        void Construct(PVMFSessionId s, int32 cmd, int32 arg1, int32 arg2, int32& arg3, const OsclAny*aContext)
        {
            PVMFOMXEncNodeCommandBase::Construct(s, cmd, aContext);
            iParam1 = (OsclAny*)arg1;
            iParam2 = (OsclAny*)arg2;
            iParam3 = (OsclAny*) & arg3;
        }
        void Parse(int32&arg1, int32&arg2, int32*&arg3)
        {
            arg1 = (int32)iParam1;
            arg2 = (int32)iParam2;
            arg3 = (int32*)iParam3;
        }

        void Construct(PVMFSessionId s, int32 cmd, PVMFMetadataList* aKeyList, uint32 aStartIndex, int32 aMaxEntries, char* aQueryKey, const OsclAny* aContext)
        {
            PVMFOMXEncNodeCommandBase::Construct(s, cmd, aContext);
            iStartIndex = aStartIndex;
            iMaxEntries = aMaxEntries;

            if (aQueryKey == NULL)
            {
                query_key[0] = 0;
            }
            else
            {
                if (aQueryKey != NULL)
                    oscl_strncpy(query_key, aQueryKey, oscl_strlen(aQueryKey) + 1);
            }

            iParam1 = (OsclAny*)aKeyList;
            iParam2 = NULL;
            iParam3 = NULL;
            iParam4 = NULL;
            iParam5 = NULL;
        }

        void Parse(PVMFMetadataList*& MetaDataListPtr, uint32 &aStartingIndex, int32 &aMaxEntries, char*&aQueryKey)
        {
            MetaDataListPtr = (PVMFMetadataList*)iParam1;
            aStartingIndex = iStartIndex;
            aMaxEntries = iMaxEntries;
            if (query_key[0] == 0)
            {
                aQueryKey = NULL;
            }
            else
            {
                aQueryKey = query_key;
            }
        }

        // Constructor and parser for GetNodeMetadataValue
        void Construct(PVMFSessionId s, int32 cmd, PVMFMetadataList* aKeyList, Oscl_Vector<PvmiKvp, OsclMemAllocator>* aValueList, uint32 aStartIndex, int32 aMaxEntries, const OsclAny* aContext)
        {
            PVMFOMXEncNodeCommandBase::Construct(s, cmd, aContext);
            iParam1 = (OsclAny*)aKeyList;
            iParam2 = (OsclAny*)aValueList;

            iStartIndex = aStartIndex;
            iMaxEntries = aMaxEntries;

            iParam3 = NULL;
            iParam4 = NULL;
            iParam5 = NULL;
        }
        void Parse(PVMFMetadataList* &aKeyList, Oscl_Vector<PvmiKvp, OsclMemAllocator>* &aValueList, uint32 &aStartingIndex, int32 &aMaxEntries)
        {
            aKeyList = (PVMFMetadataList*)iParam1;
            aValueList = (Oscl_Vector<PvmiKvp, OsclMemAllocator>*)iParam2;
            aStartingIndex = iStartIndex;
            aMaxEntries = iMaxEntries;
        }


        virtual bool hipri()
        {
            //this routine identifies commands that need to
            //go at the front of the queue.  derived command
            //classes can override it if needed.
            return (iCmd == PVOMXENC_NODE_CMD_CANCELALL
                    || iCmd == PVOMXENC_NODE_CMD_CANCELCMD);
        }

        enum PVOMXEncNodeCmdType
        {
            PVOMXENC_NODE_CMD_QUERYUUID,
            PVOMXENC_NODE_CMD_QUERYINTERFACE,
            PVOMXENC_NODE_CMD_REQUESTPORT,
            PVOMXENC_NODE_CMD_RELEASEPORT,
            PVOMXENC_NODE_CMD_INIT,
            PVOMXENC_NODE_CMD_PREPARE,
            PVOMXENC_NODE_CMD_START,
            PVOMXENC_NODE_CMD_STOP,
            PVOMXENC_NODE_CMD_FLUSH,
            PVOMXENC_NODE_CMD_PAUSE,
            PVOMXENC_NODE_CMD_RESET,
            PVOMXENC_NODE_CMD_CANCELALL,
            PVOMXENC_NODE_CMD_CANCELCMD,
            PVOMXENC_NODE_CMD_GETNODEMETADATAKEY,
            PVOMXENC_NODE_CMD_GETNODEMETADATAVALUE,
            PVOMXENC_NODE_CMD_INVALID
        };


    private:
        uint32 iStartIndex;
        uint32 iMaxEntries;
        char query_key[256];

};

//Default vector reserve size
#define PVMF_OMXENC_NODE_COMMAND_VECTOR_RESERVE 10

//Starting value for command IDs
#define PVMF_OMXENC_NODE_COMMAND_ID_START 6000

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////// STRUCTURES FOR ENCODING PARAMETERS ////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
#define MAX_LAYER 1

/** Contains supported input format */
enum EncVideoInputFormat
{
    EI_RGB24,
    EI_RGB12,
    EI_YUV420,
    EI_UYVY
};

/** Type of contents for optimal encoding mode. */
enum EncContentType
{
    /** Content is to be streamed in real-time. */
    EI_M4V_STREAMING,

    /** Content is to be downloaded and playbacked later.*/
    EI_M4V_DOWNLOAD,

    /** Content is to be 3gpp baseline compliant. */
    EI_H263,

    EI_H264
};

/** Targeted profile and level to encode. */
enum EncM4VProfileLevel
{
    /* Non-scalable profile */
    EI_SIMPLE_LEVEL0 = 0,
    EI_SIMPLE_LEVEL1,
    EI_SIMPLE_LEVEL2,
    EI_SIMPLE_LEVEL3,
    EI_CORE_LEVEL1,
    EI_CORE_LEVEL2,

    /* Scalable profile */
    EI_SIMPLE_SCALABLE_LEVEL0 = 6,
    EI_SIMPLE_SCALABLE_LEVEL1,
    EI_SIMPLE_SCALABLE_LEVEL2,

    EI_CORE_SCALABLE_LEVEL1 = 10,
    EI_CORE_SCALABLE_LEVEL2,
    EI_CORE_SCALABLE_LEVEL3
};

/** Targeted profile to encode. */
enum EncAVCProfile
{
    /* Non-scalable profile */
    EI_PROFILE_DEFAULT,
    EI_PROFILE_BASELINE,
    EI_PROFILE_MAIN,
    EI_PROFILE_EXTENDED,
    EI_PROFILE_HIGH,
    EI_PROFILE_HIGH10,
    EI_PROFILE_HIGH422,
    EI_PROFILE_HIGH444
};

/** Targeted level to encode. */
enum EncAVCLevel
{
    EI_LEVEL_AUTODETECT,
    EI_LEVEL_1,
    EI_LEVEL_1B,
    EI_LEVEL_11,
    EI_LEVEL_12,
    EI_LEVEL_13,
    EI_LEVEL_2,
    EI_LEVEL_21,
    EI_LEVEL_22,
    EI_LEVEL_3,
    EI_LEVEL_31,
    EI_LEVEL_32,
    EI_LEVEL_4,
    EI_LEVEL_41,
    EI_LEVEL_42,
    EI_LEVEL_5,
    EI_LEVEL_51,
};

/** Output format */
enum TAVCEIOutputFormat
{
    /** output in byte stream format according to Annex B */
    EAVCEI_OUTPUT_ANNEXB,

    /** output for MP4 file format */
    EAVCEI_OUTPUT_MP4,

    /** output in RTP format according to RFC 3984 */
    EAVCEI_OUTPUT_RTP
};


/** Type of contents for optimal encoding mode. */
enum EncEncodingMode
{
    /** Content is encoded as fast as possible with error protection */
    EI_ENCMODE_TWOWAY,

    /** Content is encoded as fast as possible without error protection */
    EI_ENCMODE_RECORDER,

    /** Content is encoded with better quality (slow) with error protection */
    EI_ENCMODE_STREAMING,

    /** Content is encoded with better quality (slow) without error protection */
    EI_ENCMODE_DOWNLOAD
};


/** This structure contains encoder settings. */
typedef struct PV_VideoEncodeParam
{

////////////////////////////////////////////////////////////////////////////////////
////////////////////////// COMMON PARAMETERS ///////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////

    /** Specifies an  ID that will be used to specify this encoder while returning
    the bitstream in asynchronous mode. */
    uint32              iEncodeID;


    /** Specifies whether base only (iNumLayer = 1) or base + enhancement layer
    (iNumLayer =2 ) is to be used. */
    int32               iNumLayer;

    /** Specifies the width in pixels of the encoded frames. IFrameWidth[0] is for
    base layer and iFrameWidth[1] is for enhanced layer. */
    int                 iFrameWidth[MAX_LAYER];

    /** Specifies the height in pixels of the encoded frames. IFrameHeight[0] is for
    base layer and iFrameHeight[1] is for enhanced layer. */
    int                 iFrameHeight[MAX_LAYER];

    /** Specifies the cumulative bit rate in bit per second. IBitRate[0] is for base
    layer and iBitRate[1] is for base+enhanced layer.*/
    int                 iBitRate[MAX_LAYER];

    /** Specifies the cumulative frame rate in frame per second. IFrameRate[0] is for
    base layer and iFrameRate[1] is for base+enhanced layer. */
    float               iFrameRate[MAX_LAYER];

    /** Specifies the rate control algorithm among one of the following constant Q,
    CBR and VBR.  The structure EncRateControlType is defined above.*/
    PVMFVENRateControlType iRateControlType;

    /** Specifies the initial quantization parameter for the first I-frame. If constant Q
    rate control is used, this QP will be used for all the I-frames. This number must be
    set between 1 and 31, otherwise, Initialize() will fail. */
    int                 iIquant[2];

    /** Specifies the initial quantization parameter for the first P-frame. If constant Q
    rate control is used, this QP will be used for all the P-frames. This number must be
    set between 1 and 31, otherwise, Initialize() will fail. */
    int                 iPquant[2];

    /** Specifies the initial quantization parameter for the first B-frame. If constant Q
    rate control is used, this QP will be used for all the B-frames. This number must be
    set between 1 and 31, otherwise, Initialize() will fail. */
    int                 iBquant[2];


    /** Specifies the maximum number of P-frames between 2 INTRA frames. An INTRA mode is
    forced to a frame once this interval is reached. When there is only one I-frame is present
    at the beginning of the clip, iIFrameInterval should be set to -1. */
    int32               iIFrameInterval;

    /** According to iIFrameInterval setting, the minimum number of intra MB per frame is
    optimally calculated for error resiliency. However, when iIFrameInterval is set to -1,
    iNumIntraMBRefresh must be specified to guarantee the minimum number of intra
    macroblocks per frame.*/
    uint32              iNumIntraMBRefresh;

    /** Specifies automatic scene detection where I-frame will be used the the first frame
    in a new scene. */
    bool                iSceneDetection;

    /** Specifies the packet size in bytes which represents the number of bytes between two resync markers.
    For EI_M4V_DOWNLOAD and EI_H263, if iPacketSize is set to 0, there will be no resync markers in the bitstream.
    For EI_M4V_STREAMING is parameter must be set to a value greater than 0. For AVC, this value specifies
    the packet size in bytes which represents the desired number of bytes per NAL.
    If this number is set to 0, the AVC encoder will encode the entire slice group as one NAL. */
    uint32              iPacketSize;

    /** Specifies the VBV buffer size which determines the end-to-end delay between the
    encoder and the decoder.  The size is in unit of seconds. For download application,
    the buffer size can be larger than the streaming application. For 2-way application,
    this buffer shall be kept minimal. For a special case, in VBR mode, iBufferDelay will
    be set to -1 to allow buffer underflow. */
    float               iBufferDelay;


    /** Specifies the duration of the clip in millisecond.*/
    int32               iClipDuration;


////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////// H263/M4V specific parameters ///////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////

    /** Specifies the profile and level used to encode the bitstream. When present,
    other settings will be checked against the range allowable by this target profile
    and level. Fail may be returned from the Initialize call. */
    EncM4VProfileLevel  iProfileLevel;

    /** Specifies the picture quality factor on the scale of 1 to 10. It trades off
    the picture quality with the frame rate. Higher frame quality means lower frame rate.
    Lower frame quality for higher frame rate.*/
    int32               iFrameQuality;


    /** Enable the use of iFrameQuality to determine the frame rate. If it is false,
    the encoder will try to meet the specified frame rate regardless of the frame quality.*/
    bool                iEnableFrameQuality;


    /** Specifies high quality but also high complexity mode for rate control. */
    bool                iRDOptimal;


    /** Specifies the search range in pixel unit for motion vector. The range of the
    motion vector will be of dimension [-iSearchRange.5, +iSearchRange.0]. */
    int32               iSearchRange;

    /** Specifies the use of 8x8 motion vectors. */
    bool                iMV8x8;

    /** Specifies the use of half-pel motion vectors. */
    bool                iMVHalfPel;

    /** Specifies whether the current frame skipping decision is allowed after encoding
    the current frame. If there is no memory of what has been coded for the current frame,
    iNoCurrentSkip has to be on. */
    bool                iNoCurrentSkip;

    /** Specifies that no frame skipping is allowed. Frame skipping is a tool used to
    control the average number of bits spent to meet the target bit rate. */
    bool                iNoFrameSkip;


    /** Specify short header mode in MPEG4 */
    bool                                iShortHeader;

    /** Specifies whether data partitioning mode is used or not. Has no meaning if encoding H.263 or short header */
    bool                                iDataPartitioning;


    /** Specifies whether Resync markers are used or not Has no meaning if iDataPartitioning is on */
    bool                                iResyncMarker;


    /** Specifies whether RVLC (reversible VLC) is to be used or not.
    */
    bool                iRVLCEnable;

////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////// H264 specific parameters ///////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////

    /** Specifies the targeted profile, and will also specifies available tools for iEncMode.
    If default is used, encoder will choose its own preferred profile. If autodetect is used, encoder
    will check other settings and choose the right profile that doesn't have any conflicts. */
    EncAVCProfile       iAVCProfile;

    /** Specifies the target level  When present,
    other settings will be checked against the range allowable by this target level.
    Fail will returned upon Initialize call. If not known, users must set it to autodetect. Encoder will
    calculate the right level that doesn't conflict with other settings. */
    EncAVCLevel         iAVCLevel;

    /** Specifies the encoding mode. This translates to the complexity of encoding modes and
    error resilient tools. This is for future use - enc mode will be used to set other parameters to appropriate
    values.
    */

    EncEncodingMode     iEncMode;

    /** Specifies that SPS and PPS are retrieved first and sent out-of-band */
    //bool              iOutOfBandParamSet;


} PV_VideoEncodeParam;


/** Structure for input format information */
typedef struct PV_VideoInputFormat
{
    /** Contains the width in pixels of the input frame. */
    int32           iFrameWidth;

    /** Contains the height in pixels of the input frame. */
    int32           iFrameHeight;

    /** Contains the input frame rate in the unit of frame per second. */
    float           iFrameRate;

    /** Contains Frame Orientation. Used for RGB input. 1 means Bottom_UP RGB, 0 means Top_Down RGB, -1 for video formats other than RGB*/
    int             iFrameOrientation;

    /** Contains the format of the input video, e.g., YUV 4:2:0, UYVY, RGB24, etc. */
    EncVideoInputFormat     iVideoFormat;
} PV_VideoInputFormat;


/** Structure for audio encode information */
typedef struct PV_AudioEncodeParam
{

    // DESCRIPTION: Final sampling frequency used when encoding in Hz.
    //              For example, "44100" Hz.
    // USAGE:       If the input sampling rate is not appropriate (e.g.,
    //              the codec requires a different sampling frequency),
    //              the CAEI will fill this in with the final sampling
    //              rate. The CAEI will perform resampling if the
    //              input sampling frequency is not the same as the output
    //              sampling frequency.
    uint32 iOutputSamplingRate;

    // DESCRIPTION: Number of output channels:1=Mono,2=Stereo. (Mono uses 1
    //              channel; Stereo uses 2 channels).
    // USAGE:       The CAEI will fill this in if it needs to convert
    //              the input samples to what is required by the codec.
    uint8 iOutputNumChannels;

    // DESCRIPTION: Currently, output bitrate is expressed as GSM-AMR type rate
    PVMF_GSMAMR_Rate iAMRBitrate;

    // DESCRIPTION: output bitrate in bits per second for non-AMR codecs
    uint32  iOutputBitrate;

    //
    uint32  iMaxNumOutputFramesPerBuffer;


} PV_AudioEncodeParam;

enum EInterleaveMode
{
    EINTERLEAVE_LR,        // interleaved left-right
    EGROUPED_LR,           // non-interleaved left-right
    ENUM_INTERLEAVE_MODES  // number of modes supported
};

/** Structure for input format information */
typedef struct PV_AudioInputFormat
{


    // DESCRIPTION: Number of bits per sample. For example, set it to "16"
    //              bits for PCM.
    // USAGE:       The authoring application is required to fill this in.
    //
    int32 iInputBitsPerSample;

    // DESCRIPTION: Sampling rate of the input samples in Hz.
    //              For example, set it to "22050" Hz. AMRNB is always 8khz
    // USAGE:       The authoring application is required to fill this in.
    //              If sampling rate is not known until CAEI is initialized,
    //              use '0'.
    uint32 iInputSamplingRate;


    // DESCRIPTION: Number of input channels:1=Mono,2=Stereo.(Mono uses 1 channel;
    //              Stereo uses 2 channels).
    // USAGE:       The authoring application is required to fill this in.
    //
    uint8 iInputNumChannels;

    // DESCRIPTION: Whether to interleave or not the multi-channel input samples:
    //              EINTERLEAVE_LR  = LRLRLRLRLR    (interleaved left-right)
    //              EGROUPED_LR = LLLLLL...RRRRRR   (non-interleaved left-right)
    // USAGE:       The authoring application is required to fill this in.
    //
    EInterleaveMode iInputInterleaveMode;


} PV_AudioInputFormat;


///////////////////////////////////////////////////////////////////////////////////////////////////////
//CAPABILITY AND CONFIG

// Structure to hold the key string info for
// encnode's capability-and-config
struct PVOMXEncNodeKeyStringData
{
    char iString[64];
    PvmiKvpType iType;
    PvmiKvpValueType iValueType;
};

// The number of characters to allocate for the key string
#define PVOMXENCNODECONFIG_KEYSTRING_SIZE 128


// Key string info at the base level ("x-pvmf/encoder/video")
//                                or ("x-pvmf/encoder/audio")

#ifdef _TEST_AE_ERROR_HANDLING
#define PVOMXENCNODECONFIG_BASE_NUMKEYS 8
#else
#define PVOMXENCNODECONFIG_BASE_NUMKEYS 3
#endif

const PVOMXEncNodeKeyStringData PVOMXEncNodeConfigBaseKeys[PVOMXENCNODECONFIG_BASE_NUMKEYS] =
{
    {"sampling_rate", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"channels", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"encoding_mode", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32}
#ifdef _TEST_AE_ERROR_HANDLING
    , {"error_start_init", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_BOOL}
    , {"error-encode", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32}
    , {"error-node-cmd", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32}
    , {"error-config-header", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_BOOL}
    , {"data-path-stall", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32}
#endif
};

enum BaseKeys_IndexMapType
{
    SAMPLING_RATE = 0, // audio
    CHANNELS,           // audio
    ENCODING_MODE       // avc
#ifdef _TEST_AE_ERROR_HANDLING
    , ERROR_START_INIT
    , ERROR_ENCODE
    , ERROR_NODE_CMD
    , ERROR_CONFIG_HEADER
    , ERROR_DATAPATH_STALL
#endif
};

// default encode parameters
#define DEFAULT_BITRATE 32000
#define DEFAULT_FRAME_WIDTH 176
#define DEFAULT_FRAME_HEIGHT 144
#define DEFAULT_FRAME_RATE 5
#define DEFAULT_I_FRAME_INTERVAL 10  // encode one I frame every 10 seconds.
#define DEFAULT_OMX_MP4ENC_QPI 15
#define DEFAULT_OMX_MP4ENC_QPP 12
#define DEFAULT_OMX_MP4ENC_QPB 12

#define DEFAULT_OMX_AVCENC_QPI 25
#define DEFAULT_OMX_AVCENC_QPP 30
#define DEFAULT_OMX_AVCENC_QPB 33

#define PVMF_AVCENC_NODE_SPS_VECTOR_RESERVE 16  // max allowed by standard
#define PVMF_AVCENC_NODE_PPS_VECTOR_RESERVE 256 // max allowed by standard
#define DEFAULT_PARAMS_SET_LENGTH 256

typedef enum
{
    PV_MPEG_VIDEO_SIMPLE_PROFILE = 0,
    PV_MPEG_VIDEO_SIMPLE_SCALABLE_PROFILE,
    PV_MPEG_VIDEO_CORE_PROFILE,
    PV_MPEG_VIDEO_MAIN_PROFILE,
    PV_MPEG_VIDEO_N_BIT_PROFILE,
    PV_MPEG_VIDEO_SCALABLE_TEXTURE_PROFILE,
    PV_MPEG_VIDEO_SIMPLE_FACE_ANIMATION_PROFILE,
    PV_MPEG_VIDEO_SIMPLE_FBA_PROFILE,
    PV_MPEG_VIDEO_BASIC_ANIMATED_TEXTURE_PROFILE,
    PV_MPEG_VIDEO_HYBRID_PROFILE,
    PV_MPEG_VIDEO_ADVANCE_REAL_TIME_SIMPLE_PROFILE,
    PV_MPEG_VIDEO_CORE_SCALABLE_PROFILE,
    PV_MPEG_VIDEO_ADVANCE_CODING_EFFICIENCY_PROFILE,
    PV_MPEG_VIDEO_ADVANCE_CORE_PROFILE,
    PV_MPEG_VIDEO_ADVANCE_SCALABLE_TEXTURE_PROFILE,
    PV_MPEG_VIDEO_SIMPLE_STUDIO_PROFILE,
    PV_MPEG_VIDEO_CORE_STUDIO_PROFILE,
    PV_MPEG_VIDEO_ADVANCE_SIMPLE_PROFILE,
    PV_MPEG_VIDEO_FINE_GRANUALITY_SCALABLE_PROFILE,
    PV_MPEG_VIDEO_RESERVED_PROFILE
} PVMF_MPEGVideoProfileType;

typedef enum
{
    PV_MPEG_VIDEO_LEVEL0 = 0,
    PV_MPEG_VIDEO_LEVEL1,
    PV_MPEG_VIDEO_LEVEL2,
    PV_MPEG_VIDEO_LEVEL3,
    PV_MPEG_VIDEO_LEVEL4,
    PV_MPEG_VIDEO_LEVEL5,
    PV_MPEG_VIDEO_LEVEL_UNKNOWN

} PVMF_MPEGVideoLevelType;

/////////////////////////////////////////////////////////////////////////////////////////


//Mimetypes for the custom interface
#define PVMF_OMX_ENC_NODE_MIMETYPE "pvxxx/OMXEncNode"
#define PVMF_BASEMIMETYPE "pvxxx"

//Command queue type
typedef PVMFNodeCommandQueue<PVMFOMXEncNodeCommand, PVMFOMXEncNodeAllocator> PVMFOMXEncNodeCmdQ;


class PVMFOMXEncNode
        : public OsclActiveObject
        , public PVMFNodeInterface
        , public OsclMemPoolFixedChunkAllocatorObserver
        , public PVMFOMXEncNodeExtensionInterface
        , public PVMFMetadataExtensionInterface
        , public PvmiCapabilityAndConfig
        , public PVMp4H263EncExtensionInterface
        , public PVAudioEncExtensionInterface
{
    public:
        PVMFOMXEncNode(int32 aPriority);
        ~PVMFOMXEncNode();

        // From PVMFNodeInterface
        PVMFStatus ThreadLogon();
        PVMFStatus ThreadLogoff();
        PVMFStatus GetCapability(PVMFNodeCapability& aNodeCapability);
        PVMFPortIter* GetPorts(const PVMFPortFilter* aFilter = NULL);
        PVMFCommandId QueryUUID(PVMFSessionId, const PvmfMimeString& aMimeType,
                                Oscl_Vector<PVUuid, PVMFOMXEncNodeAllocator>& aUuids,
                                bool aExactUuidsOnly = false,
                                const OsclAny* aContext = NULL);
        PVMFCommandId QueryInterface(PVMFSessionId, const PVUuid& aUuid,
                                     PVInterface*& aInterfacePtr,
                                     const OsclAny* aContext = NULL);
        PVMFCommandId RequestPort(PVMFSessionId
                                  , int32 aPortTag, const PvmfMimeString* aPortConfig = NULL, const OsclAny* aContext = NULL);
        PVMFCommandId ReleasePort(PVMFSessionId, PVMFPortInterface& aPort, const OsclAny* aContext = NULL);
        PVMFCommandId Init(PVMFSessionId, const OsclAny* aContext = NULL);
        PVMFCommandId Prepare(PVMFSessionId, const OsclAny* aContext = NULL);
        PVMFCommandId Start(PVMFSessionId, const OsclAny* aContext = NULL);
        PVMFCommandId Stop(PVMFSessionId, const OsclAny* aContext = NULL);
        PVMFCommandId Flush(PVMFSessionId, const OsclAny* aContext = NULL);
        PVMFCommandId Pause(PVMFSessionId, const OsclAny* aContext = NULL);
        PVMFCommandId Reset(PVMFSessionId, const OsclAny* aContext = NULL);
        PVMFCommandId CancelAllCommands(PVMFSessionId, const OsclAny* aContextData = NULL);
        PVMFCommandId CancelCommand(PVMFSessionId, PVMFCommandId aCmdId, const OsclAny* aContextData = NULL);

        // From PVMFPortActivityHandler
        void HandlePortActivity(const PVMFPortActivity& aActivity);

        // From PVInterface
        virtual void addRef();
        virtual void removeRef();
        virtual bool queryInterface(const PVUuid& uuid, PVInterface*& iface);


        //**********begin PVMFMetadataExtensionInterface
        uint32 GetNumMetadataKeys(char* query_key = NULL);
        uint32 GetNumMetadataValues(PVMFMetadataList& aKeyList);
        PVMFCommandId GetNodeMetadataKeys(PVMFSessionId aSessionId, PVMFMetadataList& aKeyList, uint32 starting_index, int32 max_entries,
                                          char* query_key = NULL, const OsclAny* aContextData = NULL);
        PVMFCommandId GetNodeMetadataValues(PVMFSessionId aSessionId, PVMFMetadataList& aKeyList,
                                            Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, uint32 starting_index, int32 max_entries, const OsclAny* aContextData = NULL);
        PVMFStatus ReleaseNodeMetadataKeys(PVMFMetadataList& aKeyList, uint32 starting_index, uint32 end_index);
        PVMFStatus ReleaseNodeMetadataValues(Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, uint32 starting_index, uint32 end_index);
        //**********End PVMFMetadataExtensionInterface

        bool VerifyParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters, int num_elements);

        //********** CB Functions to serve OpenMAX Encoder

        //Process callback functions. They will be executed in testapp thread context
        //  These callbacks are used only in the Multithreaded component case
        OsclReturnCode ProcessCallbackEventHandler_MultiThreaded(OsclAny* P);
        OsclReturnCode ProcessCallbackEmptyBufferDone_MultiThreaded(OsclAny* P);
        OsclReturnCode ProcessCallbackFillBufferDone_MultiThreaded(OsclAny* P);

        //Callback objects - again, these are used only in the case of Multithreaded component
        EventHandlerThreadSafeCallbackAOEnc*     iThreadSafeHandlerEventHandler;
        EmptyBufferDoneThreadSafeCallbackAOEnc* iThreadSafeHandlerEmptyBufferDone;
        FillBufferDoneThreadSafeCallbackAOEnc*  iThreadSafeHandlerFillBufferDone;

        OMX_CALLBACKTYPE       iCallbacks; // structure that contains callback ptrs.
        // OMX CALLBACKS
        // 1) AO OMX component running in the same thread as the OMX node
        //  In this case, the callbacks can be called directly from the component
        //  The callback: OMX Component->CallbackEventHandler->EventHandlerProcessing
        //  The callback can perform do RunIfNotReady

        // 2) Multithreaded component
        //  In this case, the callback is made using the threadsafe callback (TSCB) AO
        //  Component thread : OMX Component->CallbackEventHandler->TSCB(ReceiveEvent)
        //  Node thread      : TSCB(ProcessEvent)->ProcessCallbackEventHandler_MultiThreaded->EventHandlerProcessing


        //==============================================================================

        OMX_ERRORTYPE EventHandlerProcessing(OMX_OUT OMX_HANDLETYPE aComponent,
                                             OMX_OUT OMX_PTR aAppData,
                                             OMX_OUT OMX_EVENTTYPE aEvent,
                                             OMX_OUT OMX_U32 aData1,
                                             OMX_OUT OMX_U32 aData2,
                                             OMX_OUT OMX_PTR aEventData);

        OMX_ERRORTYPE EmptyBufferDoneProcessing(OMX_OUT OMX_HANDLETYPE aComponent,
                                                OMX_OUT OMX_PTR aAppData,
                                                OMX_OUT OMX_BUFFERHEADERTYPE* aBuffer);

        OMX_ERRORTYPE FillBufferDoneProcessing(OMX_OUT OMX_HANDLETYPE aComponent,
                                               OMX_OUT OMX_PTR aAppData,
                                               OMX_OUT OMX_BUFFERHEADERTYPE* aBuffer);


        bool IsComponentMultiThreaded()
        {
            return iIsOMXComponentMultiThreaded;
        };


        // From PvmiCapabilityAndConfig
        void setObserver(PvmiConfigAndCapabilityCmdObserver* aObserver);
        PVMFStatus getParametersSync(PvmiMIOSession aSession, PvmiKeyType aIdentifier, PvmiKvp*& aParameters, int& aNumParamElements, PvmiCapabilityContext aContext);
        PVMFStatus releaseParameters(PvmiMIOSession aSession, PvmiKvp* aParameters, int aNumElements);
        void createContext(PvmiMIOSession aSession, PvmiCapabilityContext& aContext);
        void setContextParameters(PvmiMIOSession aSession, PvmiCapabilityContext& aContext, PvmiKvp* aParameters, int aNumParamElements);
        void DeleteContext(PvmiMIOSession aSession, PvmiCapabilityContext& aContext);
        void setParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters, int aNumElements, PvmiKvp* &aRetKVP);
        PVMFCommandId setParametersAsync(PvmiMIOSession aSession, PvmiKvp* aParameters, int aNumElements, PvmiKvp*& aRetKVP, OsclAny* aContext = NULL);
        uint32 getCapabilityMetric(PvmiMIOSession aSession);
        PVMFStatus verifyParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters, int aNumElements);

        // Virtual functions of PVMp4H263EncExtensionInterface
//  OSCL_IMPORT_REF void addRef();
//  OSCL_IMPORT_REF void removeRef();
//  OSCL_IMPORT_REF bool queryInterface(const PVUuid& uuid, PVInterface*& iface);
        OSCL_IMPORT_REF bool SetNumLayers(uint32 aNumLayers);
        OSCL_IMPORT_REF bool SetOutputBitRate(uint32 aLayer, uint32 aBitRate);
        OSCL_IMPORT_REF bool SetOutputFrameSize(uint32 aLayer, uint32 aWidth, uint32 aHeight);
        OSCL_IMPORT_REF bool SetOutputFrameRate(uint32 aLayer, OsclFloat aFrameRate);
        OSCL_IMPORT_REF bool SetSegmentTargetSize(uint32 aLayer, uint32 aSizeBytes);
        OSCL_IMPORT_REF bool SetRateControlType(uint32 aLayer, PVMFVENRateControlType aRateControl);
        OSCL_IMPORT_REF bool SetDataPartitioning(bool aDataPartitioning);
        OSCL_IMPORT_REF bool SetRVLC(bool aRVLC);
        OSCL_IMPORT_REF bool SetIFrameInterval(uint32 aIFrameInterval);
        OSCL_IMPORT_REF bool GetVolHeader(OsclRefCounterMemFrag& aVolHeader);
        OSCL_IMPORT_REF bool RequestIFrame();
        OSCL_IMPORT_REF bool SetSceneDetection(bool aSCD);
        OSCL_IMPORT_REF bool SetCodec(PVMFFormatType aCodec);


        PVMFStatus SetCodecType(PVMFFormatType aCodec);

        OSCL_IMPORT_REF virtual bool SetFSIParam(uint8* aFSIBuff, int aFSIBuffLength);

        // from AudioEncExtensionInterface
        OSCL_IMPORT_REF PVMFStatus SetOutputBitRate(PVMF_GSMAMR_Rate aBitRate);
        OSCL_IMPORT_REF PVMFStatus SetMaxNumOutputFramesPerBuffer(uint32 aNumOutputFrames);
        OSCL_IMPORT_REF PVMFStatus SetOutputBitRate(uint32 aBitRate);
        OSCL_IMPORT_REF PVMFStatus SetOutputNumChannel(uint32 aNumChannel);
        OSCL_IMPORT_REF PVMFStatus SetOutputSamplingRate(uint32 aSamplingRate);


        PVMFStatus SetInputSamplingRate(uint32 aSamplingRate);
        PVMFStatus SetInputBitsPerSample(uint32 aBitsPerSample);
        PVMFStatus SetInputNumChannels(uint32 aNumChannels);
        uint32 GetOutputBitRate(); // for audio - void
        // encoder input format setting
        /////////////////////////////////////////////////////
        //      Encoder settings routine
        /////////////////////////////////////////////////////
        PVMFStatus SetInputFormat(PVMFFormatType aFormat);
        PVMFStatus SetInputFrameSize(uint32 aWidth, uint32 aHeight, uint8 aFrmOrient = 0);
        PVMFStatus SetInputFrameRate(OsclFloat aFrameRate);


        PVMFFormatType GetCodecType();
        uint32 GetOutputBitRate(uint32 aLayer);
        OsclFloat GetOutputFrameRate(uint32 aLayer);
        PVMFStatus GetOutputFrameSize(uint32 aLayer, uint32& aWidth, uint32& aHeight);
        uint32 GetIFrameInterval();
        uint32 GetOutputSamplingRate();
        uint32 GetOutputNumChannels();

        // Capability exchange
        PVMFNodeCapability iCapability;

    private:
        void CommandComplete(PVMFOMXEncNodeCmdQ& aCmdQ, PVMFOMXEncNodeCommand& aCmd, PVMFStatus aStatus, OsclAny* aEventData = NULL);

        void DoQueryUuid(PVMFOMXEncNodeCommand&);
        void DoQueryInterface(PVMFOMXEncNodeCommand&);
        void DoRequestPort(PVMFOMXEncNodeCommand&);
        void DoReleasePort(PVMFOMXEncNodeCommand&);
        void DoInit(PVMFOMXEncNodeCommand&);
        void DoPrepare(PVMFOMXEncNodeCommand&);
        void DoStart(PVMFOMXEncNodeCommand&);
        void DoStop(PVMFOMXEncNodeCommand&);
        void DoPause(PVMFOMXEncNodeCommand&);
        void DoReset(PVMFOMXEncNodeCommand&);
        void DoFlush(PVMFOMXEncNodeCommand&);
        PVMFStatus DoGetNodeMetadataKey(PVMFOMXEncNodeCommand&);
        PVMFStatus DoGetNodeMetadataValue(PVMFOMXEncNodeCommand&);
        void DoCancelAllCommands(PVMFOMXEncNodeCommand&);
        void DoCancelCommand(PVMFOMXEncNodeCommand&);

        void Run();
        bool ProcessCommand(PVMFOMXEncNodeCommand& aCmd);
        bool ProcessIncomingMsg(PVMFPortInterface* aPort);
        bool ProcessOutgoingMsg(PVMFPortInterface* aPort);
        PVMFStatus HandleProcessingState();


        // DV:
        bool NegotiateVideoComponentParameters();
        bool SetMP4EncoderParameters();
        bool SetH263EncoderParameters();
        bool SetH264EncoderParameters();

        bool NegotiateAudioComponentParameters();
        bool SetAMREncoderParameters();
        bool SetAACEncoderParameters();

        bool SetDefaultCapabilityFlags();
        bool CreateOutMemPool(uint32 num);
        bool CreateInputMemPool(uint32 num);
        bool ProvideBuffersToComponent(OsclMemPoolFixedChunkAllocator *aMemPool, // allocator
                                       uint32 aAllocSize,    // size to allocate from pool (hdr only or hdr+ buffer)
                                       uint32 aNumBuffers,    // number of buffers
                                       uint32 aActualBufferSize, // aactual buffer size
                                       uint32 aPortIndex,      // port idx
                                       bool aUseBufferOK,   // can component use OMX_UseBuffer?
                                       bool aIsThisInputBuffer // is this input or output
                                      );

        bool FreeBuffersFromComponent(OsclMemPoolFixedChunkAllocator *aMemPool, // allocator
                                      uint32 aAllocSize,     // size to allocate from pool (hdr only or hdr+ buffer)
                                      uint32 aNumBuffers,    // number of buffers
                                      uint32 aPortIndex,      // port idx
                                      bool  aIsThisInputBuffer      // is this input or output
                                     );

        OsclSharedPtr<class PVMFMediaDataImpl> WrapOutputBuffer(uint8 *pData, uint32 aDataLen, OsclAny *pContext);
        bool QueueOutputBuffer(OsclSharedPtr<PVMFMediaDataImpl> &mediadataimplout, uint32 aDataLen);

        bool SendOutputBufferToOMXComponent();
        bool SendInputBufferToOMXComponent();


        bool SendEOSBufferToOMXComponent();

        bool SendBeginOfMediaStreamCommand(void);
        bool SendEndOfTrackCommand(void);


        bool ReleaseAllPorts();
        bool DeleteOMXEncoder();

        void ChangeNodeState(TPVMFNodeInterfaceState aNewState);

        void HandleComponentStateChange(OMX_U32 encoder_state);

        // Capability And Config Helper Methods
        PVMFStatus DoCapConfigGetParametersSync(PvmiKeyType aIdentifier, PvmiKvp*& aParameters, int& aNumParamElements, PvmiCapabilityContext aContext);
        PVMFStatus DoCapConfigReleaseParameters(PvmiKvp* aParameters, int aNumElements);
        void DoCapConfigSetParameters(PvmiKvp* aParameters, int aNumElements, PvmiKvp* &aRetKVP);
        PVMFStatus DoCapConfigVerifyParameters(PvmiKvp* aParameters, int aNumElements);

        PVMFStatus GetConfigParameter(PvmiKvp*& aParameters, int& aNumParamElements, int32 aIndex, PvmiKvpAttr aReqattr);
        PVMFStatus VerifyAndSetConfigParameter(PvmiKvp& aParameter, bool aSetParam);

        PVMFStatus GetProfileAndLevel(PVMF_MPEGVideoProfileType& aProfile, PVMF_MPEGVideoLevelType& aLevel);


        void freechunkavailable(OsclAny*);

        PVMFCommandId QueueCommandL(PVMFOMXEncNodeCommand& aCmd);


        int32 PushBackKeyVal(Oscl_Vector<PvmiKvp, OsclMemAllocator>*&, PvmiKvp&);
        int32 Push_Back_MetadataKeys(const char*);
        int32 Push_Back_MetadataKeys(PVMFMetadataList*&, uint32);
        int32 CreateNewArray(char*&, int32);
        int32 MemAllocate(OsclAny*& , OsclMemPoolFixedChunkAllocator*, uint32);

        bool ParseFullAVCFramesIntoNALs(OMX_BUFFERHEADERTYPE* aOutputBuffer);
        bool AVCAnnexBGetNALUnit(uint8 *bitstream, uint8 **nal_unit, int32 *size, bool getPtrOnly);
        bool CheckM4vVopStartCode(uint8* data, int* len);

        friend class PVMFOMXEncPort;

        // Ports pointers
        PVMFPortInterface* iInPort;
        PVMFPortInterface* iOutPort;

        // Commands
        PVMFOMXEncNodeCmdQ iInputCommands;
        PVMFOMXEncNodeCmdQ iCurrentCommand;

        // Shared pointer for Media Msg.Input buffer
        PVMFSharedMediaDataPtr iDataIn;


        // OUTPUT BUFFER RELATED MEMBERS


        // Output buffer memory pool
        OsclMemPoolFixedChunkAllocator *iOutBufMemoryPool;

        // Memory pool for simple media data
        OsclMemPoolFixedChunkAllocator *iMediaDataMemPool;

        // Size of output buffer (negotiated with component)
        uint32 iOMXComponentOutputBufferSize;

        // size of output to allocate (OMX_ALLOCATE_BUFFER =  size of buf header )
        // (OMX_USE_BUFFER = size of buf header + iOMXCoponentOutputBufferSize)
        uint32 iOutputAllocSize;

        // Number of output buffers (negotiated with component)
        uint32 iNumOutputBuffers;

        // Number of output buffers in possession of the component or downstream,
        // namely, number of unavailable buffers
        uint32 iNumOutstandingOutputBuffers;

        // flag to prevent sending output buffers downstream during flushing etc.
        bool iDoNotSendOutputBuffersDownstreamFlag;

        // flag to prevent freeing the buffers twice
        bool iOutputBuffersFreed;


        // INPUT BUFFER RELATED MEMBERS
        OsclMemPoolFixedChunkAllocator *iInBufMemoryPool;
        uint32 iOMXComponentInputBufferSize; // size of input buffer that the component sees (negotiated with the component)
        uint32 iInputAllocSize;     // size of input buffer to allocate (OMX_ALLOCATE_BUFFER =  size of buf header )
        // (OMX_USE_BUFFER = size of buf header + iOMXCoponentInputBufferSize)
        uint32 iNumInputBuffers; // total num of input buffers (negotiated with component)

        uint32 iNumOutstandingInputBuffers; // number of input buffers in use (i.e. unavailable)

        bool iDoNotSaveInputBuffersFlag;

        // flag to prevent freeing buffers twice
        bool iInputBuffersFreed;

        // input buffer fragmentation etc.
        uint32 iCopyPosition;               // for copying memfrag data into a buffer
        uint32 iFragmentSizeRemainingToCopy;
        bool    iIsNewDataFragment;

        // input data info
        uint32 iCurrFragNum;
        uint32 iCodecSeqNum;    // sequence number tracking
        uint32 iInPacketSeqNum;

        uint32 iInTimestamp;
        uint32 iInDuration;
        uint32 iInNumFrags;
        uint32 iCurrentMsgMarkerBit;

        // DYNAMIC PORT RE-CONFIGURATION
        uint32 iInputPortIndex;
        uint32 iOutputPortIndex;
        OMX_PARAM_PORTDEFINITIONTYPE iParamPort;
        uint32 iPortIndexForDynamicReconfig;
        bool iSecondPortReportedChange;
        bool iDynamicReconfigInProgress;
        uint32 iSecondPortToReconfig;


        OMX_BUFFERHEADERTYPE *iInputBufferToResendToComponent; // ptr to input buffer that is not empty, but that the OMX component returned
        // we need to resend this same buffer back to the component


        ////////////////// OMX COMPONENT CAPABILITY RELATED MEMBERS
        bool iOMXComponentSupportsExternalOutputBufferAlloc;
        bool iOMXComponentSupportsExternalInputBufferAlloc;
        bool iOMXComponentSupportsMovableInputBuffers;
        bool iOMXComponentUsesNALStartCodes;
        bool iOMXComponentSupportsPartialFrames;
        bool iOMXComponentCanHandleIncompleteFrames;
        bool iOMXComponentUsesFullAVCFrames;

        bool iSetMarkerBitForEveryFrag;
        bool iIsOMXComponentMultiThreaded;

        // State definitions for HandleProcessingState() state machine
        typedef enum
        {
            EPVMFOMXEncNodeProcessingState_Idle,                  //default state after constraction/reset
            EPVMFOMXEncNodeProcessingState_ReadyToEncode,         //nornal operation state of the encoder
            EPVMFOMXEncNodeProcessingState_WaitForOutputBuffer,   //wait state for avalible media output buffer
            EPVMFOMXEncNodeProcessingState_WaitForOutputPort,     //wait state, output port is busy
            EPVMFOMXEncNodeProcessingState_WaitForOutgoingQueue,   //wait state, outgoing queue
            EPVMFOMXEncNodeProcessingState_PortReconfig,            // Dynamic Port Reconfiguration - step 1
            EPVMFOMXEncNodeProcessingState_WaitForBufferReturn,     //  step 2
            EPVMFOMXEncNodeProcessingState_WaitForPortDisable,      // Dynamic Port Reconfiguration - step 3
            EPVMFOMXEncNodeProcessingState_PortReEnable,            // Dynamic Port Reconfiguration - step 4
            EPVMFOMXEncNodeProcessingState_WaitForPortEnable,       // step 5
            EPVMFOMXEncNodeProcessingState_Stopping             // when STOP command is issued, the node has to wait for component to transition into
            // idle state. The buffers keep coming back , the node is rescheduled
            // to run. Prevent the node from sending buffers back
        } PVMFOMXEncNode_ProcessingState;

        // State of HandleProcessingState() state machine
        PVMFOMXEncNode_ProcessingState iProcessingState;

        // Handle of OMX Component
        OMX_HANDLETYPE iOMXEncoder;

        // Current State of the component
        OMX_STATETYPE iCurrentEncoderState;

        // BOS
        bool iSendBOS;
        uint32 iStreamID;
        uint32 iBOSTimestamp;

        //EOS control flags
        bool iIsEOSSentToComponent;
        bool iIsEOSReceivedFromComponent;

        // Send Fsi configuration flag
        bool    sendYuvFsi;

        // Width of encoded frame
        int32 iYUVWidth;
        // Height of encoded frame
        int32 iYUVHeight;


        // Pointer to input data fragment
        uint8* iBitstreamBuffer;
        // Size of input data fragment
        int32 iBitstreamSize;

        // Output frame sequence counter
        uint32 iSeqNum;

        // Input frame sequence counter
        uint32 iSeqNum_In;

        // Added to Scheduler Flag
        bool iIsAdded;

        // Log related
        PVLogger* iLogger;
        PVLogger* iDataPathLogger;
        PVLogger* iClockLogger;
        PVLogger *iRunlLogger;
        const char *iNodeTypeId;

        // Counter of fragment read from current Media Msg.Input buffer
        uint fragnum;
        // Number of fragments in the Media Msg.Input buffer
        uint numfrags;


        // Node configuration update
        //PVMFOMXEncNodeConfig iNodeConfig;

        // Reference counter for extension
        uint32 iExtensionRefCount;

        // Vector for KVP
        Oscl_Vector<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> iAvailableMetadataKeys;

        // EOS flag
        bool iEndOfDataReached;
        // Time stame upon EOS
        PVMFTimestamp iEndOfDataTimestamp;

        /* Diagnostic log related */
        PVLogger* iDiagnosticsLogger;
        bool iDiagnosticsLogged;
        void LogDiagnostics();

        uint32 iFrameCounter;

        bool CheckComponentForMultRoles(OMX_STRING aCompName, OMX_STRING aRole);
        bool CheckComponentCapabilities(PVMFFormatType* aOutFormat);

        uint32 iAvgBitrateValue;
        bool iResetInProgress;
        bool iResetMsgSent;
        bool iStopInResetMsgSent;

        PV_VideoEncodeParam iVideoEncodeParam;
        PV_VideoInputFormat iVideoInputFormat;
        PV_AudioEncodeParam iAudioEncodeParam;
        PV_AudioInputFormat iAudioInputFormat;

        PVMFFormatType iInFormat;
        PVMFFormatType iOutFormat;

        PVMFOMXEncNodeAllocDestructDealloc iAlloc;
        OsclRefCounterMemFrag iVolHeader; /** Vol header */
        OsclRefCounterMemFrag iConfigHeader;

        OsclRefCounterMemFrag iParamSet; /* place holder for sps,pps values */
        OsclMemoryFragment iSPSs[PVMF_AVCENC_NODE_SPS_VECTOR_RESERVE]; // just ptrs
        OsclMemoryFragment iPPSs[PVMF_AVCENC_NODE_PPS_VECTOR_RESERVE]; // just ptrs
        int   iNumSPSs;
        int   iNumPPSs;
        bool iSpsPpsSequenceOver;
        OsclSharedPtr<PVMFMediaDataImpl> iPreviousMediaData;
        bool iFirstNAL;
        uint32* iNALSizeArray;
        uint8** iNALPtrArray;
        uint32 iNALSizeArrayMaxElems;
        uint32 iNumNALs;
        uint32 iFirstNALStartCodeSize;

        uint32 iEndOfFrameFlagPrevious;
        uint32 iKeyFrameFlagPrevious;
        uint32 iEndOfNALFlagPrevious;
        OMX_TICKS iTimeStampPrevious;
        uint32 iBufferLenPrevious;

        uint32 iEndOfFrameFlagOut;
        uint32 iKeyFrameFlagOut;
        uint32 iEndOfNALFlagOut;
        OMX_TICKS iTimeStampOut;
        uint32 iBufferLenOut;
        OsclAny **out_ctrl_struct_ptr ;
        OsclAny **out_buff_hdr_ptr ;
        OsclAny **in_ctrl_struct_ptr ;
        OsclAny **in_buff_hdr_ptr ;
        // timescale, timestamp conversions
        uint32 iTimeScale;
        uint32 iInTimeScale;
        uint32 iOutTimeScale;

        MediaClockConverter iInputTimestampClock;
        OMX_TICKS iOMXTicksTimestamp;
        OMX_TICKS ConvertTimestampIntoOMXTicks(const MediaClockConverter &src);
        uint32 ConvertOMXTicksIntoTimestamp(const OMX_TICKS &src);

        PVInterface* ipExternalInputBufferAllocatorInterface;
        PVMFFixedSizeBufferAlloc* ipFixedSizeBufferAlloc;

#ifdef _TEST_AE_ERROR_HANDLING
        bool   iErrorHandlingInit;
        uint32 iErrorHandlingEncodeCount;
        int    iCountFrames;
        uint32 iErrorNodeCmd;
        bool iErrorConfigHeader;
        uint32 iErrorEncodeFlag;
        uint32 iErrorDataPathStall;
#endif
};


#endif // PVMF_OMXENC_NODE_H_INCLUDED