MWProCapture.h

#ifndef MWPROCAPTURE_H
#define MWPROCAPTURE_H
 
#if defined(_WIN32)
    #pragma message("platform:windows")
    #ifdef LIBMWCAPTURE_EXPORTS
        #define LIBMWCAPTURE_API __declspec(dllexport)
    #elif LIBMWCAPTURE_DLL
        #define LIBMWCAPTURE_API __declspec(dllimport)
    #else
        #define LIBMWCAPTURE_API    
    #endif
#elif defined(__linux__)
#define LIBMWCAPTURE_API
#pragma message("platform:linux")
#elif defined(__APPLE__)
#define LIBMWCAPTURE_API
#pragma message("platform:apple")
#else
#error "Error:Not support system!"
#endif
 
#include "MWCaptureExtension.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Channel
HCHANNEL
LIBMWCAPTURE_API
MWOpenChannel(
    int                             nBoardValue,
    int                             nChannelIndex
);
 
// Device Clock
MW_RESULT
LIBMWCAPTURE_API
MWGetDeviceTime(
    HCHANNEL                        hChannel,
    LONGLONG*                       pllTime
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetDeviceTime(
    HCHANNEL                        hChannel,
    LONGLONG                        llTime
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWRegulateDeviceTime(
    HCHANNEL                        hChannel,
    LONGLONG                        llTime
    );
 
// Timer Event
HTIMER
LIBMWCAPTURE_API
MWRegisterTimer(
    HCHANNEL                        hChannel,
    MWHANDLE                        hEvent
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWUnregisterTimer(
    HCHANNEL                        hChannel,
    HTIMER                          hTimer
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWScheduleTimer(
    HCHANNEL                        hChannel,
    HTIMER                          hTimer,
    LONGLONG                        llExpireTime
    );
 
HNOTIFY
LIBMWCAPTURE_API
MWRegisterNotify(
    HCHANNEL                        hChannel,
    MWHANDLE                        hEvent,
    DWORD                           dwEnableBits
    );
 
MW_RESULT
    LIBMWCAPTURE_API
    MWUnregisterNotify(
    HCHANNEL                        hChannel,
    HNOTIFY                         hNotify
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetNotifyStatus(
    HCHANNEL                        hChannel,
    HNOTIFY                         hNotify,
    ULONGLONG*                      pullStatus
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWStartVideoCapture(
    HCHANNEL                        hChannel,
    MWHANDLE                        hEvent
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWStopVideoCapture(
    HCHANNEL                        hChannel
    );
 
// * @ingroup group_functions_procapture
//@brief Pins a video buffer according to channel handle
//@param[in] hChannel       Channel handle
//@param[in] pbFrame        Virtual memory address
//@param[in] cbFrame            Virtual memory size
//@return  Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWPinVideoBuffer(
//    HCHANNEL                      hChannel,
//    MWCAP_PTR                       pbFrame,
//    DWORD                         cbFrame
//    );
//
// * @ingroup group_functions_procapture
//@brief Unlocks part of video buffer according to channel handle
//@param[in] hChannel       Channel handle
//@param[in] pbFrame        Virtual memory address
//@return  Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWUnpinVideoBuffer(
//  HCHANNEL                        hChannel,
//  LPBYTE                          pbFrame
//  );
 
MW_RESULT
LIBMWCAPTURE_API
MWCaptureVideoFrameToVirtualAddress(
    HCHANNEL                        hChannel,
    int                             iFrame,
    MWCAP_PTR                       pbFrame,
    DWORD                           cbFrame,
    DWORD                           cbStride,
    BOOLEAN                         bBottomUp,
    MWCAP_PTR64                     pvContext,
    DWORD                           dwFOURCC,
    int                             cx,
    int                             cy
    );   
 
// * @ingroup group_functions_procapture
// * @brief Stores captured video frames to physical addresses
// * @param[in] hChannel            Video channel handle that has started video capturing
// * @param[in] iFrame          Video frame number to be captured
// * @param[in] llFrameAddress  Physical addresses that store the captured video frames
// * @param[in] cbFrame         Byte length of memory that stores the captured data
// * @param[in] cbStride            Step of memory that stores the captured data
// * @param[in] bBottomUp           Whether to store the captured video frames from bottom to top
// * @param[in] pvContext           Custom context pointers
// * @param[in] dwFOURCC            Color format of captured video frames, see MWFOURCC.h.
// * @param[in] cx              Width of captured video frames
// * @param[in] cy              Height of captured video frames
// * @return  Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWCaptureVideoFrameToPhysicalAddress(
//  HCHANNEL                        hChannel,
//  int                             iFrame,
//  LARGE_INTEGER                   llFrameAddress,
//  DWORD                           cbFrame,
//  DWORD                           cbStride,
//  BOOLEAN                         bBottomUp,
//  MWCAP_PTR64                     pvContext,
//  DWORD                           dwFOURCC,
//  int                             cx,
//  int                             cy
//  );
 
// * @ingroup group_functions_procapture
// * @brief Captures video frames to virtual memory, and adds OSD.
// * @param[in] hChannel        Video channel handle that has started video capturing
// * @param[in] iFrame      Video frame number to be captured
// * @param[out] pbFrame        Physical addresses that store the captured video frames
// * @param[in] cbFrame     Byte length of memory that stores the captured data
// * @param[in] cbStride        Step of memory that stores the captured data
// * @param[in] bBottomUp       Whether to store the captured video frames from bottom to top
// * @param[in] pvContext       Custom context pointers
// * @param[in] dwFOURCC        Color format of captured video frames, see MWFOURCC.h.
// * @param[in] cx          Width of captured video frames
// * @param[in] cy          Height of captured video frames
// * @param[in] hOSDImage     Handle of OSD image which is geted using [MWCreateImage](@ref MWCreateImage)
// * @param[in] pOSDRects     Target area of OSD image
// * @param[in] cOSDRects     Number of OSD image target areas
// * @return  Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWCaptureVideoFrameWithOSDToVirtualAddress(
//  HCHANNEL                        hChannel,
//  int                             iFrame,
//  MWCAP_PTR                       pbFrame,
//  DWORD                           cbFrame,
//  DWORD                           cbStride,
//  BOOLEAN                         bBottomUp,
//  MWCAP_PTR64                     pvContext,
//  DWORD                           dwFOURCC,
//  int                             cx,
//  int                             cy,
//  HOSD                            hOSDImage,
//  const RECT *                    pOSDRects,
//  int                             cOSDRects
//  );     
 
// * @ingroup group_functions_procapture
// * @brief  Saves the captured video frame to physical memory and add OSD
// * @param[in] hChannel            Video channel handle that has started video capturing
// * @param[in] iFrame          Video frame number to be captured
// * @param[in] llFrameAddress  Physical addresses that store the captured video frames
// * @param[in] cbFrame         Byte length of memory that stores the captured data
// * @param[in] cbStride            Step of memory that stores the captured data
// * @param[in] bBottomUp           Whether to store the captured video frames from bottom to top
// * @param[in] pvContext           Custom context pointers
// * @param[in] dwFOURCC            Color format of captured video frames, see MWFOURCC.h.
// * @param[in] cx              width of captured video frames
// * @param[in] cy              Height of captured video frames
// * @param[in] hOSDImage           handle of OSD image which is geted using [MWCreateImage](@ref MWCreateImage).
// * @param[in] pOSDRects           Target area of OSD image 
// * @param[in] cOSDRects           Number of OSD image target areas
// * @return  Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWCaptureVideoFrameWithOSDToPhysicalAddress(
//  HCHANNEL                        hChannel,
//  int                             iFrame,
//  LARGE_INTEGER                   llFrameAddress,
//  DWORD                           cbFrame,
//  DWORD                           cbStride,
//  BOOLEAN                         bBottomUp,
//  MWCAP_PTR64                     pvContext,
//  DWORD                           dwFOURCC,
//  int                             cx,
//  int                             cy,
//  HOSD                            hOSDImage,
//  const RECT *                    pOSDRects,
//  int                             cOSDRects
//  );
 
MW_RESULT
LIBMWCAPTURE_API
MWCaptureVideoFrameToVirtualAddressEx(
    HCHANNEL                        hChannel,
    int                             iFrame,
    LPBYTE                          pbFrame,
    DWORD                           cbFrame,
    DWORD                           cbStride,
    BOOLEAN                         bBottomUp,
    MWCAP_PTR64                     pvContext,
    DWORD                           dwFOURCC,
    int                             cx,
    int                             cy,
    DWORD                           dwProcessSwitchs,
    int                             cyParitalNotify,
    HOSD                            hOSDImage,
    const RECT *                    pOSDRects,
    int                             cOSDRects,
    SHORT                           sContrast,
    SHORT                           sBrightness,
    SHORT                           sSaturation,
    SHORT                           sHue,
    MWCAP_VIDEO_DEINTERLACE_MODE            deinterlaceMode,
    MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE   aspectRatioConvertMode,
    const RECT *                            pRectSrc,
    const RECT *                            pRectDest,
    int                                     nAspectX,
    int                                     nAspectY,
    MWCAP_VIDEO_COLOR_FORMAT                colorFormat,
    MWCAP_VIDEO_QUANTIZATION_RANGE          quantRange,
    MWCAP_VIDEO_SATURATION_RANGE            satRange
    );
 
// * @ingroup group_functions_procapture
// * @brief Captures video frames and saves to physical memory. And is the extended version of [MWCaptureVideoFrameToPhysicalAddress](@ref MWCaptureVideoFrameToPhysicalAddress).
// * @param[in] hChannel                    Video channel handle that has started video capturing
// * @param[in] iFrame                  Video frame number to be captured
// * @param[in] llFrameAddress          Physical addresses that store the captured video frames
// * @param[in] cbFrame                 Byte length of memory that stores the captured data
// * @param[in] cbStride                    Step of memory that stores the captured data
// * @param[in] bBottomUp                   Whether to store the captured video frames from bottom to top
// * @param[in] pvContext                   Custom context pointers
// * @param[in] dwFOURCC                    Color format of captured video frames, see MWFOURCC.h.
// * @param[in] cx                      width of captured video frames
// * @param[in] cy                      Height of captured video frames
// * @param[in] dwProcessSwitchs            Mask of video processing refers to MWCAP_VIDEO_PROCESS_xx
// * @param[in] cyParitalNotify         The number of lines when capturing by lines
// * @param[in] hOSDImage                   OSD image handle which is geted using MWCreateImage(HCHANNEL hChannel,int cx,int cy)
// * @param[in] pOSDRects                   Target area of OSD image 
// * @param[in] cOSDRects                   Number of OSD image target areas
// * @param[in] sContrast                   Contrast        
// * @param[in] sBrightness             Brightness          
// * @param[in] sSaturation             Saturation      
// * @param[in] sHue                        Hue     
// * @param[in] deinterlaceMode         Deinterlace Mode    
// * @param[in] aspectRatioConvertMode  Aspect Ratio Convert Mode
// * @param[in] pRectSrc                    The source area of the image to capture
// * @param[in] pRectDest                   The destination area of the image to capture
// * @param[in] nAspectX                    Width of the aspect ratio
// * @param[in] nAspectY                    Height of the aspect ratio
// * @param[in] colorFormat             Color Format
// * @param[in] quantRange              Quantization Range
// * @param[in] satRange                    Saturation Range
// * @return  Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWCaptureVideoFrameToPhysicalAddressEx(
//  HCHANNEL                        hChannel,
//  int                             iFrame,
//  LARGE_INTEGER                   llFrameAddress,
//  DWORD                           cbFrame,
//  DWORD                           cbStride,
//  BOOLEAN                         bBottomUp,
//  MWCAP_PTR64                     pvContext,
//  DWORD                           dwFOURCC,
//  int                             cx,
//  int                             cy,
//  DWORD                           dwProcessSwitchs,
//  int                             cyParitalNotify,
//  HOSD                            hOSDImage,
//  const RECT *                    pOSDRects,
//  int                             cOSDRects,
//  SHORT                           sContrast,
//  SHORT                           sBrightness,
//  SHORT                           sSaturation,
//  SHORT                           sHue,
//  MWCAP_VIDEO_DEINTERLACE_MODE            deinterlaceMode,
//  MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE   aspectRatioConvertMode,
//  const RECT *                            pRectSrc,
//  const RECT *                            pRectDest,
//  int                                     nAspectX,
//  int                                     nAspectY,
//  MWCAP_VIDEO_COLOR_FORMAT                colorFormat,
//  MWCAP_VIDEO_QUANTIZATION_RANGE          quantRange,
//  MWCAP_VIDEO_SATURATION_RANGE            satRange
//  );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoBufferInfo(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_BUFFER_INFO *       pVideoBufferInfo
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoFrameInfo(
    HCHANNEL                        hChannel,
    BYTE                            i,
    MWCAP_VIDEO_FRAME_INFO*         pVideoFrameInfo
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoCaptureStatus(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_CAPTURE_STATUS *    pStatus
    );   
 
MW_RESULT
LIBMWCAPTURE_API
MWStartAudioCapture(
    HCHANNEL                        hChannel
    );  
 
MW_RESULT
LIBMWCAPTURE_API
MWStopAudioCapture(
    HCHANNEL                        hChannel
    );
    
MW_RESULT
LIBMWCAPTURE_API
MWCaptureAudioFrame(
    HCHANNEL                        hChannel,
    MWCAP_AUDIO_CAPTURE_FRAME*  pAudioCaptureFrame
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetPostReconfig(
    HCHANNEL                        hChannel,
    DWORD                           dwDelayMS
    );
 
// * @ingroup group_functions_procapture
//@brief Creates OSD image according to channel handle
// * @param[in] hChannel      Opened channel handle
// * @param[in] cx              Width of image
// * @param[in] cy          Height of image
//@return Returns handle of the OSD image if succeeded, otherwise returns NULL
//*/
//HOSD
//LIBMWCAPTURE_API
//MWCreateImage(
//  HCHANNEL                        hChannel,
//  int                             cx,
//  int                             cy
//  );
//
// * @ingroup group_functions_procapture
// * @brief Opens OSD images.
// * @param[in] hChannel      Opened channel handle
// * @param[in] hImage          Image handle
// * @param[out] plRet        Returns counts of the image being called  
//@return  Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWOpenImage(
//  HCHANNEL                        hChannel,
//  HOSD                            hImage,
//  LONG*                           plRet
//  );  
//
// * @ingroup group_functions_procapture
//@brief Closes image according to channel handle
// * @param[in] hChannel      Opened channel handle
// * @param[in] hImage        Image handle
// * @param[out] plRet      Returns counts of the image being called  
//@return  Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWCloseImage(
//  HCHANNEL                        hChannel,
//  HOSD                            hImage,
//  LONG*                           plRet
//  );
//
// * @ingroup group_functions_procapture
// * @brief Uploads images from system memory to capture device.
// * @param[in] hChannel                Opened channel handle
// * @param[in] hImage                      Image handle
// * @param[in] cfDest                  Color format of the target image
// * @param[in] quantRangeDest              Quantization range of the target image
// * @param[in] satRangeDest            Saturation range of the target image
// * @param[in] xDest                   Horizontal target position
// * @param[in] yDest                   Vertical target position
// * @param[in] cxDest                      Target width of image
// * @param[in] cyDest                  Target height of image
// * @param[in] pvSrcFrame                  Source image 
// * @param[in] cbSrcFrame                  Data length of source image
// * @param[in] cbSrcStride                 Data step of source image
// * @param[in] cxSrc                   Width of source image
// * @param[in] cySrc                   Height of source image
// * @param[in] bSrcBottomUp                Whether the source image is up-side-down
// * @param[in] bSrcPixelAlpha              Whether there is an alpha component in the source image
// * @param[in] bSrcPixelXBGR           Whether the color format of the source image is XBGR
//@return  Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWUploadImageFromVirtualAddress(
//  HCHANNEL                        hChannel,
//  HOSD                            hImage,
//  MWCAP_VIDEO_COLOR_FORMAT        cfDest,
//  MWCAP_VIDEO_QUANTIZATION_RANGE  quantRangeDest,
//  MWCAP_VIDEO_SATURATION_RANGE    satRangeDest,
//  WORD                            xDest,
//  WORD                            yDest,
//  WORD                            cxDest,
//  WORD                            cyDest,
//  MWCAP_PTR64                     pvSrcFrame,
//  DWORD                           cbSrcFrame,
//  DWORD                           cbSrcStride,
//  WORD                            cxSrc,
//  WORD                            cySrc,
//  BOOLEAN                         bSrcBottomUp,
//  BOOLEAN                         bSrcPixelAlpha,
//  BOOLEAN                         bSrcPixelXBGR
//  );  
//
// * @ingroup group_functions_procapture
// * @brief Uploads an image from physical memory to capture device.
// * @param[in] hChannel                Opened channel handle
// * @param[in] hImage                      Image handle
// * @param[in] cfDest                  Color format of the target image
// * @param[in] quantRangeDest              Quantization range of the target image
// * @param[in] satRangeDest            Saturation range of the target image
// * @param[in] xDest                   Horizontal target position
// * @param[in] yDest                   Vertical target position
// * @param[in] cxDest                      Target width of image
// * @param[in] cyDest                  Target height of image
// * @param[in] llSrcFrameAddress       Physical address that stores the source image 
// * @param[in] cbSrcFrame                  Data length of source image
// * @param[in] cbSrcStride                 Data step of source image
// * @param[in] cxSrc                   Width of source image
// * @param[in] cySrc                   Height of source image
// * @param[in] bSrcBottomUp                Whether the source image is up-side-down
// * @param[in] bSrcPixelAlpha              Whether there is an alpha component in the source image
// * @param[in] bSrcPixelXBGR           Whether the color format of the source image is XBGR
// * @return  Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWUploadImageFromPhysicalAddress(
//  HCHANNEL                        hChannel,
//  HOSD                            hImage,
//  MWCAP_VIDEO_COLOR_FORMAT        cfDest,
//  MWCAP_VIDEO_QUANTIZATION_RANGE  quantRangeDest,
//  MWCAP_VIDEO_SATURATION_RANGE    satRangeDest,
//  WORD                            xDest,
//  WORD                            yDest,
//  WORD                            cxDest,
//  WORD                            cyDest,
//  LARGE_INTEGER                   llSrcFrameAddress,
//  DWORD                           cbSrcFrame,
//  DWORD                           cbSrcStride,
//  WORD                            cxSrc,
//  WORD                            cySrc,
//  BOOLEAN                         bSrcBottomUp,
//  BOOLEAN                         bSrcPixelAlpha,
//  BOOLEAN                         bSrcPixelXBGR
//  );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetTemperature(
    HCHANNEL                        hChannel,
    unsigned int*                   pnTemp
    );
 
// * @ingroup group_functions_procapture
//@brief Gets OSD settings according to channel handle
//@param[in] hChannel           Channel handle
//@param[out] pOSDSettings           OSD settings of video capture
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWGetVideoOSDSettings(
//    HCHANNEL                        hChannel,
//    MWCAP_VIDEO_OSD_SETTINGS *      pOSDSettings
//    );
//
// * @ingroup group_functions_procapture
//@brief Sets OSD settings according to channel handle
//@param[in] hChannel           Channel handle
//@param[in] OSDSettings         OSD settings of video capture
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWSetVideoOSDSettings(
//    HCHANNEL                        hChannel,
//    MWCAP_VIDEO_OSD_SETTINGS        OSDSettings
//    );
//
// * @ingroup group_functions_procapture
//@brief  Gets OSD according to channel handle
//@param[in] hChannel           Channel handle
//@param[out] pOSDImage             OSD image
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWGetVideoOSDImage(
//    HCHANNEL                        hChannel,
//    MWCAP_VIDEO_OSD_IMAGE *         pOSDImage
//    );
//
// * @ingroup group_functions_procapture
//@brief  Sets OSD according to channel handle
//@param[in] hChannel           Channel handle
//@param[in] OSDImage           OSD image
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWSetVideoOSDImage(
//    HCHANNEL                        hChannel,
//    MWCAP_VIDEO_OSD_IMAGE           OSDImage
//    );   
 
// * @ingroup group_functions_procapture
//@brief  Gets the brightness of video captured according to channel handle
//@param[in] hChannel               Channel handle
//@param[out] pnBrightness              Brightness of video capture
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWGetVideoBrightness(
//    HCHANNEL hChannel,
//    int *pnBrightness
//    );
//
// * @ingroup group_functions_procapture
//@brief  Sets the brightness of video captured according to channel handle
//@param[in] hChannel               Channel handle
//@param[in] nBrightness            Brightness of video captured
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWSetVideoBrightness(
//    HCHANNEL                        hChannel,
//    int                             nBrightness
//    );
 
// * @ingroup group_functions_procapture
//@brief  Gets the contrast of video captured according to channel handle
//@param[in] hChannel               Channel handle
//@param[out] pnContrast            Contrast of video captured 
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWGetVideoContrast(
//    HCHANNEL                        hChannel,
//    int *                           pnContrast
//    );  
//
// * @ingroup group_functions_procapture
//@brief Sets the contrast of video captured according to channel handle
//@param[in] hChannel           Channel handle
//@param[in] nContrast              Contrast of video captured
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWSetVideoContrast(
//    HCHANNEL                        hChannel,
//    int                             nContrast
//    );
 
//
// * @ingroup group_functions_procapture
//@brief  Saves the presetting configurations of video capture according to channel handle.
//@param[in] hChannel           Channel handle
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWSaveSettingsAsPreset(
//    HCHANNEL                        hChannel
//    );
//
// * @ingroup group_functions_procapture
//@brief Reloads the presetting configurations of video capture according to channel handle.
//@param[in] hChannel           Channel handle
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWReloadPreset(
//    HCHANNEL                        hChannel
//    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoAutoHAlign(
    HCHANNEL                        hChannel,
    BOOLEAN *                       pbAuto
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetVideoAutoHAlign(
    HCHANNEL                        hChannel,
    BOOLEAN                         bAuto
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoSamplingPhase(
    HCHANNEL                        hChannel,
    BYTE *                          pbyValue
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetVideoSamplingPhase(
    HCHANNEL                        hChannel,
    BYTE                            byValue
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoSamplingPhaseAutoAdjust(
    HCHANNEL                        hChannel,
    BOOLEAN *                       pbAuto
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetVideoSamplingPhaseAutoAdjust(
    HCHANNEL                        hChannel,
    BOOLEAN                         bAuto
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetVideoTiming(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_TIMING              videoTiming
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoPreferredTimingArray(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_TIMING *            pVideoTiming,
    long *                          plCount
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetCustomVideoTiming(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_CUSTOM_TIMING       videoTiming
    );   
 
MW_RESULT
LIBMWCAPTURE_API
MWGetCustomVideoTimingsCount(
    HCHANNEL                        hChannel,
    DWORD*                       pdwCount
    ); 
 
MW_RESULT
LIBMWCAPTURE_API
MWGetCustomVideoTimingsArray(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_CUSTOM_TIMING *     pVideoCustomTiming,
    DWORD *                         pdwCount
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetCustomVideoTimingsArray(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_CUSTOM_TIMING *     pVideoCustomTiming,
    DWORD                           dwCount
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetCustomVideoResolutionsCount(
    HCHANNEL                        hChannel,
    DWORD *                         pdwCount
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetCustomVideoResolutionsArray(
    HCHANNEL                        hChannel,
    MWCAP_SIZE *                    pResolutionSize,
    DWORD *                         pdwCount
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetCustomVideoResolutionsArray(
    HCHANNEL                        hChannel,
    MWCAP_SIZE *                    pResolutionSize,
    DWORD                           dwCount
    );
 
MWCAP_PTR
LIBMWCAPTURE_API
MWCreateEvent(
    );  
 
MW_RESULT
LIBMWCAPTURE_API
MWCloseEvent(
    MWCAP_PTR                       hEvent
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetEvent(
    MWCAP_PTR                       hEvent
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWClearEvent(
    MWCAP_PTR                       hEvent
    );
 
BOOLEAN
LIBMWCAPTURE_API
MWIsSetEvent(
    MWCAP_PTR                       hEvent
    );
 
int
LIBMWCAPTURE_API
MWTryWaitEvent(
    MWCAP_PTR                       hEvent
    );
 
int
LIBMWCAPTURE_API
MWWaitEvent(
    MWCAP_PTR                       hEvent,
    int                             nTimeout
    );
 
DWORD
LIBMWCAPTURE_API
MWMultiWaitEvent(
    MWCAP_PTR *                 hEvents,
    int                         nCount,
    int                         nTimeout
    );
 
#ifdef __cplusplus
}
#endif
 
#endif