nvmedia_icp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2019, NVIDIA CORPORATION.  All rights reserved.  All
 * information contained herein is proprietary and confidential to NVIDIA
 * Corporation.  Any use, reproduction, or disclosure without the written
 * permission of NVIDIA Corporation is prohibited.
 */

#ifndef NVMEDIA_ICP_H
#define NVMEDIA_ICP_H

#ifdef __cplusplus
extern "C" {
#endif

#include "nvmedia_core.h"
#include "nvmedia_surface.h"
#include "nvmedia_image.h"

#define NVMEDIA_ICP_VERSION_MAJOR   4

#define NVMEDIA_ICP_VERSION_MINOR   16

#define NVMEDIA_IMAGE_CAPTURE_TIMEOUT_INFINITE  (0xFFFFFFFFu)

#define NVMEDIA_ICP_MAX_VIRTUAL_GROUPS     4u

#define NVMEDIA_ICP_MAX_VIRTUAL_CHANNELS   3u

#define NVMEDIA_ICP_HANDLER(icpEx, groupIdx) (icpEx->icp[groupIdx].hIcp)

#define NVMEDIA_ICP_SETTINGS_HANDLER(icpSettingsEx, groupIdx, vcIdx) \
        (&icpSettingsEx.virtualGroups[groupIdx].virtualChannels[vcIdx].icpSettings)

#define NVMEDIA_ICP_ERROR(_type_, _error_, _value_, _desc_)   \
        NVMEDIA_ICP_##_type_##_ERROR_##_error_ = _value_##u,

#define NVMEDIA_MAX_ICP_FRAME_BUFFERS   32u

typedef enum {
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_A,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_B,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_AB,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_C,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_D,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_CD,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_E,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_F,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_EF,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_G,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_H,
    NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_CSI_GH,
} NvMediaICPInterfaceType;

typedef enum {
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_YUV422,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_YUV422_10,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_YUV444,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RGB888,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RAW6,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RAW7,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RAW8,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RAW10,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RAW12,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RAW14,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RAW16,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RAW20,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_USER_DEFINED_1,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_USER_DEFINED_2,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_USER_DEFINED_3,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_USER_DEFINED_4,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_USER_DEFINED_5,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_USER_DEFINED_6,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_USER_DEFINED_7,
    NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_USER_DEFINED_8
} NvMediaICPInputFormatType;

typedef enum {
    NVMEDIA_BITS_PER_PIXEL_8 = 0,
    NVMEDIA_BITS_PER_PIXEL_10,
    NVMEDIA_BITS_PER_PIXEL_12,
    NVMEDIA_BITS_PER_PIXEL_14,
    NVMEDIA_BITS_PER_PIXEL_16,
    NVMEDIA_BITS_PER_PIXEL_20
} NvMediaBitsPerPixel;

typedef struct {
    NvMediaICPInputFormatType inputFormatType;
    NvMediaBitsPerPixel bitsPerPixel;
} NvMediaICPInputFormat;

typedef enum {
    /* Specifies that CSI is in DPHY mode. */
    NVMEDIA_ICP_CSI_DPHY_MODE = 0,
    /* Specifies that CSI is in CPHY mode. */
    NVMEDIA_ICP_CSI_CPHY_MODE
} NvMediaICPCsiPhyMode;

typedef struct {
    NvMediaICPInterfaceType interfaceType;
    NvMediaICPInputFormat inputFormat;
    NvMediaSurfaceType surfaceType;
    uint16_t width;
    uint16_t height;
    uint16_t startX;
    uint16_t startY;
    uint16_t embeddedDataLines;
    uint32_t interfaceLanes;
    uint32_t pixelFrequency;
    uint32_t mipiSpeed;
    uint16_t thsSettle;
    NvMediaBool embeddedDataType;
    uint8_t tpgEnable;
    NvMediaICPCsiPhyMode phyMode;
    uint32_t frameRate;
    uint32_t csiErrorMask;
    uint32_t csiErrorType;
} NvMediaICPSettings;

typedef struct {
    NvMediaICPInterfaceType interfaceType;
    uint32_t interfaceLanes;
    struct {
        struct {
            /* Holds the virtual Channel Index from CSI TX. */
            uint16_t virtualChannelIndex;
            /* Holds the image capture settings for CSI format. */
            NvMediaICPSettings icpSettings;
            /* Holds the clipping rectangle. */
            NvMediaRect clipRect;
            NvMediaBool disablePFSD;
        } virtualChannels[NVMEDIA_ICP_MAX_VIRTUAL_CHANNELS];
        uint16_t numVirtualChannels;
    } virtualGroups[NVMEDIA_ICP_MAX_VIRTUAL_GROUPS];
    uint16_t numVirtualGroups;
    NvMediaICPCsiPhyMode phyMode;
} NvMediaICPSettingsEx;

typedef enum {
    /* Specifies an LP sequence error detected on clock lane[A/B]. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DPHY_CLK_LANE_CTRL_ERR = (1 << 0),
    /* Specifies a one-bit error detected on the lane[A/B]0 sync word. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_SOT_SB_ERR0 = (1 << 1),
    /* Specifies a more than one-bit error detected on the lane[A/B]0 sync
     word. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_SOT_MB_ERR0 = (1 << 2),
    /* Specifies an LP sequence error detected on lane [A/B]0. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_CTRL_ERR0 = (1 << 3),
    /* Specifies a lane [A/B]0 FIFO overflow. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_RXFIFO_FULL_ERR0 = (1 << 4),
    /* Specifies a one-bit error detected on the lane[A/B]1 sync word. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_SOT_SB_ERR1 = (1 << 5),
    /* Specifies a more than one-bit error detected on the lane[A/B]1 sync
     word. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_SOT_MB_ERR1 = (1 << 6),
    /* Specifies an LP sequence error detected on lane [A/B]1. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_CTRL_ERR1 = (1 << 7),
    /* Specifies a Lane [A/B]1 FIFO overflow. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_RXFIFO_FULL_ERR1 = (1 << 8),
    /* Specifies a DPHY de-skew calibration not complete when sweeping the
     trimmer of data lane [A/B]0. Happens when the calibration sequence length
     is not long enough. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DPHY_DESKEW_CALIB_ERR_LANE0 = (1 << 9),
    /* Specifies a DPHY de-skew calibration not complete when sweeping the
     trimmer of data lane [A/B]1. Happens when the calibration sequence length
     is not long enough. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DPHY_DESKEW_CALIB_ERR_LANE1 = (1 << 10),
    /* Specifies a DPHY de-skew calibration not complete when sweeping the
     trimmer of clock lane [A/B]. Happens when the calibration sequence length
     is not long enough. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DPHY_DESKEW_CALIB_ERR_CTRL = (1 << 11),
    /* Specifies that an error is detected in the PHY partition [A/B]: some
     lanes detected a sync word while other lanes did not. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DPHY_LANE_ALIGN_ERR = (1 << 12),
    /* Specifies that an error is detected in the escape mode sync of lane
     [A/B]0. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_ESC_MODE_SYNC_ERR0 = (1 << 13),
    /* Specifies that an error is detected in the escape mode sync of lane
     [A/B]0. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_ESC_MODE_SYNC_ERR1 = (1 << 14),
    /* Specifies that an error is detected in the 2 LSBs of the lane [A/B]0
     sync word. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_SOT_2LSB_ERR0 = (1 << 15),
    /* Specifies that an error is detected in the 2 LSBs of the lane [A/B]1
     sync word. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_DATA_LANE_SOT_2LSB_ERR1 = (1 << 16),
    /* For DPHY mode, CSI packet header uses ECC check. If multi-bit errors
     are detected in the packet header the error bits are not able to correct
     them, the packet is not able to do the unpack, the packet is dropped, and
     this error status is set. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_NOVC_PH_ECC_MULTI_BIT_ERR = (1 << 17),
    /* Specifies that for CPHY mode, the CSI packet has two packet headers,
     each with CRC check. If both packet headers fail the CRC check, the packet
     cannot be unpacked and is dropped, and this error status is set. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_NOVC_PH_BOTH_CRC_ERR = (1 << 18),
    /* Specifies that there is a watchdog timer inside NVCSI to detect packets
     that are incomplete after a sufficient amount of time. If the timer
     expires, this error status is set. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_VC_PPFSM_TIMEOUT = (1 << 19),
    /* Specifies that for DPHY mode, the CSI packet header includes an ECC
     check. If a one-bit error in the packet header is detected the error is
     corrected, the packet can still be unpacked, and this error status is
     set. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_VC_PH_ECC_SINGLE_BIT_ERR = (1 << 20),
    /* Specifies that the CSI packet include a payload CRC check. If the CRC
     check fails, this error status is set. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_VC_PD_CRC_ERR = (1 << 21),
    /* Specifies that the CSI packet header includes the length of the packet.
     If the packet is shorter than the expected length, this error status is
     set. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_VC_PD_WC_SHORT_ERR = (1 << 22),
    /* Specifies that for CPHY mode, the CSI packet has two packet headers,
     each with CRC check. If one packet header passes CRC check and the other
     fails, the packet can still be unpacked and this error status is set. */
    NVMEDIA_ICP_CSI_ERROR_TYPE_VC_PH_SINGLE_CRC_ERR = (1 << 23),
} NvMediaICPCSIErrorType;

typedef struct NvMediaICP NvMediaICP;

typedef struct {
    /* Holds the number of virtual groups used. */
    uint16_t numVirtualGroups;
    struct {
        /* Holds the virtual group index. */
        uint16_t virtualGroupId;
        /* Holds a pointer to the image capture object. */
        NvMediaICP *hIcp;
    } icp[NVMEDIA_ICP_MAX_VIRTUAL_GROUPS];
} NvMediaICPEx;

typedef enum {
    NVMEDIA_ICP_ERROR_STATUS_NONE,
    NVMEDIA_ICP_ERROR_STATUS_CSI_INPUTFRAME,
    NVMEDIA_ICP_ERROR_STATUS_CSI_INPUTSTREAM,
    NVMEDIA_ICP_ERROR_STATUS_PIXEL_FAULT,
    NVMEDIA_ICP_ERROR_STATUS_FRAME_FAULT,
    NVMEDIA_ICP_ERROR_STATUS_MEMORYWRITE,
    NVMEDIA_ICP_ERROR_STATUS_FATAL
} NvMediaICPErrorStatus;

typedef enum {
    /* Multiple Error Bits may be set accompanying a CsiInputFrameError */
    NVMEDIA_ICP_ERROR(CSI, FE_CSI_FAULT,          6,  "A NVCSI fault received at frame end")
    NVMEDIA_ICP_ERROR(CSI, FS_FAULT,              7,  "A frame start occurred before previous frame end")
    NVMEDIA_ICP_ERROR(CSI, FE_FORCED_FAULT,       8,  "A frame end was injected by the CSI hardware")
    NVMEDIA_ICP_ERROR(CSI, FE_FRAMEID_FAULT,      9,  "Frame ID for FE packet does not match that of FS packet")
    NVMEDIA_ICP_ERROR(CSI, PXL_ENABLE_FAULT ,     10, "An illegal pixel encoding has been detected")
    NVMEDIA_ICP_ERROR(CSI, PP_FSM_TIMEOUT,        20, "Pixel Parser FSM timeout")
    NVMEDIA_ICP_ERROR(CSI, PH_ECC_DPHY,           21, "Single bit error correction code in DPHY packet header")
    NVMEDIA_ICP_ERROR(CSI, PAYLOAD_CRC,           22, "Packet Payload CRC check fail error")
    NVMEDIA_ICP_ERROR(CSI, LINE_SHORT,            23, "Packet Payload is less than word count in packet header")
    NVMEDIA_ICP_ERROR(CSI, PH_CRC_CPHY,           24, "One of the CPHY packet headers CRC error")
    NVMEDIA_ICP_ERROR(CSI, EMB_CRC,               25, "Embedded line CRC error")
} NvMediaICPCsiInputFrameError;

typedef enum {
    /* CSI Stream Errors */
    NVMEDIA_ICP_ERROR(CSI, SPURIOUS_DATA,         0,  "FIFO data was found in the gap between frame start and frame end")
    /* FIFO_OVERFLOW & FIFO_LOF Events are NOT Recoverable, application is expected to stop the capture on these errors */
    NVMEDIA_ICP_ERROR(CSI, FIFO_OVERFLOW,         1,  "An overflow occurred in a stream FIFO")
    NVMEDIA_ICP_ERROR(CSI, FIFO_LOF,              2,  "A loss of frame overflow occurred")
    NVMEDIA_ICP_ERROR(CSI, FIFO_BADPKT,           3,  "An unknown packet type has been received on a stream")
} NvMediaICPCsiInputStreamError;

typedef enum {
    /* VI Channel Sel faults from engine status */
    NVMEDIA_ICP_ERROR(VI, FS_TIMEOUT,             0,  "Frame Start Timeout Error")
    NVMEDIA_ICP_ERROR(VI, FE_TIMEOUT,             1,  "Frame End Timeout Error")
    NVMEDIA_ICP_ERROR(VI, PXL_MISSING_LE,         5,  "Two LS packets were detected without a LE packet between them")
    NVMEDIA_ICP_ERROR(VI, PXL_RUNAWAY,            6,  "More lines were received than expected")
    NVMEDIA_ICP_ERROR(VI, PXL_SPURIOUS,           7,  "A pixel data packet was received without a LS packet first")
    NVMEDIA_ICP_ERROR(VI, PXL_LONG_LINE,          8,  "More pixels were received than expected in a line")
    NVMEDIA_ICP_ERROR(VI, PXL_SHORT_LINE,         9,  "Fewer pixels were received than expected in a line")
    NVMEDIA_ICP_ERROR(VI, EMB_MISSING_LE,         10, "Two LS packets were detected without a LE packet between them in emb data")
    NVMEDIA_ICP_ERROR(VI, EMB_RUNAWAY,            11, "More lines were received than expected in emb data")
    NVMEDIA_ICP_ERROR(VI, EMB_SPURIOUS,           12, "A pixel data packet was received without a LS packet first in emb data")
    NVMEDIA_ICP_ERROR(VI, EMB_LONG_LINE,          13, "More pixels were received than expected in a line in emb data")
    NVMEDIA_ICP_ERROR(VI, EMB_INFRINGE,           14, "Embedded data was received on a frame where no embedded data was expected")
    NVMEDIA_ICP_ERROR(VI, DTYPE_MISMATCH,         15, "The pixel datatype changed in the middle of the line")
    NVMEDIA_ICP_ERROR(VI, FORCED_FE,              16, "FE didn't arrive within expected frame duration, capture engine injected FE")
    NVMEDIA_ICP_ERROR(VI, PXL_INCOMPLETE,         17, "Fewer lines of pixels in a frame were received than expected")
    NVMEDIA_ICP_ERROR(VI, EMB_INCOMPLETE,         18, "Fewer lines of emb data in a frame were received than expected")
    NVMEDIA_ICP_ERROR(VI, PFSD_FAULT,             19, "Permanent Fault Software Diagnostic is detected from engine status")
} NvMediaICPPixelFaultError;

typedef enum {
    /* VI Channel Frame faults */
    NVMEDIA_ICP_ERROR(VI, SHORT_FRAME,            0, "FE packet arrived before the normal number of pixels has appeared ")
    NVMEDIA_ICP_ERROR(VI, SHORT_EMB,              1, "FE of EMB Data packet arrived before the normal number of pixels has appeared ")
    NVMEDIA_ICP_ERROR(VI, PFSD_FAULT_NOTIFED,     2, "Permanent Fault Software Diagnostic is detected between frames")
    NVMEDIA_ICP_ERROR(VI, FAULT_FE,               3, "FE is inserted due to a stream reset or early abort")
    NVMEDIA_ICP_ERROR(VI, NOMATCH,                4, "CSI packets are discarded due to no matched capture channels")
    NVMEDIA_ICP_ERROR(VI, COLLISION,              5, "An FS packet matches a channel which is not done processing a previously matching frame")
    NVMEDIA_ICP_ERROR(VI, LOAD_FRAMED,            6, "A LOAD command is received for a channel while that channel is currently in a frame")
} NvMediaICPFrameFaultError;

typedef enum {
    /* Errors while outputing data to memory */
    NVMEDIA_ICP_ERROR(VI, PACKET_OVERFLOW,        0, "The FIFO for a surface packer has overflowed")
    NVMEDIA_ICP_ERROR(VI, FRAME_TRUNCATED,        1, "A packer has dropped a partial frame")
    NVMEDIA_ICP_ERROR(VI, FRAME_TOSSED,           2, "A packer has dropped an entire frame")
} NvMediaICPMemoryWriteError;

typedef struct {
    /* Holds the CSI stream index. */
    uint32_t csiStreamId;
    /* Holds the CSI frame index generated by CSI Tx. */
    uint32_t csiFrameId;
    /* Holds the virtual channel index. */
    uint32_t virtualChannelId;
    /* Holds the error status from capture HW engine. */
    NvMediaICPErrorStatus errorStatus;
    /* Holds a detailed error code corresponding to \ref NvMediaICPErrorStatus,
     above. */
    uint32_t errorData;
    /* Holds notified errors. Notified errors are applicable only when the
     @c errorStatus member is @c NVMEDIA_ICP_ERROR_STATUS_NONE. The array holds
     all notified errors to ICP that occurred between the current successful
     frame and the previously captured frame. @c notifiedErrors must be parsed
     for each \ref NvMediaICPErrorStatus, and may contain one or more types of
     errors per @c NvMediaICPErrorStatus. */
    uint32_t notifiedErrors[NVMEDIA_ICP_ERROR_STATUS_FATAL];
} NvMediaICPErrorInfo;

NvMediaStatus
NvMediaICPGetVersion(
    NvMediaVersion *version
);

NvMediaICPEx *
NvMediaICPCreateEx(
    NvMediaICPSettingsEx *settings
);

void
NvMediaICPDestroyEx(
    NvMediaICPEx *icpEx
);


NvMediaStatus
NvMediaICPRegisterImageGroup(
    NvMediaICP   *icp,
    NvMediaImageGroup *imageGrp
);


NvMediaStatus
NvMediaICPFeedImageGroup(
    NvMediaICP   *icp,
    NvMediaImageGroup *imageGrp,
    unsigned int millisecondTimeout
);

NvMediaStatus
NvMediaICPStop(
    NvMediaICP *icp
);

NvMediaStatus
NvMediaICPResume(
    NvMediaICP *icp);

NvMediaStatus
NvMediaICPGetImageGroup(
    NvMediaICP *icp,
    uint32_t millisecondTimeout,
    NvMediaImageGroup **imageGrp
);

NvMediaStatus
NvMediaICPUnregisterImageGroup(
    NvMediaICP   *icp,
    NvMediaImageGroup *imageGrp
);

NvMediaStatus
NvMediaICPReleaseImageGroup(
    NvMediaICP *icp,
    NvMediaImageGroup **imageGrp
);

NvMediaStatus
NvMediaICPGetErrorInfo(
    NvMediaICP *icp,
    NvMediaICPErrorInfo *icpErrorInfo
);

NvMediaStatus
NvMediaICPWaitForSoF(
    NvMediaICP *icp
)NVM_DEPRECATED_MSG("Use NvMediaICPGetSOFNvSciSyncFence");

/*
 * \defgroup history_nvmedia_icp History
 * Provides change history for the NvMedia ICP API.
 *
 * \section history_nvmedia_icp Version History
 *
 * <b> Version 2.0 </b> April 4, 2016
 * - Initial release
 *
 * <b> Version 2.1 </b> May 11, 2016
 * - Added \ref NvMediaICPCheckVersion API
 *
 * <b> Version 2.2 </b> August 17, 2016
 * - Added \ref NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_UYVY image capture input
 * format type
 *
 * <b> Version 2.3 </b> August 31, 2016
 * - Added option for enabling embeddedDataType in \ref NvMediaICPSettings
 *
 * <b> Version 2.4 </b> Jan 23, 2017
 * - Added \ref NvMediaICPErrorInfo and \ref NvMediaICPGetErrorInfo
 *
 * <b> Version 2.5 </b> March 16, 2017
 * - Added \ref NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_USER ,
 * \ref NvMediaICPUserFormatType and option for enabling userFormatType in
 * \ref NvMediaICPInputFormat
 *
 * <b> Version 3.0 </b> April 19, 2017
 * Updated to use stdint.h instead of "unsigned int",
 *   "int", "unsigned short" and "char".
 * NvMediaICPCreate and NvMediaICPDestroy are now deprecated.
 * NvMediaICPGetFrame is now deprecated.
 * NvMediaICPInterfaceFormat is now deprecated, it will be always CSI.
 *
 * <b> Version 3.1 </b> May 12, 2017
 * - Added \ref NvMediaICPGetVersion API to get the version of NvMedia ICP library
 * - NvMediaICPCheckVersion is deprecated. Use NvMediaICPGetVersion() instead
 *
 * <b> Version 3.2 </b> May 19, 2017
 * Removed \ref NvMediaICPSurfaceFormatType
 * NvMediaICPSettings now takes NvMediaSurfaceType to indicate capture surface format
 * Removed NVMEDIA_IMAGE_CAPTURE_CSI_INTERFACE_TYPE_TPG0
 * Combined NvMediaICPUserFormatType with NvMediaICPInputFormatType
 * Removed NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_YUV420
 *   from \ref NvMediaICPInputFormatType
 * Added RAW6/RAW7/RAW8/RAW10/RAW12/RAW14 in NvMediaICPInputFormatType
 * Removed pixelOrder from \ref NvMediaICPInputFormat
 * Added tpgEnagle in \ref NvMediaICPSettings
 *
 * <b> Version 4.2 </b> June 12, 2017
 * Added virtualGroupIndex inside \ref NvMediaICPSettingsEx
 * Renamed virtualChannel to virtualGroup inside \ref NvMediaICPEx
 * Added \ref NvMediaICPFeedImageGroup and \ref NvMediaICPGetImageGroup APIs
 *
 * <b> Version 4.3 </b> October 5, 2017
 * - Added \ref NvMediaICPResume API
 *
 * <b> Version 4.4 </b> October 11, 2017
 * Changed the prototypes for \ref NvMediaICPGetImageGroup and
 * \ref NvMediaICPReleaseImageGroup to accept double pointer to imageGrp
 *
 * <b> Version 4.5 </b> November 10, 2017
 * Added YUV422_10, RAW16, RAW20 support in \ref NvMediaICPInputFormatType
 * \ref NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_YUV422_10,
 * \ref NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RAW16,
 * \ref NVMEDIA_IMAGE_CAPTURE_INPUT_FORMAT_TYPE_RAW20
 *
 * <b> Version 4.6 </b> November 18, 2017
 * Added additional CSI interfaces, CSI phy mode parameter to \ref NvMediaICPSettingsEX
 *
 * <b> Version 4.7 </b> March 16, 2018
 * Added mipiSpeed in \ref NvMediaICPSettings
 *
 * <b> Version 4.8 </b> September 12, 2018
 * Added NvMediaICPWaitForSoF in \ref NvMediaICPWaitForSoF
 *
 * <b> Version 4.9 </b> March 7, 2019
 * Added detailed capture error errorData in \ref NvMediaICPErrorInfo
 * Refactor \ref NvMediaICPErrorStatus to group capture errors
 *
 * <b> Version 4.10 </b> March 10, 2019
 * Added NvMediaICPRegisterImageGroup in \ref NvMediaICPRegisterImageGroup
 * Added NvMediaICPUnregisterImageGroup in \ref NvMediaICPUnregisterImageGroup
 *
 * <b> Version 4.11 </b> March 18, 2019
 * Deprecated API's- NvMediaICPFeedFrame, NvMediaICPGetFrameEx and NvMediaICPReleaseFrame
 * Instead NvMediaICPFeedImageGroup,NvMediaICPGetImageGroup and NvMediaICPReleaseImageGroup
 * should be used
 *
 * <b> Version 4.12 </b> March 25, 2019
 * Added \ref NvMediaICPCSIErrorType Enum
 * Added csiErrorMask, csiErrorType to \ref NvMediaICPSettings
 *
 * <b> Version 4.13 </b> March 27, 2019
 * Added notifiedErrors in \ref NvMediaICPErrorInfo and disablePFSD \ref NvMediaICPSettingsEx.
 *
 * <b> Version 4.14 </b> April 2, 2019
 * Changed \ref NvMediaICP type from void to struct.
 *
 * <b> Version 4.15 </b> April 4, 2019
 * Add \ref NvMediaBitsPerPixel, NVMEDIA_MAX_ICP_FRAME_BUFFERS
 *
 * <b> version 4.16 </b> April 10, 2019
 * Added deprecated warning message for \ref NvMediaICPWaitForSoF.
 */
#ifdef __cplusplus
};     /* extern "C" */
#endif

#endif /* _NVMEDIA_ICP_H */