Google Git
Sign in
nest-open-source / nest-cam / 4320010 / av / 5121e70f983699f03625822f4e53d0759305313b / . / av / media / libstagefright / codecs / on2 / h264dec / omxdl / arm11 / vc / api / omxVC.h
blob: 7b3cc7289554a10744eacffc0d0af5ef39d61e8c [file] [log] [blame]
/**
* 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 */