MWCaptureExtension.h

 
// CONFIDENTIAL and PROPRIETARY software of Magewell Electronics Co., Ltd.
// Copyright (c) 2011-2014 Magewell Electronics Co., Ltd. (Nanjing) 
// All rights reserved.
// This copyright notice MUST be reproduced on all authorized copies.
 
#pragma once
 
#include <stdint.h>
#include "WinTypes.h"
#include "MWCommon.h"
#include "MWSMPTE.h"
#include "MWIEC60958.h"
#include "MWHDMIPackets.h"
 
#ifndef _MAX_PATH
#define _MAX_PATH   (512)
#endif
 
#pragma pack(push)
#pragma pack(1)
 
#ifdef __cplusplus
extern "C"
{
#endif
 
//#ifndef HPCICHANNEL
//#define HPCICHANNEL int
//#endif
 
#ifndef HCHANNEL
#define HCHANNEL void *
#endif
 
#ifndef MWCAP_PTR64
#define MWCAP_PTR64  MWCAP_PTR
#endif
 
#ifndef MWHANDLE
#define MWHANDLE MWCAP_PTR
#endif
 
#ifndef LPBYTE
#define LPBYTE unsigned char*
#endif
 
#ifndef HTIMER
#define HTIMER MWCAP_PTR
#endif
 
#ifndef HNOTIFY
#define HNOTIFY MWCAP_PTR
#endif
 
#ifndef HOSD
#define HOSD MWCAP_PTR
#endif
 
#ifndef LPVOID
#define LPVOID void *
#endif
 
#ifndef ULONG
#define ULONG unsigned long
#endif
 
#ifndef HANDLE64
#define HANDLE64 MWCAP_PTR
#endif
 
#ifdef __cplusplus
}
#endif
 
// Magewell Capture Extensions
 
// Data structs
typedef CHAR                                    MWCAP_BOOL;
 
typedef union _LARGE_INTEGER {
    struct {
        DWORD LowPart;
        DWORD HighPart;
    };
    struct {
        DWORD LowPart;
        DWORD HighPart;
    } u;
    LONGLONG QuadPart;
} LARGE_INTEGER, *PLARGE_INTEGER;
 
typedef enum _MW_RESULT_ {
    MW_SUCCEEDED = 0x00,
    MW_FAILED,
    MW_ENODATA,
    MW_INVALID_PARAMS
} MW_RESULT;
#define INPUT_SOURCE(type, index)               (((type) << 8) | ((index) & 0xFF))
#define INPUT_TYPE(source)                      ((source) >> 8)
#define INPUT_INDEX(source)                     ((source) & 0xFF)
 
typedef enum _MWCAP_PRODUCT_ID {
    MWCAP_PRODUCT_ID_PRO_CAPTURE_AIO                = 0x00000102,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_DVI                = 0x00000103,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_HDMI               = 0x00000104,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_SDI                = 0x00000105,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_DUAL_SDI           = 0x00000106,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_DUAL_DVI           = 0x00000107,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_DUAL_HDMI          = 0x00000108,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_QUAD_SDI           = 0x00000109,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_QUAD_HDMI          = 0x00000110,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_MINI_HDMI          = 0x00000111,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_HDMI_4K            = 0x00000112,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_MINI_SDI           = 0x00000113,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_AIO_4K_PLUS        = 0x00000114,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_HDMI_4K_PLUS       = 0x00000115,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_DVI_4K             = 0x00000116,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_AIO_4K             = 0x00000117,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_SDI_4K_PLUS        = 0x00000118,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_DUAL_HDMI_4K_PLUS  = 0x00000119,
    MWCAP_PRODUCT_ID_PRO_CAPTURE_DUAL_SDI_4K_PLUS   = 0x00000120,
 
    MWCAP_PRODUCT_ID_ECO_CAPTURE_OCTA_SDI           = 0x00000150,
    MWCAP_PRODUCT_ID_ECO_CAPTURE_DUAL_HDMI_M2       = 0x00000151,
    MWCAP_PRODUCT_ID_ECO_CAPTURE_HDMI_4K_M2         = 0x00000152,
    MWCAP_PRODUCT_ID_ECO_CAPTURE_DUAL_SDI_M2        = 0x00000153,
    MWCAP_PRODUCT_ID_ECO_CAPTURE_QUAD_SDI_M2        = 0x00000154,
 
    MWCAP_PRODUCT_ID_USB_CAPTURE_HDMI_PLUS          = 0x00000204,
    MWCAP_PRODUCT_ID_USB_CAPTURE_SDI_PLUS           = 0x00000205,
    MWCAP_PRODUCT_ID_USB_CAPTURE_HDMI               = 0x00000206,
    MWCAP_PRODUCT_ID_USB_CAPTURE_SDI                = 0x00000207,
    MWCAP_PRODUCT_ID_USB_CAPTURE_DVI                = 0x00000208,
    MWCAP_PRODUCT_ID_USB_CAPTURE_HDMI_4K        = 0x00000209,
    MWCAP_PRODUCT_ID_USB_CAPTURE_SDI_4K         = 0x00000210,
    MWCAP_PRODUCT_ID_USB_CAPTURE_AIO                = 0x00000211,
    MWCAP_PRODUCT_ID_USB_CAPTURE_AIO_4K             = 0x00000212 
} MWCAP_PRODUCT_ID;
 
typedef enum _MWCAP_VIDEO_INPUT_TYPE {          
    MWCAP_VIDEO_INPUT_TYPE_NONE                     = 0x00,
    MWCAP_VIDEO_INPUT_TYPE_HDMI                     = 0x01,
    MWCAP_VIDEO_INPUT_TYPE_VGA                      = 0x02,
    MWCAP_VIDEO_INPUT_TYPE_SDI                      = 0x04,
    MWCAP_VIDEO_INPUT_TYPE_COMPONENT                = 0x08,
    MWCAP_VIDEO_INPUT_TYPE_CVBS                     = 0x10,
    MWCAP_VIDEO_INPUT_TYPE_YC                       = 0x20 
} MWCAP_VIDEO_INPUT_TYPE;   
 
typedef enum _MWCAP_AUDIO_INPUT_TYPE {  
    MWCAP_AUDIO_INPUT_TYPE_NONE                     = 0x00,
    MWCAP_AUDIO_INPUT_TYPE_HDMI                     = 0x01,
    MWCAP_AUDIO_INPUT_TYPE_SDI                      = 0x02,
    MWCAP_AUDIO_INPUT_TYPE_LINE_IN                  = 0x04,
    MWCAP_AUDIO_INPUT_TYPE_MIC_IN                   = 0x08 
} MWCAP_AUDIO_INPUT_TYPE;                           
 
typedef enum _MWCAP_PCIE_LINK_TYPE {
    MWCAP_PCIE_LINK_GEN_1                       = 0x01,
    MWCAP_PCIE_LINK_GEN_2                       = 0x02,
    MWCAP_PCIE_LINK_GEN_3                       = 0x04,
    MWCAP_PCIE_LINK_GEN_4                       = 0x08 
} MWCAP_PCIE_LINK_TYPE;
 
typedef enum _MWCAP_VIDEO_TIMING_TYPE {                 
    MWCAP_VIDEO_TIMING_NONE                         = 0x00000000,
    MWCAP_VIDEO_TIMING_LEGACY                       = 0x00000001,
    MWCAP_VIDEO_TIMING_DMT                          = 0x00000002,
    MWCAP_VIDEO_TIMING_CEA                          = 0x00000004,
    MWCAP_VIDEO_TIMING_GTF                          = 0x00000008,
    MWCAP_VIDEO_TIMING_CVT                          = 0x00000010,
    MWCAP_VIDEO_TIMING_CVT_RB                       = 0x00000020,
    MWCAP_VIDEO_TIMING_FAILSAFE                     = 0x00002000 
} MWCAP_VIDEO_TIMING_TYPE;
 
typedef enum _MWCAP_VIDEO_COLOR_FORMAT {            
    MWCAP_VIDEO_COLOR_FORMAT_UNKNOWN                = 0x00,
    MWCAP_VIDEO_COLOR_FORMAT_RGB                    = 0x01,
    MWCAP_VIDEO_COLOR_FORMAT_YUV601                 = 0x02,
    MWCAP_VIDEO_COLOR_FORMAT_YUV709                 = 0x03,
    MWCAP_VIDEO_COLOR_FORMAT_YUV2020                = 0x04,
    MWCAP_VIDEO_COLOR_FORMAT_YUV2020C               = 0x05 
} MWCAP_VIDEO_COLOR_FORMAT;                             
 
typedef enum _MWCAP_VIDEO_QUANTIZATION_RANGE {          
    MWCAP_VIDEO_QUANTIZATION_UNKNOWN                = 0x00,
    MWCAP_VIDEO_QUANTIZATION_FULL                   = 0x01,
    MWCAP_VIDEO_QUANTIZATION_LIMITED                = 0x02 
} MWCAP_VIDEO_QUANTIZATION_RANGE;                   
 
typedef enum _MWCAP_VIDEO_SATURATION_RANGE {        
    MWCAP_VIDEO_SATURATION_UNKNOWN                  = 0x00,
    MWCAP_VIDEO_SATURATION_FULL                     = 0x01,
    MWCAP_VIDEO_SATURATION_LIMITED                  = 0x02,
    MWCAP_VIDEO_SATURATION_EXTENDED_GAMUT           = 0x03 
} MWCAP_VIDEO_SATURATION_RANGE;                     
 
typedef enum _MWCAP_VIDEO_FRAME_TYPE {
    MWCAP_VIDEO_FRAME_2D                            = 0x00,
    MWCAP_VIDEO_FRAME_3D_TOP_AND_BOTTOM_FULL        = 0x01,
    MWCAP_VIDEO_FRAME_3D_TOP_AND_BOTTOM_HALF        = 0x02,
    MWCAP_VIDEO_FRAME_3D_SIDE_BY_SIDE_FULL          = 0x03,
    MWCAP_VIDEO_FRAME_3D_SIDE_BY_SIDE_HALF          = 0x04 
} MWCAP_VIDEO_FRAME_TYPE;
 
typedef enum _MWCAP_VIDEO_DEINTERLACE_MODE {
    MWCAP_VIDEO_DEINTERLACE_WEAVE                   = 0x00,
    MWCAP_VIDEO_DEINTERLACE_BLEND                   = 0x01,
    MWCAP_VIDEO_DEINTERLACE_TOP_FIELD               = 0x02,
    MWCAP_VIDEO_DEINTERLACE_BOTTOM_FIELD            = 0x03 
} MWCAP_VIDEO_DEINTERLACE_MODE;
 
typedef enum _MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE {
    MWCAP_VIDEO_ASPECT_RATIO_IGNORE                 = 0x00,
    MWCAP_VIDEO_ASPECT_RATIO_CROPPING               = 0x01,
    MWCAP_VIDEO_ASPECT_RATIO_PADDING                = 0x02 
} MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE;
 
typedef enum _MWCAP_VIDEO_SYNC_TYPE {
    VIDEO_SYNC_ALL                                  = 0x07,
    VIDEO_SYNC_HS_VS                                = 0x01,
    VIDEO_SYNC_CS                                   = 0x02,
    VIDEO_SYNC_EMBEDDED                             = 0x04 
} MWCAP_VIDEO_SYNC_TYPE;
 
typedef struct _MWCAP_VIDEO_SYNC_INFO    {
    BYTE                                            bySyncType;         
    BOOLEAN                                         bHSPolarity;        
    BOOLEAN                                         bVSPolarity;        
    BOOLEAN                                         bInterlaced;        
    DWORD                                           dwFrameDuration;    
    WORD                                            wVSyncLineCount;    
    WORD                                            wFrameLineCount;    
} MWCAP_VIDEO_SYNC_INFO;
 
typedef struct _MWCAP_VIDEO_TIMING {
    DWORD                                           dwType;             
    DWORD                                           dwPixelClock;       
    BOOLEAN                                         bInterlaced;        
    BYTE                                            bySyncType;         
    BOOLEAN                                         bHSPolarity;        
    BOOLEAN                                         bVSPolarity;        
    WORD                                            wHActive;           
    WORD                                            wHFrontPorch;       
    WORD                                            wHSyncWidth;        
    WORD                                            wHBackPorch;        
    WORD                                            wVActive;           
    WORD                                            wVFrontPorch;       
    WORD                                            wVSyncWidth;        
    WORD                                            wVBackPorch;        
} MWCAP_VIDEO_TIMING;
 
typedef struct _MWCAP_VIDEO_TIMING_SETTINGS {
    WORD                                            wAspectX;           
    WORD                                            wAspectY;           
    WORD                                            x;                  
    WORD                                            y;                  
    WORD                                            cx;                 
    WORD                                            cy;                 
    WORD                                            cxTotal;            
    BYTE                                            byClampPos;         
} MWCAP_VIDEO_TIMING_SETTINGS;
 
typedef struct _MWCAP_SIZE {
    WORD                                        cx;
    WORD                                        cy;
} MWCAP_SIZE;
 
typedef struct _MWCAP_RECT {
    WORD                                        x;
    WORD                                        y;
    WORD                                        cx;
    WORD                                        cy;
} MWCAP_RECT;
 
typedef struct _MWCAP_DWORD_PARAMETER_RANGE {       
    DWORD                                           dwMin;              
    DWORD                                           dwMax;              
    DWORD                                           dwStep;             
    DWORD                                           dwDefault;          
} MWCAP_DWORD_PARAMETER_RANGE;                      
                                                    
#define MWCAP_DWORD_PARAMETER_FLAG_AUTO             0x01
 
typedef struct _MWCAP_DWORD_PARAMETER_VALUE {       
    DWORD                                           dwFlags;            
    DWORD                                           dwValue;            
} MWCAP_DWORD_PARAMETER_VALUE;                  
 
typedef struct _MWCAP_CHANNEL_INFO {        
    WORD                                            wFamilyID;                              
    WORD                                            wProductID;                             
    CHAR                                            chHardwareVersion;                      
    BYTE                                            byFirmwareID;                           
    DWORD                                           dwFirmwareVersion;                      
    DWORD                                           dwDriverVersion;                        
    CHAR                                            szFamilyName[MW_FAMILY_NAME_LEN];       
    CHAR                                            szProductName[MW_PRODUCT_NAME_LEN];     
    CHAR                                            szFirmwareName[MW_FIRMWARE_NAME_LEN];   
    CHAR                                            szBoardSerialNo[MW_SERIAL_NO_LEN];      
    BYTE                                            byBoardIndex;                           
    BYTE                                            byChannelIndex;                         
} MWCAP_CHANNEL_INFO;
 
typedef struct _MWCAP_PRO_CAPTURE_INFO {
    BYTE                                            byPCIBusID;                             
    BYTE                                            byPCIDevID;                             
    BYTE                                            byLinkType;                             
    BYTE                                            byLinkWidth;                            
    BYTE                                            byBoardIndex;                           
    WORD                                            wMaxPayloadSize;                        
    WORD                                            wMaxReadRequestSize;                    
    DWORD                                           cbTotalMemorySize;                      
    DWORD                                           cbFreeMemorySize;                       
} MWCAP_PRO_CAPTURE_INFO;
 
typedef struct _MWCAP_VIDEO_CAPS {
    DWORD                                           dwCaps;                                 
    WORD                                            wMaxInputWidth;                         
    WORD                                            wMaxInputHeight;                        
    WORD                                            wMaxOutputWidth;                        
    WORD                                            wMaxOutputHeight;                       
} MWCAP_VIDEO_CAPS;
 
typedef struct _MWCAP_AUDIO_CAPS {
    DWORD                                           dwCaps;                                 
} MWCAP_AUDIO_CAPS;                       
 
typedef struct _MWCAP_FIRMWARE_STORAGE_CARD{
    DWORD                                           cbStorage;                              
    DWORD                                           cbEraseBlock;                           
    DWORD                                           cbProgramBlock;                         
    DWORD                                           cbHeaderOffset;                         
}MWCAP_FIRMWARE_STORAGE_CARD;
 
typedef struct _MWCAP_FIRMWARE_STORAGE_USB{
    DWORD                                           cbStorage;                              
    DWORD                                           cbEraseBlock;                           
    DWORD                                           cbProgramBlock;                         
    DWORD                                           cbHeaderOffset;                         
 
    DWORD                                           cbFirmwareOffset;                       
    DWORD                                           cbDriverOffset;                         
    DWORD                                           cbMRFSOffset;                           
}MWCAP_FIRMWARE_STORAGE_USB;
 
typedef enum _MWCAP_LED_MODE {
    MWCAP_LED_AUTO                                  = 0x00000000,                           
    MWCAP_LED_OFF                                   = 0x80000000,                           
    MWCAP_LED_ON                                    = 0x80000001,                           
    MWCAP_LED_BLINK                                 = 0x80000002,                           
    MWCAP_LED_DBL_BLINK                             = 0x80000003,                           
    MWCAP_LED_BREATH                                = 0x80000004                            
}MWCAP_LED_MODE;
 
typedef struct _MWCAP_SDI_SPECIFIC_STATUS {
    SDI_TYPE                                        sdiType;                                
    SDI_SCANNING_FORMAT                             sdiScanningFormat;                      
    SDI_BIT_DEPTH                                   sdiBitDepth;                            
    SDI_SAMPLING_STRUCT                             sdiSamplingStruct;                      
    BOOLEAN                                         bST352DataValid;                        
    DWORD                                           dwST352Data;                            
} MWCAP_SDI_SPECIFIC_STATUS;
 
typedef struct _MWCAP_HDMI_VIDEO_TIMING {
    BOOLEAN                                         bInterlaced;                            
    DWORD                                           dwFrameDuration;                        
    WORD                                            wHSyncWidth;                            
    WORD                                            wHFrontPorch;                           
    WORD                                            wHBackPorch;                            
    WORD                                            wHActive;                               
    WORD                                            wHTotalWidth;                           
    WORD                                            wField0VSyncWidth;                      
    WORD                                            wField0VFrontPorch;                     
    WORD                                            wField0VBackPorch;                      
    WORD                                            wField0VActive;                         
    WORD                                            wField0VTotalHeight;                    
    WORD                                            wField1VSyncWidth;                      
    WORD                                            wField1VFrontPorch;                     
    WORD                                            wField1VBackPorch;                      
    WORD                                            wField1VActive;                         
    WORD                                            wField1VTotalHeight;                    
} MWCAP_HDMI_VIDEO_TIMING;
 
typedef struct _MWCAP_HDMI_SPECIFIC_STATUS {
    BOOLEAN                                         bHDMIMode;                              
    BOOLEAN                                         bHDCP;                                  
    BYTE                                            byBitDepth;                             
    HDMI_PXIEL_ENCODING                             pixelEncoding;                          
    BYTE                                            byVIC;                                  
    BOOLEAN                                         bITContent;                             
    BOOLEAN                                         b3DFormat;                              
    BYTE                                            by3DStructure;                          
    BYTE                                            bySideBySideHalfSubSampling;            
    MWCAP_HDMI_VIDEO_TIMING                         videoTiming;                            
} MWCAP_HDMI_SPECIFIC_STATUS;
 
typedef struct _MWCAP_COMPONENT_SPECIFIC_STATUS {
    MWCAP_VIDEO_SYNC_INFO                           syncInfo;                               
    BOOLEAN                                         bTriLevelSync;                          
    MWCAP_VIDEO_TIMING                              videoTiming;                            
    MWCAP_VIDEO_TIMING_SETTINGS                     videoTimingSettings;                    
} MWCAP_COMPONENT_SPECIFIC_STATUS;
 
typedef enum _MWCAP_SD_VIDEO_STANDARD {
    MWCAP_SD_VIDEO_NONE,                                                                    
    MWCAP_SD_VIDEO_NTSC_M,                                                                  
    MWCAP_SD_VIDEO_NTSC_433,                                                                
    MWCAP_SD_VIDEO_PAL_M,                                                                   
    MWCAP_SD_VIDEO_PAL_60,                                                                  
    MWCAP_SD_VIDEO_PAL_COMBN,                                                               
    MWCAP_SD_VIDEO_PAL_BGHID,                                                               
    MWCAP_SD_VIDEO_SECAM,                                                                   
    MWCAP_SD_VIDEO_SECAM_60                                                                 
} MWCAP_SD_VIDEO_STANDARD;
 
typedef struct _MWCAP_CVBS_YC_SPECIFIC_STATUS {
    MWCAP_SD_VIDEO_STANDARD                         standard;                               
    BOOLEAN                                         b50Hz;                                  
} MWCAP_CVBS_YC_SPECIFIC_STATUS;
 
typedef struct _MWCAP_INPUT_SPECIFIC_STATUS {
    BOOLEAN                                         bValid;                                 
    DWORD                                           dwVideoInputType;                       
    union {
        MWCAP_SDI_SPECIFIC_STATUS                   sdiStatus;                              
        MWCAP_HDMI_SPECIFIC_STATUS                  hdmiStatus;                             
        MWCAP_COMPONENT_SPECIFIC_STATUS             vgaComponentStatus;                     
        MWCAP_CVBS_YC_SPECIFIC_STATUS               cvbsYcStatus;                           
    };
} MWCAP_INPUT_SPECIFIC_STATUS;
 
typedef enum _MWCAP_VIDEO_SIGNAL_STATE {
    MWCAP_VIDEO_SIGNAL_NONE,                                                                
    MWCAP_VIDEO_SIGNAL_UNSUPPORTED,                                                         
    MWCAP_VIDEO_SIGNAL_LOCKING,                                                             
    MWCAP_VIDEO_SIGNAL_LOCKED                                                               
} MWCAP_VIDEO_SIGNAL_STATE;
 
typedef struct _MWCAP_VIDEO_SIGNAL_STATUS {
    MWCAP_VIDEO_SIGNAL_STATE                        state;                                  
    int                                             x;                                      
    int                                             y;                                      
    int                                             cx;                                     
    int                                             cy;                                     
    int                                             cxTotal;                                
    int                                             cyTotal;                                
    BOOLEAN                                         bInterlaced;                            
    DWORD                                           dwFrameDuration;                        
    int                                             nAspectX;                               
    int                                             nAspectY;                               
    BOOLEAN                                         bSegmentedFrame;                        
    MWCAP_VIDEO_FRAME_TYPE                          frameType;                              
    MWCAP_VIDEO_COLOR_FORMAT                        colorFormat;                            
    MWCAP_VIDEO_QUANTIZATION_RANGE                  quantRange;                             
    MWCAP_VIDEO_SATURATION_RANGE                    satRange;                               
} MWCAP_VIDEO_SIGNAL_STATUS;
 
 
typedef struct _MWCAP_AUDIO_SIGNAL_STATUS {
    WORD                                            wChannelValid;                          
    BOOLEAN                                         bLPCM;                                  
    BYTE                                            cBitsPerSample;                         
    DWORD                                           dwSampleRate;                           
    BOOLEAN                                         bChannelStatusValid;                    
    IEC60958_CHANNEL_STATUS                         channelStatus;                          
} MWCAP_AUDIO_SIGNAL_STATUS;
 
// Hardware timer
typedef struct _MWCAP_TIMER_EXPIRE_TIME {
    MWCAP_PTR                                   pvTimer;
    LONGLONG                                    llExpireTime;
} MWCAP_TIMER_EXPIRE_TIME;
 
typedef struct _MWCAP_TIMER_REGISTRATION_S {
    MWCAP_PTR                                   pvTimer;      // get
    MWCAP_PTR                                   pvEvent;      // set
} MWCAP_TIMER_REGISTRATION_S;
 
#define MWCAP_NOTIFY_INPUT_SORUCE_START_SCAN        0x0001ULL
#define MWCAP_NOTIFY_INPUT_SORUCE_STOP_SCAN         0x0002ULL
#define MWCAP_NOTIFY_INPUT_SORUCE_SCAN_CHANGE       0x0003ULL
 
 
#define MWCAP_NOTIFY_VIDEO_INPUT_SOURCE_CHANGE      0x0004ULL
 
#define MWCAP_NOTIFY_AUDIO_INPUT_SOURCE_CHANGE      0x0008ULL
 
#define MWCAP_NOTIFY_INPUT_SPECIFIC_CHANGE          0x0010ULL
 
 
#define MWCAP_NOTIFY_VIDEO_SIGNAL_CHANGE            0x0020ULL
 
 
#define MWCAP_NOTIFY_AUDIO_SIGNAL_CHANGE            0x0040ULL
 
 
#define MWCAP_NOTIFY_VIDEO_FIELD_BUFFERING          0x0080ULL
 
#define MWCAP_NOTIFY_VIDEO_FRAME_BUFFERING          0x0100ULL
 
#define MWCAP_NOTIFY_VIDEO_FIELD_BUFFERED           0x0200ULL
 
#define MWCAP_NOTIFY_VIDEO_FRAME_BUFFERED           0x0400ULL
 
#define MWCAP_NOTIFY_VIDEO_SMPTE_TIME_CODE          0x0800ULL
 
 
#define MWCAP_NOTIFY_AUDIO_FRAME_BUFFERED           0x1000ULL
 
#define MWCAP_NOTIFY_AUDIO_INPUT_RESET              0x2000ULL
 
 
#define MWCAP_NOTIFY_VIDEO_SAMPLING_PHASE_CHANGE    0x4000ULL
 
#define MWCAP_NOTIFY_LOOP_THROUGH_CHANGED           0x8000ULL
 
#define MWCAP_NOTIFY_LOOP_THROUGH_EDID_CHANGED      0x10000ULL
 
#define MWCAP_NOTIFY_NEW_SDI_ANC_PACKET             0x20000ULL
 
 
#define MWCAP_NOTIFY_HDMI_INFOFRAME_AVI             (1ULL << (32 + MWCAP_HDMI_INFOFRAME_ID_AVI))
 
#define MWCAP_NOTIFY_HDMI_INFOFRAME_AUDIO           (1ULL << (32 + MWCAP_HDMI_INFOFRAME_ID_AUDIO))
 
#define MWCAP_NOTIFY_HDMI_INFOFRAME_SPD             (1ULL << (32 + MWCAP_HDMI_INFOFRAME_ID_SPD))
 
#define MWCAP_NOTIFY_HDMI_INFOFRAME_MS              (1ULL << (32 + MWCAP_HDMI_INFOFRAME_ID_MS))
 
#define MWCAP_NOTIFY_HDMI_INFOFRAME_VS              (1ULL << (32 + MWCAP_HDMI_INFOFRAME_ID_VS))
 
#define MWCAP_NOTIFY_HDMI_INFOFRAME_ACP             (1ULL << (32 + MWCAP_HDMI_INFOFRAME_ID_ACP))
 
#define MWCAP_NOTIFY_HDMI_INFOFRAME_ISRC1           (1ULL << (32 + MWCAP_HDMI_INFOFRAME_ID_ISRC1))
 
#define MWCAP_NOTIFY_HDMI_INFOFRAME_ISRC2           (1ULL << (32 + MWCAP_HDMI_INFOFRAME_ID_ISRC2))
 
#define MWCAP_NOTIFY_HDMI_INFOFRAME_GAMUT           (1ULL << (32 + MWCAP_HDMI_INFOFRAME_ID_GAMUT))
 
typedef struct _MWCAP_NOTIFY_REGISTRATION_S {
    MWCAP_PTR                                   pvNotify;      // get
    ULONGLONG                                   ullEnableBits; // set
    MWCAP_PTR                                   pvEvent;       // set
} MWCAP_NOTIFY_REGISTRATION_S;
 
typedef struct _MWCAP_NOTIFY_STATUS {
    MWCAP_PTR                                   pvNotify;      // set
    ULONGLONG                                   ullStatusBits; // get
} MWCAP_NOTIFY_STATUS;
 
typedef struct _MWCAP_NOTIFY_ENABLE {
    BOOLEAN                                          bInterrupt;
    //MWCAP_PTR                                   pvNotify;      // set
    ULONGLONG                                   ullEnableBits; // set
} MWCAP_NOTIFY_ENABLE;
 
// Video frame information
#define MWCAP_MAX_VIDEO_FRAME_COUNT             8
 
typedef struct _MWCAP_SMPTE_TIMECODE {
    BYTE                                            byFrames;                                   
    BYTE                                            bySeconds;                                  
    BYTE                                            byMinutes;                                  
    BYTE                                            byHours;                                    
} MWCAP_SMPTE_TIMECODE;
 
typedef enum _MWCAP_VIDEO_FRAME_STATE {
    MWCAP_VIDEO_FRAME_STATE_INITIAL,                                                            
    MWCAP_VIDEO_FRAME_STATE_F0_BUFFERING,                                                       
    MWCAP_VIDEO_FRAME_STATE_F1_BUFFERING,                                                       
    MWCAP_VIDEO_FRAME_STATE_BUFFERED                                                            
} MWCAP_VIDEO_FRAME_STATE;
 
typedef struct _MWCAP_VIDEO_BUFFER_INFO {
    DWORD                                           cMaxFrames;                                 
 
    BYTE                                            iNewestBuffering;                           
    BYTE                                            iBufferingFieldIndex;                       
 
    BYTE                                            iNewestBuffered;                            
    BYTE                                            iBufferedFieldIndex;                        
 
    BYTE                                            iNewestBufferedFullFrame;                   
    DWORD                                           cBufferedFullFrames;                        
} MWCAP_VIDEO_BUFFER_INFO;
 
typedef struct _MWCAP_VIDEO_FRAME_INFO {
    MWCAP_VIDEO_FRAME_STATE                         state;                                      
 
    BOOLEAN                                         bInterlaced;                                
    BOOLEAN                                         bSegmentedFrame;                            
    BOOLEAN                                         bTopFieldFirst;                             
    BOOLEAN                                         bTopFieldInverted;                          
 
    int                                             cx;                                         
    int                                             cy;                                         
    int                                             nAspectX;                                   
    int                                             nAspectY;                                   
 
    LONGLONG                                        allFieldStartTimes[2];                      
    LONGLONG                                        allFieldBufferedTimes[2];                   
    MWCAP_SMPTE_TIMECODE                            aSMPTETimeCodes[2];                         
} MWCAP_VIDEO_FRAME_INFO;
 
// Video capture
typedef struct _MWCAP_VIDEO_CAPTURE_OPEN {
    MWCAP_PTR                                       hEvent;
} MWCAP_VIDEO_CAPTURE_OPEN;
 
#define MWCAP_VIDEO_MAX_NUM_OSD_RECTS           4
 
#define MWCAP_VIDEO_FRAME_ID_NEWEST_BUFFERED        (-1)
 
#define MWCAP_VIDEO_FRAME_ID_NEWEST_BUFFERING       (-2)
 
#define MWCAP_VIDEO_FRAME_ID_NEXT_BUFFERED          (-3)
 
#define MWCAP_VIDEO_FRAME_ID_NEXT_BUFFERING         (-4)
 
#define MWCAP_VIDEO_FRAME_ID_EMPTY                  (-100)
 
#define MWCAP_VIDEO_PROCESS_FLIP                    0x00000001
 
#define MWCAP_VIDEO_PROCESS_MIRROR                  0x00000002
 
 
typedef struct _MWCAP_VIDEO_CAPTURE_FRAME {
    // Processing parameters
    DWORD                                       dwFOURCC;
    WORD                                        cx;
    WORD                                        cy;
    int                                         nAspectX;
    int                                         nAspectY;
    MWCAP_VIDEO_COLOR_FORMAT                    colorFormat;
    MWCAP_VIDEO_QUANTIZATION_RANGE              quantRange;
    MWCAP_VIDEO_SATURATION_RANGE                satRange;
 
    SHORT                                       sContrast;          // [50, 200]
    SHORT                                       sBrightness;        // [-100, 100]
    SHORT                                       sSaturation;        // [0, 200]
    SHORT                                       sHue;               // [-90, 90]
 
    RECT                                        rectSource;
    RECT                                        rectTarget;
 
    MWCAP_VIDEO_DEINTERLACE_MODE                deinterlaceMode;
    MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE       aspectRatioConvertMode;
 
    // Source frame
    int                                         iSrcFrame;
 
    // OSD (within rectTarget and [0,0-cx,cy))
    MWCAP_PTR                                   pOSDImage;
    RECT                                        aOSDRects[MWCAP_VIDEO_MAX_NUM_OSD_RECTS];
    int                                         cOSDRects;
 
    // Buffer parameters
    BOOLEAN                                     bPhysicalAddress;
    union {
        MWCAP_PTR                               pvFrame;
        LARGE_INTEGER                           liPhysicalAddress;
    };
 
    DWORD                                       cbFrame;
    DWORD                                       cbStride;
 
    BOOLEAN                                     bBottomUp;
 
    // 0: Not use partial notify
    WORD                                        cyPartialNotify;
 
    DWORD                                       dwProcessSwitchs;       // MWCAP_VIDEO_PROCESS_xx
 
    // Context
    MWCAP_PTR                                   pvContext;
} MWCAP_VIDEO_CAPTURE_FRAME;
 
 
typedef struct _MWCAP_VIDEO_CAPTURE_STATUS {
    MWCAP_PTR                                   pvContext;                                                                  
 
    BOOLEAN                                         bPhysicalAddress;                                                           
    union {
        MWCAP_PTR                                   pvFrame;                                                                    
        LARGE_INTEGER                               liPhysicalAddress;                                                          
    };
 
    int                                             iFrame;                                                                     
    BOOLEAN                                         bFrameCompleted;                                                            
    WORD                                            cyCompleted;                                                                
    WORD                                            cyCompletedPrev;                                                            
} MWCAP_VIDEO_CAPTURE_STATUS;
 
// Audio capture
#define MWCAP_AUDIO_FRAME_SYNC_CODE             0xFECA0357
#define MWCAP_AUDIO_SAMPLES_PER_FRAME           192
#define MWCAP_AUDIO_MAX_NUM_CHANNELS            8
 
// Audio samples are 32bits wide, cBitsPerSample of high bits are valid
typedef struct _MWCAP_AUDIO_CAPTURE_FRAME {
    DWORD                                           cFrameCount;                                                                
    DWORD                                           iFrame;                                                                     
    DWORD                                           dwSyncCode;                                                                 
    DWORD                                           dwReserved;                                                                 
    LONGLONG                                        llTimestamp;                                                                
    DWORD                                           adwSamples[MWCAP_AUDIO_SAMPLES_PER_FRAME * MWCAP_AUDIO_MAX_NUM_CHANNELS];   
} MWCAP_AUDIO_CAPTURE_FRAME;
 
 
typedef enum _MWCAP_HDMI_INFOFRAME_ID {
    MWCAP_HDMI_INFOFRAME_ID_AVI,                                                                                            
    MWCAP_HDMI_INFOFRAME_ID_AUDIO,                                                                                          
    MWCAP_HDMI_INFOFRAME_ID_SPD,                                                                                            
    MWCAP_HDMI_INFOFRAME_ID_MS,                                                                                             
    MWCAP_HDMI_INFOFRAME_ID_VS,                                                                                             
    MWCAP_HDMI_INFOFRAME_ID_ACP,                                                                                            
    MWCAP_HDMI_INFOFRAME_ID_ISRC1,                                                                                          
    MWCAP_HDMI_INFOFRAME_ID_ISRC2,                                                                                          
    MWCAP_HDMI_INFOFRAME_ID_GAMUT,                                                                                          
    MWCAP_HDMI_INFOFRAME_ID_VBI,                                                                                            
    MWCAP_HDMI_INFOFRAME_ID_HDR,                                                                                            
    MWCAP_HDMI_INFOFRAME_COUNT,                                                                                             
} MWCAP_HDMI_INFOFRAME_ID;
 
typedef enum _MWCAP_HDMI_INFOFRAME_MASK {
    MWCAP_HDMI_INFOFRAME_MASK_AVI                   = (1 << MWCAP_HDMI_INFOFRAME_ID_AVI),                                   
    MWCAP_HDMI_INFOFRAME_MASK_AUDIO                 = (1 << MWCAP_HDMI_INFOFRAME_ID_AUDIO),                                 
    MWCAP_HDMI_INFOFRAME_MASK_SPD                   = (1 << MWCAP_HDMI_INFOFRAME_ID_SPD),                                   
    MWCAP_HDMI_INFOFRAME_MASK_MS                    = (1 << MWCAP_HDMI_INFOFRAME_ID_MS),                                    
    MWCAP_HDMI_INFOFRAME_MASK_VS                    = (1 << MWCAP_HDMI_INFOFRAME_ID_VS),                                    
    MWCAP_HDMI_INFOFRAME_MASK_ACP                   = (1 << MWCAP_HDMI_INFOFRAME_ID_ACP),                                   
    MWCAP_HDMI_INFOFRAME_MASK_ISRC1                 = (1 << MWCAP_HDMI_INFOFRAME_ID_ISRC1),                                 
    MWCAP_HDMI_INFOFRAME_MASK_ISRC2                 = (1 << MWCAP_HDMI_INFOFRAME_ID_ISRC2),                                 
    MWCAP_HDMI_INFOFRAME_MASK_GAMUT                 = (1 << MWCAP_HDMI_INFOFRAME_ID_GAMUT),                                 
    MWCAP_HDMI_INFOFRAME_MASK_VBI                   = (1 << MWCAP_HDMI_INFOFRAME_ID_VBI),                                   
    MWCAP_HDMI_INFOFRAME_MASK_HDR                   = (1 << MWCAP_HDMI_INFOFRAME_ID_HDR)                                    
} MWCAP_HDMI_INFOFRAME_MASK;
 
typedef struct _MWCAP_VIDEO_ASPECT_RATIO {
    int                                         nAspectX;
    int                                         nAspectY;
} MWCAP_VIDEO_ASPECT_RATIO;
 
typedef struct _MWCAP_VIDEO_CONNECTION_FORMAT {
    // Valid flag
    BOOLEAN                                         bConnected;                                                             
    
    // Basic information
    LONG                                            cx;                                                                     
    LONG                                            cy;                                                                     
    DWORD                                           dwFrameDuration;                                                        
    DWORD                                           dwFOURCC;                                                               
 
    // Preferred parameters
    int                                             nAspectX;                                                               
    int                                             nAspectY;                                                               
    MWCAP_VIDEO_COLOR_FORMAT                        colorFormat;                                                            
    MWCAP_VIDEO_QUANTIZATION_RANGE                  quantRange;                                                             
    MWCAP_VIDEO_SATURATION_RANGE                    satRange;                                                               
} MWCAP_VIDEO_CONNECTION_FORMAT;
 
typedef struct _MWCAP_VIDEO_PROCESS_SETTINGS {
    DWORD                                           dwProcessSwitchs;                                                       
    RECT                                            rectSource;                                                             
    int                                             nAspectX;                                                               
    int                                             nAspectY;                                                               
    BOOLEAN                                         bLowLatency;                                                            
    MWCAP_VIDEO_COLOR_FORMAT                        colorFormat;                                                            
    MWCAP_VIDEO_QUANTIZATION_RANGE                  quantRange;                                                             
    MWCAP_VIDEO_SATURATION_RANGE                    satRange;                                                               
    MWCAP_VIDEO_DEINTERLACE_MODE                    deinterlaceMode;                                                        
    MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE           aspectRatioConvertMode;                                                 
} MWCAP_VIDEO_PROCESS_SETTINGS;
 
#define MWCAP_VIDEO_MAX_NUM_PREFERRED_TIMINGS   8
 
typedef struct _MWCAP_VIDEO_CREATE_IMAGE {
    WORD                                        cx; // set
    WORD                                        cy; // set
    MWCAP_PTR                                   pvImage; // get
} MWCAP_VIDEO_CREATE_IMAGE;
 
typedef struct _MWCAP_VIDEO_IMAGE_REF {
    MWCAP_PTR                                   pvImage; // set
    int                                         nRefCount; // get
} MWCAP_VIDEO_IMAGE_REF;
 
 
typedef enum _MWCAP_VIDEO_RESOLUTION_MODE{
    MWCAP_VIDEO_RESOLUTION_MODE_RANGE,
    MWCAP_VIDEO_RESOLUTION_MODE_LIST
} MWCAP_VIDEO_RESOLUTION_MODE;
 
typedef struct _MWCAP_VIDEO_RESOLUTION{
    int         cx;
    int         cy;
}MWCAP_VIDEO_RESOLUTION;
 
typedef struct _MWCAP_VIDEO_RESOLUTION_RANGE{
    int                     nStepCx;
    int                     nStepCy;
    MWCAP_VIDEO_RESOLUTION  minResolution;
    MWCAP_VIDEO_RESOLUTION  maxResolution;
}MWCAP_VIDEO_RESOLUTION_RANGE;
 
typedef struct _MWCAP_VIDEO_RESOLUTION_LIST{
    int                     nListSize;
    MWCAP_VIDEO_RESOLUTION* plistResolution;
}MWCAP_VIDEO_RESOLUTION_LIST;
 
 
typedef enum _MWCAP_VIDEO_PROC_PARAM_TYPE{
    MWCAP_VIDEO_PROC_BRIGHTNESS,
    MWCAP_VIDEO_PROC_CONTRAST,
    MWCAP_VIDEO_PROC_HUE,
    MWCAP_VIDEO_PROC_SATURATION
}MWCAP_VIDEO_PROC_PARAM_TYPE;
 
 
 
typedef struct _MWCAP_VIDEO_UPLOAD_IMAGE {
    // Destination parameters
    MWCAP_PTR                                   pvDestImage;
    MWCAP_VIDEO_COLOR_FORMAT                    cfDest;
    WORD                                        xDest;
    WORD                                        yDest;
    WORD                                        cxDest;
    WORD                                        cyDest;
 
    MWCAP_VIDEO_QUANTIZATION_RANGE              quantRangeDest;
    MWCAP_VIDEO_SATURATION_RANGE                satRangeDest;
 
    // Source parameters
    BOOLEAN                                     bSrcPhysicalAddress;
    union {
        MWCAP_PTR                               pvSrcFrame;
        LARGE_INTEGER                           liSrcPhysicalAddress;
    };
 
    DWORD                                       cbSrcFrame;
    DWORD                                       cbSrcStride;
 
    WORD                                        cxSrc;
    WORD                                        cySrc;
    BOOLEAN                                     bSrcBottomUp;
    BOOLEAN                                     bSrcPixelAlpha;
    BOOLEAN                                     bSrcPixelXBGR;
} MWCAP_VIDEO_UPLOAD_IMAGE;
 
 
typedef struct _MWCAP_VIDEO_OSD_SETTINGS {
    BOOLEAN                                     bEnable;
    char                                        szPNGFilePath[_MAX_PATH];
} MWCAP_VIDEO_OSD_SETTINGS;
 
typedef struct _MWCAP_VIDEO_OSD_IMAGE {
    MWCAP_PTR                                   pvOSDImage;
    RECT                                        aOSDRects[MWCAP_VIDEO_MAX_NUM_OSD_RECTS];
    int                                         cOSDRects;
} MWCAP_VIDEO_OSD_IMAGE;
 
typedef struct _MWCAP_VIDEO_CUSTOM_TIMING {
    MWCAP_VIDEO_SYNC_INFO                       syncInfo;
    MWCAP_VIDEO_TIMING_SETTINGS                 videoTimingSettings;
} MWCAP_VIDEO_CUSTOM_TIMING;
 
typedef struct _MWCAP_VIDEO_PIN_BUFFER {
    MWCAP_PTR                                       pvBuffer;
    DWORD                                           cbBuffer;
    int                                             mem_type;   /* see mw-dma-mem.h */
    unsigned long long                              reserved;
} MWCAP_VIDEO_PIN_BUFFER;
 
typedef enum _MW_VIDEO_CAPTURE_MODE {
    MW_VIDEO_CAPTURE_NORMAL = 0x00,
    MW_VIDEO_CAPTURE_LOW_LATENCY,
} MW_VIDEO_CAPTURE_MODE;
 
typedef enum _MWCAP_AUDIO_CAPTURE_NODE {
    MWCAP_AUDIO_CAPTURE_NODE_DEFAULT,                                                                                   
    MWCAP_AUDIO_CAPTURE_NODE_EMBEDDED_CAPTURE,                                                                          
    MWCAP_AUDIO_CAPTURE_NODE_MICROPHONE,                                                                                
    MWCAP_AUDIO_CAPTURE_NODE_USB_CAPTURE,                                                                               
    MWCAP_AUDIO_CAPTURE_NODE_LINE_IN,                                                                                   
} MWCAP_AUDIO_CAPTURE_NODE;                     
 
typedef enum _MWCAP_AUDIO_NODE {
    MWCAP_AUDIO_MICROPHONE,                                                                                             
    MWCAP_AUDIO_HEADPHONE,                                                                                              
    MWCAP_AUDIO_LINE_IN,                                                                                                
    MWCAP_AUDIO_LINE_OUT,                                                                                               
    MWCAP_AUDIO_EMBEDDED_CAPTURE,                                                                                       
    MWCAP_AUDIO_EMBEDDED_PLAYBACK,                                                                                      
    MWCAP_AUDIO_USB_CAPTURE,                                                                                            
    MWCAP_AUDIO_USB_PLAYBACK                                                                                            
} MWCAP_AUDIO_NODE;
 
typedef void(*LPFN_VIDEO_CAPTURE_CALLBACK)(MWCAP_PTR pbFrame, DWORD cbFrame, DWORD cbStride, MWCAP_VIDEO_FRAME_INFO* pFrameInfo, void* pvContent);
typedef void(*LPFN_AUDIO_CAPTURE_CALLBACK)(MWCAP_AUDIO_CAPTURE_FRAME* pAudioCaptureFrame, void* pvContent);
typedef void(*LPFN_TIMER_CALLBACK)(HTIMER pTimer, void* pvContent);
typedef void(*LPFN_NOTIFY_CALLBACK)(MWCAP_PTR pNotify, DWORD dwEnableBits, void* pvContent);
 
typedef void (*VIDEO_CAPTURE_CALLBACK)(BYTE *pBuffer, long iBufferLen, long stride, void* pParam);
typedef void (*AUDIO_CAPTURE_CALLBACK)(const BYTE * pbFrame, int cbFrame, uint64_t u64TimeStamp, void* pParam);
 
typedef struct _MWCAP_SDI_ANC_TYPE {
    BYTE                                            byId;                                                               
    BOOLEAN                                         bHANC;                                                              
    BOOLEAN                                         bVANC;                                                              
    BYTE                                            byDID;                                                              
    BYTE                                            bySDID;                                                             
} MWCAP_SDI_ANC_TYPE;
 
typedef struct _MWCAP_SDI_ANC_PACKET {
    BYTE                                            byDID;                                                              
    BYTE                                            bySDID;                                                             
    BYTE                                            byDC;                                                               
    BYTE                                            abyUDW[255];                                                        
    BYTE                                            abyReserved[2];                                                     
} MWCAP_SDI_ANC_PACKET;
 
typedef struct _MWCAP_VIDEO_ECO_CAPTURE_OPEN {
    MWCAP_PTR64                                     hEvent;                                                             
 
    DWORD                                           dwFOURCC;                                                           
    WORD                                            cx;                                                                 
    WORD                                            cy;                                                                 
    LONGLONG                                        llFrameDuration;                                                    
} MWCAP_VIDEO_ECO_CAPTURE_OPEN;
 
typedef struct _MWCAP_VIDEO_ECO_CAPTURE_SETTINGS {
    MWCAP_VIDEO_COLOR_FORMAT                        colorFormat;                                                        
    MWCAP_VIDEO_QUANTIZATION_RANGE                  quantRange;                                                         
    MWCAP_VIDEO_SATURATION_RANGE                    satRange;                                                           
    SHORT                                           sContrast;                                                          
    SHORT                                           sBrightness;                                                        
    SHORT                                           sSaturation;                                                        
    SHORT                                           sHue;                                                               
} MWCAP_VIDEO_ECO_CAPTURE_SETTINGS;
 
typedef struct _MWCAP_VIDEO_ECO_CAPTURE_FRAME {
    MWCAP_PTR64                                     pvFrame;                                                            
    DWORD                                           cbFrame;                                                            
    DWORD                                           cbStride;                                                           
 
    BOOLEAN                                         bBottomUp;                                                          
    MWCAP_VIDEO_DEINTERLACE_MODE                    deinterlaceMode;                                                    
 
    MWCAP_PTR64                                     pvContext;                                                          
} MWCAP_VIDEO_ECO_CAPTURE_FRAME;
 
typedef struct _MWCAP_VIDEO_ECO_CAPTURE_STATUS {
    MWCAP_PTR64                                     pvContext;                                                          
    MWCAP_PTR64                                     pvFrame;                                                            
    LONGLONG                                        llTimestamp;                                                        
} MWCAP_VIDEO_ECO_CAPTURE_STATUS;
 
#pragma pack(pop)