xref: /frameworks/av/media/libstagefright/codecs/on2/h264dec/omxdl/arm11/vc/api/omxVC.h

/**
 * File: omxVC.h
 * Brief: OpenMAX DL v1.0.2 - Video Coding library
 *
 * Copyright  2005-2008 The Khronos Group Inc. All Rights Reserved.
 *
 * These materials are protected by copyright laws and contain material
 * proprietary to the Khronos Group, Inc.  You may use these materials
 * for implementing Khronos specifications, without altering or removing
 * any trademark, copyright or other notice from the specification.
 *
 * Khronos Group makes no, and expressly disclaims any, representations
 * or warranties, express or implied, regarding these materials, including,
 * without limitation, any implied warranties of merchantability or fitness
 * for a particular purpose or non-infringement of any intellectual property.
 * Khronos Group makes no, and expressly disclaims any, warranties, express
 * or implied, regarding the correctness, accuracy, completeness, timeliness,
 * and reliability of these materials.
 *
 * Under no circumstances will the Khronos Group, or any of its Promoters,
 * Contributors or Members or their respective partners, officers, directors,
 * employees, agents or representatives be liable for any damages, whether
 * direct, indirect, special or consequential damages for lost revenues,
 * lost profits, or otherwise, arising from or in connection with these
 * materials.
 *
 * Khronos and OpenMAX are trademarks of the Khronos Group Inc.
 *
 */

/* *****************************************************************************************/

#ifndef _OMXVC_H_
#define _OMXVC_H_

#include "omxtypes.h"

#ifdef __cplusplus
extern "C" {
#endif


/* 6.1.1.1 Motion Vectors  */
/* In omxVC, motion vectors are represented as follows:  */

typedef struct {
    OMX_S16 dx;
    OMX_S16 dy;
} OMXVCMotionVector;



/**
 * Function:  omxVCCOMM_Average_8x   (6.1.3.1.1)
 *
 * Description:
 * This function calculates the average of two 8x4, 8x8, or 8x16 blocks.  The
 * result is rounded according to (a+b+1)/2.  The block average function can
 * be used in conjunction with half-pixel interpolation to obtain quarter
 * pixel motion estimates, as described in [ISO14496-10], subclause 8.4.2.2.1.
 *
 * Input Arguments:
 *
 *   pPred0     - Pointer to the top-left corner of reference block 0
 *   pPred1     - Pointer to the top-left corner of reference block 1
 *   iPredStep0 - Step of reference block 0
 *   iPredStep1 - Step of reference block 1
 *   iDstStep   - Step of the destination buffer.
 *   iHeight    - Height of the blocks
 *
 * Output Arguments:
 *
 *   pDstPred - Pointer to the destination buffer. 8-byte aligned.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned under any of the following
 *              conditions:
 *    -   one or more of the following pointers is NULL: pPred0, pPred1, or
 *              pDstPred.
 *    -   pDstPred is not aligned on an 8-byte boundary.
 *    -   iPredStep0 <= 0 or iPredStep0 is not a multiple of 8.
 *    -   iPredStep1 <= 0 or iPredStep1 is not a multiple of 8.
 *    -   iDstStep   <= 0 or iDstStep is not a multiple of 8.
 *    -   iHeight is not 4, 8, or 16.
 *
 */
OMXResult omxVCCOMM_Average_8x (
    const OMX_U8 *pPred0,
    const OMX_U8 *pPred1,
    OMX_U32 iPredStep0,
    OMX_U32 iPredStep1,
    OMX_U8 *pDstPred,
    OMX_U32 iDstStep,
    OMX_U32 iHeight
);



/**
 * Function:  omxVCCOMM_Average_16x   (6.1.3.1.2)
 *
 * Description:
 * This function calculates the average of two 16x16 or 16x8 blocks.  The
 * result is rounded according to (a+b+1)/2.  The block average function can
 * be used in conjunction with half-pixel interpolation to obtain quarter
 * pixel motion estimates, as described in [ISO14496-10], subclause 8.4.2.2.1.
 *
 * Input Arguments:
 *
 *   pPred0 - Pointer to the top-left corner of reference block 0
 *   pPred1 - Pointer to the top-left corner of reference block 1
 *   iPredStep0 - Step of reference block 0
 *   iPredStep1 - Step of reference block 1
 *   iDstStep - Step of the destination buffer
 *   iHeight - Height of the blocks
 *
 * Output Arguments:
 *
 *   pDstPred - Pointer to the destination buffer. 16-byte aligned.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned under any of the following
 *              conditions:
 *    -   one or more of the following pointers is NULL: pPred0, pPred1, or
 *              pDstPred.
 *    -   pDstPred is not aligned on a 16-byte boundary.
 *    -   iPredStep0 <= 0 or iPredStep0 is not a multiple of 16.
 *    -   iPredStep1 <= 0 or iPredStep1 is not a multiple of 16.
 *    -   iDstStep <= 0 or iDstStep is not a multiple of 16.
 *    -   iHeight is not 8 or 16.
 *
 */
OMXResult omxVCCOMM_Average_16x (
    const OMX_U8 *pPred0,
    const OMX_U8 *pPred1,
    OMX_U32 iPredStep0,
    OMX_U32 iPredStep1,
    OMX_U8 *pDstPred,
    OMX_U32 iDstStep,
    OMX_U32 iHeight
);



/**
 * Function:  omxVCCOMM_ExpandFrame_I   (6.1.3.2.1)
 *
 * Description:
 * This function expands a reconstructed frame in-place.  The unexpanded
 * source frame should be stored in a plane buffer with sufficient space
 * pre-allocated for edge expansion, and the input frame should be located in
 * the plane buffer center.  This function executes the pixel expansion by
 * replicating source frame edge pixel intensities in the empty pixel
 * locations (expansion region) between the source frame edge and the plane
 * buffer edge.  The width/height of the expansion regions on the
 * horizontal/vertical edges is controlled by the parameter iExpandPels.
 *
 * Input Arguments:
 *
 *   pSrcDstPlane - pointer to the top-left corner of the frame to be
 *            expanded; must be aligned on an 8-byte boundary.
 *   iFrameWidth - frame width; must be a multiple of 8.
 *   iFrameHeight -frame height; must be a multiple of 8.
 *   iExpandPels - number of pixels to be expanded in the horizontal and
 *            vertical directions; must be a multiple of 8.
 *   iPlaneStep - distance, in bytes, between the start of consecutive lines
 *            in the plane buffer; must be larger than or equal to
 *            (iFrameWidth + 2 * iExpandPels).
 *
 * Output Arguments:
 *
 *   pSrcDstPlane -Pointer to the top-left corner of the frame (NOT the
 *            top-left corner of the plane); must be aligned on an 8-byte
 *            boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned under any of the following
 *              conditions:
 *    -    pSrcDstPlane is NULL.
 *    -    pSrcDstPlane is not aligned on an 8-byte boundary.
 *    -    one of the following parameters is either equal to zero or is a
 *              non-multiple of 8: iFrameHeight, iFrameWidth, iPlaneStep, or
 *              iExpandPels.
 *    -    iPlaneStep < (iFrameWidth + 2 * iExpandPels).
 *
 */
OMXResult omxVCCOMM_ExpandFrame_I (
    OMX_U8 *pSrcDstPlane,
    OMX_U32 iFrameWidth,
    OMX_U32 iFrameHeight,
    OMX_U32 iExpandPels,
    OMX_U32 iPlaneStep
);



/**
 * Function:  omxVCCOMM_Copy8x8   (6.1.3.3.1)
 *
 * Description:
 * Copies the reference 8x8 block to the current block.
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the reference block in the source frame; must be
 *            aligned on an 8-byte boundary.
 *   step - distance between the starts of consecutive lines in the reference
 *            frame, in bytes; must be a multiple of 8 and must be larger than
 *            or equal to 8.
 *
 * Output Arguments:
 *
 *   pDst - pointer to the destination block; must be aligned on an 8-byte
 *            boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned under any of the following
 *              conditions:
 *    -   one or more of the following pointers is NULL: pSrc, pDst
 *    -   one or more of the following pointers is not aligned on an 8-byte
 *              boundary: pSrc, pDst
 *    -    step <8 or step is not a multiple of 8.
 *
 */
OMXResult omxVCCOMM_Copy8x8 (
    const OMX_U8 *pSrc,
    OMX_U8 *pDst,
    OMX_INT step
);



/**
 * Function:  omxVCCOMM_Copy16x16   (6.1.3.3.2)
 *
 * Description:
 * Copies the reference 16x16 macroblock to the current macroblock.
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the reference macroblock in the source frame; must be
 *            aligned on a 16-byte boundary.
 *   step - distance between the starts of consecutive lines in the reference
 *            frame, in bytes; must be a multiple of 16 and must be larger
 *            than or equal to 16.
 *
 * Output Arguments:
 *
 *   pDst - pointer to the destination macroblock; must be aligned on a
 *            16-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned under any of the following
 *              conditions:
 *    -   one or more of the following pointers is NULL: pSrc, pDst
 *    -   one or more of the following pointers is not aligned on a 16-byte
 *              boundary: pSrc, pDst
 *    -    step <16 or step is not a multiple of 16.
 *
 */
OMXResult omxVCCOMM_Copy16x16 (
    const OMX_U8 *pSrc,
    OMX_U8 *pDst,
    OMX_INT step
);



/**
 * Function:  omxVCCOMM_ComputeTextureErrorBlock_SAD   (6.1.4.1.1)
 *
 * Description:
 * Computes texture error of the block; also returns SAD.
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the source plane; must be aligned on an 8-byte
 *            boundary.
 *   srcStep - step of the source plane
 *   pSrcRef - pointer to the reference buffer, an 8x8 block; must be aligned
 *            on an 8-byte boundary.
 *
 * Output Arguments:
 *
 *   pDst - pointer to the destination buffer, an 8x8 block; must be aligned
 *            on an 8-byte boundary.
 *   pDstSAD - pointer to the Sum of Absolute Differences (SAD) value
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments
 *    -    At least one of the following
 *         pointers is NULL: pSrc, pSrcRef, pDst and pDstSAD.
 *    -    pSrc is not 8-byte aligned.
 *    -    SrcStep <= 0 or srcStep is not a multiple of 8.
 *    -    pSrcRef is not 8-byte aligned.
 *    -    pDst is not 8-byte aligned.
 *
 */
OMXResult omxVCCOMM_ComputeTextureErrorBlock_SAD (
    const OMX_U8 *pSrc,
    OMX_INT srcStep,
    const OMX_U8 *pSrcRef,
    OMX_S16 *pDst,
    OMX_INT *pDstSAD
);



/**
 * Function:  omxVCCOMM_ComputeTextureErrorBlock   (6.1.4.1.2)
 *
 * Description:
 * Computes the texture error of the block.
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the source plane. This should be aligned on an 8-byte
 *            boundary.
 *   srcStep - step of the source plane
 *   pSrcRef - pointer to the reference buffer, an 8x8 block. This should be
 *            aligned on an 8-byte boundary.
 *
 * Output Arguments:
 *
 *   pDst - pointer to the destination buffer, an 8x8 block. This should be
 *            aligned on an 8-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments:
 *    -    At least one of the following pointers is NULL:
 *         pSrc, pSrcRef, pDst.
 *    -    pSrc is not 8-byte aligned.
 *    -    SrcStep <= 0 or srcStep is not a multiple of 8.
 *    -    pSrcRef is not 8-byte aligned.
 *    -    pDst is not 8-byte aligned
 *
 */
OMXResult omxVCCOMM_ComputeTextureErrorBlock (
    const OMX_U8 *pSrc,
    OMX_INT srcStep,
    const OMX_U8 *pSrcRef,
    OMX_S16 *pDst
);



/**
 * Function:  omxVCCOMM_LimitMVToRect   (6.1.4.1.3)
 *
 * Description:
 * Limits the motion vector associated with the current block/macroblock to
 * prevent the motion compensated block/macroblock from moving outside a
 * bounding rectangle as shown in Figure 6-1.
 *
 * Input Arguments:
 *
 *   pSrcMV - pointer to the motion vector associated with the current block
 *            or macroblock
 *   pRectVOPRef - pointer to the bounding rectangle
 *   Xcoord, Ycoord  - coordinates of the current block or macroblock
 *   size - size of the current block or macroblock; must be equal to 8 or
 *            16.
 *
 * Output Arguments:
 *
 *   pDstMV - pointer to the limited motion vector
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments.  Returned if one or more of the
 *              following conditions is true:
 *    -    at least one of the following pointers is NULL:
 *         pSrcMV, pDstMV, or pRectVOPRef.
 *    -    size is not equal to either 8 or 16.
 *    -    the width or height of the bounding rectangle is less than
 *         twice the block size.
 */
OMXResult omxVCCOMM_LimitMVToRect (
    const OMXVCMotionVector *pSrcMV,
    OMXVCMotionVector *pDstMV,
    const OMXRect *pRectVOPRef,
    OMX_INT Xcoord,
    OMX_INT Ycoord,
    OMX_INT size
);



/**
 * Function:  omxVCCOMM_SAD_16x   (6.1.4.1.4)
 *
 * Description:
 * This function calculates the SAD for 16x16 and 16x8 blocks.
 *
 * Input Arguments:
 *
 *   pSrcOrg - Pointer to the original block; must be aligned on a 16-byte
 *             boundary.
 *   iStepOrg - Step of the original block buffer
 *   pSrcRef  - Pointer to the reference block
 *   iStepRef - Step of the reference block buffer
 *   iHeight  - Height of the block
 *
 * Output Arguments:
 *
 *   pDstSAD - Pointer of result SAD
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments.  Returned if one or more of the
 *              following conditions is true:
 *    -    at least one of the following pointers is NULL:
 *         pSrcOrg, pDstSAD, or pSrcRef
 *    -    pSrcOrg is not 16-byte aligned.
 *    -    iStepOrg  <= 0 or iStepOrg is not a multiple of 16
 *    -    iStepRef <= 0 or iStepRef is not a multiple of 16
 *    -    iHeight is not 8 or 16
 *
 */
OMXResult omxVCCOMM_SAD_16x (
    const OMX_U8 *pSrcOrg,
    OMX_U32 iStepOrg,
    const OMX_U8 *pSrcRef,
    OMX_U32 iStepRef,
    OMX_S32 *pDstSAD,
    OMX_U32 iHeight
);



/**
 * Function:  omxVCCOMM_SAD_8x   (6.1.4.1.5)
 *
 * Description:
 * This function calculates the SAD for 8x16, 8x8, 8x4 blocks.
 *
 * Input Arguments:
 *
 *   pSrcOrg  - Pointer to the original block; must be aligned on a 8-byte
 *              boundary.
 *   iStepOrg - Step of the original block buffer
 *   pSrcRef  - Pointer to the reference block
 *   iStepRef - Step of the reference block buffer
 *   iHeight  - Height of the block
 *
 * Output Arguments:
 *
 *   pDstSAD -Pointer of result SAD
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments.  Returned if one or more of the
 *              following conditions is true:
 *    -    at least one of the following pointers is NULL:
 *         pSrcOrg, pDstSAD, or pSrcRef
 *    -    pSrcOrg is not 8-byte aligned.
 *    -    iStepOrg  <= 0 or iStepOrg is not a multiple of 8
 *    -    iStepRef <= 0 or iStepRef is not a multiple of 8
 *    -    iHeight is not 4, 8 or 16
 *
 */
OMXResult omxVCCOMM_SAD_8x (
    const OMX_U8 *pSrcOrg,
    OMX_U32 iStepOrg,
    const OMX_U8 *pSrcRef,
    OMX_U32 iStepRef,
    OMX_S32*pDstSAD,
    OMX_U32 iHeight
);



/* 6.2.1.1 Direction  */
/* The direction enumerator is used with functions that perform AC/DC prediction and zig-zag scan.  */

enum {
    OMX_VC_NONE       = 0,
    OMX_VC_HORIZONTAL = 1,
    OMX_VC_VERTICAL   = 2
};



/* 6.2.1.2 Bilinear Interpolation  */
/* The bilinear interpolation enumerator is used with motion estimation, motion compensation, and reconstruction functions.  */

enum {
    OMX_VC_INTEGER_PIXEL = 0, /* case a */
    OMX_VC_HALF_PIXEL_X  = 1, /* case b */
    OMX_VC_HALF_PIXEL_Y  = 2, /* case c */
    OMX_VC_HALF_PIXEL_XY = 3  /* case d */
};



/* 6.2.1.3 Neighboring Macroblock Availability  */
/* Neighboring macroblock availability is indicated using the following flags:   */

enum {
    OMX_VC_UPPER = 1,        /** above macroblock is available */
    OMX_VC_LEFT = 2,         /** left macroblock is available */
    OMX_VC_CENTER = 4,
    OMX_VC_RIGHT = 8,
    OMX_VC_LOWER = 16,
    OMX_VC_UPPER_LEFT = 32,  /** above-left macroblock is available */
    OMX_VC_UPPER_RIGHT = 64, /** above-right macroblock is available */
    OMX_VC_LOWER_LEFT = 128,
    OMX_VC_LOWER_RIGHT = 256
};



/* 6.2.1.4 Video Components  */
/* A data type that enumerates video components is defined as follows:  */

typedef enum {
    OMX_VC_LUMINANCE,    /** Luminance component */
    OMX_VC_CHROMINANCE   /** chrominance component */
} OMXVCM4P2VideoComponent;



/* 6.2.1.5 MacroblockTypes  */
/* A data type that enumerates macroblock types is defined as follows:  */

typedef enum {
    OMX_VC_INTER     = 0, /** P picture or P-VOP */
    OMX_VC_INTER_Q   = 1, /** P picture or P-VOP */
    OMX_VC_INTER4V   = 2, /** P picture or P-VOP */
    OMX_VC_INTRA     = 3, /** I and P picture, I- and P-VOP */
    OMX_VC_INTRA_Q   = 4, /** I and P picture, I- and P-VOP */
    OMX_VC_INTER4V_Q = 5  /** P picture or P-VOP (H.263)*/
} OMXVCM4P2MacroblockType;



/* 6.2.1.6 Coordinates  */
/* Coordinates are represented as follows:  */

typedef struct {
    OMX_INT x;
    OMX_INT y;
} OMXVCM4P2Coordinate;



/* 6.2.1.7 Motion Estimation Algorithms  */
/* A data type that enumerates motion estimation search methods is defined as follows:  */

typedef enum {
    OMX_VC_M4P2_FAST_SEARCH = 0,  /** Fast motion search */
    OMX_VC_M4P2_FULL_SEARCH = 1   /** Full motion search */
} OMXVCM4P2MEMode;



/* 6.2.1.8 Motion Estimation Parameters  */
/* A data structure containing control parameters for
 * motion estimation functions is defined as follows:
 */

typedef struct {
    OMX_INT searchEnable8x8;     /** enables 8x8 search */
    OMX_INT halfPelSearchEnable; /** enables half-pel resolution */
    OMX_INT searchRange;         /** search range */
    OMX_INT rndVal;              /** rounding control; 0-disabled, 1-enabled*/
} OMXVCM4P2MEParams;



/* 6.2.1.9 Macroblock Information   */
/* A data structure containing macroblock parameters for
 * motion estimation functions is defined as follows:
 */

typedef struct {
    OMX_S32 sliceId;                 /* slice number */
    OMXVCM4P2MacroblockType mbType;  /* MB type: OMX_VC_INTRA, OMX_VC_INTER, or OMX_VC_INTER4 */
    OMX_S32 qp;                      /* quantization parameter*/
    OMX_U32 cbpy;                    /* CBP Luma */
    OMX_U32 cbpc;                    /* CBP Chroma */
    OMXVCMotionVector pMV0[2][2];    /* motion vector, represented using 1/2-pel units,
                                      * pMV0[blocky][blockx] (blocky = 0~1, blockx =0~1)
                                      */
    OMXVCMotionVector pMVPred[2][2]; /* motion vector prediction, represented using 1/2-pel units,
                                      * pMVPred[blocky][blockx] (blocky = 0~1, blockx = 0~1)
                                      */
    OMX_U8 pPredDir[2][2];           /* AC prediction direction:
                                      *   OMX_VC_NONE, OMX_VC_VERTICAL, OMX_VC_HORIZONTAL
                                      */
} OMXVCM4P2MBInfo, *OMXVCM4P2MBInfoPtr;



/**
 * Function:  omxVCM4P2_FindMVpred   (6.2.3.1.1)
 *
 * Description:
 * Predicts a motion vector for the current block using the procedure
 * specified in [ISO14496-2], subclause 7.6.5.  The resulting predicted MV is
 * returned in pDstMVPred. If the parameter pDstMVPredME if is not NULL then
 * the set of three MV candidates used for prediction is also returned,
 * otherwise pDstMVPredMEis NULL upon return.
 *
 * Input Arguments:
 *
 *   pSrcMVCurMB - pointer to the MV buffer associated with the current Y
 *            macroblock; a value of NULL indicates unavailability.
 *   pSrcCandMV1 - pointer to the MV buffer containing the 4 MVs associated
 *            with the MB located to the left of the current MB; set to NULL
 *            if there is no MB to the left.
 *   pSrcCandMV2 - pointer to the MV buffer containing the 4 MVs associated
 *            with the MB located above the current MB; set to NULL if there
 *            is no MB located above the current MB.
 *   pSrcCandMV3 - pointer to the MV buffer containing the 4 MVs associated
 *            with the MB located to the right and above the current MB; set
 *            to NULL if there is no MB located to the above-right.
 *   iBlk - the index of block in the current macroblock
 *   pDstMVPredME - MV candidate return buffer;  if set to NULL then
 *            prediction candidate MVs are not returned and pDstMVPredME will
 *            be NULL upon function return; if pDstMVPredME is non-NULL then it
 *            must point to a buffer containing sufficient space for three
 *            return MVs.
 *
 * Output Arguments:
 *
 *   pDstMVPred - pointer to the predicted motion vector
 *   pDstMVPredME - if non-NULL upon input then pDstMVPredME  points upon
 *            return to a buffer containing the three motion vector candidates
 *            used for prediction as specified in [ISO14496-2], subclause
 *            7.6.5, otherwise if NULL upon input then pDstMVPredME is NULL
 *            upon output.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned under any of the following
 *              conditions:
 *    -    the pointer pDstMVPred is NULL
 *    -    the parameter iBlk does not fall into the range 0 <= iBlk<=3
 *
 */
OMXResult omxVCM4P2_FindMVpred (
    const OMXVCMotionVector *pSrcMVCurMB,
    const OMXVCMotionVector *pSrcCandMV1,
    const OMXVCMotionVector *pSrcCandMV2,
    const OMXVCMotionVector *pSrcCandMV3,
    OMXVCMotionVector *pDstMVPred,
    OMXVCMotionVector *pDstMVPredME,
    OMX_INT iBlk
);



/**
 * Function:  omxVCM4P2_IDCT8x8blk   (6.2.3.2.1)
 *
 * Description:
 * Computes a 2D inverse DCT for a single 8x8 block, as defined in
 * [ISO14496-2].
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the start of the linearly arranged IDCT input buffer;
 *            must be aligned on a 16-byte boundary.  According to
 *            [ISO14496-2], the input coefficient values should lie within the
 *            range [-2048, 2047].
 *
 * Output Arguments:
 *
 *   pDst - pointer to the start of the linearly arranged IDCT output buffer;
 *            must be aligned on a 16-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments:
 *    -    pSrc or pDst is NULL.
 *    -    pSrc or pDst is not 16-byte aligned.
 *
 */
OMXResult omxVCM4P2_IDCT8x8blk (
    const OMX_S16 *pSrc,
    OMX_S16 *pDst
);



/**
 * Function:  omxVCM4P2_MEGetBufSize   (6.2.4.1.1)
 *
 * Description:
 * Computes the size, in bytes, of the vendor-specific specification
 * structure for the following motion estimation functions:
 * BlockMatch_Integer_8x8, BlockMatch_Integer_16x16, and MotionEstimationMB.
 *
 * Input Arguments:
 *
 *   MEmode - motion estimation mode; available modes are defined by the
 *            enumerated type OMXVCM4P2MEMode
 *   pMEParams - motion estimation parameters
 *
 * Output Arguments:
 *
 *   pSize - pointer to the number of bytes required for the specification
 *            structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - one or more of the following is true:
 *    -    an invalid value was specified for the parameter MEmode
 *    -    a negative or zero value was specified for the
 *         parameter pMEParams->searchRange
 *
 */
OMXResult omxVCM4P2_MEGetBufSize (
    OMXVCM4P2MEMode MEmode,
    const OMXVCM4P2MEParams *pMEParams,
    OMX_U32 *pSize
);



/**
 * Function:  omxVCM4P2_MEInit   (6.2.4.1.2)
 *
 * Description:
 * Initializes the vendor-specific specification structure required for the
 * following motion estimation functions:  BlockMatch_Integer_8x8,
 * BlockMatch_Integer_16x16, and MotionEstimationMB. Memory for the
 * specification structure *pMESpec must be allocated prior to calling the
 * function, and should be aligned on a 4-byte boundary.  Following
 * initialization by this function, the vendor-specific structure *pMESpec
 * should contain an implementation-specific representation of all motion
 * estimation parameters received via the structure pMEParams, for example
 * rndVal, searchRange, etc.  The number of bytes required for the
 * specification structure can be determined using the function
 * omxVCM4P2_MEGetBufSize.
 *
 * Input Arguments:
 *
 *   MEmode - motion estimation mode; available modes are defined by the
 *            enumerated type OMXVCM4P2MEMode
 *   pMEParams - motion estimation parameters
 *   pMESpec - pointer to the uninitialized ME specification structure
 *
 * Output Arguments:
 *
 *   pMESpec - pointer to the initialized ME specification structure
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - one or more of the following is true:
 *    -    an invalid value was specified for the parameter MEmode
 *    -    a negative or zero value was specified for the
 *         parameter pMEParams->searchRange
 *
 */
OMXResult omxVCM4P2_MEInit (
    OMXVCM4P2MEMode MEmode,
    const OMXVCM4P2MEParams*pMEParams,
    void *pMESpec
);



/**
 * Function:  omxVCM4P2_BlockMatch_Integer_16x16   (6.2.4.2.1)
 *
 * Description:
 * Performs a 16x16 block search; estimates motion vector and associated
 * minimum SAD. Both the input and output motion vectors are represented using
 * half-pixel units, and therefore a shift left or right by 1 bit may be
 * required, respectively, to match the input or output MVs with other
 * functions that either generate output MVs or expect input MVs represented
 * using integer pixel units.
 *
 * Input Arguments:
 *
 *   pSrcRefBuf - pointer to the reference Y plane; points to the reference
 *            MB that corresponds to the location of the current macroblock in
 *            the current plane.
 *   refWidth - width of the reference plane
 *   pRefRect - pointer to the valid reference plane rectangle; coordinates
 *            are specified relative to the image origin.  Rectangle
 *            boundaries may extend beyond image boundaries if the image has
 *            been padded.  For example, if padding extends 4 pixels beyond
 *            frame border, then the value for the left border could be set to
 *            -4.
 *   pSrcCurrBuf - pointer to the current block in the current macroblock
 *            buffer extracted from the original plane (linear array, 256
 *            entries); must be aligned on a 16-byte boundary.  The number of
 *            bytes between lines (step) is 16.
 *   pCurrPointPos - position of the current macroblock in the current plane
 *   pSrcPreMV - pointer to predicted motion vector; NULL indicates no
 *            predicted MV
 *   pSrcPreSAD - pointer to SAD associated with the predicted MV (referenced
 *            by pSrcPreMV); may be set to NULL if unavailable.
 *   pMESpec - vendor-specific motion estimation specification structure;
 *            must have been allocated and then initialized using
 *            omxVCM4P2_MEInit prior to calling the block matching function.
 *
 * Output Arguments:
 *
 *   pDstMV - pointer to estimated MV
 *   pDstSAD - pointer to minimum SAD
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments.  Returned if one of the following
 *              conditions is true:
 *    -    at least one of the following pointers is NULL: pSrcRefBuf,
 *              pRefRect, pSrcCurrBuff, pCurrPointPos, pDstMV, pDstSAD or
 *              pMESpec, or
 *    -    pSrcCurrBuf is not 16-byte aligned
 *
 */
OMXResult omxVCM4P2_BlockMatch_Integer_16x16 (
    const OMX_U8 *pSrcRefBuf,
    OMX_INT refWidth,
    const OMXRect *pRefRect,
    const OMX_U8 *pSrcCurrBuf,
    const OMXVCM4P2Coordinate *pCurrPointPos,
    const OMXVCMotionVector*pSrcPreMV,
    const OMX_INT *pSrcPreSAD,
    void *pMESpec,
    OMXVCMotionVector*pDstMV,
    OMX_INT *pDstSAD
);



/**
 * Function:  omxVCM4P2_BlockMatch_Integer_8x8   (6.2.4.2.2)
 *
 * Description:
 * Performs an 8x8 block search; estimates motion vector and associated
 * minimum SAD.  Both the input and output motion vectors are represented
 * using half-pixel units, and therefore a shift left or right by 1 bit may be
 * required, respectively, to match the input or output MVs with other
 * functions that either generate output MVs or expect input MVs represented
 * using integer pixel units.
 *
 * Input Arguments:
 *
 *   pSrcRefBuf - pointer to the reference Y plane; points to the reference
 *            block that corresponds to the location of the current 8x8 block
 *            in the current plane.
 *   refWidth - width of the reference plane
 *   pRefRect - pointer to the valid reference plane rectangle; coordinates
 *            are specified relative to the image origin.  Rectangle
 *            boundaries may extend beyond image boundaries if the image has
 *            been padded.
 *   pSrcCurrBuf - pointer to the current block in the current macroblock
 *            buffer extracted from the original plane (linear array, 128
 *            entries); must be aligned on an 8-byte boundary.  The number of
 *            bytes between lines (step) is 16 bytes.
 *   pCurrPointPos - position of the current block in the current plane
 *   pSrcPreMV - pointer to predicted motion vector; NULL indicates no
 *            predicted MV
 *   pSrcPreSAD - pointer to SAD associated with the predicted MV (referenced
 *            by pSrcPreMV); may be set to NULL if unavailable.
 *   pMESpec - vendor-specific motion estimation specification structure;
 *            must have been allocated and then initialized using
 *            omxVCM4P2_MEInit prior to calling the block matching function.
 *
 * Output Arguments:
 *
 *   pDstMV - pointer to estimated MV
 *   pDstSAD - pointer to minimum SAD
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments.  Returned if one of the following
 *              conditions is true:
 *    -    at least one of the following pointers is NULL: pSrcRefBuf,
 *              pRefRect, pSrcCurrBuff, pCurrPointPos, pDstMV, pDstSAD or
 *              pMESpec, or
 *    -    pSrcCurrBuf is not 8-byte aligned
 *
 */
OMXResult omxVCM4P2_BlockMatch_Integer_8x8 (
    const OMX_U8 *pSrcRefBuf,
    OMX_INT refWidth,
    const OMXRect *pRefRect,
    const OMX_U8 *pSrcCurrBuf,
    const OMXVCM4P2Coordinate *pCurrPointPos,
    const OMXVCMotionVector *pSrcPreMV,
    const OMX_INT *pSrcPreSAD,
    void *pMESpec,
    OMXVCMotionVector *pDstMV,
    OMX_INT *pDstSAD
);



/**
 * Function:  omxVCM4P2_BlockMatch_Half_16x16   (6.2.4.2.3)
 *
 * Description:
 * Performs a 16x16 block match with half-pixel resolution.  Returns the
 * estimated motion vector and associated minimum SAD.  This function
 * estimates the half-pixel motion vector by interpolating the integer
 * resolution motion vector referenced by the input parameter pSrcDstMV, i.e.,
 * the initial integer MV is generated externally.  The input parameters
 * pSrcRefBuf and pSearchPointRefPos should be shifted by the winning MV of
 * 16x16 integer search prior to calling BlockMatch_Half_16x16. The function
 * BlockMatch_Integer_16x16 may be used for integer motion estimation.
 *
 * Input Arguments:
 *
 *   pSrcRefBuf - pointer to the reference Y plane; points to the reference
 *            macroblock that corresponds to the location of the current
 *            macroblock in the current plane.
 *   refWidth - width of the reference plane
 *   pRefRect - reference plane valid region rectangle
 *   pSrcCurrBuf - pointer to the current block in the current macroblock
 *            buffer extracted from the original plane (linear array, 256
 *            entries); must be aligned on a 16-byte boundary.  The number of
 *            bytes between lines (step) is 16.
 *   pSearchPointRefPos - position of the starting point for half pixel
 *            search (specified in terms of integer pixel units) in the
 *            reference plane, i.e., the reference position pointed to by the
 *            predicted motion vector.
 *   rndVal - rounding control parameter: 0 - disabled; 1 - enabled.
 *   pSrcDstMV - pointer to the initial MV estimate; typically generated
 *            during a prior 16X16 integer search; specified in terms of
 *            half-pixel units.
 *
 * Output Arguments:
 *
 *   pSrcDstMV - pointer to estimated MV
 *   pDstSAD - pointer to minimum SAD
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments.  Returned if one of the following
 *              conditions is true:
 *    -    at least one of the following pointers is NULL: pSrcRefBuf,
 *         pRefRect, pSrcCurrBuff, pSearchPointRefPos, pSrcDstMV.
 *    -    pSrcCurrBuf is not 16-byte aligned, or
 *
 */
OMXResult omxVCM4P2_BlockMatch_Half_16x16 (
    const OMX_U8 *pSrcRefBuf,
    OMX_INT refWidth,
    const OMXRect *pRefRect,
    const OMX_U8 *pSrcCurrBuf,
    const OMXVCM4P2Coordinate *pSearchPointRefPos,
    OMX_INT rndVal,
    OMXVCMotionVector *pSrcDstMV,
    OMX_INT *pDstSAD
);



/**
 * Function:  omxVCM4P2_BlockMatch_Half_8x8   (6.2.4.2.4)
 *
 * Description:
 * Performs an 8x8 block match with half-pixel resolution. Returns the
 * estimated motion vector and associated minimum SAD.  This function
 * estimates the half-pixel motion vector by interpolating the integer
 * resolution motion vector referenced by the input parameter pSrcDstMV, i.e.,
 * the initial integer MV is generated externally.  The input parameters
 * pSrcRefBuf and pSearchPointRefPos should be shifted by the winning MV of
 * 8x8 integer search prior to calling BlockMatch_Half_8x8. The function
 * BlockMatch_Integer_8x8 may be used for integer motion estimation.
 *
 * Input Arguments:
 *
 *   pSrcRefBuf - pointer to the reference Y plane; points to the reference
 *            block that corresponds to the location of the current 8x8 block
 *            in the current plane.
 *   refWidth - width of the reference plane
 *   pRefRect - reference plane valid region rectangle
 *   pSrcCurrBuf - pointer to the current block in the current macroblock
 *            buffer extracted from the original plane (linear array, 128
 *            entries); must be aligned on a 8-byte boundary.  The number of
 *            bytes between lines (step) is 16.
 *   pSearchPointRefPos - position of the starting point for half pixel
 *            search (specified in terms of integer pixel units) in the
 *            reference plane.
 *   rndVal - rounding control parameter: 0 - disabled; 1 - enabled.
 *   pSrcDstMV - pointer to the initial MV estimate; typically generated
 *            during a prior 8x8 integer search, specified in terms of
 *            half-pixel units.
 *
 * Output Arguments:
 *
 *   pSrcDstMV - pointer to estimated MV
 *   pDstSAD - pointer to minimum SAD
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments.  Returned if one of the following
 *              conditions is true:
 *    -    at least one of the following pointers is NULL:
 *         pSrcRefBuf, pRefRect, pSrcCurrBuff, pSearchPointRefPos, pSrcDstMV
 *    -    pSrcCurrBuf is not 8-byte aligned
 *
 */
OMXResult omxVCM4P2_BlockMatch_Half_8x8 (
    const OMX_U8 *pSrcRefBuf,
    OMX_INT refWidth,
    const OMXRect *pRefRect,
    const OMX_U8 *pSrcCurrBuf,
    const OMXVCM4P2Coordinate *pSearchPointRefPos,
    OMX_INT rndVal,
    OMXVCMotionVector *pSrcDstMV,
    OMX_INT *pDstSAD
);



/**
 * Function:  omxVCM4P2_MotionEstimationMB   (6.2.4.3.1)
 *
 * Description:
 * Performs motion search for a 16x16 macroblock.  Selects best motion search
 * strategy from among inter-1MV, inter-4MV, and intra modes.  Supports
 * integer and half pixel resolution.
 *
 * Input Arguments:
 *
 *   pSrcCurrBuf - pointer to the top-left corner of the current MB in the
 *            original picture plane; must be aligned on a 16-byte boundary.
 *            The function does not expect source data outside the region
 *            bounded by the MB to be available; for example it is not
 *            necessary for the caller to guarantee the availability of
 *            pSrcCurrBuf[-SrcCurrStep], i.e., the row of pixels above the MB
 *            to be processed.
 *   srcCurrStep - width of the original picture plane, in terms of full
 *            pixels; must be a multiple of 16.
 *   pSrcRefBuf - pointer to the reference Y plane; points to the reference
 *            plane location corresponding to the location of the current
 *            macroblock in the current plane; must be aligned on a 16-byte
 *            boundary.
 *   srcRefStep - width of the reference picture plane, in terms of full
 *            pixels; must be a multiple of 16.
 *   pRefRect - reference plane valid region rectangle, specified relative to
 *            the image origin
 *   pCurrPointPos - position of the current macroblock in the current plane
 *   pMESpec - pointer to the vendor-specific motion estimation specification
 *            structure; must be allocated and then initialized using
 *            omxVCM4P2_MEInit prior to calling this function.
 *   pMBInfo - array, of dimension four, containing pointers to information
 *            associated with four nearby MBs:
 *            -   pMBInfo[0] - pointer to left MB information
 *            -   pMBInfo[1] - pointer to top MB information
 *            -   pMBInfo[2] - pointer to top-left MB information
 *            -   pMBInfo[3] - pointer to top-right MB information
 *            Any pointer in the array may be set equal to NULL if the
 *            corresponding MB doesn't exist.  For each MB, the following structure
 *            members are used:
 *            -   mbType - macroblock type, either OMX_VC_INTRA, OMX_VC_INTER, or
 *                OMX_VC_INTER4V
 *            -   pMV0[2][2] - estimated motion vectors; represented
 *                in 1/2 pixel units
 *            -   sliceID - number of the slice to which the MB belongs
 *   pSrcDstMBCurr - pointer to information structure for the current MB.
 *            The following entries should be set prior to calling the
 *            function: sliceID - the number of the slice the to which the
 *            current MB belongs.  The structure elements cbpy and cbpc are
 *            ignored.
 *
 * Output Arguments:
 *
 *   pSrcDstMBCurr - pointer to updated information structure for the current
 *            MB after MB-level motion estimation has been completed.  The
 *            following structure members are updated by the ME function:
 *              -  mbType - macroblock type: OMX_VC_INTRA, OMX_VC_INTER, or
 *                 OMX_VC_INTER4V.
 *              -  pMV0[2][2] - estimated motion vectors; represented in
 *                 terms of 1/2 pel units.
 *              -  pMVPred[2][2] - predicted motion vectors; represented
 *                 in terms of 1/2 pel units.
 *            The structure members cbpy and cbpc are not updated by the function.
 *   pDstSAD - pointer to the minimum SAD for INTER1V, or sum of minimum SADs
 *            for INTER4V
 *   pDstBlockSAD - pointer to an array of SAD values for each of the four
 *            8x8 luma blocks in the MB.  The block SADs are in scan order for
 *            each MB.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments.  Returned if one or more of the
 *              following conditions is true:
 *    -    at least one of the following pointers is NULL: pSrcCurrBuf,
 *              pSrcRefBuf, pRefRect, pCurrPointPos, pMBInter, pMBIntra,
 *              pSrcDstMBCurr, or pDstSAD.
 *
 */
OMXResult omxVCM4P2_MotionEstimationMB (
    const OMX_U8 *pSrcCurrBuf,
    OMX_S32 srcCurrStep,
    const OMX_U8 *pSrcRefBuf,
    OMX_S32 srcRefStep,
    const OMXRect*pRefRect,
    const OMXVCM4P2Coordinate *pCurrPointPos,
    void *pMESpec,
    const OMXVCM4P2MBInfoPtr *pMBInfo,
    OMXVCM4P2MBInfo *pSrcDstMBCurr,
    OMX_U16 *pDstSAD,
    OMX_U16 *pDstBlockSAD
);



/**
 * Function:  omxVCM4P2_DCT8x8blk   (6.2.4.4.1)
 *
 * Description:
 * Computes a 2D forward DCT for a single 8x8 block, as defined in
 * [ISO14496-2].
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the start of the linearly arranged input buffer; must
 *            be aligned on a 16-byte boundary.  Input values (pixel
 *            intensities) are valid in the range [-255,255].
 *
 * Output Arguments:
 *
 *   pDst - pointer to the start of the linearly arranged output buffer; must
 *            be aligned on a 16-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments, returned if:
 *    -    pSrc or pDst is NULL.
 *    -    pSrc or pDst is not 16-byte aligned.
 *
 */
OMXResult omxVCM4P2_DCT8x8blk (
    const OMX_S16 *pSrc,
    OMX_S16 *pDst
);



/**
 * Function:  omxVCM4P2_QuantIntra_I   (6.2.4.4.2)
 *
 * Description:
 * Performs quantization on intra block coefficients. This function supports
 * bits_per_pixel == 8.
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the input intra block coefficients; must be aligned
 *            on a 16-byte boundary.
 *   QP - quantization parameter (quantizer_scale).
 *   blockIndex - block index indicating the component type and position,
 *            valid in the range 0 to 5, as defined in [ISO14496-2], subclause
 *            6.1.3.8.
 *   shortVideoHeader - binary flag indicating presence of
 *            short_video_header; shortVideoHeader==1 selects linear intra DC
 *            mode, and shortVideoHeader==0 selects non linear intra DC mode.
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to the output (quantized) interblock coefficients.
 *            When shortVideoHeader==1, AC coefficients are saturated on the
 *            interval [-127, 127], and DC coefficients are saturated on the
 *            interval [1, 254].  When shortVideoHeader==0, AC coefficients
 *            are saturated on the interval [-2047, 2047].
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments:
 *    -    pSrcDst is NULL.
 *    -    blockIndex < 0 or blockIndex >= 10
 *    -    QP <= 0 or QP >= 32.
 *
 */
OMXResult omxVCM4P2_QuantIntra_I (
    OMX_S16 *pSrcDst,
    OMX_U8 QP,
    OMX_INT blockIndex,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_QuantInter_I   (6.2.4.4.3)
 *
 * Description:
 * Performs quantization on an inter coefficient block; supports
 * bits_per_pixel == 8.
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the input inter block coefficients; must be aligned
 *            on a 16-byte boundary.
 *   QP - quantization parameter (quantizer_scale)
 *   shortVideoHeader - binary flag indicating presence of short_video_header;
 *            shortVideoHeader==1 selects linear intra DC mode, and
 *            shortVideoHeader==0 selects non linear intra DC mode.
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to the output (quantized) interblock coefficients.
 *            When shortVideoHeader==1, AC coefficients are saturated on the
 *            interval [-127, 127], and DC coefficients are saturated on the
 *            interval [1, 254].  When shortVideoHeader==0, AC coefficients
 *            are saturated on the interval [-2047, 2047].
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments:
 *    -    pSrcDst is NULL.
 *    -    QP <= 0 or QP >= 32.
 *
 */
OMXResult omxVCM4P2_QuantInter_I (
    OMX_S16 *pSrcDst,
    OMX_U8 QP,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_TransRecBlockCoef_intra   (6.2.4.4.4)
 *
 * Description:
 * Quantizes the DCT coefficients, implements intra block AC/DC coefficient
 * prediction, and reconstructs the current intra block texture for prediction
 * on the next frame.  Quantized row and column coefficients are returned in
 * the updated coefficient buffers.
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the pixels of current intra block; must be aligned on
 *            an 8-byte boundary.
 *   pPredBufRow - pointer to the coefficient row buffer containing
 *            ((num_mb_per_row * 2 + 1) * 8) elements of type OMX_S16.
 *            Coefficients are organized into blocks of eight as described
 *            below (Internal Prediction Coefficient Update Procedures).  The
 *            DC coefficient is first, and the remaining buffer locations
 *            contain the quantized AC coefficients. Each group of eight row
 *            buffer elements combined with one element eight elements ahead
 *            contains the coefficient predictors of the neighboring block
 *            that is spatially above or to the left of the block currently to
 *            be decoded. A negative-valued DC coefficient indicates that this
 *            neighboring block is not INTRA-coded or out of bounds, and
 *            therefore the AC and DC coefficients are invalid.  Pointer must
 *            be aligned on an 8-byte boundary.
 *   pPredBufCol - pointer to the prediction coefficient column buffer
 *            containing 16 elements of type OMX_S16. Coefficients are
 *            organized as described in section 6.2.2.5.  Pointer must be
 *            aligned on an 8-byte boundary.
 *   pSumErr - pointer to a flag indicating whether or not AC prediction is
 *            required; AC prediction is enabled if *pSumErr >=0, but the
 *            value is not used for coefficient prediction, i.e., the sum of
 *            absolute differences starts from 0 for each call to this
 *            function.  Otherwise AC prediction is disabled if *pSumErr < 0 .
 *   blockIndex - block index indicating the component type and position, as
 *            defined in [ISO14496-2], subclause 6.1.3.8.
 *   curQp - quantization parameter of the macroblock to which the current
 *            block belongs
 *   pQpBuf - pointer to a 2-element quantization parameter buffer; pQpBuf[0]
 *            contains the quantization parameter associated with the 8x8
 *            block left of the current block (QPa), and pQpBuf[1] contains
 *            the quantization parameter associated with the 8x8 block above
 *            the current block (QPc).  In the event that the corresponding
 *            block is outside of the VOP bound, the Qp value will not affect
 *            the intra prediction process, as described in [ISO14496-2],
 *            sub-clause 7.4.3.3,  Adaptive AC Coefficient Prediction.
 *   srcStep - width of the source buffer; must be a multiple of 8.
 *   dstStep - width of the reconstructed destination buffer; must be a
 *            multiple of 16.
 *   shortVideoHeader - binary flag indicating presence of
 *            short_video_header; shortVideoHeader==1 selects linear intra DC
 *            mode, and shortVideoHeader==0 selects non linear intra DC mode.
 *
 * Output Arguments:
 *
 *   pDst - pointer to the quantized DCT coefficient buffer; pDst[0] contains
 *            the predicted DC coefficient; the remaining entries contain the
 *            quantized AC coefficients (without prediction).  The pointer
 *            pDstmust be aligned on a 16-byte boundary.
 *   pRec - pointer to the reconstructed texture; must be aligned on an
 *            8-byte boundary.
 *   pPredBufRow - pointer to the updated coefficient row buffer
 *   pPredBufCol - pointer to the updated coefficient column buffer
 *   pPreACPredict - if prediction is enabled, the parameter points to the
 *            start of the buffer containing the coefficient differences for
 *            VLC encoding. The entry pPreACPredict[0]indicates prediction
 *            direction for the current block and takes one of the following
 *            values: OMX_VC_NONE (prediction disabled), OMX_VC_HORIZONTAL, or
 *            OMX_VC_VERTICAL.  The entries
 *            pPreACPredict[1]-pPreACPredict[7]contain predicted AC
 *            coefficients.  If prediction is disabled (*pSumErr<0) then the
 *            contents of this buffer are undefined upon return from the
 *            function
 *   pSumErr - pointer to the value of the accumulated AC coefficient errors,
 *            i.e., sum of the absolute differences between predicted and
 *            unpredicted AC coefficients
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - Bad arguments:
 *    -    At least one of the following pointers is NULL: pSrc, pDst, pRec,
 *         pCoefBufRow, pCoefBufCol, pQpBuf, pPreACPredict, pSumErr.
 *    -    blockIndex < 0 or blockIndex >= 10;
 *    -    curQP <= 0 or curQP >= 32.
 *    -    srcStep, or dstStep <= 0 or not a multiple of 8.
 *    -    pDst is not 16-byte aligned: .
 *    -    At least one of the following pointers is not 8-byte aligned:
 *         pSrc, pRec.
 *
 *  Note: The coefficient buffers must be updated in accordance with the
 *        update procedures defined in section in 6.2.2.
 *
 */
OMXResult omxVCM4P2_TransRecBlockCoef_intra (
    const OMX_U8 *pSrc,
    OMX_S16 *pDst,
    OMX_U8 *pRec,
    OMX_S16 *pPredBufRow,
    OMX_S16 *pPredBufCol,
    OMX_S16 *pPreACPredict,
    OMX_INT *pSumErr,
    OMX_INT blockIndex,
    OMX_U8 curQp,
    const OMX_U8 *pQpBuf,
    OMX_INT srcStep,
    OMX_INT dstStep,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_TransRecBlockCoef_inter   (6.2.4.4.5)
 *
 * Description:
 * Implements DCT, and quantizes the DCT coefficients of the inter block
 * while reconstructing the texture residual. There is no boundary check for
 * the bit stream buffer.
 *
 * Input Arguments:
 *
 *   pSrc -pointer to the residuals to be encoded; must be aligned on an
 *            16-byte boundary.
 *   QP - quantization parameter.
 *   shortVideoHeader - binary flag indicating presence of short_video_header;
 *                      shortVideoHeader==1 selects linear intra DC mode, and
 *                      shortVideoHeader==0 selects non linear intra DC mode.
 *
 * Output Arguments:
 *
 *   pDst - pointer to the quantized DCT coefficients buffer; must be aligned
 *            on a 16-byte boundary.
 *   pRec - pointer to the reconstructed texture residuals; must be aligned
 *            on a 16-byte boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments:
 *    -    At least one of the following pointers is either NULL or
 *         not 16-byte aligned:
 *            - pSrc
 *            - pDst
 *            - pRec
 *    -    QP <= 0 or QP >= 32.
 *
 */
OMXResult omxVCM4P2_TransRecBlockCoef_inter (
    const OMX_S16 *pSrc,
    OMX_S16 *pDst,
    OMX_S16 *pRec,
    OMX_U8 QP,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_EncodeVLCZigzag_IntraDCVLC   (6.2.4.5.2)
 *
 * Description:
 * Performs zigzag scan and VLC encoding of AC and DC coefficients for one
 * intra block.  Two versions of the function (DCVLC and ACVLC) are provided
 * in order to support the two different methods of processing DC
 * coefficients, as described in [ISO14496-2], subclause 7.4.1.4, "Intra DC
 * Coefficient Decoding for the Case of Switched VLC Encoding".
 *
 * Input Arguments:
 *
 *   ppBitStream - double pointer to the current byte in the bitstream
 *   pBitOffset - pointer to the bit position in the byte pointed by
 *            *ppBitStream. Valid within 0 to 7.
 *   pQDctBlkCoef - pointer to the quantized DCT coefficient
 *   predDir - AC prediction direction, which is used to decide the zigzag
 *            scan pattern; takes one of the following values:
 *            -  OMX_VC_NONE - AC prediction not used.
 *                             Performs classical zigzag scan.
 *            -  OMX_VC_HORIZONTAL - Horizontal prediction.
 *                             Performs alternate-vertical zigzag scan.
 *            -  OMX_VC_VERTICAL - Vertical prediction.
 *                             Performs alternate-horizontal zigzag scan.
 *   pattern - block pattern which is used to decide whether this block is
 *            encoded
 *   shortVideoHeader - binary flag indicating presence of
 *            short_video_header; escape modes 0-3 are used if
 *            shortVideoHeader==0, and escape mode 4 is used when
 *            shortVideoHeader==1.
 *   videoComp - video component type (luminance, chrominance) of the current
 *            block
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after the block is encoded, so
 *            that it points to the current byte in the bit stream buffer.
 *   pBitOffset - *pBitOffset is updated so that it points to the current bit
 *            position in the byte pointed by *ppBitStream.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - Bad arguments:
 *    -    At least one of the following pointers is NULL: ppBitStream,
 *              *ppBitStream, pBitOffset, pQDctBlkCoef.
 *    -   *pBitOffset < 0, or *pBitOffset >7.
 *    -    PredDir is not one of: OMX_VC_NONE, OMX_VC_HORIZONTAL, or
 *         OMX_VC_VERTICAL.
 *    -    VideoComp is not one component of enum OMXVCM4P2VideoComponent.
 *
 */
OMXResult omxVCM4P2_EncodeVLCZigzag_IntraDCVLC (
    OMX_U8 **ppBitStream,
    OMX_INT *pBitOffset,
    const OMX_S16 *pQDctBlkCoef,
    OMX_U8 predDir,
    OMX_U8 pattern,
    OMX_INT shortVideoHeader,
    OMXVCM4P2VideoComponent videoComp
);



/**
 * Function:  omxVCM4P2_EncodeVLCZigzag_IntraACVLC   (6.2.4.5.2)
 *
 * Description:
 * Performs zigzag scan and VLC encoding of AC and DC coefficients for one
 * intra block.  Two versions of the function (DCVLC and ACVLC) are provided
 * in order to support the two different methods of processing DC
 * coefficients, as described in [ISO14496-2], subclause 7.4.1.4,  Intra DC
 * Coefficient Decoding for the Case of Switched VLC Encoding.
 *
 * Input Arguments:
 *
 *   ppBitStream - double pointer to the current byte in the bitstream
 *   pBitOffset - pointer to the bit position in the byte pointed by
 *            *ppBitStream. Valid within 0 to 7.
 *   pQDctBlkCoef - pointer to the quantized DCT coefficient
 *   predDir - AC prediction direction, which is used to decide the zigzag
 *            scan pattern; takes one of the following values:
 *            -  OMX_VC_NONE - AC prediction not used.
 *                             Performs classical zigzag scan.
 *            -  OMX_VC_HORIZONTAL - Horizontal prediction.
 *                             Performs alternate-vertical zigzag scan.
 *            -  OMX_VC_VERTICAL - Vertical prediction.
 *                             Performs alternate-horizontal zigzag scan.
 *   pattern - block pattern which is used to decide whether this block is
 *            encoded
 *   shortVideoHeader - binary flag indicating presence of
 *            short_video_header; escape modes 0-3 are used if
 *            shortVideoHeader==0, and escape mode 4 is used when
 *            shortVideoHeader==1.
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after the block is encoded, so
 *            that it points to the current byte in the bit stream buffer.
 *   pBitOffset - *pBitOffset is updated so that it points to the current bit
 *            position in the byte pointed by *ppBitStream.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - Bad arguments:
 *    -    At least one of the following pointers is NULL: ppBitStream,
 *              *ppBitStream, pBitOffset, pQDctBlkCoef.
 *    -   *pBitOffset < 0, or *pBitOffset >7.
 *    -    PredDir is not one of: OMX_VC_NONE, OMX_VC_HORIZONTAL, or
 *         OMX_VC_VERTICAL.
 *    -    VideoComp is not one component of enum OMXVCM4P2VideoComponent.
 *
 */
OMXResult omxVCM4P2_EncodeVLCZigzag_IntraACVLC (
    OMX_U8 **ppBitStream,
    OMX_INT *pBitOffset,
    const OMX_S16 *pQDctBlkCoef,
    OMX_U8 predDir,
    OMX_U8 pattern,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_EncodeVLCZigzag_Inter   (6.2.4.5.3)
 *
 * Description:
 * Performs classical zigzag scanning and VLC encoding for one inter block.
 *
 * Input Arguments:
 *
 *   ppBitStream - pointer to the pointer to the current byte in the bit
 *            stream
 *   pBitOffset - pointer to the bit position in the byte pointed by
 *            *ppBitStream. Valid within 0 to 7
 *   pQDctBlkCoef - pointer to the quantized DCT coefficient
 *   pattern - block pattern which is used to decide whether this block is
 *            encoded
 *   shortVideoHeader - binary flag indicating presence of
 *            short_video_header; escape modes 0-3 are used if
 *            shortVideoHeader==0, and escape mode 4 is used when
 *            shortVideoHeader==1.
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after the block is encoded so that
 *            it points to the current byte in the bit stream buffer.
 *   pBitOffset - *pBitOffset is updated so that it points to the current bit
 *            position in the byte pointed by *ppBitStream.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - Bad arguments
 *    -    At least one of the pointers: is NULL: ppBitStream, *ppBitStream,
 *              pBitOffset, pQDctBlkCoef
 *    -   *pBitOffset < 0, or *pBitOffset >7.
 *
 */
OMXResult omxVCM4P2_EncodeVLCZigzag_Inter (
    OMX_U8 **ppBitStream,
    OMX_INT *pBitOffset,
    const OMX_S16 *pQDctBlkCoef,
    OMX_U8 pattern,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_EncodeMV   (6.2.4.5.4)
 *
 * Description:
 * Predicts a motion vector for the current macroblock, encodes the
 * difference, and writes the output to the stream buffer. The input MVs
 * pMVCurMB, pSrcMVLeftMB, pSrcMVUpperMB, and pSrcMVUpperRightMB should lie
 * within the ranges associated with the input parameter fcodeForward, as
 * described in [ISO14496-2], subclause 7.6.3.  This function provides a
 * superset of the functionality associated with the function
 * omxVCM4P2_FindMVpred.
 *
 * Input Arguments:
 *
 *   ppBitStream - double pointer to the current byte in the bitstream buffer
 *   pBitOffset - index of the first free (next available) bit in the stream
 *            buffer referenced by *ppBitStream, valid in the range 0 to 7.
 *   pMVCurMB - pointer to the current macroblock motion vector; a value of
 *            NULL indicates unavailability.
 *   pSrcMVLeftMB - pointer to the source left macroblock motion vector; a
 *            value of  NULLindicates unavailability.
 *   pSrcMVUpperMB - pointer to source upper macroblock motion vector; a
 *            value of NULL indicates unavailability.
 *   pSrcMVUpperRightMB - pointer to source upper right MB motion vector; a
 *            value of NULL indicates unavailability.
 *   fcodeForward - an integer with values from 1 to 7; used in encoding
 *            motion vectors related to search range, as described in
 *            [ISO14496-2], subclause 7.6.3.
 *   MBType - macro block type, valid in the range 0 to 5
 *
 * Output Arguments:
 *
 *   ppBitStream - updated pointer to the current byte in the bit stream
 *            buffer
 *   pBitOffset - updated index of the next available bit position in stream
 *            buffer referenced by *ppBitStream
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments
 *    -    At least one of the following pointers is NULL: ppBitStream,
 *              *ppBitStream, pBitOffset, pMVCurMB
 *    -    *pBitOffset < 0, or *pBitOffset >7.
 *    -    fcodeForward <= 0, or fcodeForward > 7, or MBType < 0.
 *
 */
OMXResult omxVCM4P2_EncodeMV (
    OMX_U8 **ppBitStream,
    OMX_INT *pBitOffset,
    const OMXVCMotionVector *pMVCurMB,
    const OMXVCMotionVector*pSrcMVLeftMB,
    const OMXVCMotionVector *pSrcMVUpperMB,
    const OMXVCMotionVector *pSrcMVUpperRightMB,
    OMX_INT fcodeForward,
    OMXVCM4P2MacroblockType MBType
);



/**
 * Function:  omxVCM4P2_DecodePadMV_PVOP   (6.2.5.1.1)
 *
 * Description:
 * Decodes and pads the four motion vectors associated with a non-intra P-VOP
 * macroblock.  For macroblocks of type OMX_VC_INTER4V, the output MV is
 * padded as specified in [ISO14496-2], subclause 7.6.1.6. Otherwise, for
 * macroblocks of types other than OMX_VC_INTER4V, the decoded MV is copied to
 * all four output MV buffer entries.
 *
 * Input Arguments:
 *
 *   ppBitStream - pointer to the pointer to the current byte in the bit
 *            stream buffer
 *   pBitOffset - pointer to the bit position in the byte pointed to by
 *            *ppBitStream. *pBitOffset is valid within [0-7].
 *   pSrcMVLeftMB, pSrcMVUpperMB, and pSrcMVUpperRightMB - pointers to the
 *            motion vector buffers of the macroblocks specially at the left,
 *            upper, and upper-right side of the current macroblock,
 *            respectively; a value of NULL indicates unavailability.  Note:
 *            Any neighborhood macroblock outside the current VOP or video
 *            packet or outside the current GOB (when short_video_header is
 *             1 ) for which gob_header_empty is  0  is treated as
 *            transparent, according to [ISO14496-2], subclause 7.6.5.
 *   fcodeForward - a code equal to vop_fcode_forward in MPEG-4 bit stream
 *            syntax
 *   MBType - the type of the current macroblock. If MBType is not equal to
 *            OMX_VC_INTER4V, the destination motion vector buffer is still
 *            filled with the same decoded vector.
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after the block is decoded, so
 *            that it points to the current byte in the bit stream buffer
 *   pBitOffset - *pBitOffset is updated so that it points to the current bit
 *            position in the byte pointed by *ppBitStream
 *   pDstMVCurMB - pointer to the motion vector buffer for the current
 *            macroblock; contains four decoded motion vectors
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments:
 *    -    At least one of the following pointers is NULL:
 *         ppBitStream, *ppBitStream, pBitOffset, pDstMVCurMB
 *    -    *pBitOffset exceeds [0,7]
 *    -    fcodeForward exceeds (0,7]
 *    -    MBType less than zero
 *    -    motion vector buffer is not 4-byte aligned.
 *    OMX_Sts_Err - status error
 *
 */
OMXResult omxVCM4P2_DecodePadMV_PVOP (
    const OMX_U8 **ppBitStream,
    OMX_INT *pBitOffset,
    OMXVCMotionVector *pSrcMVLeftMB,
    OMXVCMotionVector*pSrcMVUpperMB,
    OMXVCMotionVector *pSrcMVUpperRightMB,
    OMXVCMotionVector*pDstMVCurMB,
    OMX_INT fcodeForward,
    OMXVCM4P2MacroblockType MBType
);



/**
 * Function:  omxVCM4P2_DecodeVLCZigzag_IntraDCVLC   (6.2.5.2.2)
 *
 * Description:
 * Performs VLC decoding and inverse zigzag scan of AC and DC coefficients
 * for one intra block.  Two versions of the function (DCVLC and ACVLC) are
 * provided in order to support the two different methods of processing DC
 * coefficients, as described in [ISO14496-2], subclause 7.4.1.4,  Intra DC
 * Coefficient Decoding for the Case of Switched VLC Encoding.
 *
 * Input Arguments:
 *
 *   ppBitStream - pointer to the pointer to the current byte in the
 *            bitstream buffer
 *   pBitOffset - pointer to the bit position in the current byte referenced
 *            by *ppBitStream.  The parameter *pBitOffset is valid in the
 *            range [0-7].
 *            Bit Position in one byte:  |Most      Least|
 *                    *pBitOffset        |0 1 2 3 4 5 6 7|
 *   predDir - AC prediction direction; used to select the zigzag scan
 *            pattern; takes one of the following values:
 *            -  OMX_VC_NONE - AC prediction not used;
 *                             performs classical zigzag scan.
 *            -  OMX_VC_HORIZONTAL - Horizontal prediction;
 *                             performs alternate-vertical zigzag scan;
 *            -  OMX_VC_VERTICAL - Vertical prediction;
 *                             performs alternate-horizontal zigzag scan.
 *   shortVideoHeader - binary flag indicating presence of
 *            short_video_header; escape modes 0-3 are used if
 *            shortVideoHeader==0, and escape mode 4 is used when
 *            shortVideoHeader==1.
 *   videoComp - video component type (luminance or chrominance) of the
 *            current block
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after the block is decoded such
 *            that it points to the current byte in the bit stream buffer
 *   pBitOffset - *pBitOffset is updated such that it points to the current
 *            bit position in the byte pointed by *ppBitStream
 *   pDst - pointer to the coefficient buffer of current block; must be
 *            4-byte aligned.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments, if:
 *    -    At least one of the following pointers is NULL:
 *         ppBitStream, *ppBitStream, pBitOffset, pDst
 *    -    *pBitOffset exceeds [0,7]
 *    -    preDir exceeds [0,2]
 *    -    pDst is not 4-byte aligned
 *    OMX_Sts_Err - if:
 *    -    In DecodeVLCZigzag_IntraDCVLC, dc_size > 12
 *    -    At least one of mark bits equals zero
 *    -    Illegal stream encountered; code cannot be located in VLC table
 *    -    Forbidden code encountered in the VLC FLC table.
 *    -    The number of coefficients is greater than 64
 *
 */
OMXResult omxVCM4P2_DecodeVLCZigzag_IntraDCVLC (
    const OMX_U8 **ppBitStream,
    OMX_INT *pBitOffset,
    OMX_S16 *pDst,
    OMX_U8 predDir,
    OMX_INT shortVideoHeader,
    OMXVCM4P2VideoComponent videoComp
);



/**
 * Function:  omxVCM4P2_DecodeVLCZigzag_IntraACVLC   (6.2.5.2.2)
 *
 * Description:
 * Performs VLC decoding and inverse zigzag scan of AC and DC coefficients
 * for one intra block.  Two versions of the function (DCVLC and ACVLC) are
 * provided in order to support the two different methods of processing DC
 * coefficients, as described in [ISO14496-2], subclause 7.4.1.4,  Intra DC
 * Coefficient Decoding for the Case of Switched VLC Encoding.
 *
 * Input Arguments:
 *
 *   ppBitStream - pointer to the pointer to the current byte in the
 *            bitstream buffer
 *   pBitOffset - pointer to the bit position in the current byte referenced
 *            by *ppBitStream.  The parameter *pBitOffset is valid in the
 *            range [0-7]. Bit Position in one byte:  |Most Least| *pBitOffset
 *            |0 1 2 3 4 5 6 7|
 *   predDir - AC prediction direction; used to select the zigzag scan
 *            pattern; takes one of the following values: OMX_VC_NONE - AC
 *            prediction not used; performs classical zigzag scan.
 *            OMX_VC_HORIZONTAL - Horizontal prediction; performs
 *            alternate-vertical zigzag scan; OMX_VC_VERTICAL - Vertical
 *            prediction; performs alternate-horizontal zigzag scan.
 *   shortVideoHeader - binary flag indicating presence of
 *            short_video_header; escape modes 0-3 are used if
 *            shortVideoHeader==0, and escape mode 4 is used when
 *            shortVideoHeader==1.
 *   videoComp - video component type (luminance or chrominance) of the
 *            current block
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after the block is decoded such
 *            that it points to the current byte in the bit stream buffer
 *   pBitOffset - *pBitOffset is updated such that it points to the current
 *            bit position in the byte pointed by *ppBitStream
 *   pDst - pointer to the coefficient buffer of current block; must be
 *            4-byte aligned.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments At least one of the following
 *              pointers is NULL: ppBitStream, *ppBitStream, pBitOffset, pDst,
 *              or At least one of the following conditions is true:
 *              *pBitOffset exceeds [0,7], preDir exceeds [0,2], or pDst is
 *              not 4-byte aligned
 *    OMX_Sts_Err In DecodeVLCZigzag_IntraDCVLC, dc_size > 12 At least one of
 *              mark bits equals zero Illegal stream encountered; code cannot
 *              be located in VLC table Forbidden code encountered in the VLC
 *              FLC table The number of coefficients is greater than 64
 *
 */
OMXResult omxVCM4P2_DecodeVLCZigzag_IntraACVLC (
    const OMX_U8 **ppBitStream,
    OMX_INT *pBitOffset,
    OMX_S16 *pDst,
    OMX_U8 predDir,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_DecodeVLCZigzag_Inter   (6.2.5.2.3)
 *
 * Description:
 * Performs VLC decoding and inverse zigzag scan for one inter-coded block.
 *
 * Input Arguments:
 *
 *   ppBitStream - double pointer to the current byte in the stream buffer
 *   pBitOffset - pointer to the next available bit in the current stream
 *            byte referenced by *ppBitStream. The parameter *pBitOffset is
 *            valid within the range [0-7].
 *   shortVideoHeader - binary flag indicating presence of
 *            short_video_header; escape modes 0-3 are used if
 *            shortVideoHeader==0, and escape mode 4 is used when
 *            shortVideoHeader==1.
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after the block is decoded such
 *            that it points to the current byte in the stream buffer
 *   pBitOffset - *pBitOffset is updated after decoding such that it points
 *            to the next available bit in the stream byte referenced by
 *            *ppBitStream
 *   pDst - pointer to the coefficient buffer of current block; must be
 *            4-byte aligned.
 *
 * Return Value:
 *
 *    OMX_Sts_BadArgErr - bad arguments:
 *    -    At least one of the following pointers is NULL:
 *         ppBitStream, *ppBitStream, pBitOffset, pDst
 *    -    pDst is not 4-byte aligned
 *    -   *pBitOffset exceeds [0,7]
 *    OMX_Sts_Err - status error, if:
 *    -    At least one mark bit is equal to zero
 *    -    Encountered an illegal stream code that cannot be found in the VLC table
 *    -    Encountered an illegal code in the VLC FLC table
 *    -    The number of coefficients is greater than 64
 *
 */
OMXResult omxVCM4P2_DecodeVLCZigzag_Inter (
    const OMX_U8 **ppBitStream,
    OMX_INT *pBitOffset,
    OMX_S16 *pDst,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_QuantInvIntra_I   (6.2.5.3.2)
 *
 * Description:
 * Performs the second inverse quantization mode on an intra/inter coded
 * block. Supports bits_per_pixel = 8. The output coefficients are clipped to
 * the range [-2048, 2047].
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the input (quantized) intra/inter block; must be
 *            aligned on a 16-byte boundary.
 *   QP - quantization parameter (quantizer_scale)
 *   videoComp - video component type of the current block. Takes one of the
 *            following flags: OMX_VC_LUMINANCE, OMX_VC_CHROMINANCE (intra
 *            version only).
 *   shortVideoHeader - binary flag indicating presence of short_video_header
 *            (intra version only).
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to the output (dequantized) intra/inter block
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; one or more of the following is
 *              true:
 *    -    pSrcDst is NULL
 *    -    QP <= 0 or QP >=31
 *    -    videoComp is neither OMX_VC_LUMINANCE nor OMX_VC_CHROMINANCE.
 *
 */
OMXResult omxVCM4P2_QuantInvIntra_I (
    OMX_S16 *pSrcDst,
    OMX_INT QP,
    OMXVCM4P2VideoComponent videoComp,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_QuantInvInter_I   (6.2.5.3.2)
 *
 * Description:
 * Performs the second inverse quantization mode on an intra/inter coded
 * block. Supports bits_per_pixel = 8. The output coefficients are clipped to
 * the range [-2048, 2047].
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the input (quantized) intra/inter block; must be
 *            aligned on a 16-byte boundary.
 *   QP - quantization parameter (quantizer_scale)
 *   videoComp - video component type of the current block. Takes one of the
 *            following flags: OMX_VC_LUMINANCE, OMX_VC_CHROMINANCE (intra
 *            version only).
 *   shortVideoHeader - binary flag indicating presence of short_video_header
 *            (intra version only).
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to the output (dequantized) intra/inter block
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; one or more of the following is
 *              true:
 *    -    pSrcDst is NULL
 *    -    QP <= 0 or QP >=31
 *    -    videoComp is neither OMX_VC_LUMINANCE nor OMX_VC_CHROMINANCE.
 *
 */
OMXResult omxVCM4P2_QuantInvInter_I (
    OMX_S16 *pSrcDst,
    OMX_INT QP
);



/**
 * Function:  omxVCM4P2_DecodeBlockCoef_Intra   (6.2.5.4.1)
 *
 * Description:
 * Decodes the INTRA block coefficients. Inverse quantization, inversely
 * zigzag positioning, and IDCT, with appropriate clipping on each step, are
 * performed on the coefficients. The results are then placed in the output
 * frame/plane on a pixel basis.  Note: This function will be used only when
 * at least one non-zero AC coefficient of current block exists in the bit
 * stream. The DC only condition will be handled in another function.
 *
 *
 * Input Arguments:
 *
 *   ppBitStream - pointer to the pointer to the current byte in the bit
 *            stream buffer. There is no boundary check for the bit stream
 *            buffer.
 *   pBitOffset - pointer to the bit position in the byte pointed to by
 *            *ppBitStream. *pBitOffset is valid within [0-7].
 *   step - width of the destination plane
 *   pCoefBufRow - pointer to the coefficient row buffer; must be aligned on
 *            an 8-byte boundary.
 *   pCoefBufCol - pointer to the coefficient column buffer; must be aligned
 *            on an 8-byte boundary.
 *   curQP - quantization parameter of the macroblock which the current block
 *            belongs to
 *   pQPBuf - pointer to the quantization parameter buffer
 *   blockIndex - block index indicating the component type and position as
 *            defined in [ISO14496-2], subclause 6.1.3.8, Figure 6-5.
 *   intraDCVLC - a code determined by intra_dc_vlc_thr and QP. This allows a
 *            mechanism to switch between two VLC for coding of Intra DC
 *            coefficients as per [ISO14496-2], Table 6-21.
 *   ACPredFlag - a flag equal to ac_pred_flag (of luminance) indicating if
 *            the ac coefficients of the first row or first column are
 *            differentially coded for intra coded macroblock.
 *   shortVideoHeader - binary flag indicating presence of
 *            short_video_header; shortVideoHeader==1 selects linear intra DC
 *            mode, and shortVideoHeader==0 selects non linear intra DC mode.
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after the block is decoded, so
 *            that it points to the current byte in the bit stream buffer
 *   pBitOffset - *pBitOffset is updated so that it points to the current bit
 *            position in the byte pointed by *ppBitStream
 *   pDst - pointer to the block in the destination plane; must be aligned on
 *            an 8-byte boundary.
 *   pCoefBufRow - pointer to the updated coefficient row buffer.
 *   pCoefBufCol - pointer to the updated coefficient column buffer  Note:
 *            The coefficient buffers must be updated in accordance with the
 *            update procedure defined in section 6.2.2.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments, if:
 *    -    At least one of the following pointers is NULL:
 *         ppBitStream, *ppBitStream, pBitOffset, pCoefBufRow, pCoefBufCol,
 *         pQPBuf, pDst.
 *    -    *pBitOffset exceeds [0,7]
 *    -    curQP exceeds (1, 31)
 *    -    blockIndex exceeds [0,5]
 *    -    step is not the multiple of 8
 *    -    a pointer alignment requirement was violated.
 *    OMX_Sts_Err - status error. Refer to OMX_Sts_Err of DecodeVLCZigzag_Intra.
 *
 */
OMXResult omxVCM4P2_DecodeBlockCoef_Intra (
    const OMX_U8 **ppBitStream,
    OMX_INT *pBitOffset,
    OMX_U8 *pDst,
    OMX_INT step,
    OMX_S16 *pCoefBufRow,
    OMX_S16 *pCoefBufCol,
    OMX_U8 curQP,
    const OMX_U8 *pQPBuf,
    OMX_INT blockIndex,
    OMX_INT intraDCVLC,
    OMX_INT ACPredFlag,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_DecodeBlockCoef_Inter   (6.2.5.4.2)
 *
 * Description:
 * Decodes the INTER block coefficients. This function performs inverse
 * quantization, inverse zigzag positioning, and IDCT (with appropriate
 * clipping on each step) on the coefficients. The results (residuals) are
 * placed in a contiguous array of 64 elements. For INTER block, the output
 * buffer holds the residuals for further reconstruction.
 *
 * Input Arguments:
 *
 *   ppBitStream - pointer to the pointer to the current byte in the bit
 *            stream buffer. There is no boundary check for the bit stream
 *            buffer.
 *   pBitOffset - pointer to the bit position in the byte pointed to by
 *            *ppBitStream. *pBitOffset is valid within [0-7]
 *   QP - quantization parameter
 *   shortVideoHeader - binary flag indicating presence of
 *            short_video_header; shortVideoHeader==1 selects linear intra DC
 *            mode, and shortVideoHeader==0 selects non linear intra DC mode.
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after the block is decoded, so
 *            that it points to the current byte in the bit stream buffer
 *   pBitOffset - *pBitOffset is updated so that it points to the current bit
 *            position in the byte pointed by *ppBitStream
 *   pDst - pointer to the decoded residual buffer (a contiguous array of 64
 *            elements of OMX_S16 data type); must be aligned on a 16-byte
 *            boundary.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments, if:
 *    -    At least one of the following pointers is Null:
 *         ppBitStream, *ppBitStream, pBitOffset , pDst
 *    -    *pBitOffset exceeds [0,7]
 *    -    QP <= 0.
 *    -    pDst is not 16-byte aligned
 *    OMX_Sts_Err - status error. Refer to OMX_Sts_Err of DecodeVLCZigzag_Inter .
 *
 */
OMXResult omxVCM4P2_DecodeBlockCoef_Inter (
    const OMX_U8 **ppBitStream,
    OMX_INT *pBitOffset,
    OMX_S16 *pDst,
    OMX_INT QP,
    OMX_INT shortVideoHeader
);



/**
 * Function:  omxVCM4P2_PredictReconCoefIntra   (6.2.5.4.3)
 *
 * Description:
 * Performs adaptive DC/AC coefficient prediction for an intra block.  Prior
 * to the function call, prediction direction (predDir) should be selected as
 * specified in [ISO14496-2], subclause 7.4.3.1.
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the coefficient buffer which contains the quantized
 *            coefficient residuals (PQF) of the current block; must be
 *            aligned on a 4-byte boundary.  The output coefficients are
 *            saturated to the range [-2048, 2047].
 *   pPredBufRow - pointer to the coefficient row buffer; must be aligned on
 *            a 4-byte boundary.
 *   pPredBufCol - pointer to the coefficient column buffer; must be aligned
 *            on a 4-byte boundary.
 *   curQP - quantization parameter of the current block. curQP may equal to
 *            predQP especially when the current block and the predictor block
 *            are in the same macroblock.
 *   predQP - quantization parameter of the predictor block
 *   predDir - indicates the prediction direction which takes one of the
 *            following values: OMX_VC_HORIZONTAL - predict horizontally
 *            OMX_VC_VERTICAL - predict vertically
 *   ACPredFlag - a flag indicating if AC prediction should be performed. It
 *            is equal to ac_pred_flag in the bit stream syntax of MPEG-4
 *   videoComp - video component type (luminance or chrominance) of the
 *            current block
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to the coefficient buffer which contains the quantized
 *            coefficients (QF) of the current block
 *   pPredBufRow - pointer to the updated coefficient row buffer
 *   pPredBufCol - pointer to the updated coefficient column buffer  Note:
 *            Buffer update: Update the AC prediction buffer (both row and
 *            column buffer).
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments, if:
 *        -    At least one of the pointers is NULL:
 *              pSrcDst, pPredBufRow, or pPredBufCol.
 *        -    curQP <= 0,
 *        -    predQP <= 0,
 *        -    curQP >31,
 *        -    predQP > 31,
 *        -    preDir exceeds [1,2]
 *        -    pSrcDst, pPredBufRow, or pPredBufCol is not 4-byte aligned.
 *
 */
OMXResult omxVCM4P2_PredictReconCoefIntra (
    OMX_S16 *pSrcDst,
    OMX_S16 *pPredBufRow,
    OMX_S16 *pPredBufCol,
    OMX_INT curQP,
    OMX_INT predQP,
    OMX_INT predDir,
    OMX_INT ACPredFlag,
    OMXVCM4P2VideoComponent videoComp
);



/**
 * Function:  omxVCM4P2_MCReconBlock   (6.2.5.5.1)
 *
 * Description:
 * Performs motion compensation prediction for an 8x8 block using
 * interpolation described in [ISO14496-2], subclause 7.6.2.
 *
 * Input Arguments:
 *
 *   pSrc - pointer to the block in the reference plane.
 *   srcStep - distance between the start of consecutive lines in the
 *            reference plane, in bytes; must be a multiple of 8.
 *   dstStep - distance between the start of consecutive lines in the
 *            destination plane, in bytes; must be a multiple of 8.
 *   pSrcResidue - pointer to a buffer containing the 16-bit prediction
 *            residuals; must be 16-byte aligned. If the pointer is NULL, then
 *            no prediction is done, only motion compensation, i.e., the block
 *            is moved with interpolation.
 *   predictType - bilinear interpolation type, as defined in section
 *            6.2.1.2.
 *   rndVal - rounding control parameter: 0 - disabled; 1 - enabled.
 *
 * Output Arguments:
 *
 *   pDst - pointer to the destination buffer; must be 8-byte aligned.  If
 *            prediction residuals are added then output intensities are
 *            clipped to the range [0,255].
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned under any of the following
 *              conditions:
 *    -    pDst is not 8-byte aligned.
 *    -    pSrcResidue is not 16-byte aligned.
 *    -    one or more of the following pointers is NULL: pSrc or pDst.
 *    -    either srcStep or dstStep is not a multiple of 8.
 *    -    invalid type specified for the parameter predictType.
 *    -    the parameter rndVal is not equal either to 0 or 1.
 *
 */
OMXResult omxVCM4P2_MCReconBlock (
    const OMX_U8 *pSrc,
    OMX_INT srcStep,
    const OMX_S16 *pSrcResidue,
    OMX_U8 *pDst,
    OMX_INT dstStep,
    OMX_INT predictType,
    OMX_INT rndVal
);



/* 6.3.1.1 Intra 16x16 Prediction Modes  */
/* A data type that enumerates intra_16x16 macroblock prediction modes is defined as follows:  */

typedef enum {
    OMX_VC_16X16_VERT = 0,  /** Intra_16x16_Vertical */
    OMX_VC_16X16_HOR = 1,   /** Intra_16x16_Horizontal */
    OMX_VC_16X16_DC = 2,    /** Intra_16x16_DC */
    OMX_VC_16X16_PLANE = 3  /** Intra_16x16_Plane */
} OMXVCM4P10Intra16x16PredMode;



/* 6.3.1.2 Intra 4x4 Prediction Modes  */
/* A data type that enumerates intra_4x4 macroblock prediction modes is defined as follows:  */

typedef enum {
    OMX_VC_4X4_VERT = 0,     /** Intra_4x4_Vertical */
    OMX_VC_4X4_HOR = 1,      /** Intra_4x4_Horizontal */
    OMX_VC_4X4_DC = 2,       /** Intra_4x4_DC */
    OMX_VC_4X4_DIAG_DL = 3,  /** Intra_4x4_Diagonal_Down_Left */
    OMX_VC_4X4_DIAG_DR = 4,  /** Intra_4x4_Diagonal_Down_Right */
    OMX_VC_4X4_VR = 5,       /** Intra_4x4_Vertical_Right */
    OMX_VC_4X4_HD = 6,       /** Intra_4x4_Horizontal_Down */
    OMX_VC_4X4_VL = 7,       /** Intra_4x4_Vertical_Left */
    OMX_VC_4X4_HU = 8        /** Intra_4x4_Horizontal_Up */
} OMXVCM4P10Intra4x4PredMode;



/* 6.3.1.3 Chroma Prediction Modes  */
/* A data type that enumerates intra chroma prediction modes is defined as follows:  */

typedef enum {
    OMX_VC_CHROMA_DC = 0,    /** Intra_Chroma_DC */
    OMX_VC_CHROMA_HOR = 1,   /** Intra_Chroma_Horizontal */
    OMX_VC_CHROMA_VERT = 2,  /** Intra_Chroma_Vertical */
    OMX_VC_CHROMA_PLANE = 3  /** Intra_Chroma_Plane */
} OMXVCM4P10IntraChromaPredMode;



/* 6.3.1.4 Motion Estimation Modes  */
/* A data type that enumerates H.264 motion estimation modes is defined as follows:  */

typedef enum {
    OMX_VC_M4P10_FAST_SEARCH = 0, /** Fast motion search */
    OMX_VC_M4P10_FULL_SEARCH = 1  /** Full motion search */
} OMXVCM4P10MEMode;



/* 6.3.1.5 Macroblock Types  */
/* A data type that enumerates H.264 macroblock types is defined as follows:  */

typedef enum {
    OMX_VC_P_16x16  = 0, /* defined by [ISO14496-10] */
    OMX_VC_P_16x8  = 1,
    OMX_VC_P_8x16  = 2,
    OMX_VC_P_8x8  = 3,
    OMX_VC_PREF0_8x8  = 4,
    OMX_VC_INTER_SKIP  = 5,
    OMX_VC_INTRA_4x4  = 8,
    OMX_VC_INTRA_16x16  = 9,
    OMX_VC_INTRA_PCM = 10
} OMXVCM4P10MacroblockType;



/* 6.3.1.6 Sub-Macroblock Types  */
/* A data type that enumerates H.264 sub-macroblock types is defined as follows:  */

typedef enum {
    OMX_VC_SUB_P_8x8 = 0, /* defined by [ISO14496-10] */
    OMX_VC_SUB_P_8x4 = 1,
    OMX_VC_SUB_P_4x8 = 2,
    OMX_VC_SUB_P_4x4 = 3
} OMXVCM4P10SubMacroblockType;



/* 6.3.1.7 Variable Length Coding (VLC) Information  */

typedef struct {
    OMX_U8 uTrailing_Ones;      /* Trailing ones; 3 at most */
    OMX_U8 uTrailing_One_Signs; /* Trailing ones signal */
    OMX_U8 uNumCoeffs;          /* Total number of non-zero coefs, including trailing ones */
    OMX_U8 uTotalZeros;         /* Total number of zero coefs */
    OMX_S16 iLevels[16];        /* Levels of non-zero coefs, in reverse zig-zag order */
    OMX_U8 uRuns[16];           /* Runs for levels and trailing ones, in reverse zig-zag order */
} OMXVCM4P10VLCInfo;



/* 6.3.1.8 Macroblock Information  */

typedef struct {
    OMX_S32 sliceId;                          /* slice number */
    OMXVCM4P10MacroblockType mbType;          /* MB type */
    OMXVCM4P10SubMacroblockType subMBType[4]; /* sub-block type */
    OMX_S32 qpy;                              /* qp for luma */
    OMX_S32 qpc;                              /* qp for chroma */
    OMX_U32 cbpy;                             /* CBP Luma */
    OMX_U32 cbpc;                             /* CBP Chroma */
    OMXVCMotionVector pMV0[4][4]; /* motion vector, represented using 1/4-pel units, pMV0[blocky][blockx] (blocky = 0~3, blockx =0~3) */
    OMXVCMotionVector pMVPred[4][4]; /* motion vector prediction, Represented using 1/4-pel units, pMVPred[blocky][blockx] (blocky = 0~3, blockx = 0~3) */
    OMX_U8 pRefL0Idx[4];                      /* reference picture indices */
    OMXVCM4P10Intra16x16PredMode Intra16x16PredMode; /* best intra 16x16 prediction mode */
    OMXVCM4P10Intra4x4PredMode pIntra4x4PredMode[16]; /* best intra 4x4 prediction mode for each block, pMV0 indexed as above */
} OMXVCM4P10MBInfo, *OMXVCM4P10MBInfoPtr;



/* 6.3.1.9 Motion Estimation Parameters  */

typedef struct {
    OMX_S32 blockSplitEnable8x8; /* enables 16x8, 8x16, 8x8 */
    OMX_S32 blockSplitEnable4x4; /* enable splitting of 8x4, 4x8, 4x4 blocks */
    OMX_S32 halfSearchEnable;
    OMX_S32 quarterSearchEnable;
    OMX_S32 intraEnable4x4;      /* 1=enable, 0=disable */
    OMX_S32 searchRange16x16;    /* integer pixel units */
    OMX_S32 searchRange8x8;
    OMX_S32 searchRange4x4;
} OMXVCM4P10MEParams;



/**
 * Function:  omxVCM4P10_PredictIntra_4x4   (6.3.3.1.1)
 *
 * Description:
 * Perform Intra_4x4 prediction for luma samples. If the upper-right block is
 * not available, then duplication work should be handled inside the function.
 * Users need not define them outside.
 *
 * Input Arguments:
 *
 *   pSrcLeft -  Pointer to the buffer of 4 left pixels:
 *                  p[x, y] (x = -1, y = 0..3)
 *   pSrcAbove - Pointer to the buffer of 8 above pixels:
 *                  p[x,y] (x = 0..7, y =-1);
 *               must be aligned on a 4-byte boundary.
 *   pSrcAboveLeft - Pointer to the above left pixels: p[x,y] (x = -1, y = -1)
 *   leftStep - Step of left pixel buffer; must be a multiple of 4.
 *   dstStep - Step of the destination buffer; must be a multiple of 4.
 *   predMode - Intra_4x4 prediction mode.
 *   availability - Neighboring 4x4 block availability flag, refer to
 *             "Neighboring Macroblock Availability" .
 *
 * Output Arguments:
 *
 *   pDst - Pointer to the destination buffer; must be aligned on a 4-byte
 *            boundary.
 *
 * Return Value:
 *    If the function runs without error, it returns OMX_Sts_NoErr.
 *    If one of the following cases occurs, the function returns
 *              OMX_Sts_BadArgErr:
 *    pDst is NULL.
 *    dstStep < 4, or dstStep is not a multiple of 4.
 *    leftStep is not a multiple of 4.
 *    predMode is not in the valid range of enumeration
 *              OMXVCM4P10Intra4x4PredMode.
 *    predMode is OMX_VC_4x4_VERT, but availability doesn't set OMX_VC_UPPER
 *              indicating p[x,-1] (x = 0..3) is not available.
 *    predMode is OMX_VC_4x4_HOR, but availability doesn't set OMX_VC_LEFT
 *              indicating p[-1,y] (y = 0..3) is not available.
 *    predMode is OMX_VC_4x4_DIAG_DL, but availability doesn't set
 *              OMX_VC_UPPER indicating p[x, -1] (x = 0..3) is not available.
 *    predMode is OMX_VC_4x4_DIAG_DR, but availability doesn't set
 *              OMX_VC_UPPER_LEFT or OMX_VC_UPPER or OMX_VC_LEFT indicating
 *              p[x,-1] (x = 0..3), or p[-1,y] (y = 0..3) or p[-1,-1] is not
 *              available.
 *    predMode is OMX_VC_4x4_VR, but availability doesn't set
 *              OMX_VC_UPPER_LEFT or OMX_VC_UPPER or OMX_VC_LEFT indicating
 *              p[x,-1] (x = 0..3), or p[-1,y] (y = 0..3) or p[-1,-1] is not
 *              available.
 *    predMode is OMX_VC_4x4_HD, but availability doesn't set
 *              OMX_VC_UPPER_LEFT or OMX_VC_UPPER or OMX_VC_LEFT indicating
 *              p[x,-1] (x = 0..3), or p[-1,y] (y = 0..3) or p[-1,-1] is not
 *              available.
 *    predMode is OMX_VC_4x4_VL, but availability doesn't set OMX_VC_UPPER
 *              indicating p[x,-1] (x = 0..3) is not available.
 *    predMode is OMX_VC_4x4_HU, but availability doesn't set OMX_VC_LEFT
 *              indicating p[-1,y] (y = 0..3) is not available.
 *    availability sets OMX_VC_UPPER, but pSrcAbove is NULL.
 *    availability sets OMX_VC_LEFT, but pSrcLeft is NULL.
 *    availability sets OMX_VC_UPPER_LEFT, but pSrcAboveLeft is NULL.
 *    either pSrcAbove or pDst is not aligned on a 4-byte boundary.
 *
 * Note:
 *     pSrcAbove, pSrcAbove, pSrcAboveLeft may be invalid pointers if
 *     they are not used by intra prediction as implied in predMode.
 *
 */
OMXResult omxVCM4P10_PredictIntra_4x4 (
    const OMX_U8 *pSrcLeft,
    const OMX_U8 *pSrcAbove,
    const OMX_U8 *pSrcAboveLeft,
    OMX_U8 *pDst,
    OMX_INT leftStep,
    OMX_INT dstStep,
    OMXVCM4P10Intra4x4PredMode predMode,
    OMX_S32 availability
);



/**
 * Function:  omxVCM4P10_PredictIntra_16x16   (6.3.3.1.2)
 *
 * Description:
 * Perform Intra_16x16 prediction for luma samples. If the upper-right block
 * is not available, then duplication work should be handled inside the
 * function. Users need not define them outside.
 *
 * Input Arguments:
 *
 *   pSrcLeft - Pointer to the buffer of 16 left pixels: p[x, y] (x = -1, y =
 *            0..15)
 *   pSrcAbove - Pointer to the buffer of 16 above pixels: p[x,y] (x = 0..15,
 *            y= -1); must be aligned on a 16-byte boundary.
 *   pSrcAboveLeft - Pointer to the above left pixels: p[x,y] (x = -1, y = -1)
 *   leftStep - Step of left pixel buffer; must be a multiple of 16.
 *   dstStep - Step of the destination buffer; must be a multiple of 16.
 *   predMode - Intra_16x16 prediction mode, please refer to section 3.4.1.
 *   availability - Neighboring 16x16 MB availability flag. Refer to
 *                  section 3.4.4.
 *
 * Output Arguments:
 *
 *   pDst -Pointer to the destination buffer; must be aligned on a 16-byte
 *            boundary.
 *
 * Return Value:
 *    If the function runs without error, it returns OMX_Sts_NoErr.
 *    If one of the following cases occurs, the function returns
 *              OMX_Sts_BadArgErr:
 *    pDst is NULL.
 *    dstStep < 16. or dstStep is not a multiple of 16.
 *    leftStep is not a multiple of 16.
 *    predMode is not in the valid range of enumeration
 *              OMXVCM4P10Intra16x16PredMode
 *    predMode is OMX_VC_16X16_VERT, but availability doesn't set
 *              OMX_VC_UPPER indicating p[x,-1] (x = 0..15) is not available.
 *    predMode is OMX_VC_16X16_HOR, but availability doesn't set OMX_VC_LEFT
 *              indicating p[-1,y] (y = 0..15) is not available.
 *    predMode is OMX_VC_16X16_PLANE, but availability doesn't set
 *              OMX_VC_UPPER_LEFT or OMX_VC_UPPER or OMX_VC_LEFT indicating
 *              p[x,-1](x = 0..15), or p[-1,y] (y = 0..15), or p[-1,-1] is not
 *              available.
 *    availability sets OMX_VC_UPPER, but pSrcAbove is NULL.
 *    availability sets OMX_VC_LEFT, but pSrcLeft is NULL.
 *    availability sets OMX_VC_UPPER_LEFT, but pSrcAboveLeft is NULL.
 *    either pSrcAbove or pDst is not aligned on a 16-byte boundary.
 *
 * Note:
 *     pSrcAbove, pSrcAbove, pSrcAboveLeft may be invalid pointers if
 *     they are not used by intra prediction implied in predMode.
 * Note:
 *     OMX_VC_UPPER_RIGHT is not used in intra_16x16 luma prediction.
 *
 */
OMXResult omxVCM4P10_PredictIntra_16x16 (
    const OMX_U8 *pSrcLeft,
    const OMX_U8 *pSrcAbove,
    const OMX_U8 *pSrcAboveLeft,
    OMX_U8 *pDst,
    OMX_INT leftStep,
    OMX_INT dstStep,
    OMXVCM4P10Intra16x16PredMode predMode,
    OMX_S32 availability
);



/**
 * Function:  omxVCM4P10_PredictIntraChroma_8x8   (6.3.3.1.3)
 *
 * Description:
 * Performs intra prediction for chroma samples.
 *
 * Input Arguments:
 *
 *   pSrcLeft - Pointer to the buffer of 8 left pixels: p[x, y] (x = -1, y=
 *            0..7).
 *   pSrcAbove - Pointer to the buffer of 8 above pixels: p[x,y] (x = 0..7, y
 *            = -1); must be aligned on an 8-byte boundary.
 *   pSrcAboveLeft - Pointer to the above left pixels: p[x,y] (x = -1, y = -1)
 *   leftStep - Step of left pixel buffer; must be a multiple of 8.
 *   dstStep - Step of the destination buffer; must be a multiple of 8.
 *   predMode - Intra chroma prediction mode, please refer to section 3.4.3.
 *   availability - Neighboring chroma block availability flag, please refer
 *            to  "Neighboring Macroblock Availability".
 *
 * Output Arguments:
 *
 *   pDst - Pointer to the destination buffer; must be aligned on an 8-byte
 *            boundary.
 *
 * Return Value:
 *    If the function runs without error, it returns OMX_Sts_NoErr.
 *    If any of the following cases occurs, the function returns
 *              OMX_Sts_BadArgErr:
 *    pDst is NULL.
 *    dstStep < 8 or dstStep is not a multiple of 8.
 *    leftStep is not a multiple of 8.
 *    predMode is not in the valid range of enumeration
 *              OMXVCM4P10IntraChromaPredMode.
 *    predMode is OMX_VC_CHROMA_VERT, but availability doesn't set
 *              OMX_VC_UPPER indicating p[x,-1] (x = 0..7) is not available.
 *    predMode is OMX_VC_CHROMA_HOR, but availability doesn't set OMX_VC_LEFT
 *              indicating p[-1,y] (y = 0..7) is not available.
 *    predMode is OMX_VC_CHROMA_PLANE, but availability doesn't set
 *              OMX_VC_UPPER_LEFT or OMX_VC_UPPER or OMX_VC_LEFT indicating
 *              p[x,-1](x = 0..7), or p[-1,y] (y = 0..7), or p[-1,-1] is not
 *              available.
 *    availability sets OMX_VC_UPPER, but pSrcAbove is NULL.
 *    availability sets OMX_VC_LEFT, but pSrcLeft is NULL.
 *    availability sets OMX_VC_UPPER_LEFT, but pSrcAboveLeft is NULL.
 *    either pSrcAbove or pDst is not aligned on a 8-byte boundary.
 *
 *  Note: pSrcAbove, pSrcAbove, pSrcAboveLeft may be invalid pointer if
 *  they are not used by intra prediction implied in predMode.
 *
 *  Note: OMX_VC_UPPER_RIGHT is not used in intra chroma prediction.
 *
 */
OMXResult omxVCM4P10_PredictIntraChroma_8x8 (
    const OMX_U8 *pSrcLeft,
    const OMX_U8 *pSrcAbove,
    const OMX_U8 *pSrcAboveLeft,
    OMX_U8 *pDst,
    OMX_INT leftStep,
    OMX_INT dstStep,
    OMXVCM4P10IntraChromaPredMode predMode,
    OMX_S32 availability
);



/**
 * Function:  omxVCM4P10_InterpolateLuma   (6.3.3.2.1)
 *
 * Description:
 * Performs quarter-pixel interpolation for inter luma MB. It is assumed that
 * the frame is already padded when calling this function.
 *
 * Input Arguments:
 *
 *   pSrc - Pointer to the source reference frame buffer
 *   srcStep - reference frame step, in bytes; must be a multiple of roi.width
 *   dstStep - destination frame step, in bytes; must be a multiple of
 *            roi.width
 *   dx - Fractional part of horizontal motion vector component in 1/4 pixel
 *            unit; valid in the range [0,3]
 *   dy - Fractional part of vertical motion vector y component in 1/4 pixel
 *            unit; valid in the range [0,3]
 *   roi - Dimension of the interpolation region; the parameters roi.width and
 *            roi.height must be equal to either 4, 8, or 16.
 *
 * Output Arguments:
 *
 *   pDst - Pointer to the destination frame buffer:
 *          if roi.width==4,  4-byte alignment required
 *          if roi.width==8,  8-byte alignment required
 *          if roi.width==16, 16-byte alignment required
 *
 * Return Value:
 *    If the function runs without error, it returns OMX_Sts_NoErr.
 *    If one of the following cases occurs, the function returns
 *              OMX_Sts_BadArgErr:
 *    pSrc or pDst is NULL.
 *    srcStep or dstStep < roi.width.
 *    dx or dy is out of range [0,3].
 *    roi.width or roi.height is out of range {4, 8, 16}.
 *    roi.width is equal to 4, but pDst is not 4 byte aligned.
 *    roi.width is equal to 8 or 16, but pDst is not 8 byte aligned.
 *    srcStep or dstStep is not a multiple of 8.
 *
 */
OMXResult omxVCM4P10_InterpolateLuma (
    const OMX_U8 *pSrc,
    OMX_S32 srcStep,
    OMX_U8 *pDst,
    OMX_S32 dstStep,
    OMX_S32 dx,
    OMX_S32 dy,
    OMXSize roi
);



/**
 * Function:  omxVCM4P10_InterpolateChroma   (6.3.3.2.2)
 *
 * Description:
 * Performs 1/8-pixel interpolation for inter chroma MB.
 *
 * Input Arguments:
 *
 *   pSrc -Pointer to the source reference frame buffer
 *   srcStep -Reference frame step in bytes
 *   dstStep -Destination frame step in bytes; must be a multiple of
 *            roi.width.
 *   dx -Fractional part of horizontal motion vector component in 1/8 pixel
 *            unit; valid in the range [0,7]
 *   dy -Fractional part of vertical motion vector component in 1/8 pixel
 *            unit; valid in the range [0,7]
 *   roi -Dimension of the interpolation region; the parameters roi.width and
 *            roi.height must be equal to either 2, 4, or 8.
 *
 * Output Arguments:
 *
 *   pDst -Pointer to the destination frame buffer:
 *         if roi.width==2,  2-byte alignment required
 *         if roi.width==4,  4-byte alignment required
 *         if roi.width==8, 8-byte alignment required
 *
 * Return Value:
 *    If the function runs without error, it returns OMX_Sts_NoErr.
 *    If one of the following cases occurs, the function returns
 *              OMX_Sts_BadArgErr:
 *    pSrc or pDst is NULL.
 *    srcStep or dstStep < 8.
 *    dx or dy is out of range [0-7].
 *    roi.width or roi.height is out of range {2,4,8}.
 *    roi.width is equal to 2, but pDst is not 2-byte aligned.
 *    roi.width is equal to 4, but pDst is not 4-byte aligned.
 *    roi.width is equal to 8, but pDst is not 8 byte aligned.
 *    srcStep or dstStep is not a multiple of 8.
 *
 */
OMXResult omxVCM4P10_InterpolateChroma (
    const OMX_U8 *pSrc,
    OMX_S32 srcStep,
    OMX_U8 *pDst,
    OMX_S32 dstStep,
    OMX_S32 dx,
    OMX_S32 dy,
    OMXSize roi
);



/**
 * Function:  omxVCM4P10_FilterDeblockingLuma_VerEdge_I   (6.3.3.3.1)
 *
 * Description:
 * Performs in-place deblock filtering on four vertical edges of the luma
 * macroblock (16x16).
 *
 * Input Arguments:
 *
 *   pSrcDst - Pointer to the input macroblock; must be 16-byte aligned.
 *   srcdstStep -Step of the arrays; must be a multiple of 16.
 *   pAlpha -Array of size 2 of alpha thresholds (the first item is the alpha
 *            threshold for the external vertical edge, and the second item is
 *            for the internal vertical edge); per [ISO14496-10] alpha values
 *            must be in the range [0,255].
 *   pBeta -Array of size 2 of beta thresholds (the first item is the beta
 *            threshold for the external vertical edge, and the second item is
 *            for the internal vertical edge); per [ISO14496-10] beta values
 *            must be in the range [0,18].
 *   pThresholds -Array of size 16 of Thresholds (TC0) (values for the left
 *            edge of each 4x4 block, arranged in vertical block order); must
 *            be aligned on a 4-byte boundary..  Per [ISO14496-10] values must
 *            be in the range [0,25].
 *   pBS -Array of size 16 of BS parameters (arranged in vertical block
 *            order); valid in the range [0,4] with the following
 *            restrictions: i) pBS[i]== 4 may occur only for 0<=i<=3, ii)
 *            pBS[i]== 4 if and only if pBS[i^3]== 4.  Must be 4-byte aligned.
 *
 * Output Arguments:
 *
 *   pSrcDst -Pointer to filtered output macroblock.
 *
 * Return Value:
 *    If the function runs without error, it returns OMX_Sts_NoErr.
 *    If one of the following cases occurs, the function returns
 *              OMX_Sts_BadArgErr:
 *    Either of the pointers in pSrcDst, pAlpha, pBeta, pThresholds, or pBS
 *              is NULL.
 *    Either pThresholds or pBS is not aligned on a 4-byte boundary.
 *    pSrcDst is not 16-byte aligned.
 *    srcdstStep is not a multiple of 16.
 *    pAlpha[0] and/or pAlpha[1] is outside the range [0,255].
 *    pBeta[0] and/or pBeta[1] is outside the range [0,18].
 *    One or more entries in the table pThresholds[0..15]is outside of the
 *              range [0,25].
 *    pBS is out of range, i.e., one of the following conditions is true:
 *              pBS[i]<0, pBS[i]>4, pBS[i]==4 for i>=4, or (pBS[i]==4 &&
 *              pBS[i^3]!=4) for 0<=i<=3.
 *
 */
OMXResult omxVCM4P10_FilterDeblockingLuma_VerEdge_I (
    OMX_U8 *pSrcDst,
    OMX_S32 srcdstStep,
    const OMX_U8 *pAlpha,
    const OMX_U8 *pBeta,
    const OMX_U8 *pThresholds,
    const OMX_U8 *pBS
);



/**
 * Function:  omxVCM4P10_FilterDeblockingLuma_HorEdge_I   (6.3.3.3.2)
 *
 * Description:
 * Performs in-place deblock filtering on four horizontal edges of the luma
 * macroblock (16x16).
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the input macroblock; must be 16-byte aligned.
 *   srcdstStep - step of the arrays; must be a multiple of 16.
 *   pAlpha - array of size 2 of alpha thresholds (the first item is the alpha
 *            threshold for the external vertical edge, and the second item is
 *            for the internal horizontal edge); per [ISO14496-10] alpha
 *            values must be in the range [0,255].
 *   pBeta - array of size 2 of beta thresholds (the first item is the beta
 *            threshold for the external horizontal edge, and the second item
 *            is for the internal horizontal edge). Per [ISO14496-10] beta
 *            values must be in the range [0,18].
 *   pThresholds - array of size 16 containing thresholds, TC0, for the top
 *            horizontal edge of each 4x4 block, arranged in horizontal block
 *            order; must be aligned on a 4-byte boundary.  Per [ISO14496 10]
 *            values must be in the range [0,25].
 *   pBS - array of size 16 of BS parameters (arranged in horizontal block
 *            order); valid in the range [0,4] with the following
 *            restrictions: i) pBS[i]== 4 may occur only for 0<=i<=3, ii)
 *            pBS[i]== 4 if and only if pBS[i^3]== 4.  Must be 4-byte aligned.
 *
 * Output Arguments:
 *
 *   pSrcDst -Pointer to filtered output macroblock.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr, if the function runs without error.
 *
 *    OMX_Sts_BadArgErr, if one of the following cases occurs:
 *    -    one or more of the following pointers is NULL: pSrcDst, pAlpha,
 *              pBeta, pThresholds, or pBS.
 *    -    either pThresholds or pBS is not aligned on a 4-byte boundary.
 *    -    pSrcDst is not 16-byte aligned.
 *    -    srcdstStep is not a multiple of 16.
 *    -    pAlpha[0] and/or pAlpha[1] is outside the range [0,255].
 *    -    pBeta[0] and/or pBeta[1] is outside the range [0,18].
 *    -    One or more entries in the table pThresholds[0..15] is
 *         outside of the range [0,25].
 *    -    pBS is out of range, i.e., one of the following conditions is true:
 *              pBS[i]<0, pBS[i]>4, pBS[i]==4 for i>=4, or
 *              (pBS[i]==4 && pBS[i^3]!=4) for 0<=i<=3.
 *
 */
OMXResult omxVCM4P10_FilterDeblockingLuma_HorEdge_I (
    OMX_U8 *pSrcDst,
    OMX_S32 srcdstStep,
    const OMX_U8 *pAlpha,
    const OMX_U8 *pBeta,
    const OMX_U8 *pThresholds,
    const OMX_U8 *pBS
);



/**
 * Function:  omxVCM4P10_FilterDeblockingChroma_VerEdge_I   (6.3.3.3.3)
 *
 * Description:
 * Performs in-place deblock filtering on four vertical edges of the chroma
 * macroblock (8x8).
 *
 * Input Arguments:
 *
 *   pSrcDst - Pointer to the input macroblock; must be 8-byte aligned.
 *   srcdstStep - Step of the arrays; must be a multiple of 8.
 *   pAlpha - Array of size 2 of alpha thresholds (the first item is alpha
 *            threshold for external vertical edge, and the second item is for
 *            internal vertical edge); per [ISO14496-10] alpha values must be
 *            in the range [0,255].
 *   pBeta - Array of size 2 of beta thresholds (the first item is the beta
 *            threshold for the external vertical edge, and the second item is
 *            for the internal vertical edge); per [ISO14496-10] beta values
 *            must be in the range [0,18].
 *   pThresholds - Array of size 8 containing thresholds, TC0, for the left
 *            vertical edge of each 4x2 chroma block, arranged in vertical
 *            block order; must be aligned on a 4-byte boundary.  Per
 *            [ISO14496-10] values must be in the range [0,25].
 *   pBS - Array of size 16 of BS parameters (values for each 2x2 chroma
 *            block, arranged in vertical block order). This parameter is the
 *            same as the pBS parameter passed into FilterDeblockLuma_VerEdge;
 *            valid in the range [0,4] with the following restrictions: i)
 *            pBS[i]== 4 may occur only for 0<=i<=3, ii) pBS[i]== 4 if and
 *            only if pBS[i^3]== 4.  Must be 4 byte aligned.
 *
 * Output Arguments:
 *
 *   pSrcDst -Pointer to filtered output macroblock.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr, if the function runs without error.
 *
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    one or more of the following pointers is NULL: pSrcDst, pAlpha,
 *              pBeta, pThresholds, or pBS.
 *    -    pSrcDst is not 8-byte aligned.
 *    -    srcdstStep is not a multiple of 8.
 *    -    pThresholds is not 4-byte aligned.
 *    -    pAlpha[0] and/or pAlpha[1] is outside the range [0,255].
 *    -    pBeta[0] and/or pBeta[1] is outside the range [0,18].
 *    -    One or more entries in the table pThresholds[0..7] is outside
 *         of the range [0,25].
 *    -    pBS is out of range, i.e., one of the following conditions is true:
 *         pBS[i]<0, pBS[i]>4, pBS[i]==4 for i>=4, or
 *         (pBS[i]==4 && pBS[i^3]!=4) for 0<=i<=3.
 *    -    pBS is not 4-byte aligned.
 *
 */
OMXResult omxVCM4P10_FilterDeblockingChroma_VerEdge_I (
    OMX_U8 *pSrcDst,
    OMX_S32 srcdstStep,
    const OMX_U8 *pAlpha,
    const OMX_U8 *pBeta,
    const OMX_U8 *pThresholds,
    const OMX_U8 *pBS
);



/**
 * Function:  omxVCM4P10_FilterDeblockingChroma_HorEdge_I   (6.3.3.3.4)
 *
 * Description:
 * Performs in-place deblock filtering on the horizontal edges of the chroma
 * macroblock (8x8).
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the input macroblock; must be 8-byte aligned.
 *   srcdstStep - array step; must be a multiple of 8.
 *   pAlpha - array of size 2 containing alpha thresholds; the first element
 *            contains the threshold for the external horizontal edge, and the
 *            second element contains the threshold for internal horizontal
 *            edge.  Per [ISO14496-10] alpha values must be in the range
 *            [0,255].
 *   pBeta - array of size 2 containing beta thresholds; the first element
 *            contains the threshold for the external horizontal edge, and the
 *            second element contains the threshold for the internal
 *            horizontal edge.  Per [ISO14496-10] beta values must be in the
 *            range [0,18].
 *   pThresholds - array of size 8 containing thresholds, TC0, for the top
 *            horizontal edge of each 2x4 chroma block, arranged in horizontal
 *            block order; must be aligned on a 4-byte boundary.  Per
 *            [ISO14496-10] values must be in the range [0,25].
 *   pBS - array of size 16 containing BS parameters for each 2x2 chroma
 *            block, arranged in horizontal block order; valid in the range
 *            [0,4] with the following restrictions: i) pBS[i]== 4 may occur
 *            only for 0<=i<=3, ii) pBS[i]== 4 if and only if pBS[i^3]== 4.
 *            Must be 4-byte aligned.
 *
 * Output Arguments:
 *
 *   pSrcDst -Pointer to filtered output macroblock.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr, if the function runs without error.
 *
 *    OMX_Sts_BadArgErr, if one of the following cases occurs:
 *    -    any of the following pointers is NULL:
 *         pSrcDst, pAlpha, pBeta, pThresholds, or pBS.
 *    -    pSrcDst is not 8-byte aligned.
 *    -    srcdstStep is not a multiple of 8.
 *    -    pThresholds is not 4-byte aligned.
 *    -    pAlpha[0] and/or pAlpha[1] is outside the range [0,255].
 *    -    pBeta[0] and/or pBeta[1] is outside the range [0,18].
 *    -    One or more entries in the table pThresholds[0..7] is outside
 *         of the range [0,25].
 *    -    pBS is out of range, i.e., one of the following conditions is true:
 *              pBS[i]<0, pBS[i]>4, pBS[i]==4 for i>=4, or
 *              (pBS[i]==4 && pBS[i^3]!=4) for 0<=i<=3.
 *    -    pBS is not 4-byte aligned.
 *
 */
OMXResult omxVCM4P10_FilterDeblockingChroma_HorEdge_I (
    OMX_U8 *pSrcDst,
    OMX_S32 srcdstStep,
    const OMX_U8 *pAlpha,
    const OMX_U8 *pBeta,
    const OMX_U8 *pThresholds,
    const OMX_U8 *pBS
);



/**
 * Function:  omxVCM4P10_DeblockLuma_I   (6.3.3.3.5)
 *
 * Description:
 * This function performs in-place deblock filtering the horizontal and
 * vertical edges of a luma macroblock (16x16).
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the input macroblock; must be 16-byte aligned.
 *   srcdstStep - image width; must be a multiple of 16.
 *   pAlpha - pointer to a 2x2 table of alpha thresholds, organized as
 *            follows: {external vertical edge, internal vertical edge,
 *            external horizontal edge, internal horizontal edge }.  Per
 *            [ISO14496-10] alpha values must be in the range [0,255].
 *   pBeta - pointer to a 2x2 table of beta thresholds, organized as follows:
 *            {external vertical edge, internal vertical edge, external
 *            horizontal edge, internal horizontal edge }.  Per [ISO14496-10]
 *            beta values must be in the range [0,18].
 *   pThresholds - pointer to a 16x2 table of threshold (TC0), organized as
 *            follows: {values for the left or above edge of each 4x4 block,
 *            arranged in vertical block order and then in horizontal block
 *            order}; must be aligned on a 4-byte boundary.  Per [ISO14496-10]
 *            values must be in the range [0,25].
 *   pBS - pointer to a 16x2 table of BS parameters arranged in scan block
 *            order for vertical edges and then horizontal edges; valid in the
 *            range [0,4] with the following restrictions: i) pBS[i]== 4 may
 *            occur only for 0<=i<=3, ii) pBS[i]== 4 if and only if pBS[i^3]==
 *            4. Must be 4-byte aligned.
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to filtered output macroblock.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments
 *    -     one or more of the following pointers is NULL: pSrcDst, pAlpha,
 *              pBeta, pThresholds or pBS.
 *    -    pSrcDst is not 16-byte aligned.
 *    -    either pThresholds or pBS is not aligned on a 4-byte boundary.
 *    -    one or more entries in the table pAlpha[0..3] is outside the range
 *              [0,255].
 *    -    one or more entries in the table pBeta[0..3] is outside the range
 *              [0,18].
 *    -    one or more entries in the table pThresholds[0..31]is outside of
 *              the range [0,25].
 *    -    pBS is out of range, i.e., one of the following conditions is true:
 *              pBS[i]<0, pBS[i]>4, pBS[i]==4 for i>=4, or
 *             (pBS[i]==4 && pBS[i^3]!=4) for 0<=i<=3.
 *    -    srcdstStep is not a multiple of 16.
 *
 */
OMXResult omxVCM4P10_DeblockLuma_I (
    OMX_U8 *pSrcDst,
    OMX_S32 srcdstStep,
    const OMX_U8 *pAlpha,
    const OMX_U8 *pBeta,
    const OMX_U8 *pThresholds,
    const OMX_U8 *pBS
);



/**
 * Function:  omxVCM4P10_DeblockChroma_I   (6.3.3.3.6)
 *
 * Description:
 * Performs in-place deblocking filtering on all edges of the chroma
 * macroblock (16x16).
 *
 * Input Arguments:
 *
 *   pSrcDst - pointer to the input macroblock; must be 8-byte aligned.
 *   srcdstStep - step of the arrays; must be a multiple of 8.
 *   pAlpha - pointer to a 2x2 array of alpha thresholds, organized as
 *            follows: {external vertical edge, internal vertical edge,
 *            external horizontal edge, internal horizontal edge }.  Per
 *            [ISO14496-10] alpha values must be in the range [0,255].
 *   pBeta - pointer to a 2x2 array of Beta Thresholds, organized as follows:
 *            { external vertical edge, internal vertical edge, external
 *            horizontal edge, internal horizontal edge }.  Per [ISO14496-10]
 *            beta values must be in the range [0,18].
 *   pThresholds - array of size 8x2 of Thresholds (TC0) (values for the left
 *            or above edge of each 4x2 or 2x4 block, arranged in vertical
 *            block order and then in horizontal block order); must be aligned
 *            on a 4-byte boundary. Per [ISO14496-10] values must be in the
 *            range [0,25].
 *   pBS - array of size 16x2 of BS parameters (arranged in scan block order
 *            for vertical edges and then horizontal edges); valid in the
 *            range [0,4] with the following restrictions: i) pBS[i]== 4 may
 *            occur only for 0<=i<=3, ii) pBS[i]== 4 if and only if pBS[i^3]==
 *            4.  Must be 4-byte aligned.
 *
 * Output Arguments:
 *
 *   pSrcDst - pointer to filtered output macroblock.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments
 *    -   one or more of the following pointers is NULL: pSrcDst, pAlpha,
 *              pBeta, pThresholds, or pBS.
 *    -   pSrcDst is not 8-byte aligned.
 *    -   either pThresholds or pBS is not 4-byte aligned.
 *    -   one or more entries in the table pAlpha[0..3] is outside the range
 *              [0,255].
 *    -   one or more entries in the table pBeta[0..3] is outside the range
 *              [0,18].
 *    -   one or more entries in the table pThresholds[0..15]is outside of
 *              the range [0,25].
 *    -   pBS is out of range, i.e., one of the following conditions is true:
 *            pBS[i]<0, pBS[i]>4, pBS[i]==4  for i>=4, or
 *            (pBS[i]==4 && pBS[i^3]!=4) for 0<=i<=3.
 *    -   srcdstStep is not a multiple of 8.
 *
 */
OMXResult omxVCM4P10_DeblockChroma_I (
    OMX_U8 *pSrcDst,
    OMX_S32 srcdstStep,
    const OMX_U8 *pAlpha,
    const OMX_U8 *pBeta,
    const OMX_U8 *pThresholds,
    const OMX_U8 *pBS
);



/**
 * Function:  omxVCM4P10_DecodeChromaDcCoeffsToPairCAVLC   (6.3.4.1.1)
 *
 * Description:
 * Performs CAVLC decoding and inverse raster scan for a 2x2 block of
 * ChromaDCLevel.  The decoded coefficients in the packed position-coefficient
 * buffer are stored in reverse zig-zag order, i.e., the first buffer element
 * contains the last non-zero postion-coefficient pair of the block. Within
 * each position-coefficient pair, the position entry indicates the
 * raster-scan position of the coefficient, while the coefficient entry
 * contains the coefficient value.
 *
 * Input Arguments:
 *
 *   ppBitStream - Double pointer to current byte in bit stream buffer
 *   pOffset - Pointer to current bit position in the byte pointed to by
 *            *ppBitStream; valid in the range [0,7].
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after each block is decoded
 *   pOffset - *pOffset is updated after each block is decoded
 *   pNumCoeff - Pointer to the number of nonzero coefficients in this block
 *   ppPosCoefBuf - Double pointer to destination residual
 *            coefficient-position pair buffer.  Buffer position
 *            (*ppPosCoefBuf) is updated upon return, unless there are only
 *            zero coefficients in the currently decoded block.  In this case
 *            the caller is expected to bypass the transform/dequantization of
 *            the empty blocks.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr, if the function runs without error.
 *
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    ppBitStream or pOffset is NULL.
 *    -    ppPosCoefBuf or pNumCoeff is NULL.
 *    OMX_Sts_Err - if one of the following is true:
 *    -    an illegal code is encountered in the bitstream
 *
 */
OMXResult omxVCM4P10_DecodeChromaDcCoeffsToPairCAVLC (
    const OMX_U8 **ppBitStream,
    OMX_S32*pOffset,
    OMX_U8 *pNumCoeff,
    OMX_U8 **ppPosCoefbuf
);



/**
 * Function:  omxVCM4P10_DecodeCoeffsToPairCAVLC   (6.3.4.1.2)
 *
 * Description:
 * Performs CAVLC decoding and inverse zigzag scan for 4x4 block of
 * Intra16x16DCLevel, Intra16x16ACLevel, LumaLevel, and ChromaACLevel. Inverse
 * field scan is not supported. The decoded coefficients in the packed
 * position-coefficient buffer are stored in reverse zig-zag order, i.e., the
 * first buffer element contains the last non-zero postion-coefficient pair of
 * the block. Within each position-coefficient pair, the position entry
 * indicates the raster-scan position of the coefficient, while the
 * coefficient entry contains the coefficient value.
 *
 * Input Arguments:
 *
 *   ppBitStream -Double pointer to current byte in bit stream buffer
 *   pOffset - Pointer to current bit position in the byte pointed to by
 *            *ppBitStream; valid in the range [0,7].
 *   sMaxNumCoeff - Maximum the number of non-zero coefficients in current
 *            block
 *   sVLCSelect - VLC table selector, obtained from the number of non-zero
 *            coefficients contained in the above and left 4x4 blocks.  It is
 *            equivalent to the variable nC described in H.264 standard table
 *            9 5, except its value can t be less than zero.
 *
 * Output Arguments:
 *
 *   ppBitStream - *ppBitStream is updated after each block is decoded.
 *            Buffer position (*ppPosCoefBuf) is updated upon return, unless
 *            there are only zero coefficients in the currently decoded block.
 *             In this case the caller is expected to bypass the
 *            transform/dequantization of the empty blocks.
 *   pOffset - *pOffset is updated after each block is decoded
 *   pNumCoeff - Pointer to the number of nonzero coefficients in this block
 *   ppPosCoefBuf - Double pointer to destination residual
 *            coefficient-position pair buffer
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    ppBitStream or pOffset is NULL.
 *    -    ppPosCoefBuf or pNumCoeff is NULL.
 *    -    sMaxNumCoeff is not equal to either 15 or 16.
 *    -    sVLCSelect is less than 0.
 *
 *    OMX_Sts_Err - if one of the following is true:
 *    -    an illegal code is encountered in the bitstream
 *
 */
OMXResult omxVCM4P10_DecodeCoeffsToPairCAVLC (
    const OMX_U8 **ppBitStream,
    OMX_S32 *pOffset,
    OMX_U8 *pNumCoeff,
    OMX_U8 **ppPosCoefbuf,
    OMX_INT sVLCSelect,
    OMX_INT sMaxNumCoeff
);



/**
 * Function:  omxVCM4P10_TransformDequantLumaDCFromPair   (6.3.4.2.1)
 *
 * Description:
 * Reconstructs the 4x4 LumaDC block from the coefficient-position pair
 * buffer, performs integer inverse, and dequantization for 4x4 LumaDC
 * coefficients, and updates the pair buffer pointer to the next non-empty
 * block.
 *
 * Input Arguments:
 *
 *   ppSrc - Double pointer to residual coefficient-position pair buffer
 *            output by CALVC decoding
 *   QP - Quantization parameter QpY
 *
 * Output Arguments:
 *
 *   ppSrc - *ppSrc is updated to the start of next non empty block
 *   pDst - Pointer to the reconstructed 4x4 LumaDC coefficients buffer; must
 *            be aligned on a 8-byte boundary.
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    ppSrc or pDst is NULL.
 *    -    pDst is not 8 byte aligned.
 *    -    QP is not in the range of [0-51].
 *
 */
OMXResult omxVCM4P10_TransformDequantLumaDCFromPair (
    const OMX_U8 **ppSrc,
    OMX_S16 *pDst,
    OMX_INT QP
);



/**
 * Function:  omxVCM4P10_TransformDequantChromaDCFromPair   (6.3.4.2.2)
 *
 * Description:
 * Reconstruct the 2x2 ChromaDC block from coefficient-position pair buffer,
 * perform integer inverse transformation, and dequantization for 2x2 chroma
 * DC coefficients, and update the pair buffer pointer to next non-empty
 * block.
 *
 * Input Arguments:
 *
 *   ppSrc - Double pointer to residual coefficient-position pair buffer
 *            output by CALVC decoding
 *   QP - Quantization parameter QpC
 *
 * Output Arguments:
 *
 *   ppSrc - *ppSrc is updated to the start of next non empty block
 *   pDst - Pointer to the reconstructed 2x2 ChromaDC coefficients buffer;
 *            must be aligned on a 4-byte boundary.
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    ppSrc or pDst is NULL.
 *    -    pDst is not 4-byte aligned.
 *    -    QP is not in the range of [0-51].
 *
 */
OMXResult omxVCM4P10_TransformDequantChromaDCFromPair (
    const OMX_U8 **ppSrc,
    OMX_S16 *pDst,
    OMX_INT QP
);



/**
 * Function:  omxVCM4P10_DequantTransformResidualFromPairAndAdd   (6.3.4.2.3)
 *
 * Description:
 * Reconstruct the 4x4 residual block from coefficient-position pair buffer,
 * perform dequantization and integer inverse transformation for 4x4 block of
 * residuals with previous intra prediction or motion compensation data, and
 * update the pair buffer pointer to next non-empty block. If pDC == NULL,
 * there re 16 non-zero AC coefficients at most in the packed buffer starting
 * from 4x4 block position 0; If pDC != NULL, there re 15 non-zero AC
 * coefficients at most in the packet buffer starting from 4x4 block position
 * 1.
 *
 * Input Arguments:
 *
 *   ppSrc - Double pointer to residual coefficient-position pair buffer
 *            output by CALVC decoding
 *   pPred - Pointer to the predicted 4x4 block; must be aligned on a 4-byte
 *            boundary
 *   predStep - Predicted frame step size in bytes; must be a multiple of 4
 *   dstStep - Destination frame step in bytes; must be a multiple of 4
 *   pDC - Pointer to the DC coefficient of this block, NULL if it doesn't
 *            exist
 *   QP - QP Quantization parameter.  It should be QpC in chroma 4x4 block
 *            decoding, otherwise it should be QpY.
 *   AC - Flag indicating if at least one non-zero AC coefficient exists
 *
 * Output Arguments:
 *
 *   pDst - pointer to the reconstructed 4x4 block data; must be aligned on a
 *            4-byte boundary
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    pPred or pDst is NULL.
 *    -    pPred or pDst is not 4-byte aligned.
 *    -    predStep or dstStep is not a multiple of 4.
 *    -    AC !=0 and Qp is not in the range of [0-51] or ppSrc == NULL.
 *    -    AC ==0 && pDC ==NULL.
 *
 */
OMXResult omxVCM4P10_DequantTransformResidualFromPairAndAdd (
    const OMX_U8 **ppSrc,
    const OMX_U8 *pPred,
    const OMX_S16 *pDC,
    OMX_U8 *pDst,
    OMX_INT predStep,
    OMX_INT dstStep,
    OMX_INT QP,
    OMX_INT AC
);



/**
 * Function:  omxVCM4P10_MEGetBufSize   (6.3.5.1.1)
 *
 * Description:
 * Computes the size, in bytes, of the vendor-specific specification
 * structure for the omxVCM4P10 motion estimation functions BlockMatch_Integer
 * and MotionEstimationMB.
 *
 * Input Arguments:
 *
 *   MEmode - motion estimation mode; available modes are defined by the
 *            enumerated type OMXVCM4P10MEMode
 *   pMEParams -motion estimation parameters
 *
 * Output Arguments:
 *
 *   pSize - pointer to the number of bytes required for the motion
 *            estimation specification structure
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    pMEParams or pSize is NULL.
 *    -    an invalid MEMode is specified.
 *
 */
OMXResult omxVCM4P10_MEGetBufSize (
    OMXVCM4P10MEMode MEmode,
    const OMXVCM4P10MEParams *pMEParams,
    OMX_U32 *pSize
);



/**
 * Function:  omxVCM4P10_MEInit   (6.3.5.1.2)
 *
 * Description:
 * Initializes the vendor-specific specification structure required for the
 * omxVCM4P10 motion estimation functions:  BlockMatch_Integer and
 * MotionEstimationMB. Memory for the specification structure *pMESpec must be
 * allocated prior to calling the function, and should be aligned on a 4-byte
 * boundary.  The number of bytes required for the specification structure can
 * be determined using the function omxVCM4P10_MEGetBufSize. Following
 * initialization by this function, the vendor-specific structure *pMESpec
 * should contain an implementation-specific representation of all motion
 * estimation parameters received via the structure pMEParams, for example
 * searchRange16x16, searchRange8x8, etc.
 *
 * Input Arguments:
 *
 *   MEmode - motion estimation mode; available modes are defined by the
 *            enumerated type OMXVCM4P10MEMode
 *   pMEParams - motion estimation parameters
 *   pMESpec - pointer to the uninitialized ME specification structure
 *
 * Output Arguments:
 *
 *   pMESpec - pointer to the initialized ME specification structure
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    pMEParams or pSize is NULL.
 *    -    an invalid value was specified for the parameter MEmode
 *    -    a negative or zero value was specified for one of the search ranges
 *         (e.g.,  pMBParams >searchRange8x8, pMEParams->searchRange16x16, etc.)
 *    -    either in isolation or in combination, one or more of the enables or
 *         search ranges in the structure *pMEParams were configured such
 *         that the requested behavior fails to comply with [ISO14496-10].
 *
 */
OMXResult omxVCM4P10_MEInit (
    OMXVCM4P10MEMode MEmode,
    const OMXVCM4P10MEParams *pMEParams,
    void *pMESpec
);



/**
 * Function:  omxVCM4P10_BlockMatch_Integer   (6.3.5.2.1)
 *
 * Description:
 * Performs integer block match.  Returns best MV and associated cost.
 *
 * Input Arguments:
 *
 *   pSrcOrgY - Pointer to the top-left corner of the current block:
 *            If iBlockWidth==4,  4-byte alignment required.
 *            If iBlockWidth==8,  8-byte alignment required.
 *            If iBlockWidth==16, 16-byte alignment required.
 *   pSrcRefY - Pointer to the top-left corner of the co-located block in the
 *            reference picture:
 *            If iBlockWidth==4,  4-byte alignment required.
 *            If iBlockWidth==8,  8-byte alignment required.
 *            If iBlockWidth==16, 16-byte alignment required.
 *   nSrcOrgStep - Stride of the original picture plane, expressed in terms
 *            of integer pixels; must be a multiple of iBlockWidth.
 *   nSrcRefStep - Stride of the reference picture plane, expressed in terms
 *            of integer pixels
 *   pRefRect - pointer to the valid reference rectangle inside the reference
 *            picture plane
 *   nCurrPointPos - position of the current block in the current plane
 *   iBlockWidth - Width of the current block, expressed in terms of integer
 *            pixels; must be equal to either 4, 8, or 16.
 *   iBlockHeight - Height of the current block, expressed in terms of
 *            integer pixels; must be equal to either 4, 8, or 16.
 *   nLamda - Lamda factor; used to compute motion cost
 *   pMVPred - Predicted MV; used to compute motion cost, expressed in terms
 *            of 1/4-pel units
 *   pMVCandidate - Candidate MV; used to initialize the motion search,
 *            expressed in terms of integer pixels
 *   pMESpec - pointer to the ME specification structure
 *
 * Output Arguments:
 *
 *   pDstBestMV - Best MV resulting from integer search, expressed in terms
 *            of 1/4-pel units
 *   pBestCost - Motion cost associated with the best MV; computed as
 *            SAD+Lamda*BitsUsedByMV
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    any of the following pointers are NULL:
 *         pSrcOrgY, pSrcRefY, pRefRect, pMVPred, pMVCandidate, or pMESpec.
 *    -    Either iBlockWidth or iBlockHeight are values other than 4, 8, or 16.
 *    -    Any alignment restrictions are violated
 *
 */
OMXResult omxVCM4P10_BlockMatch_Integer (
    const OMX_U8 *pSrcOrgY,
    OMX_S32 nSrcOrgStep,
    const OMX_U8 *pSrcRefY,
    OMX_S32 nSrcRefStep,
    const OMXRect *pRefRect,
    const OMXVCM4P2Coordinate *pCurrPointPos,
    OMX_U8 iBlockWidth,
    OMX_U8 iBlockHeight,
    OMX_U32 nLamda,
    const OMXVCMotionVector *pMVPred,
    const OMXVCMotionVector *pMVCandidate,
    OMXVCMotionVector *pBestMV,
    OMX_S32 *pBestCost,
    void *pMESpec
);



/**
 * Function:  omxVCM4P10_BlockMatch_Half   (6.3.5.2.2)
 *
 * Description:
 * Performs a half-pel block match using results from a prior integer search.
 *  Returns the best MV and associated cost.  This function estimates the
 * half-pixel motion vector by interpolating the integer resolution motion
 * vector referenced by the input parameter pSrcDstBestMV, i.e., the initial
 * integer MV is generated externally.  The function
 * omxVCM4P10_BlockMatch_Integer may be used for integer motion estimation.
 *
 * Input Arguments:
 *
 *   pSrcOrgY - Pointer to the current position in original picture plane:
 *              If iBlockWidth==4,  4-byte alignment required.
 *              If iBlockWidth==8,  8-byte alignment required.
 *              If iBlockWidth==16, 16-byte alignment required.
 *   pSrcRefY - Pointer to the top-left corner of the co-located block in the
 *            reference picture:
 *              If iBlockWidth==4,  4-byte alignment required.
 *              If iBlockWidth==8,  8-byte alignment required.
 *              If iBlockWidth==16, 16-byte alignment required.
 *   nSrcOrgStep - Stride of the original picture plane in terms of full
 *            pixels; must be a multiple of iBlockWidth.
 *   nSrcRefStep - Stride of the reference picture plane in terms of full
 *            pixels
 *   iBlockWidth - Width of the current block in terms of full pixels; must
 *            be equal to either 4, 8, or 16.
 *   iBlockHeight - Height of the current block in terms of full pixels; must
 *            be equal to either 4, 8, or 16.
 *   nLamda - Lamda factor, used to compute motion cost
 *   pMVPred - Predicted MV, represented in terms of 1/4-pel units; used to
 *            compute motion cost
 *   pSrcDstBestMV - The best MV resulting from a prior integer search,
 *            represented in terms of 1/4-pel units
 *
 * Output Arguments:
 *
 *   pSrcDstBestMV - Best MV resulting from the half-pel search, expressed in
 *            terms of 1/4-pel units
 *   pBestCost - Motion cost associated with the best MV; computed as
 *            SAD+Lamda*BitsUsedByMV
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    any of the following pointers is NULL: pSrcOrgY, pSrcRefY,
 *              pSrcDstBestMV, pMVPred, pBestCost
 *    -    iBlockWidth or iBlockHeight are equal to values other than 4, 8, or 16.
 *    -    Any alignment restrictions are violated
 *
 */
OMXResult omxVCM4P10_BlockMatch_Half (
    const OMX_U8 *pSrcOrgY,
    OMX_S32 nSrcOrgStep,
    const OMX_U8 *pSrcRefY,
    OMX_S32 nSrcRefStep,
    OMX_U8 iBlockWidth,
    OMX_U8 iBlockHeight,
    OMX_U32 nLamda,
    const OMXVCMotionVector *pMVPred,
    OMXVCMotionVector *pSrcDstBestMV,
    OMX_S32 *pBestCost
);



/**
 * Function:  omxVCM4P10_BlockMatch_Quarter   (6.3.5.2.3)
 *
 * Description:
 * Performs a quarter-pel block match using results from a prior half-pel
 * search.  Returns the best MV and associated cost.  This function estimates
 * the quarter-pixel motion vector by interpolating the half-pel resolution
 * motion vector referenced by the input parameter pSrcDstBestMV, i.e., the
 * initial half-pel MV is generated externally.  The function
 * omxVCM4P10_BlockMatch_Half may be used for half-pel motion estimation.
 *
 * Input Arguments:
 *
 *   pSrcOrgY - Pointer to the current position in original picture plane:
 *            If iBlockWidth==4,  4-byte alignment required.
 *            If iBlockWidth==8,  8-byte alignment required.
 *            If iBlockWidth==16, 16-byte alignment required.
 *   pSrcRefY - Pointer to the top-left corner of the co-located block in the
 *            reference picture:
 *            If iBlockWidth==4,  4-byte alignment required.
 *            If iBlockWidth==8,  8-byte alignment required.
 *            If iBlockWidth==16, 16-byte alignment required.
 *   nSrcOrgStep - Stride of the original picture plane in terms of full
 *            pixels; must be a multiple of iBlockWidth.
 *   nSrcRefStep - Stride of the reference picture plane in terms of full
 *            pixels
 *   iBlockWidth - Width of the current block in terms of full pixels; must
 *            be equal to either 4, 8, or 16.
 *   iBlockHeight - Height of the current block in terms of full pixels; must
 *            be equal to either 4, 8, or 16.
 *   nLamda - Lamda factor, used to compute motion cost
 *   pMVPred - Predicted MV, represented in terms of 1/4-pel units; used to
 *            compute motion cost
 *   pSrcDstBestMV - The best MV resulting from a prior half-pel search,
 *            represented in terms of 1/4 pel units
 *
 * Output Arguments:
 *
 *   pSrcDstBestMV - Best MV resulting from the quarter-pel search, expressed
 *            in terms of 1/4-pel units
 *   pBestCost - Motion cost associated with the best MV; computed as
 *            SAD+Lamda*BitsUsedByMV
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    One or more of the following pointers is NULL:
 *         pSrcOrgY, pSrcRefY, pSrcDstBestMV, pMVPred, pBestCost
 *    -    iBlockWidth or iBlockHeight are equal to values other than 4, 8, or 16.
 *    -    Any alignment restrictions are violated
 *
 */
OMXResult omxVCM4P10_BlockMatch_Quarter (
    const OMX_U8 *pSrcOrgY,
    OMX_S32 nSrcOrgStep,
    const OMX_U8 *pSrcRefY,
    OMX_S32 nSrcRefStep,
    OMX_U8 iBlockWidth,
    OMX_U8 iBlockHeight,
    OMX_U32 nLamda,
    const OMXVCMotionVector *pMVPred,
    OMXVCMotionVector *pSrcDstBestMV,
    OMX_S32 *pBestCost
);



/**
 * Function:  omxVCM4P10_MotionEstimationMB   (6.3.5.3.1)
 *
 * Description:
 * Performs MB-level motion estimation and selects best motion estimation
 * strategy from the set of modes supported in baseline profile [ISO14496-10].
 *
 * Input Arguments:
 *
 *   pSrcCurrBuf - Pointer to the current position in original picture plane;
 *            16-byte alignment required
 *   pSrcRefBufList - Pointer to an array with 16 entries.  Each entry points
 *            to the top-left corner of the co-located MB in a reference
 *            picture.  The array is filled from low-to-high with valid
 *            reference frame pointers; the unused high entries should be set
 *            to NULL.  Ordering of the reference frames should follow
 *            [ISO14496-10] subclause 8.2.4  Decoding Process for Reference
 *            Picture Lists.   The entries must be 16-byte aligned.
 *   pSrcRecBuf - Pointer to the top-left corner of the co-located MB in the
 *            reconstructed picture; must be 16-byte aligned.
 *   SrcCurrStep - Width of the original picture plane in terms of full
 *            pixels; must be a multiple of 16.
 *   SrcRefStep - Width of the reference picture plane in terms of full
 *            pixels; must be a multiple of 16.
 *   SrcRecStep - Width of the reconstructed picture plane in terms of full
 *            pixels; must be a multiple of 16.
 *   pRefRect - Pointer to the valid reference rectangle; relative to the
 *            image origin.
 *   pCurrPointPos - Position of the current macroblock in the current plane.
 *   Lambda - Lagrange factor for computing the cost function
 *   pMESpec - Pointer to the motion estimation specification structure; must
 *            have been allocated and initialized prior to calling this
 *            function.
 *   pMBInter - Array, of dimension four, containing pointers to information
 *            associated with four adjacent type INTER MBs (Left, Top,
 *            Top-Left, Top-Right). Any pointer in the array may be set equal
 *            to NULL if the corresponding MB doesn t exist or is not of type
 *            INTER.
 *            -  pMBInter[0] - Pointer to left MB information
 *            -  pMBInter[1] - Pointer to top MB information
 *            -  pMBInter[2] - Pointer to top-left MB information
 *            -  pMBInter[3] - Pointer to top-right MB information
 *   pMBIntra - Array, of dimension four, containing pointers to information
 *            associated with four adjacent type INTRA MBs (Left, Top,
 *            Top-Left, Top-Right). Any pointer in the array may be set equal
 *            to NULL if the corresponding MB doesn t exist or is not of type
 *            INTRA.
 *            -  pMBIntra[0] - Pointer to left MB information
 *            -  pMBIntra[1] - Pointer to top MB information
 *            -  pMBIntra[2] - Pointer to top-left MB information
 *            -  pMBIntra[3] - Pointer to top-right MB information
 *   pSrcDstMBCurr - Pointer to information structure for the current MB.
 *            The following entries should be set prior to calling the
 *            function:  sliceID - the number of the slice the to which the
 *            current MB belongs.
 *
 * Output Arguments:
 *
 *   pDstCost - Pointer to the minimum motion cost for the current MB.
 *   pDstBlockSAD - Pointer to the array of SADs for each of the sixteen luma
 *            4x4 blocks in each MB.  The block SADs are in scan order for
 *            each MB.  For implementations that cannot compute the SAD values
 *            individually, the maximum possible value (0xffff) is returned
 *            for each of the 16 block SAD entries.
 *   pSrcDstMBCurr - Pointer to updated information structure for the current
 *            MB after MB-level motion estimation has been completed.  The
 *            following fields are updated by the ME function.   The following
 *            parameter set quantifies the MB-level ME search results:
 *            -  MbType
 *            -  subMBType[4]
 *            -  pMV0[4][4]
 *            -  pMVPred[4][4]
 *            -  pRefL0Idx[4]
 *            -  Intra16x16PredMode
 *            -  pIntra4x4PredMode[4][4]
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -   One or more of the following pointers is NULL: pSrcCurrBuf,
 *           pSrcRefBufList, pSrcRecBuf, pRefRect, pCurrPointPos, pMESpec,
 *           pMBInter, pMBIntra,pSrcDstMBCurr, pDstCost, pSrcRefBufList[0]
 *    -    SrcRefStep, SrcRecStep are not multiples of 16
 *    -    iBlockWidth or iBlockHeight are values other than 4, 8, or 16.
 *    -    Any alignment restrictions are violated
 *
 */
OMXResult omxVCM4P10_MotionEstimationMB (
    const OMX_U8 *pSrcCurrBuf,
    OMX_S32 SrcCurrStep,
    const OMX_U8 *pSrcRefBufList[15],
    OMX_S32 SrcRefStep,
    const OMX_U8 *pSrcRecBuf,
    OMX_S32 SrcRecStep,
    const OMXRect *pRefRect,
    const OMXVCM4P2Coordinate *pCurrPointPos,
    OMX_U32 Lambda,
    void *pMESpec,
    const OMXVCM4P10MBInfoPtr *pMBInter,
    const OMXVCM4P10MBInfoPtr *pMBIntra,
    OMXVCM4P10MBInfoPtr pSrcDstMBCurr,
    OMX_INT *pDstCost,
    OMX_U16 *pDstBlockSAD
);



/**
 * Function:  omxVCM4P10_SAD_4x   (6.3.5.4.1)
 *
 * Description:
 * This function calculates the SAD for 4x8 and 4x4 blocks.
 *
 * Input Arguments:
 *
 *   pSrcOrg -Pointer to the original block; must be aligned on a 4-byte
 *            boundary.
 *   iStepOrg -Step of the original block buffer; must be a multiple of 4.
 *   pSrcRef -Pointer to the reference block
 *   iStepRef -Step of the reference block buffer
 *   iHeight -Height of the block; must be equal to either 4 or 8.
 *
 * Output Arguments:
 *
 *   pDstSAD -Pointer of result SAD
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    One or more of the following pointers is NULL:
 *         pSrcOrg, pSrcRef, or pDstSAD
 *    -    iHeight is not equal to either 4 or 8.
 *    -    iStepOrg is not a multiple of 4
 *    -    Any alignment restrictions are violated
 *
 */
OMXResult omxVCM4P10_SAD_4x (
    const OMX_U8 *pSrcOrg,
    OMX_U32 iStepOrg,
    const OMX_U8 *pSrcRef,
    OMX_U32 iStepRef,
    OMX_S32 *pDstSAD,
    OMX_U32 iHeight
);



/**
 * Function:  omxVCM4P10_SADQuar_4x   (6.3.5.4.2)
 *
 * Description:
 * This function calculates the SAD between one block (pSrc) and the average
 * of the other two (pSrcRef0 and pSrcRef1) for 4x8 or 4x4 blocks.  Rounding
 * is applied according to the convention (a+b+1)>>1.
 *
 * Input Arguments:
 *
 *   pSrc - Pointer to the original block; must be aligned on a 4-byte
 *            boundary.
 *   pSrcRef0 - Pointer to reference block 0
 *   pSrcRef1 - Pointer to reference block 1
 *   iSrcStep - Step of the original block buffer; must be a multiple of 4.
 *   iRefStep0 - Step of reference block 0
 *   iRefStep1 - Step of reference block 1
 *   iHeight - Height of the block; must be equal to either 4 or 8.
 *
 * Output Arguments:
 *
 *   pDstSAD - Pointer of result SAD
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    iHeight is not equal to either 4 or 8.
 *    -    One or more of the following pointers is NULL: pSrc, pSrcRef0,
 *              pSrcRef1, pDstSAD.
 *    -    iSrcStep is not a multiple of 4
 *    -    Any alignment restrictions are violated
 *
 */
OMXResult omxVCM4P10_SADQuar_4x (
    const OMX_U8 *pSrc,
    const OMX_U8 *pSrcRef0,
    const OMX_U8 *pSrcRef1,
    OMX_U32 iSrcStep,
    OMX_U32 iRefStep0,
    OMX_U32 iRefStep1,
    OMX_U32 *pDstSAD,
    OMX_U32 iHeight
);



/**
 * Function:  omxVCM4P10_SADQuar_8x   (6.3.5.4.3)
 *
 * Description:
 * This function calculates the SAD between one block (pSrc) and the average
 * of the other two (pSrcRef0 and pSrcRef1) for 8x16, 8x8, or 8x4 blocks.
 * Rounding is applied according to the convention (a+b+1)>>1.
 *
 * Input Arguments:
 *
 *   pSrc - Pointer to the original block; must be aligned on an 8-byte
 *            boundary.
 *   pSrcRef0 - Pointer to reference block 0
 *   pSrcRef1 - Pointer to reference block 1
 *   iSrcStep - Step of the original block buffer; must be a multiple of 8.
 *   iRefStep0 - Step of reference block 0
 *   iRefStep1 - Step of reference block 1
 *   iHeight - Height of the block; must be equal either 4, 8, or 16.
 *
 * Output Arguments:
 *
 *   pDstSAD - Pointer of result SAD
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    iHeight is not equal to either 4, 8, or 16.
 *    -    One or more of the following pointers is NULL: pSrc, pSrcRef0,
 *              pSrcRef1, pDstSAD.
 *    -    iSrcStep is not a multiple of 8
 *    -    Any alignment restrictions are violated
 *
 */
OMXResult omxVCM4P10_SADQuar_8x (
    const OMX_U8 *pSrc,
    const OMX_U8 *pSrcRef0,
    const OMX_U8 *pSrcRef1,
    OMX_U32 iSrcStep,
    OMX_U32 iRefStep0,
    OMX_U32 iRefStep1,
    OMX_U32 *pDstSAD,
    OMX_U32 iHeight
);



/**
 * Function:  omxVCM4P10_SADQuar_16x   (6.3.5.4.4)
 *
 * Description:
 * This function calculates the SAD between one block (pSrc) and the average
 * of the other two (pSrcRef0 and pSrcRef1) for 16x16 or 16x8 blocks.
 * Rounding is applied according to the convention (a+b+1)>>1.
 *
 * Input Arguments:
 *
 *   pSrc - Pointer to the original block; must be aligned on a 16-byte
 *            boundary.
 *   pSrcRef0 - Pointer to reference block 0
 *   pSrcRef1 - Pointer to reference block 1
 *   iSrcStep - Step of the original block buffer; must be a multiple of 16
 *   iRefStep0 - Step of reference block 0
 *   iRefStep1 - Step of reference block 1
 *   iHeight - Height of the block; must be equal to either 8 or 16
 *
 * Output Arguments:
 *
 *   pDstSAD -Pointer of result SAD
 *
 * Return Value:
 *    OMX_Sts_NoErr, if the function runs without error.
 *    OMX_Sts_BadArgErr - bad arguments: if one of the following cases occurs:
 *    -    iHeight is not equal to either 8 or 16.
 *    -    One or more of the following pointers is NULL: pSrc, pSrcRef0,
 *              pSrcRef1, pDstSAD.
 *    -    iSrcStep is not a multiple of 16
 *    -    Any alignment restrictions are violated
 *
 */
OMXResult omxVCM4P10_SADQuar_16x (
    const OMX_U8 *pSrc,
    const OMX_U8 *pSrcRef0,
    const OMX_U8 *pSrcRef1,
    OMX_U32 iSrcStep,
    OMX_U32 iRefStep0,
    OMX_U32 iRefStep1,
    OMX_U32 *pDstSAD,
    OMX_U32 iHeight
);



/**
 * Function:  omxVCM4P10_SATD_4x4   (6.3.5.4.5)
 *
 * Description:
 * This function calculates the sum of absolute transform differences (SATD)
 * for a 4x4 block by applying a Hadamard transform to the difference block
 * and then calculating the sum of absolute coefficient values.
 *
 * Input Arguments:
 *
 *   pSrcOrg - Pointer to the original block; must be aligned on a 4-byte
 *            boundary
 *   iStepOrg - Step of the original block buffer; must be a multiple of 4
 *   pSrcRef - Pointer to the reference block; must be aligned on a 4-byte
 *            boundary
 *   iStepRef - Step of the reference block buffer; must be a multiple of 4
 *
 * Output Arguments:
 *
 *   pDstSAD - pointer to the resulting SAD
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL:
 *         pSrcOrg, pSrcRef, or pDstSAD either pSrcOrg
 *    -    pSrcRef is not aligned on a 4-byte boundary
 *    -    iStepOrg <= 0 or iStepOrg is not a multiple of 4
 *    -    iStepRef <= 0 or iStepRef is not a multiple of 4
 *
 */
OMXResult omxVCM4P10_SATD_4x4 (
    const OMX_U8 *pSrcOrg,
    OMX_U32 iStepOrg,
    const OMX_U8 *pSrcRef,
    OMX_U32 iStepRef,
    OMX_U32 *pDstSAD
);



/**
 * Function:  omxVCM4P10_InterpolateHalfHor_Luma   (6.3.5.5.1)
 *
 * Description:
 * This function performs interpolation for two horizontal 1/2-pel positions
 * (-1/2,0) and (1/2, 0) - around a full-pel position.
 *
 * Input Arguments:
 *
 *   pSrc - Pointer to the top-left corner of the block used to interpolate in
 *            the reconstruction frame plane.
 *   iSrcStep - Step of the source buffer.
 *   iDstStep - Step of the destination(interpolation) buffer; must be a
 *            multiple of iWidth.
 *   iWidth - Width of the current block; must be equal to either 4, 8, or 16
 *   iHeight - Height of the current block; must be equal to 4, 8, or 16
 *
 * Output Arguments:
 *
 *   pDstLeft -Pointer to the interpolation buffer of the left -pel position
 *            (-1/2, 0)
 *                 If iWidth==4,  4-byte alignment required.
 *                 If iWidth==8,  8-byte alignment required.
 *                 If iWidth==16, 16-byte alignment required.
 *   pDstRight -Pointer to the interpolation buffer of the right -pel
 *            position (1/2, 0)
 *                 If iWidth==4,  4-byte alignment required.
 *                 If iWidth==8,  8-byte alignment required.
 *                 If iWidth==16, 16-byte alignment required.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL:
 *             pSrc, pDstLeft, or pDstRight
 *    -    iWidth or iHeight have values other than 4, 8, or 16
 *    -    iWidth==4 but pDstLeft and/or pDstRight is/are not aligned on a 4-byte boundary
 *    -    iWidth==8 but pDstLeft and/or pDstRight is/are not aligned on a 8-byte boundary
 *    -    iWidth==16 but pDstLeft and/or pDstRight is/are not aligned on a 16-byte boundary
 *    -    any alignment restrictions are violated
 *
 */
OMXResult omxVCM4P10_InterpolateHalfHor_Luma (
    const OMX_U8 *pSrc,
    OMX_U32 iSrcStep,
    OMX_U8 *pDstLeft,
    OMX_U8 *pDstRight,
    OMX_U32 iDstStep,
    OMX_U32 iWidth,
    OMX_U32 iHeight
);



/**
 * Function:  omxVCM4P10_InterpolateHalfVer_Luma   (6.3.5.5.2)
 *
 * Description:
 * This function performs interpolation for two vertical 1/2-pel positions -
 * (0, -1/2) and (0, 1/2) - around a full-pel position.
 *
 * Input Arguments:
 *
 *   pSrc - Pointer to top-left corner of block used to interpolate in the
 *            reconstructed frame plane
 *   iSrcStep - Step of the source buffer.
 *   iDstStep - Step of the destination (interpolation) buffer; must be a
 *            multiple of iWidth.
 *   iWidth - Width of the current block; must be equal to either 4, 8, or 16
 *   iHeight - Height of the current block; must be equal to either 4, 8, or 16
 *
 * Output Arguments:
 *
 *   pDstUp -Pointer to the interpolation buffer of the -pel position above
 *            the current full-pel position (0, -1/2)
 *                If iWidth==4, 4-byte alignment required.
 *                If iWidth==8, 8-byte alignment required.
 *                If iWidth==16, 16-byte alignment required.
 *   pDstDown -Pointer to the interpolation buffer of the -pel position below
 *            the current full-pel position (0, 1/2)
 *                If iWidth==4, 4-byte alignment required.
 *                If iWidth==8, 8-byte alignment required.
 *                If iWidth==16, 16-byte alignment required.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL:
 *            pSrc, pDstUp, or pDstDown
 *    -    iWidth or iHeight have values other than 4, 8, or 16
 *    -    iWidth==4 but pDstUp and/or pDstDown is/are not aligned on a 4-byte boundary
 *    -    iWidth==8 but pDstUp and/or pDstDown is/are not aligned on a 8-byte boundary
 *    -    iWidth==16 but pDstUp and/or pDstDown is/are not aligned on a 16-byte boundary
 *
 */
OMXResult omxVCM4P10_InterpolateHalfVer_Luma (
    const OMX_U8 *pSrc,
    OMX_U32 iSrcStep,
    OMX_U8 *pDstUp,
    OMX_U8 *pDstDown,
    OMX_U32 iDstStep,
    OMX_U32 iWidth,
    OMX_U32 iHeight
);



/**
 * Function:  omxVCM4P10_Average_4x   (6.3.5.5.3)
 *
 * Description:
 * This function calculates the average of two 4x4, 4x8 blocks.  The result
 * is rounded according to (a+b+1)/2.
 *
 * Input Arguments:
 *
 *   pPred0 - Pointer to the top-left corner of reference block 0
 *   pPred1 - Pointer to the top-left corner of reference block 1
 *   iPredStep0 - Step of reference block 0; must be a multiple of 4.
 *   iPredStep1 - Step of reference block 1; must be a multiple of 4.
 *   iDstStep - Step of the destination buffer; must be a multiple of 4.
 *   iHeight - Height of the blocks; must be either 4 or 8.
 *
 * Output Arguments:
 *
 *   pDstPred - Pointer to the destination buffer. 4-byte alignment required.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL:
 *           pPred0, pPred1, or pDstPred
 *    -    pDstPred is not aligned on a 4-byte boundary
 *    -    iPredStep0 <= 0 or iPredStep0 is not a multiple of 4
 *    -    iPredStep1 <= 0 or iPredStep1 is not a multiple of 4
 *    -    iDstStep <= 0 or iDstStep is not a multiple of 4
 *    -    iHeight is not equal to either 4 or 8
 *
 */
OMXResult omxVCM4P10_Average_4x (
    const OMX_U8 *pPred0,
    const OMX_U8 *pPred1,
    OMX_U32 iPredStep0,
    OMX_U32 iPredStep1,
    OMX_U8 *pDstPred,
    OMX_U32 iDstStep,
    OMX_U32 iHeight
);



/**
 * Function:  omxVCM4P10_TransformQuant_ChromaDC   (6.3.5.6.1)
 *
 * Description:
 * This function performs 2x2 Hadamard transform of chroma DC coefficients
 * and then quantizes the coefficients.
 *
 * Input Arguments:
 *
 *   pSrcDst - Pointer to the 2x2 array of chroma DC coefficients.  8-byte
 *            alignment required.
 *   iQP - Quantization parameter; must be in the range [0,51].
 *   bIntra - Indicate whether this is an INTRA block. 1-INTRA, 0-INTER
 *
 * Output Arguments:
 *
 *   pSrcDst - Pointer to transformed and quantized coefficients.  8-byte
 *            alignment required.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL:
 *             pSrcDst
 *    -    pSrcDst is not aligned on an 8-byte boundary
 *
 */
OMXResult omxVCM4P10_TransformQuant_ChromaDC (
    OMX_S16 *pSrcDst,
    OMX_U32 iQP,
    OMX_U8 bIntra
);



/**
 * Function:  omxVCM4P10_TransformQuant_LumaDC   (6.3.5.6.2)
 *
 * Description:
 * This function performs a 4x4 Hadamard transform of luma DC coefficients
 * and then quantizes the coefficients.
 *
 * Input Arguments:
 *
 *   pSrcDst - Pointer to the 4x4 array of luma DC coefficients.  16-byte
 *            alignment required.
 *   iQP - Quantization parameter; must be in the range [0,51].
 *
 * Output Arguments:
 *
 *   pSrcDst - Pointer to transformed and quantized coefficients.  16-byte
 *             alignment required.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL: pSrcDst
 *    -    pSrcDst is not aligned on an 16-byte boundary
 *
 */
OMXResult omxVCM4P10_TransformQuant_LumaDC (
    OMX_S16 *pSrcDst,
    OMX_U32 iQP
);



/**
 * Function:  omxVCM4P10_InvTransformDequant_LumaDC   (6.3.5.6.3)
 *
 * Description:
 * This function performs inverse 4x4 Hadamard transform and then dequantizes
 * the coefficients.
 *
 * Input Arguments:
 *
 *   pSrc - Pointer to the 4x4 array of the 4x4 Hadamard-transformed and
 *            quantized coefficients.  16 byte alignment required.
 *   iQP - Quantization parameter; must be in the range [0,51].
 *
 * Output Arguments:
 *
 *   pDst - Pointer to inverse-transformed and dequantized coefficients.
 *            16-byte alignment required.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL: pSrc
 *    -    pSrc or pDst is not aligned on a 16-byte boundary
 *
 */
OMXResult omxVCM4P10_InvTransformDequant_LumaDC (
    const OMX_S16 *pSrc,
    OMX_S16 *pDst,
    OMX_U32 iQP
);



/**
 * Function:  omxVCM4P10_InvTransformDequant_ChromaDC   (6.3.5.6.4)
 *
 * Description:
 * This function performs inverse 2x2 Hadamard transform and then dequantizes
 * the coefficients.
 *
 * Input Arguments:
 *
 *   pSrc - Pointer to the 2x2 array of the 2x2 Hadamard-transformed and
 *            quantized coefficients.  8 byte alignment required.
 *   iQP - Quantization parameter; must be in the range [0,51].
 *
 * Output Arguments:
 *
 *   pDst - Pointer to inverse-transformed and dequantized coefficients.
 *            8-byte alignment required.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL: pSrc
 *    -    pSrc or pDst is not aligned on an 8-byte boundary
 *
 */
OMXResult omxVCM4P10_InvTransformDequant_ChromaDC (
    const OMX_S16 *pSrc,
    OMX_S16 *pDst,
    OMX_U32 iQP
);



/**
 * Function:  omxVCM4P10_InvTransformResidualAndAdd   (6.3.5.7.1)
 *
 * Description:
 * This function performs inverse an 4x4 integer transformation to produce
 * the difference signal and then adds the difference to the prediction to get
 * the reconstructed signal.
 *
 * Input Arguments:
 *
 *   pSrcPred - Pointer to prediction signal.  4-byte alignment required.
 *   pDequantCoeff - Pointer to the transformed coefficients.  8-byte
 *            alignment required.
 *   iSrcPredStep - Step of the prediction buffer; must be a multiple of 4.
 *   iDstReconStep - Step of the destination reconstruction buffer; must be a
 *            multiple of 4.
 *   bAC - Indicate whether there is AC coefficients in the coefficients
 *            matrix.
 *
 * Output Arguments:
 *
 *   pDstRecon -Pointer to the destination reconstruction buffer.  4-byte
 *            alignment required.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL:
 *            pSrcPred, pDequantCoeff, pDstRecon
 *    -    pSrcPred is not aligned on a 4-byte boundary
 *    -    iSrcPredStep or iDstReconStep is not a multiple of 4.
 *    -    pDequantCoeff is not aligned on an 8-byte boundary
 *
 */
OMXResult omxVCM4P10_InvTransformResidualAndAdd (
    const OMX_U8 *pSrcPred,
    const OMX_S16 *pDequantCoeff,
    OMX_U8 *pDstRecon,
    OMX_U32 iSrcPredStep,
    OMX_U32 iDstReconStep,
    OMX_U8 bAC
);



/**
 * Function:  omxVCM4P10_SubAndTransformQDQResidual   (6.3.5.8.1)
 *
 * Description:
 * This function subtracts the prediction signal from the original signal to
 * produce the difference signal and then performs a 4x4 integer transform and
 * quantization. The quantized transformed coefficients are stored as
 * pDstQuantCoeff. This function can also output dequantized coefficients or
 * unquantized DC coefficients optionally by setting the pointers
 * pDstDeQuantCoeff, pDCCoeff.
 *
 * Input Arguments:
 *
 *   pSrcOrg - Pointer to original signal. 4-byte alignment required.
 *   pSrcPred - Pointer to prediction signal. 4-byte alignment required.
 *   iSrcOrgStep - Step of the original signal buffer; must be a multiple of
 *            4.
 *   iSrcPredStep - Step of the prediction signal buffer; must be a multiple
 *            of 4.
 *   pNumCoeff -Number of non-zero coefficients after quantization. If this
 *            parameter is not required, it is set to NULL.
 *   nThreshSAD - Zero-block early detection threshold. If this parameter is
 *            not required, it is set to 0.
 *   iQP - Quantization parameter; must be in the range [0,51].
 *   bIntra - Indicates whether this is an INTRA block, either 1-INTRA or
 *            0-INTER
 *
 * Output Arguments:
 *
 *   pDstQuantCoeff - Pointer to the quantized transformed coefficients.
 *            8-byte alignment required.
 *   pDstDeQuantCoeff - Pointer to the dequantized transformed coefficients
 *            if this parameter is not equal to NULL.  8-byte alignment
 *            required.
 *   pDCCoeff - Pointer to the unquantized DC coefficient if this parameter
 *            is not equal to NULL.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL:
 *            pSrcOrg, pSrcPred, pNumCoeff, pDstQuantCoeff,
 *            pDstDeQuantCoeff, pDCCoeff
 *    -    pSrcOrg is not aligned on a 4-byte boundary
 *    -    pSrcPred is not aligned on a 4-byte boundary
 *    -    iSrcOrgStep is not a multiple of 4
 *    -    iSrcPredStep is not a multiple of 4
 *    -    pDstQuantCoeff or pDstDeQuantCoeff is not aligned on an 8-byte boundary
 *
 */
OMXResult omxVCM4P10_SubAndTransformQDQResidual (
    const OMX_U8 *pSrcOrg,
    const OMX_U8 *pSrcPred,
    OMX_U32 iSrcOrgStep,
    OMX_U32 iSrcPredStep,
    OMX_S16 *pDstQuantCoeff,
    OMX_S16 *pDstDeQuantCoeff,
    OMX_S16 *pDCCoeff,
    OMX_S8 *pNumCoeff,
    OMX_U32 nThreshSAD,
    OMX_U32 iQP,
    OMX_U8 bIntra
);



/**
 * Function:  omxVCM4P10_GetVLCInfo   (6.3.5.9.1)
 *
 * Description:
 * This function extracts run-length encoding (RLE) information from the
 * coefficient matrix.  The results are returned in an OMXVCM4P10VLCInfo
 * structure.
 *
 * Input Arguments:
 *
 *   pSrcCoeff - pointer to the transform coefficient matrix.  8-byte
 *            alignment required.
 *   pScanMatrix - pointer to the scan order definition matrix.  For a luma
 *            block the scan matrix should follow [ISO14496-10] section 8.5.4,
 *            and should contain the values 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13,
 *            10, 7, 11, 14, 15.  For a chroma block, the scan matrix should
 *            contain the values 0, 1, 2, 3.
 *   bAC - indicates presence of a DC coefficient; 0 = DC coefficient
 *            present, 1= DC coefficient absent.
 *   MaxNumCoef - specifies the number of coefficients contained in the
 *            transform coefficient matrix, pSrcCoeff. The value should be 16
 *            for blocks of type LUMADC, LUMAAC, LUMALEVEL, and CHROMAAC. The
 *            value should be 4 for blocks of type CHROMADC.
 *
 * Output Arguments:
 *
 *   pDstVLCInfo - pointer to structure that stores information for
 *            run-length coding.
 *
 * Return Value:
 *
 *    OMX_Sts_NoErr - no error
 *    OMX_Sts_BadArgErr - bad arguments; returned if any of the following
 *              conditions are true:
 *    -    at least one of the following pointers is NULL:
 *            pSrcCoeff, pScanMatrix, pDstVLCInfo
 *    -    pSrcCoeff is not aligned on an 8-byte boundary
 *
 */
OMXResult omxVCM4P10_GetVLCInfo (
    const OMX_S16 *pSrcCoeff,
    const OMX_U8 *pScanMatrix,
    OMX_U8 bAC,
    OMX_U32 MaxNumCoef,
    OMXVCM4P10VLCInfo*pDstVLCInfo
);



#ifdef __cplusplus
}
#endif

#endif /** end of #define _OMXVC_H_ */

/** EOF */