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
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetFirmwareStorageInfo(
    HCHANNEL                        hChannel,
    MWCAP_FIRMWARE_STORAGE *        pFirmwareStorageInfo
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWEraseFirmwareData(
    HCHANNEL                        hChannel,
    DWORD                           cbOffset,
    DWORD                           cbErase
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWReadFirmwareData(
    HCHANNEL                        hChannel,
    DWORD                           cbOffset,
    BYTE *                          pbyData,
    DWORD                           cbToRead,
    DWORD *                         pcbRead
    );
 
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
    );
 
MW_RESULT
LIBMWCAPTURE_API
MWGetVideoProcParamRange(
    HANDLE hVideo,
    MWCAP_VIDEO_PROC_PARAM_TYPE videoProcParamType,
    long * plParamValueMin,
    long * plParamValueMax,
    long * plParamValueDef
    );
 
MW_RESULT
    LIBMWCAPTURE_API
    MWGetVideoProcParam(
    HANDLE hVideo,
    MWCAP_VIDEO_PROC_PARAM_TYPE videoProcParamType,
    long * plParamValue
    );
 
 
MW_RESULT
    LIBMWCAPTURE_API
    MWSetVideoProcParam(
    HANDLE hVideo,
    MWCAP_VIDEO_PROC_PARAM_TYPE videoProcParamType,
    long lParamValue
    );
 
 
#ifdef __cplusplus
}
#endif