MWCapture.h

/************************************************************************************************/
// MWCapture.h : header file
 
// MAGEWELL PROPRIETARY INFORMATION
 
// The following license only applies to head files and library within Magewell's SDK 
// and not to Magewell's SDK as a whole. 
 
// Copyrights © Nanjing Magewell Electronics Co., Ltd. ("Magewell") All rights reserved.
 
// Magewell grands to any person who obtains the copy of Magewell's head files and library 
// the rights,including without limitation, to use on the condition that the following terms are met:
// - The above copyright notice shall be retained in any circumstances.
// -The following disclaimer shall be included in the software and documentation and/or 
// other materials provided for the purpose of publish, distribution or sublicense.
 
// THE SOFTWARE IS PROVIDED BY MAGEWELL "AS IS" AND ANY EXPRESS, INCLUDING BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL MAGEWELL BE LIABLE 
 
// FOR ANY CLAIM, DIRECT OR INDIRECT DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT,
// TORT OR OTHERWISE, ARISING IN ANY WAY OF USING THE SOFTWARE.
 
// CONTACT INFORMATION:
// SDK@magewell.net
// http://www.magewell.com/
//
/************************************************************************************************/
#pragma once
 
#ifdef LIBMWCAPTURE_EXPORTS
#define LIBMWCAPTURE_API __declspec(dllexport)
#elif LIBMWCAPTURE_DLL
#define LIBMWCAPTURE_API __declspec(dllimport)
#else
#define LIBMWCAPTURE_API 
#endif
 
#include <stdint.h>
#include "MWLinux.h"
#include "MWProCapture.h"
#include "MWCaptureExtension.h"
#include "MWUSBCapture.h"
#include "MWUSBCaptureExtension.h"
 
#ifdef __cplusplus
 
extern "C"
{
#endif
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVersion(
    BYTE*                           pbyMaj,
    BYTE*                           pbyMin,
    WORD*                           pwBuild
    );
 
BOOL
LIBMWCAPTURE_API
MWCaptureInitInstance(
    );
 
    
void
LIBMWCAPTURE_API
MWCaptureExitInstance(
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWRefreshDevice(
    );
 
int 
LIBMWCAPTURE_API
MWGetChannelCount(
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetChannelInfoByIndex(
    int                             nIndex,
    MWCAP_CHANNEL_INFO *            pChannelInfo
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetFamilyInfoByIndex(
    int                             nIndex,
    LPVOID                          pFamilyInfo,
    DWORD                           dwSize
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetDevicePath(
    int                             nIndex,
    char*                           pDevicePath
);
 
HCHANNEL
LIBMWCAPTURE_API
MWOpenChannelByPath(
    const char*                 pszDevicePath
    );
 
void
LIBMWCAPTURE_API
MWCloseChannel(
    HCHANNEL                        hChannel
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetChannelInfo(
    HCHANNEL                        hChannel,
    MWCAP_CHANNEL_INFO *            pChannelInfo
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetFamilyInfo(
    HCHANNEL                        hChannel,
    LPVOID                          pFamilyInfo,
    DWORD                           dwSize
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoCaps(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_CAPS*               pVideoCaps
    );
    
MW_RESULT
LIBMWCAPTURE_API
MWGetAudioCaps(
    HCHANNEL                        hChannel,
    MWCAP_AUDIO_CAPS*               pAudioCaps
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoInputSourceArray(
    HCHANNEL                        hChannel,
    DWORD*                          pdwInputSource,
    DWORD*                          pdwInputCount
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetAudioInputSourceArray(
    HCHANNEL                        hChannel,
    DWORD*                          pdwInputSource,
    DWORD*                          pdwInputCount
    );
 
    
MW_RESULT
LIBMWCAPTURE_API
MWGetInputSourceScan(
    HCHANNEL                        hChannel,
    BOOLEAN*                        pbScan
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetInputSourceScan(
    HCHANNEL                        hChannel,
    BOOLEAN                         bScan
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetAVInputSourceLink(
    HCHANNEL                        hChannel,
    BOOLEAN*                        pbLink
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetAVInputSourceLink(
    HCHANNEL                        hChannel,
    BOOLEAN                         bLink
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoInputSource(
    HCHANNEL                        hChannel,
    DWORD*                          pdwSource
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetVideoInputSource(
    HCHANNEL                        hChannel,
    DWORD                           dwSource
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetAudioInputSource(
    HCHANNEL                        hChannel,
    DWORD*                          pdwSource
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetAudioInputSource(
    HCHANNEL                        hChannel,
    DWORD                           dwSource
    );
 
// EDID
MW_RESULT
LIBMWCAPTURE_API
MWGetEDID(
    HCHANNEL                        hChannel,
    BYTE*                           pbyData,
    ULONG*                          pulSize
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetEDID(
    HCHANNEL                        hChannel,
    BYTE*                           pbyData,
    ULONG                           ulSize
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetInputSpecificStatus(
    HCHANNEL                        hChannel,
    MWCAP_INPUT_SPECIFIC_STATUS *   pInputStatus
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoSignalStatus(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_SIGNAL_STATUS *     pSignalStatus
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetAudioSignalStatus(
    HCHANNEL                        hChannel,
    MWCAP_AUDIO_SIGNAL_STATUS *     pSignalStatus
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetHDMIInfoFrameValidFlag(
    HCHANNEL                        hChannel,
    DWORD*                          pdwValidFlag
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetHDMIInfoFramePacket(
    HCHANNEL                        hChannel,
    MWCAP_HDMI_INFOFRAME_ID         id,
    HDMI_INFOFRAME_PACKET*          pPacket
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetVideoInputAspectRatio(
    HCHANNEL                        hChannel,
    int                             nAspectX,
    int                             nAspectY
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoInputAspectRatio(
    HCHANNEL                        hChannel,
    int*                            pnAspectX,
    int*                            pnAspectY
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetVideoInputColorFormat(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_COLOR_FORMAT        colorFormat
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoInputColorFormat(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_COLOR_FORMAT *      pColorFormat
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetVideoInputQuantizationRange(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_QUANTIZATION_RANGE  quantRange
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoInputQuantizationRange(
    HCHANNEL                        hChannel,
    MWCAP_VIDEO_QUANTIZATION_RANGE* pQuantRange
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWSetLEDMode(
    HCHANNEL                        hChannel,
    DWORD                           dwMode
    );
 
// * @ingroup group_functions_common
//@brief Gets firmware storage information according to channel handle
//@param[in] hChannel               Channel handle
//@param[out] pFirmwareStorageInfo    The structure contains information about the device firmware
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWGetFirmwareStorageInfo(
//  HCHANNEL                        hChannel,
//  MWCAP_FIRMWARE_STORAGE *        pFirmwareStorageInfo
//  );
//
// * @ingroup group_functions_common
//@brief  Erases the firmware data according to the channel handle
//@param[in] hChannel     Channel handle
//@param[in] cbOffset     Offset
//@param[in] cbErase        The data size needed to erase 
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWEraseFirmwareData(
//  HCHANNEL                        hChannel,
//  DWORD                           cbOffset,
//  DWORD                           cbErase
//  );
//
// * @ingroup group_functions_common
//@brief  Obtains the firmware data according to the channel handle
//@param[in] hChannel     Channel handle
//@param[in] cbOffset     Offset
//@param[out] pbyData     the firmware data being read 
//@param[in] cbToRead     The length of the data to read
//@param[out] pcbRead     The length of the data being read 
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWReadFirmwareData(
//  HCHANNEL                        hChannel,
//  DWORD                           cbOffset,
//  BYTE *                          pbyData,
//  DWORD                           cbToRead,
//  DWORD *                         pcbRead
//  );
//
// * @ingroup group_functions_common
//@brief Writes the firmware data according to the channel handle
//@param[in] hChannel     Channel handle
//@param[in] cbOffset     Offset
//@param[in] pbyData      The firmware data to write
//@param[in] cbData       The firmware data being written
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWWriteFirmwareData(
//  HCHANNEL                        hChannel,
//  DWORD                           cbOffset,
//  BYTE *                          pbyData,
//  DWORD                           cbData
//  );
 
MW_RESULT
MWGetVideoDevicePathByChannel(
    HCHANNEL hChannel,
    char *pszVideoDevicePath
    );
 
HANDLE
LIBMWCAPTURE_API
MWCreateVideoCapture(
    char                            *pszVideoDevicePath,
    int                             nWidth,
    int                             nHeight,
    int                             nFourcc,
    int                             nFrameDuration,
    VIDEO_CAPTURE_CALLBACK          callback,
    void*                           pParam
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWDestoryVideoCapture(
    HANDLE                          hVideo
    );
 
HANDLE
LIBMWCAPTURE_API
MWCreateAudioCapture(
    HCHANNEL                        hChannel,
    MWCAP_AUDIO_CAPTURE_NODE        captureNode,
    DWORD                           dwSamplesPerSec,
    WORD                            wBitsPerSample,
    WORD                            wChannels,
    AUDIO_CAPTURE_CALLBACK          callback,
    void*                           pParam
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWDestoryAudioCapture(
    HANDLE                          hAudio
    );
 
MW_RESULT
    LIBMWCAPTURE_API
    MWGetAudioVolume(
    HCHANNEL                        hChannel,
    MWCAP_AUDIO_NODE                audioNode,
    MWCAP_AUDIO_VOLUME*             pVolume
    );
 
MW_RESULT
    LIBMWCAPTURE_API
    MWSetAudioVolume(
    HCHANNEL                        hChannel,
    MWCAP_AUDIO_NODE                audioNode,
    MWCAP_AUDIO_VOLUME*             pVolume
    );
 
 
MW_RESULT
    LIBMWCAPTURE_API
    MWCaptureSetSDIANCType(
    HCHANNEL                                        hChannel,
    BYTE                                            byIndex,
    BOOLEAN                                         bHANC,
    BOOLEAN                                         bVANC,
    BYTE                                            byDID,
    BYTE                                            bySDID
    );
 
MW_RESULT
    LIBMWCAPTURE_API
    MWCaptureGetSDIANCPacket(
    HCHANNEL                                        hChannel,
    MWCAP_SDI_ANC_PACKET*                           pPacket
    );
 
MW_RESULT
    LIBMWCAPTURE_API
    MWGetVideoCaptureSupportResolutionMode(
        HCHANNEL                        hChannel,
        MWCAP_VIDEO_RESOLUTION_MODE     *pMode,
        int                             *pCount
    );
 
MW_RESULT
    LIBMWCAPTURE_API
    MWGetVideoCaptureSupportRangeResolution(
        HCHANNEL                        hChannel,
        MWCAP_VIDEO_RESOLUTION_RANGE*   pRange
    );
 
MW_RESULT
    LIBMWCAPTURE_API
    MWGetVideoCaptureSupportListResolution(
        HCHANNEL                        hChannel,
        MWCAP_VIDEO_RESOLUTION_LIST*    pList
    );
 
 
MW_RESULT
LIBMWCAPTURE_API
    MWGetVideoCaptureSupportColorFormat(
    HCHANNEL                    hChannel,
    DWORD*                      pColorFourcc,
    int*                        nCount
    );
 
// * @ingroup group_functions_common
//@brief Gets the range of the video processing parameter
//@param[in] hVideo                             Video handle
//@param[in] videoProcParamType                 Parameter type of video processing (like brightness, contrast, hue, saturation)
//@param[out] plParamValueMin                   Minimum value of this parameter
//@param[out] plParamValueMax               Maximum value of this parameter
//@param[out] plParamValueDef               Default value of this parameter
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//LIBMWCAPTURE_API
//MWGetVideoProcParamRange(
//  HANDLE hVideo,
//  MWCAP_VIDEO_PROC_PARAM_TYPE videoProcParamType,
//  long * plParamValueMin,
//  long * plParamValueMax,
//  long * plParamValueDef
//  );
//
// * @ingroup group_functions_common
//@brief Get the current value of the video processing parameter
//@param[in] hVideo                             Video handle
//@param[in] videoProcParamType                 Parameter type of video processing (like brightness, contrast, hue, saturation)
//@param[out] plParamValue                      Current value of this parameter
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//  LIBMWCAPTURE_API
//  MWGetVideoProcParam(
//  HANDLE hVideo,
//  MWCAP_VIDEO_PROC_PARAM_TYPE videoProcParamType,
//  long * plParamValue
//  );
//
//
// * @ingroup group_functions_common
//@brief Set the current value of the video processing parameter
//@param[in] hVideo                             Video handle
//@param[in] videoProcParamType                 Parameter type of video processing (like brightness,contrast,hue,saturation)
//@param[in] lParamValue                    Parameters should be within the range
//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
//*/
//MW_RESULT
//  LIBMWCAPTURE_API
//  MWSetVideoProcParam(
//  HANDLE hVideo,
//  MWCAP_VIDEO_PROC_PARAM_TYPE videoProcParamType,
//  long lParamValue
//  );
//
 
#ifdef __cplusplus
}
#endif