csl_fvid2_dataTypes.h

Go to the documentation of this file.

/*
 *  Copyright (c) Texas Instruments Incorporated 2012-2018
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef CSL_FVID2_DATATYPES_H_
#define CSL_FVID2_DATATYPES_H_

/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */

#include <ti/csl/tistdtypes.h>

#ifdef __cplusplus
extern "C" {
#endif

/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */

#define FVID2_SOK                       ((int32_t) 0)

#define FVID2_EFAIL                     (-(int32_t) 1)

#define FVID2_EBADARGS                  (-(int32_t) 2)

#define FVID2_EINVALID_PARAMS           (-(int32_t) 3)

#define FVID2_EDEVICE_INUSE             (-(int32_t) 4)

#define FVID2_ETIMEOUT                  (-(int32_t) 5)

#define FVID2_EALLOC                    (-(int32_t) 6)

#define FVID2_EOUT_OF_RANGE             (-(int32_t) 7)

#define FVID2_EAGAIN                    (-(int32_t) 8)

#define FVID2_EUNSUPPORTED_CMD          (-(int32_t) 9)

#define FVID2_ENO_MORE_BUFFERS          (-(int32_t) 10)

#define FVID2_EUNSUPPORTED_OPS          (-(int32_t) 11)

#define FVID2_EDRIVER_INUSE             (-(int32_t) 12)

#define FVID2_WNON_RECOMMENDED_PARAMS   (-(int32_t) 13)

#define FVID2_ENO_DEVICE                (-(int32_t) 14)

/* @} */

#define FVID2_MAX_FRAME_PTR             (64U)

#define FVID2_MAX_FIELDS                (2U)

#define FVID2_MAX_PLANES_PER_FIELD      (3U)

#define FVID2_MAX_PLANES                (FVID2_MAX_FIELDS * \
                                         FVID2_MAX_PLANES_PER_FIELD)

/* @} */

#define FVID2_TIMEOUT_NONE              (0U)

#define FVID2_TIMEOUT_FOREVER           (~((uint32_t) 0U))

#define FVID2_YUV_PL_Y_ADDR_IDX         (0U)

#define FVID2_YUV_PL_CB_ADDR_IDX        (1U)

#define FVID2_YUV_PL_CR_ADDR_IDX        (2U)

#define FVID2_YUV_SP_Y_ADDR_IDX         (0U)

#define FVID2_YUV_SP_CBCR_ADDR_IDX      (1U)

#define FVID2_RGB_ADDR_IDX              (0U)

#define FVID2_YUV_INT_ADDR_IDX          (0U)

#define FVID2_YUV_PL_Y_FID2_ADDR_IDX    (FVID2_YUV_PL_Y_ADDR_IDX + 3U)

#define FVID2_YUV_PL_CB_FID2_ADDR_IDX   (FVID2_YUV_PL_CB_ADDR_IDX + 3U)

#define FVID2_YUV_PL_CR_FID2_ADDR_IDX   (FVID2_YUV_PL_CR_ADDR_IDX + 3U)

#define FVID2_YUV_SP_Y_FID2_ADDR_IDX    (FVID2_YUV_SP_Y_ADDR_IDX + 3U)

#define FVID2_YUV_SP_CBCR_FID2_ADDR_IDX (FVID2_YUV_SP_CBCR_ADDR_IDX + 3U)

#define FVID2_RGB_FID2_ADDR_IDX         (FVID2_RGB_ADDR_IDX + 3U)

#define FVID2_YUV_INT_FID2_ADDR_IDX     (FVID2_YUV_INT_ADDR_IDX + 3U)
/* @} */

typedef uint32_t Fvid2_DVFormat;
#define FVID2_DV_BT656_EMBSYNC                 ((uint32_t) 0x00U)

#define FVID2_DV_BT1120_EMBSYNC                ((uint32_t) 0x01U)

#define FVID2_DV_GENERIC_DISCSYNC              ((uint32_t) 0x02U)
/* @} */

typedef uint32_t Fvid2_FlipType;
#define FVID2_FLIP_TYPE_NONE                   ((uint32_t) 0x00U)

#define FVID2_FLIP_TYPE_H                      ((uint32_t) 0x01U)

#define FVID2_FLIP_TYPE_V                      ((uint32_t) 0x02U)

#define FVID2_FLIP_TYPE_HV                     ((uint32_t) 0x03U)
/* @} */

#define FVID2_CSI2_DF_YUV420_8B                   ((uint32_t) 0x18)

#define FVID2_CSI2_DF_YUV420_10B                  ((uint32_t) 0x19)

#define FVID2_CSI2_DF_YUV420_8B_LEGACY            ((uint32_t) 0x1A)

#define FVID2_CSI2_DF_YUV420_8B_CHROMA_SHIFT      ((uint32_t) 0x1C)

#define FVID2_CSI2_DF_YUV420_10B_CHROMA_SHIFT     ((uint32_t) 0x1D)

#define FVID2_CSI2_DF_YUV422_8B                   ((uint32_t) 0x1E)

#define FVID2_CSI2_DF_YUV422_10B                  ((uint32_t) 0x1F)

#define FVID2_CSI2_DF_RGB444                      ((uint32_t) 0x20)

#define FVID2_CSI2_DF_RGB555                      ((uint32_t) 0x21)

#define FVID2_CSI2_DF_RGB565                      ((uint32_t) 0x22)

#define FVID2_CSI2_DF_RGB666                      ((uint32_t) 0x23)

#define FVID2_CSI2_DF_RGB888                      ((uint32_t) 0x24)

#define FVID2_CSI2_DF_RAW6                        ((uint32_t) 0x28)

#define FVID2_CSI2_DF_RAW7                        ((uint32_t) 0x29)

#define FVID2_CSI2_DF_RAW8                        ((uint32_t) 0x2A)

#define FVID2_CSI2_DF_RAW10                       ((uint32_t) 0x2B)

#define FVID2_CSI2_DF_RAW12                       ((uint32_t) 0x2C)

#define FVID2_CSI2_DF_RAW14                       ((uint32_t) 0x2D)

#define FVID2_CSI2_DF_RAW16                       ((uint32_t) 0x2E)

#define FVID2_CSI2_DF_RAW20                       ((uint32_t) 0x2F)
/* @} */

typedef uint32_t Fvid2_DataFormat;
#define FVID2_DF_YUV422I_UYVY            ((uint32_t) 0x0000U)

#define FVID2_DF_YUV422I_YUYV            ((uint32_t) 0x0001U)

#define FVID2_DF_YUV422I_YVYU            ((uint32_t) 0x0002U)

#define FVID2_DF_YUV422I_VYUY            ((uint32_t) 0x0003U)

#define FVID2_DF_YUV422SP_UV             ((uint32_t) 0x0004U)

#define FVID2_DF_YUV422SP_VU             ((uint32_t) 0x0005U)

#define FVID2_DF_YUV422P                 ((uint32_t) 0x0006U)

#define FVID2_DF_YUV420SP_UV             ((uint32_t) 0x0007U)

#define FVID2_DF_YUV420SP_VU             ((uint32_t) 0x0008U)

#define FVID2_DF_YUV420P                 ((uint32_t) 0x0009U)

#define FVID2_DF_YUV444P                 ((uint32_t) 0x000AU)

#define FVID2_DF_YUV444I                 ((uint32_t) 0x000BU)

#define FVID2_DF_RGB16_565               ((uint32_t) 0x000CU)

#define FVID2_DF_ARGB16_1555             ((uint32_t) 0x000DU)

#define FVID2_DF_RGBA16_5551             ((uint32_t) 0x000EU)

#define FVID2_DF_ARGB16_4444             ((uint32_t) 0x000FU)

#define FVID2_DF_RGBA16_4444             ((uint32_t) 0x0010U)

#define FVID2_DF_RGBX16_4444             ((uint32_t) 0x0011U)

#define FVID2_DF_ARGB24_6666             ((uint32_t) 0x0012U)

#define FVID2_DF_RGBA24_6666             ((uint32_t) 0x0013U)

#define FVID2_DF_RGB24_888               ((uint32_t) 0x0014U)

#define FVID2_DF_BGRX_4444               ((uint32_t) 0x0015U)

#define FVID2_DF_XBGR_4444               ((uint32_t) 0x0016U)

#define FVID2_DF_ARGB32_8888             ((uint32_t) 0x0017U)

#define FVID2_DF_XRGB32_8888             ((uint32_t) 0x0018U)

#define FVID2_DF_RGBA32_8888             ((uint32_t) 0x0019U)

#define FVID2_DF_BGR16_565               ((uint32_t) 0x001AU)

#define FVID2_DF_ABGR16_1555             ((uint32_t) 0x001BU)

#define FVID2_DF_ABGR16_4444             ((uint32_t) 0x001CU)

#define FVID2_DF_BGRA16_5551             ((uint32_t) 0x001DU)

#define FVID2_DF_BGRA16_4444             ((uint32_t) 0x001EU)

#define FVID2_DF_AGBR16_1555             ((uint32_t) 0x001FU)

#define FVID2_DF_AGBR16_4444             ((uint32_t) 0x0020U)

#define FVID2_DF_XGBR16_1555             ((uint32_t) 0x0021U)

#define FVID2_DF_BGRX16_5551             ((uint32_t) 0x0022U)

#define FVID2_DF_ABGR24_6666             ((uint32_t) 0x0023U)

#define FVID2_DF_BGR24_888               ((uint32_t) 0x0024U)

#define FVID2_DF_XBGR24_8888             ((uint32_t) 0x0025U)

#define FVID2_DF_RGBX24_8888             ((uint32_t) 0x0026U)

#define FVID2_DF_BGRX24_8888             ((uint32_t) 0x0027U)

#define FVID2_DF_ABGR32_8888             ((uint32_t) 0x0028U)

#define FVID2_DF_BGRA24_6666             ((uint32_t) 0x0029U)

#define FVID2_DF_BGRA32_8888             ((uint32_t) 0x002AU)

#define FVID2_DF_BGRX32_8888             ((uint32_t) 0x002BU)

#define FVID2_DF_BGRA16_1555             ((uint32_t) 0x002CU)

#define FVID2_DF_BGRX16_1555             ((uint32_t) 0x002DU)

#define FVID2_DF_BGRA32_1010102          ((uint32_t) 0x002EU)

#define FVID2_DF_BGRX32_1010102          ((uint32_t) 0x002FU)

#define FVID2_DF_RGBA32_1010102          ((uint32_t) 0x0030U)

#define FVID2_DF_RGBX32_1010102          ((uint32_t) 0x0031U)

#define FVID2_DF_BGRA64_16161616         ((uint32_t) 0x0032U)

#define FVID2_DF_BGRX64_16161616         ((uint32_t) 0x0033U)

#define FVID2_DF_ABGR64_16161616         ((uint32_t) 0x0034U)

#define FVID2_DF_XBGR64_16161616         ((uint32_t) 0x0035U)

#define FVID2_DF_BITMAP8                 ((uint32_t) 0x0036U)

#define FVID2_DF_BITMAP4_LOWER           ((uint32_t) 0x0037U)

#define FVID2_DF_BITMAP4_UPPER           ((uint32_t) 0x0038U)

#define FVID2_DF_BITMAP2_OFFSET0         ((uint32_t) 0x0039U)

#define FVID2_DF_BITMAP2_OFFSET1         ((uint32_t) 0x003AU)

#define FVID2_DF_BITMAP2_OFFSET2         ((uint32_t) 0x003BU)

#define FVID2_DF_BITMAP2_OFFSET3         ((uint32_t) 0x003CU)

#define FVID2_DF_BITMAP1_OFFSET0         ((uint32_t) 0x003DU)

#define FVID2_DF_BITMAP1_OFFSET1         ((uint32_t) 0x003EU)

#define FVID2_DF_BITMAP1_OFFSET2         ((uint32_t) 0x003FU)

#define FVID2_DF_BITMAP1_OFFSET3         ((uint32_t) 0x0040U)

#define FVID2_DF_BITMAP1_OFFSET4         ((uint32_t) 0x0041U)

#define FVID2_DF_BITMAP1_OFFSET5         ((uint32_t) 0x0042U)

#define FVID2_DF_BITMAP1_OFFSET6         ((uint32_t) 0x0043U)

#define FVID2_DF_BITMAP1_OFFSET7         ((uint32_t) 0x0044U)

#define FVID2_DF_BITMAP8_BGRA32          ((uint32_t) 0x0045U)

#define FVID2_DF_BITMAP4_BGRA32_LOWER    ((uint32_t) 0x0046U)

#define FVID2_DF_BITMAP4_BGRA32_UPPER    ((uint32_t) 0x0047U)

#define FVID2_DF_BITMAP2_BGRA32_OFFSET0  ((uint32_t) 0x0048U)

#define FVID2_DF_BITMAP2_BGRA32_OFFSET1  ((uint32_t) 0x0049U)

#define FVID2_DF_BITMAP2_BGRA32_OFFSET2  ((uint32_t) 0x004AU)

#define FVID2_DF_BITMAP2_BGRA32_OFFSET3  ((uint32_t) 0x004BU)

#define FVID2_DF_BITMAP1_BGRA32_OFFSET0  ((uint32_t) 0x004CU)

#define FVID2_DF_BITMAP1_BGRA32_OFFSET1  ((uint32_t) 0x004DU)

#define FVID2_DF_BITMAP1_BGRA32_OFFSET2  ((uint32_t) 0x004EU)

#define FVID2_DF_BITMAP1_BGRA32_OFFSET3  ((uint32_t) 0x004FU)

#define FVID2_DF_BITMAP1_BGRA32_OFFSET4  ((uint32_t) 0x0050U)

#define FVID2_DF_BITMAP1_BGRA32_OFFSET5  ((uint32_t) 0x0051U)

#define FVID2_DF_BITMAP1_BGRA32_OFFSET6  ((uint32_t) 0x0052U)

#define FVID2_DF_BITMAP1_BGRA32_OFFSET7  ((uint32_t) 0x0053U)

#define FVID2_DF_BAYER_RAW               ((uint32_t) 0x0054U)

#define FVID2_DF_BAYER_GRBG              ((uint32_t) 0x0055U)

#define FVID2_DF_BAYER_RGGB              ((uint32_t) 0x0056U)

#define FVID2_DF_BAYER_BGGR              ((uint32_t) 0x0057U)

#define FVID2_DF_BAYER_GBRG              ((uint32_t) 0x0058U)

#define FVID2_DF_RAW_VBI                 ((uint32_t) 0x0059U)

#define FVID2_DF_RAW24                   ((uint32_t) 0x005AU)

#define FVID2_DF_RAW16                   ((uint32_t) 0x005BU)

#define FVID2_DF_RAW08                   ((uint32_t) 0x005CU)

#define FVID2_DF_MISC                    ((uint32_t) 0x005DU)

#define FVID2_DF_BITMAP4                 ((uint32_t) FVID2_DF_BITMAP4_LOWER)

#define FVID2_DF_BITMAP2                 ((uint32_t) FVID2_DF_BITMAP2_OFFSET0)

#define FVID2_DF_BITMAP1                 ((uint32_t) FVID2_DF_BITMAP1_OFFSET0)

#define FVID2_DF_RAW06                   ((uint32_t) 0x5EU)

#define FVID2_DF_RAW07                   ((uint32_t) 0x5FU)

#define FVID2_DF_RAW10                   ((uint32_t) 0x60U)

#define FVID2_DF_RAW12                   ((uint32_t) 0x61U)

#define FVID2_DF_RAW14                   ((uint32_t) 0x62U)

#define FVID2_DF_JPEG1_INTERCHANGE       ((uint32_t) 0x63U)

#define FVID2_DF_JPEG2_JFIF              ((uint32_t) 0x64U)

#define FVID2_DF_JPEG3_EXIF              ((uint32_t) 0x65U)

#define FVID2_DF_DPCM_10_8_10_PRED1      ((uint32_t) 0x66U)

#define FVID2_DF_DPCM_10_8_10_PRED2      ((uint32_t) 0x67U)

#define FVID2_DF_DPCM_10_7_10_PRED1      ((uint32_t) 0x68U)

#define FVID2_DF_DPCM_10_7_10_PRED2      ((uint32_t) 0x69U)

#define FVID2_DF_DPCM_10_6_10_PRED1      ((uint32_t) 0x6AU)

#define FVID2_DF_DPCM_10_6_10_PRED2      ((uint32_t) 0x6BU)

#define FVID2_DF_DPCM_12_8_10_PRED1      ((uint32_t) 0x6CU)

#define FVID2_DF_DPCM_12_8_10_PRED2      ((uint32_t) 0x6DU)

#define FVID2_DF_DPCM_12_7_10_PRED1      ((uint32_t) 0x6EU)

#define FVID2_DF_DPCM_12_7_10_PRED2      ((uint32_t) 0x6FU)

#define FVID2_DF_DPCM_12_6_10_PRED1      ((uint32_t) 0x70U)

#define FVID2_DF_DPCM_12_6_10_PRED2      ((uint32_t) 0x71U)

#define FVID2_DF_BGR16_565_A8            ((uint32_t) 0x72U)

#define FVID2_DF_RGB16_565_A8            ((uint32_t) 0x73U)

#define FVID2_DF_LUMA_ONLY               ((uint32_t) 0x74U)

#define FVID2_DF_CHROMA_ONLY             ((uint32_t) 0x75U)

#define FVID2_DF_RGB24_888_PLANAR        ((uint32_t) 0x76U)

#define FVID2_DF_ARGB48_12121212         ((uint32_t) 0x0077U)


#define FVID2_DF_GREY                    ((uint32_t) 0x0078U)

#define FVID2_DF_SATURATION              ((uint32_t) 0x0079U)

#define FVID2_DF_HUE                     ((uint32_t) 0x007AU)

#define FVID2_DF_RAW                     ((uint32_t) 0x007BU)

#define FVID2_DF_RED                     ((uint32_t) 0x007CU)

#define FVID2_DF_GREEN                   ((uint32_t) 0x007DU)

#define FVID2_DF_BLUE                    ((uint32_t) 0x007EU)

#define FVID2_DF_INVALID                 ((uint32_t) 0x00FFU)
/* @} */

typedef uint32_t Fvid2_ScanFormat;
#define FVID2_SF_INTERLACED                 ((uint32_t) 0x00U)

#define FVID2_SF_PROGRESSIVE                ((uint32_t) 0x01U)

#define FVID2_SF_MAX                        ((uint32_t) 0x02U)
/* @} */

typedef uint32_t Fvid2_Standard;
#define FVID2_STD_NTSC                      ((uint32_t) 0x00U)

#define FVID2_STD_PAL                       ((uint32_t) 0x01U)

#define FVID2_STD_480I                      ((uint32_t) 0x02U)

#define FVID2_STD_576I                      ((uint32_t) 0x03U)

#define FVID2_STD_CIF                       ((uint32_t) 0x04U)

#define FVID2_STD_HALF_D1                   ((uint32_t) 0x05U)

#define FVID2_STD_D1                        ((uint32_t) 0x06U)

#define FVID2_STD_480P                      ((uint32_t) 0x07U)

#define FVID2_STD_576P                      ((uint32_t) 0x08U)

#define FVID2_STD_720P_60                   ((uint32_t) 0x09U)

#define FVID2_STD_720P_50                   ((uint32_t) 0x0AU)

#define FVID2_STD_1080I_60                  ((uint32_t) 0x0BU)

#define FVID2_STD_1080I_50                  ((uint32_t) 0x0CU)

#define FVID2_STD_1080P_60                  ((uint32_t) 0x0DU)

#define FVID2_STD_1080P_50                  ((uint32_t) 0x0EU)

#define FVID2_STD_1080P_24                  ((uint32_t) 0x0FU)

#define FVID2_STD_1080P_30                  ((uint32_t) 0x10U)

#define FVID2_STD_VGA_60                    ((uint32_t) 0x11U)

#define FVID2_STD_VGA_72                    ((uint32_t) 0x12U)

#define FVID2_STD_VGA_75                    ((uint32_t) 0x13U)

#define FVID2_STD_VGA_85                    ((uint32_t) 0x14U)

#define FVID2_STD_WVGA_60                   ((uint32_t) 0x15U)

#define FVID2_STD_SVGA_60                   ((uint32_t) 0x16U)

#define FVID2_STD_SVGA_72                   ((uint32_t) 0x17U)

#define FVID2_STD_SVGA_75                   ((uint32_t) 0x18U)

#define FVID2_STD_SVGA_85                   ((uint32_t) 0x19U)

#define FVID2_STD_WSVGA_70                  ((uint32_t) 0x1AU)

#define FVID2_STD_XGA_60                    ((uint32_t) 0x1BU)

#define FVID2_STD_XGA_DSS_TDM_60            ((uint32_t) 0x1CU)

#define FVID2_STD_XGA_70                    ((uint32_t) 0x1DU)

#define FVID2_STD_XGA_75                    ((uint32_t) 0x1EU)

#define FVID2_STD_XGA_85                    ((uint32_t) 0x1FU)

#define FVID2_STD_1368_768_60               ((uint32_t) 0x20U)

#define FVID2_STD_1366_768_60               ((uint32_t) 0x21U)

#define FVID2_STD_1360_768_60               ((uint32_t) 0x22U)

#define FVID2_STD_WXGA_30                   ((uint32_t) 0x23U)

#define FVID2_STD_WXGA_60                   ((uint32_t) 0x24U)

#define FVID2_STD_WXGA_75                   ((uint32_t) 0x25U)

#define FVID2_STD_WXGA_85                   ((uint32_t) 0x26U)

#define FVID2_STD_1440_900_60               ((uint32_t) 0x27U)

#define FVID2_STD_SXGA_60                   ((uint32_t) 0x28U)

#define FVID2_STD_SXGA_75                   ((uint32_t) 0x29U)

#define FVID2_STD_SXGA_85                   ((uint32_t) 0x2AU)

#define FVID2_STD_WSXGAP_60                 ((uint32_t) 0x2BU)

#define FVID2_STD_SXGAP_60                  ((uint32_t) 0x2CU)

#define FVID2_STD_SXGAP_75                  ((uint32_t) 0x2DU)

#define FVID2_STD_UXGA_60                   ((uint32_t) 0x2EU)

#define FVID2_STD_MUX_2CH_D1                ((uint32_t) 0x2FU)

#define FVID2_STD_MUX_2CH_HALF_D1           ((uint32_t) 0x30U)

#define FVID2_STD_MUX_2CH_CIF               ((uint32_t) 0x31U)

#define FVID2_STD_MUX_4CH_D1                ((uint32_t) 0x32U)

#define FVID2_STD_MUX_4CH_CIF               ((uint32_t) 0x33U)

#define FVID2_STD_MUX_4CH_HALF_D1           ((uint32_t) 0x34U)

#define FVID2_STD_MUX_8CH_CIF               ((uint32_t) 0x35U)

#define FVID2_STD_MUX_8CH_HALF_D1           ((uint32_t) 0x36U)

#define FVID2_STD_WXGA_5x3_30               ((uint32_t) 0x37U)

#define FVID2_STD_WXGA_5x3_60               ((uint32_t) 0x38U)

#define FVID2_STD_WXGA_5x3_75               ((uint32_t) 0x39U)

#define FVID2_STD_AUTO_DETECT               ((uint32_t) 0x3AU)

#define FVID2_STD_CUSTOM                    ((uint32_t) 0x3BU)
/* @} */

typedef uint32_t Fvid2_Fid;
#define FVID2_FID_TOP                    ((uint32_t) 0U)

#define FVID2_FID_BOTTOM                 ((uint32_t) 1U)

#define FVID2_FID_FRAME                  ((uint32_t) 2U)

#define FVID2_FID_MAX                    ((uint32_t) 3U)
/* @} */

typedef uint32_t Fvid2_Polarity;
#define FVID2_POL_LOW                    ((uint32_t) 0U)

#define FVID2_POL_HIGH                   ((uint32_t) 1U)

#define FVID2_POL_MAX                    ((uint32_t) 2U)
/* @} */

typedef uint32_t Fvid2_EdgePolarity;
#define FVID2_EDGE_POL_RISING            ((uint32_t) 0U)

#define FVID2_EDGE_POL_FALLING           ((uint32_t) 1U)

#define FVID2_EDGE_POL_MAX               ((uint32_t) 2U)
/* @} */

typedef uint32_t Fvid2_FidPol;
#define FVID2_FIDPOL_NORMAL              ((uint32_t) 0U)

#define FVID2_FIDPOL_INVERT              ((uint32_t) 1U)
/* @} */

typedef uint32_t Fvid2_BufferFormat;
#define FVID2_BUF_FMT_FIELD              ((uint32_t) 0U)

#define FVID2_BUF_FMT_FRAME              ((uint32_t) 1U)
/* @} */

typedef uint32_t Fvid2_ColorCompStorageFmt;
#define FVID2_CCSF_BITS1_PACKED                        ((uint32_t) 0x00U)

#define FVID2_CCSF_BITS2_PACKED                        ((uint32_t) 0x01U)

#define FVID2_CCSF_BITS4_PACKED                        ((uint32_t) 0x02U)

#define FVID2_CCSF_BITS8_PACKED                        ((uint32_t) 0x03U)

#define FVID2_CCSF_BITS10_PACKED                       ((uint32_t) 0x04U)

#define FVID2_CCSF_BITS12_PACKED                       ((uint32_t) 0x05U)

#define FVID2_CCSF_BITS14_PACKED                       ((uint32_t) 0x06U)

#define FVID2_CCSF_BITS16_PACKED                       ((uint32_t) 0x07U)

#define FVID2_CCSF_BITS24_PACKED                       ((uint32_t) 0x08U)

#define FVID2_CCSF_BITS32_PACKED                       ((uint32_t) 0x09U)

#define FVID2_CCSF_BITS6_UNPACKED8                     ((uint32_t) 0x0AU)

#define FVID2_CCSF_BITS7_UNPACKED8                     ((uint32_t) 0x0BU)

#define FVID2_CCSF_BITS8_UNPACKED12                    ((uint32_t) 0x0CU)

#define FVID2_CCSF_BITS8_UNPACKED16                    ((uint32_t) 0x0DU)

#define FVID2_CCSF_BITS9_UNPACKED16                    ((uint32_t) 0x0EU)

#define FVID2_CCSF_BITS10_UNPACKED16                   ((uint32_t) 0x0FU)

#define FVID2_CCSF_BITS11_UNPACKED16                   ((uint32_t) 0x10U)

#define FVID2_CCSF_BITS12_UNPACKED16                   ((uint32_t) 0x11U)

#define FVID2_CCSF_BITS13_UNPACKED16                   ((uint32_t) 0x12U)

#define FVID2_CCSF_BITS14_UNPACKED16                   ((uint32_t) 0x13U)

#define FVID2_CCSF_BITS15_UNPACKED16                   ((uint32_t) 0x14U)

#define FVID2_CCSF_BITS20_UNPACKED24                   ((uint32_t) 0x15U)

#define FVID2_CCSF_BITS6_UNPACKED8_MSB_ALIGNED         ((uint32_t) 0x16U)

#define FVID2_CCSF_BITS7_UNPACKED8_MSB_ALIGNED         ((uint32_t) 0x17U)

#define FVID2_CCSF_BITS8_UNPACKED12_MSB_ALIGNED        ((uint32_t) 0x18U)

#define FVID2_CCSF_BITS8_UNPACKED16_MSB_ALIGNED        ((uint32_t) 0x19U)

#define FVID2_CCSF_BITS9_UNPACKED16_MSB_ALIGNED        ((uint32_t) 0x1AU)

#define FVID2_CCSF_BITS10_UNPACKED16_MSB_ALIGNED       ((uint32_t) 0x1BU)

#define FVID2_CCSF_BITS11_UNPACKED16_MSB_ALIGNED       ((uint32_t) 0x1CU)

#define FVID2_CCSF_BITS12_UNPACKED16_MSB_ALIGNED       ((uint32_t) 0x1DU)

#define FVID2_CCSF_BITS13_UNPACKED16_MSB_ALIGNED       ((uint32_t) 0x1EU)

#define FVID2_CCSF_BITS14_UNPACKED16_MSB_ALIGNED       ((uint32_t) 0x1FU)

#define FVID2_CCSF_BITS15_UNPACKED16_MSB_ALIGNED       ((uint32_t) 0x20U)

#define FVID2_CCSF_BITS20_UNPACKED24_MSB_ALIGNED       ((uint32_t) 0x21U)

#define FVID2_CCSF_MAX                                 ((uint32_t) 0x22U)
/* @} */

typedef uint32_t Fvid2_VideoIfWidth;
#define FVID2_VIFW_8BIT                         ((uint32_t) 0x00U)

#define FVID2_VIFW_10BIT                        ((uint32_t) 0x01U)

#define FVID2_VIFW_12BIT                        ((uint32_t) 0x02U)

#define FVID2_VIFW_14BIT                        ((uint32_t) 0x03U)

#define FVID2_VIFW_16BIT                        ((uint32_t) 0x04U)

#define FVID2_VIFW_18BIT                        ((uint32_t) 0x05U)

#define FVID2_VIFW_20BIT                        ((uint32_t) 0x06U)

#define FVID2_VIFW_24BIT                        ((uint32_t) 0x07U)

#define FVID2_VIFW_30BIT                        ((uint32_t) 0x08U)

#define FVID2_VIFW_36BIT                        ((uint32_t) 0x09U)

#define FVID2_VIFW_1LANES                       ((uint32_t) 0x0AU)

#define FVID2_VIFW_2LANES                       ((uint32_t) 0x0BU)

#define FVID2_VIFW_3LANES                       ((uint32_t) 0x0CU)

#define FVID2_VIFW_4LANES                       ((uint32_t) 0x0DU)

#define FVID2_VIFW_MAX                          ((uint32_t) 0x0EU)
/* @} */

typedef uint32_t Fvid2_VideoIfMode;
#define FVID2_VIFM_SCH_ES                       (0U)

#define FVID2_VIFM_MCH_LINE_MUX_ES              (1U)

#define FVID2_VIFM_MCH_PIXEL_MUX_ES             (2U)

#define FVID2_VIFM_SCH_DS_HSYNC_VBLK            (3U)

#define FVID2_VIFM_SCH_DS_HSYNC_VSYNC           (4U)

#define FVID2_VIFM_SCH_DS_AVID_VBLK             (5U)

#define FVID2_VIFM_SCH_DS_AVID_VSYNC            (6U)

#define FVID2_VIFM_MCH_LINE_MUX_SPLIT_LINE_ES   (7U)

#define FVID2_VIFM_SCH_CSI2                     (8U)

#define FVID2_VIFM_SCH_LVDS                     (9U)

#define FVID2_VIFM_SCH_CPI                      (10U)

#define FVID2_VIFM_MAX                          (11U)

/* @} */

typedef uint32_t Fvid2_ChromaPos;
#define FVID2_CHROMA_POS_COSITED                (0U)

#define FVID2_CHROMA_POS_CENTERED               (1U)

/* @} */

typedef uint32_t Fvid2_BayerColorComp;
#define FVID2_BAYER_COLOR_COMP_R                (0U)

#define FVID2_BAYER_COLOR_COMP_GR               (1U)

#define FVID2_BAYER_COLOR_COMP_GB               (2U)

#define FVID2_BAYER_COLOR_COMP_B                (3U)

#define FVID2_BAYER_COLOR_COMP_MAX              (4U)

/* @} */

typedef uint32_t Fvid2_FrameStatus;
#define FVID2_FRAME_STATUS_INIT                 (0U)

#define FVID2_FRAME_STATUS_COMPLETED            (1U)

#define FVID2_FRAME_STATUS_PENDING              (2U)

#define FVID2_FRAME_STATUS_SUBMITTED            (3U)

#define FVID2_FRAME_STATUS_ERROR                (4U)

#define FVID2_FRAME_STATUS_ABORTED              (5U)

#define FVID2_FRAME_STATUS_OVERFLOW             (6U)

#define FVID2_FRAME_STATUS_ECC_CORRECTED        (7U)

#define FVID2_FRAME_STATUS_CRC_ERROR            (8U)

#define FVID2_FRAME_STATUS_ECC_ERROR            (9U)

#define FVID2_FRAME_STATUS_MAX                  (10U)

/* @} */

/* ========================================================================== */
/*                         Structure Declarations                             */
/* ========================================================================== */

typedef struct
{
    uint32_t chNum;
    uint32_t width;
    uint32_t height;
    uint32_t pitch[FVID2_MAX_PLANES];
    uint32_t fieldMerged[FVID2_MAX_PLANES_PER_FIELD];
    uint32_t dataFormat;
    uint32_t scanFormat;
    uint32_t ccsFormat;
} Fvid2_Format;

typedef struct
{
    uint32_t subFrameNum;
    uint32_t numInLines;
    uint32_t numOutLines;
} Fvid2_SubFrameInfo;

typedef struct
{
    uint64_t addr[FVID2_MAX_PLANES];
    uint32_t fid;
    uint32_t chNum;
    uint64_t timeStamp64;
    void  *appData;
    void  *perFrameCfg;
    void               *drvData;
    Fvid2_SubFrameInfo *subFrameInfo;
    uint32_t            status;
} Fvid2_Frame;

typedef struct
{
    Fvid2_Frame *frames[FVID2_MAX_FRAME_PTR];
    uint32_t     numFrames;
    void        *drvData;
    void        *appData;
    void        *perListCfg;
} Fvid2_FrameList;

typedef struct
{
    uint32_t standard;
    uint32_t width;
    uint32_t height;
    uint32_t scanFormat;
    uint32_t pixelClock;
    uint32_t fps;
    uint32_t hFrontPorch;
    uint32_t hBackPorch;
    uint32_t hSyncLen;
    uint32_t vFrontPorch;
    uint32_t vBackPorch;
    uint32_t vSyncLen;
} Fvid2_ModeInfo;

typedef struct
{
    uint32_t cropStartX;
    uint32_t cropStartY;
    uint32_t cropWidth;
    uint32_t cropHeight;
} Fvid2_CropConfig;

typedef struct
{
    uint32_t cropTop;
    uint32_t cropBottom;
    uint32_t cropLeft;
    uint32_t cropRight;
} Fvid2_EdgeCropConfig;

typedef struct
{
    uint32_t startX;
    uint32_t startY;
} Fvid2_PosConfig;

typedef struct
{
    UInt32 width;
    UInt32 height;
} Fvid2_SizeConfig;

/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */

int32_t Fvid2_getModeInfo(Fvid2_ModeInfo *modeInfo);

const Char *Fvid2_getDataFmtString(uint32_t dataFmt);

const Char *Fvid2_getStandardString(uint32_t standard);

static inline int32_t Fvid2_isDataFmtYuv422(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtYuv420(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtYuv420Sp(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtYuv422Sp(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtSemiPlanar(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtYuv422I(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtYuv444(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtYuv(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtBayer(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtRgb16bit(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtRgb(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtRgb24bit(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtRgb32bit(uint32_t dataFmt);

static inline int32_t Fvid2_isDataFmtRgb64bit(uint32_t dataFmt);

static inline uint32_t Fvid2_BayerColorIndex(uint32_t dataFmt, uint32_t color);

static inline int32_t Fvid2_isStandardVesa(uint32_t standard);

static inline void Fvid2Format_init(Fvid2_Format *fmt);

static inline void Fvid2SubFrameInfo_init(Fvid2_SubFrameInfo *sfInfo);

static inline void Fvid2Frame_init(Fvid2_Frame *frm);

static inline void Fvid2FrameList_init(Fvid2_FrameList *fList);

static inline void Fvid2ModeInfo_init(Fvid2_ModeInfo *modeInfo);

static inline void Fvid2CropConfig_init(Fvid2_CropConfig *cropCfg);

static inline void Fvid2EdgeCropConfig_init(Fvid2_EdgeCropConfig *edgeCropCfg);

static inline void Fvid2PosConfig_init(Fvid2_PosConfig *posCfg);

/* ========================================================================== */
/*                       Static Function Definitions                          */
/* ========================================================================== */

static inline int32_t Fvid2_isDataFmtYuv422(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_YUV422I_UYVY:
        case FVID2_DF_YUV422I_YUYV:
        case FVID2_DF_YUV422I_YVYU:
        case FVID2_DF_YUV422I_VYUY:
        case FVID2_DF_YUV422SP_UV:
        case FVID2_DF_YUV422SP_VU:
        case FVID2_DF_YUV422P:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtYuv420(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_YUV420SP_UV:
        case FVID2_DF_YUV420SP_VU:
        case FVID2_DF_YUV420P:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtYuv420Sp(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_YUV420SP_UV:
        case FVID2_DF_YUV420SP_VU:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtYuv422Sp(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_YUV422SP_UV:
        case FVID2_DF_YUV422SP_VU:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtSemiPlanar(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_YUV422SP_UV:
        case FVID2_DF_YUV422SP_VU:
        case FVID2_DF_YUV420SP_UV:
        case FVID2_DF_YUV420SP_VU:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtYuv422I(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_YUV422I_UYVY:
        case FVID2_DF_YUV422I_YUYV:
        case FVID2_DF_YUV422I_YVYU:
        case FVID2_DF_YUV422I_VYUY:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtYuv444(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_YUV444P:
        case FVID2_DF_YUV444I:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtBayer(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_BAYER_GBRG:
        case FVID2_DF_BAYER_BGGR:
        case FVID2_DF_BAYER_RGGB:
        case FVID2_DF_BAYER_GRBG:
        case FVID2_DF_BAYER_RAW:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtYuv(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_YUV422I_UYVY:
        case FVID2_DF_YUV422I_YUYV:
        case FVID2_DF_YUV422I_YVYU:
        case FVID2_DF_YUV422I_VYUY:
        case FVID2_DF_YUV422SP_UV:
        case FVID2_DF_YUV422SP_VU:
        case FVID2_DF_YUV422P:
        case FVID2_DF_YUV420SP_UV:
        case FVID2_DF_YUV420SP_VU:
        case FVID2_DF_YUV420P:
        case FVID2_DF_YUV444P:
        case FVID2_DF_YUV444I:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtRgb(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_RGB16_565:
        case FVID2_DF_RGBA16_5551:
        case FVID2_DF_RGBA16_4444:
        case FVID2_DF_RGBX16_4444:
        case FVID2_DF_RGBA24_6666:
        case FVID2_DF_RGB24_888:
        case FVID2_DF_RGBA32_8888:
        case FVID2_DF_RGBX24_8888:
        case FVID2_DF_RGBA32_1010102:
        case FVID2_DF_RGBX32_1010102:
        case FVID2_DF_BGRX_4444:
        case FVID2_DF_BGR16_565:
        case FVID2_DF_BGRA16_5551:
        case FVID2_DF_BGRA16_4444:
        case FVID2_DF_BGRX16_5551:
        case FVID2_DF_BGR24_888:
        case FVID2_DF_BGRX24_8888:
        case FVID2_DF_BGRA24_6666:
        case FVID2_DF_BGRA32_8888:
        case FVID2_DF_BGRX32_8888:
        case FVID2_DF_BGRA16_1555:
        case FVID2_DF_BGRX16_1555:
        case FVID2_DF_BGRA32_1010102:
        case FVID2_DF_BGRX32_1010102:
        case FVID2_DF_BGRA64_16161616:
        case FVID2_DF_BGRX64_16161616:
        case FVID2_DF_XBGR_4444:
        case FVID2_DF_XBGR24_8888:
        case FVID2_DF_XBGR64_16161616:
        case FVID2_DF_ABGR16_1555:
        case FVID2_DF_ABGR16_4444:
        case FVID2_DF_ABGR24_6666:
        case FVID2_DF_ABGR32_8888:
        case FVID2_DF_ABGR64_16161616:
        case FVID2_DF_ARGB16_1555:
        case FVID2_DF_ARGB16_4444:
        case FVID2_DF_ARGB24_6666:
        case FVID2_DF_ARGB32_8888:
        case FVID2_DF_XRGB32_8888:
        case FVID2_DF_BITMAP8_BGRA32:
        case FVID2_DF_BITMAP4_BGRA32_LOWER:
        case FVID2_DF_BITMAP4_BGRA32_UPPER:
        case FVID2_DF_BITMAP2_BGRA32_OFFSET0:
        case FVID2_DF_BITMAP2_BGRA32_OFFSET1:
        case FVID2_DF_BITMAP2_BGRA32_OFFSET2:
        case FVID2_DF_BITMAP2_BGRA32_OFFSET3:
        case FVID2_DF_BITMAP1_BGRA32_OFFSET0:
        case FVID2_DF_BITMAP1_BGRA32_OFFSET1:
        case FVID2_DF_BITMAP1_BGRA32_OFFSET2:
        case FVID2_DF_BITMAP1_BGRA32_OFFSET3:
        case FVID2_DF_BITMAP1_BGRA32_OFFSET4:
        case FVID2_DF_BITMAP1_BGRA32_OFFSET5:
        case FVID2_DF_BITMAP1_BGRA32_OFFSET6:
        case FVID2_DF_BITMAP1_BGRA32_OFFSET7:
        case FVID2_DF_BAYER_RAW:
        case FVID2_DF_BAYER_GRBG:
        case FVID2_DF_BAYER_RGGB:
        case FVID2_DF_BAYER_BGGR:
        case FVID2_DF_BAYER_GBRG:
        case FVID2_DF_BGR16_565_A8:
        case FVID2_DF_RGB16_565_A8:
        case FVID2_DF_RGB24_888_PLANAR:
        case FVID2_DF_ARGB48_12121212:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtRgb16bit(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_BGRX_4444:
        case FVID2_DF_XBGR_4444:
        case FVID2_DF_AGBR16_4444:
        case FVID2_DF_RGBA16_4444:
        case FVID2_DF_RGBX16_4444:
        case FVID2_DF_XGBR16_1555:
        case FVID2_DF_AGBR16_1555:
        case FVID2_DF_BGR16_565:
        case FVID2_DF_RGB16_565:
        case FVID2_DF_ARGB16_1555:
        case FVID2_DF_RGBA16_5551:
        case FVID2_DF_ARGB16_4444:
        case FVID2_DF_ABGR16_1555:
        case FVID2_DF_ABGR16_4444:
        case FVID2_DF_BGRA16_5551:
        case FVID2_DF_BGRA16_4444:
        case FVID2_DF_BGRX16_5551:
        case FVID2_DF_BGRA16_1555:
        case FVID2_DF_BGRX16_1555:
        case FVID2_DF_BGR16_565_A8:
        case FVID2_DF_RGB16_565_A8:
            /* BGR16_565_A8 and RGB16_565_A8 data formats have 24 bits per pixel
             * With 8 bits Alpha in different plane.
             * Since this function is used to check pitch, added in RGB16bit */
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtRgb24bit(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_BGR24_888:
        case FVID2_DF_RGB24_888:
        case FVID2_DF_ABGR24_6666:
        case FVID2_DF_BGRA24_6666:
        case FVID2_DF_ARGB24_6666:
        case FVID2_DF_RGBA24_6666:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtRgb32bit(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_XBGR24_8888:
        case FVID2_DF_RGBX24_8888:
        case FVID2_DF_ABGR32_8888:
        case FVID2_DF_RGBA32_8888:
        case FVID2_DF_BGRX24_8888:
        case FVID2_DF_BGRA32_8888:
        case FVID2_DF_ARGB32_8888:
        case FVID2_DF_BGRX32_8888:
        case FVID2_DF_XRGB32_8888:
        case FVID2_DF_RGBA32_1010102:
        case FVID2_DF_RGBX32_1010102:
        case FVID2_DF_BGRA32_1010102:
        case FVID2_DF_BGRX32_1010102:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline int32_t Fvid2_isDataFmtRgb64bit(uint32_t dataFmt)
{
    int32_t retVal = (int32_t) FALSE;

    switch(dataFmt)
    {
        case FVID2_DF_BGRA64_16161616:
        case FVID2_DF_BGRX64_16161616:
        case FVID2_DF_ABGR64_16161616:
        case FVID2_DF_XBGR64_16161616:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline uint32_t Fvid2_BayerColorIndex(uint32_t dataFmt, uint32_t color)
{
    uint32_t dataFmtIndex;

    switch(dataFmt)
    {
        case FVID2_DF_BAYER_RGGB:
            if(FVID2_BAYER_COLOR_COMP_R == color)
            {
                dataFmtIndex = 0U;
            }
            else if(FVID2_BAYER_COLOR_COMP_GR == color)
            {
                dataFmtIndex = 1U;
            }
            else if(FVID2_BAYER_COLOR_COMP_GB == color)
            {
                dataFmtIndex = 2U;
            }
            else
            {
                dataFmtIndex = 3U;
            }
            break;
        case FVID2_DF_BAYER_GRBG:
            if(FVID2_BAYER_COLOR_COMP_R == color)
            {
                dataFmtIndex = 1U;
            }
            else if(FVID2_BAYER_COLOR_COMP_GR == color)
            {
                dataFmtIndex = 0U;
            }
            else if(FVID2_BAYER_COLOR_COMP_GB == color)
            {
                dataFmtIndex = 3U;
            }
            else
            {
                dataFmtIndex = 2U;
            }
            break;
        case FVID2_DF_BAYER_BGGR:
            if(FVID2_BAYER_COLOR_COMP_R == color)
            {
                dataFmtIndex = 3U;
            }
            else if(FVID2_BAYER_COLOR_COMP_GR == color)
            {
                dataFmtIndex = 2U;
            }
            else if(FVID2_BAYER_COLOR_COMP_GB == color)
            {
                dataFmtIndex = 1U;
            }
            else
            {
                dataFmtIndex = 0U;
            }
            break;
        case FVID2_DF_BAYER_GBRG:
            if(FVID2_BAYER_COLOR_COMP_R == color)
            {
                dataFmtIndex = 2U;
            }
            else if(FVID2_BAYER_COLOR_COMP_GR == color)
            {
                dataFmtIndex = 3U;
            }
            else if(FVID2_BAYER_COLOR_COMP_GB == color)
            {
                dataFmtIndex = 0U;
            }
            else
            {
                dataFmtIndex = 1U;
            }
            break;
        default:
            if(FVID2_BAYER_COLOR_COMP_R == color)
            {
                dataFmtIndex = 0U;
            }
            else if(FVID2_BAYER_COLOR_COMP_GR == color)
            {
                dataFmtIndex = 1U;
            }
            else if(FVID2_BAYER_COLOR_COMP_GB == color)
            {
                dataFmtIndex = 2U;
            }
            else
            {
                dataFmtIndex = 3U;
            }
            break;
    }

    return (dataFmtIndex);
}

static inline int32_t Fvid2_isStandardVesa(uint32_t standard)
{
    int32_t retVal = (int32_t) FALSE;

    switch(standard)
    {
        case FVID2_STD_VGA_60:
        case FVID2_STD_VGA_72:
        case FVID2_STD_VGA_75:
        case FVID2_STD_VGA_85:
        case FVID2_STD_SVGA_60:
        case FVID2_STD_SVGA_72:
        case FVID2_STD_SVGA_75:
        case FVID2_STD_SVGA_85:
        case FVID2_STD_WSVGA_70:
        case FVID2_STD_XGA_60:
        case FVID2_STD_XGA_DSS_TDM_60:
        case FVID2_STD_XGA_70:
        case FVID2_STD_XGA_75:
        case FVID2_STD_XGA_85:
        case FVID2_STD_WXGA_60:
        case FVID2_STD_WXGA_75:
        case FVID2_STD_WXGA_85:
        case FVID2_STD_SXGA_60:
        case FVID2_STD_SXGA_75:
        case FVID2_STD_SXGA_85:
        case FVID2_STD_SXGAP_60:
        case FVID2_STD_SXGAP_75:
        case FVID2_STD_UXGA_60:
            retVal = (int32_t) TRUE;
            break;

        default:
            retVal = (int32_t) FALSE;
            break;
    }

    return (retVal);
}

static inline void Fvid2Format_init(Fvid2_Format *fmt)
{
    uint32_t i;

    if(NULL != fmt)
    {
        fmt->chNum  = 0U;
        fmt->width  = 0U;
        fmt->height = 0U;
        for(i = 0U; i < FVID2_MAX_PLANES; i++)
        {
            fmt->pitch[i] = 0U;
        }
        for(i = 0U; i < FVID2_MAX_PLANES_PER_FIELD; i++)
        {
            fmt->fieldMerged[i] = (uint32_t) FALSE;
        }
        fmt->dataFormat = FVID2_DF_YUV422I_YUYV;
        fmt->scanFormat = FVID2_SF_PROGRESSIVE;
        fmt->ccsFormat  = FVID2_CCSF_BITS8_PACKED;
    }

    return;
}

static inline void Fvid2SubFrameInfo_init(Fvid2_SubFrameInfo *sfInfo)
{
    if(NULL != sfInfo)
    {
        sfInfo->subFrameNum = 0U;
        sfInfo->numInLines  = 0U;
        sfInfo->numOutLines = 0U;
    }

    return;
}

static inline void Fvid2Frame_init(Fvid2_Frame *frm)
{
    uint32_t j;

    if(NULL != frm)
    {
        for(j = 0U; j < FVID2_MAX_PLANES; j++)
        {
            frm->addr[j] = 0U;
        }
        frm->chNum        = 0U;
        frm->timeStamp64  = 0U;
        frm->appData      = NULL;
        frm->perFrameCfg  = NULL;
        frm->drvData      = NULL;
        frm->subFrameInfo = NULL;
        frm->status       = FVID2_FRAME_STATUS_INIT;
    }

    return;
}

static inline void Fvid2FrameList_init(Fvid2_FrameList *fList)
{
    uint32_t i;

    if(NULL != fList)
    {
        for(i = 0U; i < FVID2_MAX_FRAME_PTR; i++)
        {
            fList->frames[i] = NULL;
        }
        fList->numFrames  = 0U;
        fList->drvData    = NULL;
        fList->appData    = NULL;
    }

    return;
}

static inline void Fvid2ModeInfo_init(Fvid2_ModeInfo *modeInfo)
{
    if(NULL != modeInfo)
    {
        modeInfo->standard     = FVID2_STD_1080P_60;
        modeInfo->width        = 1920U;
        modeInfo->height       = 1080U;
        modeInfo->scanFormat   = FVID2_SF_PROGRESSIVE;
        modeInfo->pixelClock   = 148500U;
        modeInfo->fps          = 60U;
        modeInfo->hFrontPorch  = 88U;
        modeInfo->hBackPorch   = 148U;
        modeInfo->hSyncLen     = 44U;
        modeInfo->vFrontPorch  = 4U;
        modeInfo->vBackPorch   = 36U;
        modeInfo->vSyncLen     = 5U;
    }

    return;
}

static inline void Fvid2CropConfig_init(Fvid2_CropConfig *cropCfg)
{
    if(NULL != cropCfg)
    {
        cropCfg->cropStartX = 0U;
        cropCfg->cropStartY = 0U;
        cropCfg->cropWidth  = 0U;
        cropCfg->cropHeight = 0U;
    }

    return;
}

static inline void Fvid2EdgeCropConfig_init(Fvid2_EdgeCropConfig *edgeCropCfg)
{
    if(NULL != edgeCropCfg)
    {
        edgeCropCfg->cropTop    = 0U;
        edgeCropCfg->cropBottom = 0U;
        edgeCropCfg->cropLeft   = 0U;
        edgeCropCfg->cropRight  = 0U;
    }

    return;
}

static inline void Fvid2PosConfig_init(Fvid2_PosConfig *posCfg)
{
    if(NULL != posCfg)
    {
        posCfg->startX = 0U;
        posCfg->startY = 0U;
    }

    return;
}

#ifdef __cplusplus
}
#endif

#endif  /* #ifndef CSL_FVID2_DATATYPES_H_ */

/* @} */