MWCapture SDK Mac 3.4.62314

- Home
- Development Library
- Release Notes

MWProCapture.h
1#ifndef MWPROCAPTURE_H
2#define MWPROCAPTURE_H
3
4#if defined(_WIN32)
5 #pragma message("platform:windows")
6 #ifdef LIBMWCAPTURE_EXPORTS
7 #define LIBMWCAPTURE_API __declspec(dllexport)
8 #elif LIBMWCAPTURE_DLL
9 #define LIBMWCAPTURE_API __declspec(dllimport)
10 #else
11 #define LIBMWCAPTURE_API
12 #endif
13#elif defined(__linux__)
14#define LIBMWCAPTURE_API
15#pragma message("platform:linux")
16#elif defined(__APPLE__)
17#define LIBMWCAPTURE_API
18#pragma message("platform:apple")
19#else
20#error "Error:Not support system!"
21#endif
22
23#include "MWCaptureExtension.h"
24
25#ifdef __cplusplus
26 extern "C" {
27#endif
28
48// Channel
49HCHANNEL
50LIBMWCAPTURE_API
51 MWOpenChannel(
52 int nBoardValue,
53 int nChannelIndex
54);
55
56// Device Clock
94 MW_RESULT
95LIBMWCAPTURE_API
96 MWGetDeviceTime(
97 HCHANNEL hChannel,
98 LONGLONG* pllTime
99 );
100
137MW_RESULT
138LIBMWCAPTURE_API
139 MWSetDeviceTime(
140 HCHANNEL hChannel,
141 LONGLONG llTime
142 );
143
183MW_RESULT
184LIBMWCAPTURE_API
185 MWRegulateDeviceTime(
186 HCHANNEL hChannel,
187 LONGLONG llTime
188 );
189
190// Timer Event
229 HTIMER
230LIBMWCAPTURE_API
231 MWRegisterTimer(
232 HCHANNEL hChannel,
233 MWHANDLE hEvent
234 );
235
261MW_RESULT
262LIBMWCAPTURE_API
263 MWUnregisterTimer(
264 HCHANNEL hChannel,
265 HTIMER hTimer
266 );
267
295MW_RESULT
296LIBMWCAPTURE_API
297 MWScheduleTimer(
298 HCHANNEL hChannel,
299 HTIMER hTimer,
300 LONGLONG llExpireTime
301 );
302
345HNOTIFY
346LIBMWCAPTURE_API
347 MWRegisterNotify(
348 HCHANNEL hChannel,
349 MWHANDLE hEvent,
350 DWORD dwEnableBits
351 );
352
378MW_RESULT
379 LIBMWCAPTURE_API
380 MWUnregisterNotify(
381 HCHANNEL hChannel,
382 HNOTIFY hNotify
383 );
384
411MW_RESULT
412LIBMWCAPTURE_API
413 MWGetNotifyStatus(
414 HCHANNEL hChannel,
415 HNOTIFY hNotify,
416 ULONGLONG* pullStatus
417 );
418
445MW_RESULT
446LIBMWCAPTURE_API
447 MWStartVideoCapture(
448 HCHANNEL hChannel,
449 MWHANDLE hEvent
450 );
451
476MW_RESULT
477LIBMWCAPTURE_API
478 MWStopVideoCapture(
479 HCHANNEL hChannel
480 );
481
483// * @ingroup group_functions_procapture
484//@brief Pins a video buffer according to channel handle
485//@param[in] hChannel Channel handle
486//@param[in] pbFrame Virtual memory address
487//@param[in] cbFrame Virtual memory size
488//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
489//*/
490//MW_RESULT
491//LIBMWCAPTURE_API
492//MWPinVideoBuffer(
493// HCHANNEL hChannel,
494// MWCAP_PTR pbFrame,
495// DWORD cbFrame
496// );
497//
499// * @ingroup group_functions_procapture
500//@brief Unlocks part of video buffer according to channel handle
501//@param[in] hChannel Channel handle
502//@param[in] pbFrame Virtual memory address
503//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
504//*/
505//MW_RESULT
506//LIBMWCAPTURE_API
507//MWUnpinVideoBuffer(
508// HCHANNEL hChannel,
509// LPBYTE pbFrame
510// );
511
545MW_RESULT
546LIBMWCAPTURE_API
547 MWCaptureVideoFrameToVirtualAddress(
548 HCHANNEL hChannel,
549 int iFrame,
550 MWCAP_PTR pbFrame,
551 DWORD cbFrame,
552 DWORD cbStride,
553 BOOLEAN bBottomUp,
554 MWCAP_PTR64 pvContext,
555 DWORD dwFOURCC,
556 int cx,
557 int cy
558 );
559
561// * @ingroup group_functions_procapture
562// * @brief Stores captured video frames to physical addresses
563// * @param[in] hChannel Video channel handle that has started video capturing
564// * @param[in] iFrame Video frame number to be captured
565// * @param[in] llFrameAddress Physical addresses that store the captured video frames
566// * @param[in] cbFrame Byte length of memory that stores the captured data
567// * @param[in] cbStride Step of memory that stores the captured data
568// * @param[in] bBottomUp Whether to store the captured video frames from bottom to top
569// * @param[in] pvContext Custom context pointers
570// * @param[in] dwFOURCC Color format of captured video frames, see MWFOURCC.h.
571// * @param[in] cx Width of captured video frames
572// * @param[in] cy Height of captured video frames
573// * @return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
574//*/
575//MW_RESULT
576//LIBMWCAPTURE_API
577//MWCaptureVideoFrameToPhysicalAddress(
578// HCHANNEL hChannel,
579// int iFrame,
580// LARGE_INTEGER llFrameAddress,
581// DWORD cbFrame,
582// DWORD cbStride,
583// BOOLEAN bBottomUp,
584// MWCAP_PTR64 pvContext,
585// DWORD dwFOURCC,
586// int cx,
587// int cy
588// );
589
591// * @ingroup group_functions_procapture
592// * @brief Captures video frames to virtual memory, and adds OSD.
593// * @param[in] hChannel Video channel handle that has started video capturing
594// * @param[in] iFrame Video frame number to be captured
595// * @param[out] pbFrame Physical addresses that store the captured video frames
596// * @param[in] cbFrame Byte length of memory that stores the captured data
597// * @param[in] cbStride Step of memory that stores the captured data
598// * @param[in] bBottomUp Whether to store the captured video frames from bottom to top
599// * @param[in] pvContext Custom context pointers
600// * @param[in] dwFOURCC Color format of captured video frames, see MWFOURCC.h.
601// * @param[in] cx Width of captured video frames
602// * @param[in] cy Height of captured video frames
603// * @param[in] hOSDImage Handle of OSD image which is geted using [MWCreateImage](@ref MWCreateImage)
604// * @param[in] pOSDRects Target area of OSD image
605// * @param[in] cOSDRects Number of OSD image target areas
606// * @return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
607//*/
608//MW_RESULT
609//LIBMWCAPTURE_API
610//MWCaptureVideoFrameWithOSDToVirtualAddress(
611// HCHANNEL hChannel,
612// int iFrame,
613// MWCAP_PTR pbFrame,
614// DWORD cbFrame,
615// DWORD cbStride,
616// BOOLEAN bBottomUp,
617// MWCAP_PTR64 pvContext,
618// DWORD dwFOURCC,
619// int cx,
620// int cy,
621// HOSD hOSDImage,
622// const RECT * pOSDRects,
623// int cOSDRects
624// );
625
627// * @ingroup group_functions_procapture
628// * @brief Saves the captured video frame to physical memory and add OSD
629// * @param[in] hChannel Video channel handle that has started video capturing
630// * @param[in] iFrame Video frame number to be captured
631// * @param[in] llFrameAddress Physical addresses that store the captured video frames
632// * @param[in] cbFrame Byte length of memory that stores the captured data
633// * @param[in] cbStride Step of memory that stores the captured data
634// * @param[in] bBottomUp Whether to store the captured video frames from bottom to top
635// * @param[in] pvContext Custom context pointers
636// * @param[in] dwFOURCC Color format of captured video frames, see MWFOURCC.h.
637// * @param[in] cx width of captured video frames
638// * @param[in] cy Height of captured video frames
639// * @param[in] hOSDImage handle of OSD image which is geted using [MWCreateImage](@ref MWCreateImage).
640// * @param[in] pOSDRects Target area of OSD image
641// * @param[in] cOSDRects Number of OSD image target areas
642// * @return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
643//*/
644//MW_RESULT
645//LIBMWCAPTURE_API
646//MWCaptureVideoFrameWithOSDToPhysicalAddress(
647// HCHANNEL hChannel,
648// int iFrame,
649// LARGE_INTEGER llFrameAddress,
650// DWORD cbFrame,
651// DWORD cbStride,
652// BOOLEAN bBottomUp,
653// MWCAP_PTR64 pvContext,
654// DWORD dwFOURCC,
655// int cx,
656// int cy,
657// HOSD hOSDImage,
658// const RECT * pOSDRects,
659// int cOSDRects
660// );
661
748MW_RESULT
749LIBMWCAPTURE_API
750 MWCaptureVideoFrameToVirtualAddressEx(
751 HCHANNEL hChannel,
752 int iFrame,
753 LPBYTE pbFrame,
754 DWORD cbFrame,
755 DWORD cbStride,
756 BOOLEAN bBottomUp,
757 MWCAP_PTR64 pvContext,
758 DWORD dwFOURCC,
759 int cx,
760 int cy,
761 DWORD dwProcessSwitchs,
762 int cyParitalNotify,
763 HOSD hOSDImage,
764 const RECT * pOSDRects,
765 int cOSDRects,
766 SHORT sContrast,
767 SHORT sBrightness,
768 SHORT sSaturation,
769 SHORT sHue,
770 MWCAP_VIDEO_DEINTERLACE_MODE deinterlaceMode,
771 MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE aspectRatioConvertMode,
772 const RECT * pRectSrc,
773 const RECT * pRectDest,
774 int nAspectX,
775 int nAspectY,
776 MWCAP_VIDEO_COLOR_FORMAT colorFormat,
777 MWCAP_VIDEO_QUANTIZATION_RANGE quantRange,
778 MWCAP_VIDEO_SATURATION_RANGE satRange
779 );
780
782// * @ingroup group_functions_procapture
783// * @brief Captures video frames and saves to physical memory. And is the extended version of [MWCaptureVideoFrameToPhysicalAddress](@ref MWCaptureVideoFrameToPhysicalAddress).
784// * @param[in] hChannel Video channel handle that has started video capturing
785// * @param[in] iFrame Video frame number to be captured
786// * @param[in] llFrameAddress Physical addresses that store the captured video frames
787// * @param[in] cbFrame Byte length of memory that stores the captured data
788// * @param[in] cbStride Step of memory that stores the captured data
789// * @param[in] bBottomUp Whether to store the captured video frames from bottom to top
790// * @param[in] pvContext Custom context pointers
791// * @param[in] dwFOURCC Color format of captured video frames, see MWFOURCC.h.
792// * @param[in] cx width of captured video frames
793// * @param[in] cy Height of captured video frames
794// * @param[in] dwProcessSwitchs Mask of video processing refers to MWCAP_VIDEO_PROCESS_xx
795// * @param[in] cyParitalNotify The number of lines when capturing by lines
796// * @param[in] hOSDImage OSD image handle which is geted using MWCreateImage(HCHANNEL hChannel,int cx,int cy)
797// * @param[in] pOSDRects Target area of OSD image
798// * @param[in] cOSDRects Number of OSD image target areas
799// * @param[in] sContrast Contrast
800// * @param[in] sBrightness Brightness
801// * @param[in] sSaturation Saturation
802// * @param[in] sHue Hue
803// * @param[in] deinterlaceMode Deinterlace Mode
804// * @param[in] aspectRatioConvertMode Aspect Ratio Convert Mode
805// * @param[in] pRectSrc The source area of the image to capture
806// * @param[in] pRectDest The destination area of the image to capture
807// * @param[in] nAspectX Width of the aspect ratio
808// * @param[in] nAspectY Height of the aspect ratio
809// * @param[in] colorFormat Color Format
810// * @param[in] quantRange Quantization Range
811// * @param[in] satRange Saturation Range
812// * @return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
813//*/
814//MW_RESULT
815//LIBMWCAPTURE_API
816//MWCaptureVideoFrameToPhysicalAddressEx(
817// HCHANNEL hChannel,
818// int iFrame,
819// LARGE_INTEGER llFrameAddress,
820// DWORD cbFrame,
821// DWORD cbStride,
822// BOOLEAN bBottomUp,
823// MWCAP_PTR64 pvContext,
824// DWORD dwFOURCC,
825// int cx,
826// int cy,
827// DWORD dwProcessSwitchs,
828// int cyParitalNotify,
829// HOSD hOSDImage,
830// const RECT * pOSDRects,
831// int cOSDRects,
832// SHORT sContrast,
833// SHORT sBrightness,
834// SHORT sSaturation,
835// SHORT sHue,
836// MWCAP_VIDEO_DEINTERLACE_MODE deinterlaceMode,
837// MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE aspectRatioConvertMode,
838// const RECT * pRectSrc,
839// const RECT * pRectDest,
840// int nAspectX,
841// int nAspectY,
842// MWCAP_VIDEO_COLOR_FORMAT colorFormat,
843// MWCAP_VIDEO_QUANTIZATION_RANGE quantRange,
844// MWCAP_VIDEO_SATURATION_RANGE satRange
845// );
846
873MW_RESULT
874LIBMWCAPTURE_API
875 MWGetVideoBufferInfo(
876 HCHANNEL hChannel,
877 MWCAP_VIDEO_BUFFER_INFO * pVideoBufferInfo
878 );
879
907MW_RESULT
908LIBMWCAPTURE_API
909 MWGetVideoFrameInfo(
910 HCHANNEL hChannel,
911 BYTE i,
912 MWCAP_VIDEO_FRAME_INFO* pVideoFrameInfo
913 );
914
941MW_RESULT
942LIBMWCAPTURE_API
943 MWGetVideoCaptureStatus(
944 HCHANNEL hChannel,
945 MWCAP_VIDEO_CAPTURE_STATUS * pStatus
946 );
947
995MW_RESULT
996LIBMWCAPTURE_API
997 MWStartAudioCapture(
998 HCHANNEL hChannel
999 );
1000
1025MW_RESULT
1026LIBMWCAPTURE_API
1027 MWStopAudioCapture(
1028 HCHANNEL hChannel
1029 );
1030
1057MW_RESULT
1058LIBMWCAPTURE_API
1059 MWCaptureAudioFrame(
1060 HCHANNEL hChannel,
1061 MWCAP_AUDIO_CAPTURE_FRAME* pAudioCaptureFrame
1062 );
1063
1071MW_RESULT
1072LIBMWCAPTURE_API
1073 MWSetPostReconfig(
1074 HCHANNEL hChannel,
1075 DWORD dwDelayMS
1076 );
1077
1079// * @ingroup group_functions_procapture
1080//@brief Creates OSD image according to channel handle
1081// * @param[in] hChannel Opened channel handle
1082// * @param[in] cx Width of image
1083// * @param[in] cy Height of image
1084//@return Returns handle of the OSD image if succeeded, otherwise returns NULL
1085//*/
1086//HOSD
1087//LIBMWCAPTURE_API
1088//MWCreateImage(
1089// HCHANNEL hChannel,
1090// int cx,
1091// int cy
1092// );
1093//
1095// * @ingroup group_functions_procapture
1096// * @brief Opens OSD images.
1097// * @param[in] hChannel Opened channel handle
1098// * @param[in] hImage Image handle
1099// * @param[out] plRet Returns counts of the image being called
1100//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1101//*/
1102//MW_RESULT
1103//LIBMWCAPTURE_API
1104//MWOpenImage(
1105// HCHANNEL hChannel,
1106// HOSD hImage,
1107// LONG* plRet
1108// );
1109//
1111// * @ingroup group_functions_procapture
1112//@brief Closes image according to channel handle
1113// * @param[in] hChannel Opened channel handle
1114// * @param[in] hImage Image handle
1115// * @param[out] plRet Returns counts of the image being called
1116//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1117//*/
1118//MW_RESULT
1119//LIBMWCAPTURE_API
1120//MWCloseImage(
1121// HCHANNEL hChannel,
1122// HOSD hImage,
1123// LONG* plRet
1124// );
1125//
1127// * @ingroup group_functions_procapture
1128// * @brief Uploads images from system memory to capture device.
1129// * @param[in] hChannel Opened channel handle
1130// * @param[in] hImage Image handle
1131// * @param[in] cfDest Color format of the target image
1132// * @param[in] quantRangeDest Quantization range of the target image
1133// * @param[in] satRangeDest Saturation range of the target image
1134// * @param[in] xDest Horizontal target position
1135// * @param[in] yDest Vertical target position
1136// * @param[in] cxDest Target width of image
1137// * @param[in] cyDest Target height of image
1138// * @param[in] pvSrcFrame Source image
1139// * @param[in] cbSrcFrame Data length of source image
1140// * @param[in] cbSrcStride Data step of source image
1141// * @param[in] cxSrc Width of source image
1142// * @param[in] cySrc Height of source image
1143// * @param[in] bSrcBottomUp Whether the source image is up-side-down
1144// * @param[in] bSrcPixelAlpha Whether there is an alpha component in the source image
1145// * @param[in] bSrcPixelXBGR Whether the color format of the source image is XBGR
1146//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1147//*/
1148//MW_RESULT
1149//LIBMWCAPTURE_API
1150//MWUploadImageFromVirtualAddress(
1151// HCHANNEL hChannel,
1152// HOSD hImage,
1153// MWCAP_VIDEO_COLOR_FORMAT cfDest,
1154// MWCAP_VIDEO_QUANTIZATION_RANGE quantRangeDest,
1155// MWCAP_VIDEO_SATURATION_RANGE satRangeDest,
1156// WORD xDest,
1157// WORD yDest,
1158// WORD cxDest,
1159// WORD cyDest,
1160// MWCAP_PTR64 pvSrcFrame,
1161// DWORD cbSrcFrame,
1162// DWORD cbSrcStride,
1163// WORD cxSrc,
1164// WORD cySrc,
1165// BOOLEAN bSrcBottomUp,
1166// BOOLEAN bSrcPixelAlpha,
1167// BOOLEAN bSrcPixelXBGR
1168// );
1169//
1171// * @ingroup group_functions_procapture
1172// * @brief Uploads an image from physical memory to capture device.
1173// * @param[in] hChannel Opened channel handle
1174// * @param[in] hImage Image handle
1175// * @param[in] cfDest Color format of the target image
1176// * @param[in] quantRangeDest Quantization range of the target image
1177// * @param[in] satRangeDest Saturation range of the target image
1178// * @param[in] xDest Horizontal target position
1179// * @param[in] yDest Vertical target position
1180// * @param[in] cxDest Target width of image
1181// * @param[in] cyDest Target height of image
1182// * @param[in] llSrcFrameAddress Physical address that stores the source image
1183// * @param[in] cbSrcFrame Data length of source image
1184// * @param[in] cbSrcStride Data step of source image
1185// * @param[in] cxSrc Width of source image
1186// * @param[in] cySrc Height of source image
1187// * @param[in] bSrcBottomUp Whether the source image is up-side-down
1188// * @param[in] bSrcPixelAlpha Whether there is an alpha component in the source image
1189// * @param[in] bSrcPixelXBGR Whether the color format of the source image is XBGR
1190// * @return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1191//*/
1192//MW_RESULT
1193//LIBMWCAPTURE_API
1194//MWUploadImageFromPhysicalAddress(
1195// HCHANNEL hChannel,
1196// HOSD hImage,
1197// MWCAP_VIDEO_COLOR_FORMAT cfDest,
1198// MWCAP_VIDEO_QUANTIZATION_RANGE quantRangeDest,
1199// MWCAP_VIDEO_SATURATION_RANGE satRangeDest,
1200// WORD xDest,
1201// WORD yDest,
1202// WORD cxDest,
1203// WORD cyDest,
1204// LARGE_INTEGER llSrcFrameAddress,
1205// DWORD cbSrcFrame,
1206// DWORD cbSrcStride,
1207// WORD cxSrc,
1208// WORD cySrc,
1209// BOOLEAN bSrcBottomUp,
1210// BOOLEAN bSrcPixelAlpha,
1211// BOOLEAN bSrcPixelXBGR
1212// );
1213
1221MW_RESULT
1222LIBMWCAPTURE_API
1223 MWGetTemperature(
1224 HCHANNEL hChannel,
1225 unsigned int* pnTemp
1226 );
1227
1229// * @ingroup group_functions_procapture
1230//@brief Gets OSD settings according to channel handle
1231//@param[in] hChannel Channel handle
1232//@param[out] pOSDSettings OSD settings of video capture
1233//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1234//*/
1235//MW_RESULT
1236//LIBMWCAPTURE_API
1237//MWGetVideoOSDSettings(
1238// HCHANNEL hChannel,
1239// MWCAP_VIDEO_OSD_SETTINGS * pOSDSettings
1240// );
1241//
1243// * @ingroup group_functions_procapture
1244//@brief Sets OSD settings according to channel handle
1245//@param[in] hChannel Channel handle
1246//@param[in] OSDSettings OSD settings of video capture
1247//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1248//*/
1249//MW_RESULT
1250//LIBMWCAPTURE_API
1251//MWSetVideoOSDSettings(
1252// HCHANNEL hChannel,
1253// MWCAP_VIDEO_OSD_SETTINGS OSDSettings
1254// );
1255//
1257// * @ingroup group_functions_procapture
1258//@brief Gets OSD according to channel handle
1259//@param[in] hChannel Channel handle
1260//@param[out] pOSDImage OSD image
1261//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1262//*/
1263//MW_RESULT
1264//LIBMWCAPTURE_API
1265//MWGetVideoOSDImage(
1266// HCHANNEL hChannel,
1267// MWCAP_VIDEO_OSD_IMAGE * pOSDImage
1268// );
1269//
1271// * @ingroup group_functions_procapture
1272//@brief Sets OSD according to channel handle
1273//@param[in] hChannel Channel handle
1274//@param[in] OSDImage OSD image
1275//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1276//*/
1277//MW_RESULT
1278//LIBMWCAPTURE_API
1279//MWSetVideoOSDImage(
1280// HCHANNEL hChannel,
1281// MWCAP_VIDEO_OSD_IMAGE OSDImage
1282// );
1283
1285// * @ingroup group_functions_procapture
1286//@brief Gets the brightness of video captured according to channel handle
1287//@param[in] hChannel Channel handle
1288//@param[out] pnBrightness Brightness of video capture
1289//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1290//*/
1291//MW_RESULT
1292//LIBMWCAPTURE_API
1293//MWGetVideoBrightness(
1294// HCHANNEL hChannel,
1295// int *pnBrightness
1296// );
1297//
1299// * @ingroup group_functions_procapture
1300//@brief Sets the brightness of video captured according to channel handle
1301//@param[in] hChannel Channel handle
1302//@param[in] nBrightness Brightness of video captured
1303//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1304//*/
1305//MW_RESULT
1306//LIBMWCAPTURE_API
1307//MWSetVideoBrightness(
1308// HCHANNEL hChannel,
1309// int nBrightness
1310// );
1311
1313// * @ingroup group_functions_procapture
1314//@brief Gets the contrast of video captured according to channel handle
1315//@param[in] hChannel Channel handle
1316//@param[out] pnContrast Contrast of video captured
1317//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1318//*/
1319//MW_RESULT
1320//LIBMWCAPTURE_API
1321//MWGetVideoContrast(
1322// HCHANNEL hChannel,
1323// int * pnContrast
1324// );
1325//
1327// * @ingroup group_functions_procapture
1328//@brief Sets the contrast of video captured according to channel handle
1329//@param[in] hChannel Channel handle
1330//@param[in] nContrast Contrast of video captured
1331//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1332//*/
1333//MW_RESULT
1334//LIBMWCAPTURE_API
1335//MWSetVideoContrast(
1336// HCHANNEL hChannel,
1337// int nContrast
1338// );
1339
1395//
1397// * @ingroup group_functions_procapture
1398//@brief Saves the presetting configurations of video capture according to channel handle.
1399//@param[in] hChannel Channel handle
1400//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1401//*/
1402//MW_RESULT
1403//LIBMWCAPTURE_API
1404//MWSaveSettingsAsPreset(
1405// HCHANNEL hChannel
1406// );
1407//
1409// * @ingroup group_functions_procapture
1410//@brief Reloads the presetting configurations of video capture according to channel handle.
1411//@param[in] hChannel Channel handle
1412//@return Returns MW_SUCCEED if succeeded, otherwise returns MW_FAILED or MW_INVALID_PARAMS
1413//*/
1414//MW_RESULT
1415//LIBMWCAPTURE_API
1416//MWReloadPreset(
1417// HCHANNEL hChannel
1418// );
1419
1427MW_RESULT
1428LIBMWCAPTURE_API
1429 MWGetVideoAutoHAlign(
1430 HCHANNEL hChannel,
1431 BOOLEAN * pbAuto
1432 );
1433
1441MW_RESULT
1442LIBMWCAPTURE_API
1443 MWSetVideoAutoHAlign(
1444 HCHANNEL hChannel,
1445 BOOLEAN bAuto
1446 );
1447
1455MW_RESULT
1456LIBMWCAPTURE_API
1457 MWGetVideoSamplingPhase(
1458 HCHANNEL hChannel,
1459 BYTE * pbyValue
1460 );
1461
1469MW_RESULT
1470LIBMWCAPTURE_API
1471 MWSetVideoSamplingPhase(
1472 HCHANNEL hChannel,
1473 BYTE byValue
1474 );
1475
1483MW_RESULT
1484LIBMWCAPTURE_API
1485 MWGetVideoSamplingPhaseAutoAdjust(
1486 HCHANNEL hChannel,
1487 BOOLEAN * pbAuto
1488 );
1489
1497MW_RESULT
1498LIBMWCAPTURE_API
1499 MWSetVideoSamplingPhaseAutoAdjust(
1500 HCHANNEL hChannel,
1501 BOOLEAN bAuto
1502 );
1503
1511MW_RESULT
1512LIBMWCAPTURE_API
1513 MWSetVideoTiming(
1514 HCHANNEL hChannel,
1515 MWCAP_VIDEO_TIMING videoTiming
1516 );
1517
1526MW_RESULT
1527LIBMWCAPTURE_API
1528 MWGetVideoPreferredTimingArray(
1529 HCHANNEL hChannel,
1530 MWCAP_VIDEO_TIMING * pVideoTiming,
1531 long * plCount
1532 );
1533
1541MW_RESULT
1542LIBMWCAPTURE_API
1543 MWSetCustomVideoTiming(
1544 HCHANNEL hChannel,
1545 MWCAP_VIDEO_CUSTOM_TIMING videoTiming
1546 );
1547
1555MW_RESULT
1556LIBMWCAPTURE_API
1557 MWGetCustomVideoTimingsCount(
1558 HCHANNEL hChannel,
1559 DWORD* pdwCount
1560 );
1561
1570MW_RESULT
1571LIBMWCAPTURE_API
1572 MWGetCustomVideoTimingsArray(
1573 HCHANNEL hChannel,
1574 MWCAP_VIDEO_CUSTOM_TIMING * pVideoCustomTiming,
1575 DWORD * pdwCount
1576 );
1577
1586MW_RESULT
1587LIBMWCAPTURE_API
1588 MWSetCustomVideoTimingsArray(
1589 HCHANNEL hChannel,
1590 MWCAP_VIDEO_CUSTOM_TIMING * pVideoCustomTiming,
1591 DWORD dwCount
1592 );
1593
1601MW_RESULT
1602LIBMWCAPTURE_API
1603 MWGetCustomVideoResolutionsCount(
1604 HCHANNEL hChannel,
1605 DWORD * pdwCount
1606 );
1607
1616MW_RESULT
1617LIBMWCAPTURE_API
1618 MWGetCustomVideoResolutionsArray(
1619 HCHANNEL hChannel,
1620 MWCAP_SIZE * pResolutionSize,
1621 DWORD * pdwCount
1622 );
1623
1632MW_RESULT
1633LIBMWCAPTURE_API
1634 MWSetCustomVideoResolutionsArray(
1635 HCHANNEL hChannel,
1636 MWCAP_SIZE * pResolutionSize,
1637 DWORD dwCount
1638 );
1639
1645MWCAP_PTR
1646LIBMWCAPTURE_API
1647 MWCreateEvent(
1648 );
1649
1656MW_RESULT
1657LIBMWCAPTURE_API
1658 MWCloseEvent(
1659 MWCAP_PTR hEvent
1660 );
1661
1668MW_RESULT
1669LIBMWCAPTURE_API
1670 MWSetEvent(
1671 MWCAP_PTR hEvent
1672 );
1673
1680MW_RESULT
1681LIBMWCAPTURE_API
1682 MWClearEvent(
1683 MWCAP_PTR hEvent
1684 );
1685
1692BOOLEAN
1693LIBMWCAPTURE_API
1694 MWIsSetEvent(
1695 MWCAP_PTR hEvent
1696 );
1697
1704 int
1705LIBMWCAPTURE_API
1706 MWTryWaitEvent(
1707 MWCAP_PTR hEvent
1708 );
1709
1717 int
1718LIBMWCAPTURE_API
1719 MWWaitEvent(
1720 MWCAP_PTR hEvent,
1721 int nTimeout
1722 );
1723
1732DWORD
1733LIBMWCAPTURE_API
1734 MWMultiWaitEvent(
1735 MWCAP_PTR * hEvents,
1736 int nCount,
1737 int nTimeout
1738 );
1739
1740#ifdef __cplusplus
1741}
1742#endif
1743
1744#endif
MWTryWaitEvent
int LIBMWCAPTURE_API MWTryWaitEvent(MWCAP_PTR hEvent)
Waits for the event.
MWGetCustomVideoResolutionsArray
MW_RESULT LIBMWCAPTURE_API MWGetCustomVideoResolutionsArray(HCHANNEL hChannel, MWCAP_SIZE *pResolutionSize, DWORD *pdwCount)
Gets customized video resolution array according to channel handle.
MWGetCustomVideoTimingsCount
MW_RESULT LIBMWCAPTURE_API MWGetCustomVideoTimingsCount(HCHANNEL hChannel, DWORD *pdwCount)
Gets the number of customized video timing according to channel handle.
MWRegisterNotify
HNOTIFY LIBMWCAPTURE_API MWRegisterNotify(HCHANNEL hChannel, MWHANDLE hEvent, DWORD dwEnableBits)
Registers an event notification.
MWGetVideoBufferInfo
MW_RESULT LIBMWCAPTURE_API MWGetVideoBufferInfo(HCHANNEL hChannel, MWCAP_VIDEO_BUFFER_INFO *pVideoBufferInfo)
‍**
MWUnregisterTimer
MW_RESULT LIBMWCAPTURE_API MWUnregisterTimer(HCHANNEL hChannel, HTIMER hTimer)
Unregisters a time event object.
MWCaptureVideoFrameToVirtualAddressEx
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)
‍**
MWCreateEvent
MWCAP_PTR LIBMWCAPTURE_API MWCreateEvent()
Creates events.
MWCloseEvent
MW_RESULT LIBMWCAPTURE_API MWCloseEvent(MWCAP_PTR hEvent)
Destroys the event.
MWIsSetEvent
BOOLEAN LIBMWCAPTURE_API MWIsSetEvent(MWCAP_PTR hEvent)
Querys whether the event is triggered.
MWWaitEvent
int LIBMWCAPTURE_API MWWaitEvent(MWCAP_PTR hEvent, int nTimeout)
Waits for the event.
MWSetVideoAutoHAlign
MW_RESULT LIBMWCAPTURE_API MWSetVideoAutoHAlign(HCHANNEL hChannel, BOOLEAN bAuto)
Sets whether the horizontal direction of the video is automatically adjusted according to channel han...
MWGetVideoAutoHAlign
MW_RESULT LIBMWCAPTURE_API MWGetVideoAutoHAlign(HCHANNEL hChannel, BOOLEAN *pbAuto)
‍**
MWGetDeviceTime
MW_RESULT LIBMWCAPTURE_API MWGetDeviceTime(HCHANNEL hChannel, LONGLONG *pllTime)
Gets time of capture channel.
MWCaptureVideoFrameToVirtualAddress
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)
‍**
MWGetNotifyStatus
MW_RESULT LIBMWCAPTURE_API MWGetNotifyStatus(HCHANNEL hChannel, HNOTIFY hNotify, ULONGLONG *pullStatus)
Gets current notification type.
MWGetVideoPreferredTimingArray
MW_RESULT LIBMWCAPTURE_API MWGetVideoPreferredTimingArray(HCHANNEL hChannel, MWCAP_VIDEO_TIMING *pVideoTiming, long *plCount)
Gets the preset video timing array according to channel handle.
MWGetVideoCaptureStatus
MW_RESULT LIBMWCAPTURE_API MWGetVideoCaptureStatus(HCHANNEL hChannel, MWCAP_VIDEO_CAPTURE_STATUS *pStatus)
Gets video capture state, and frees up system storage.
MWSetCustomVideoTiming
MW_RESULT LIBMWCAPTURE_API MWSetCustomVideoTiming(HCHANNEL hChannel, MWCAP_VIDEO_CUSTOM_TIMING videoTiming)
Sets the customized video timing according to channel handle.
MWSetCustomVideoResolutionsArray
MW_RESULT LIBMWCAPTURE_API MWSetCustomVideoResolutionsArray(HCHANNEL hChannel, MWCAP_SIZE *pResolutionSize, DWORD dwCount)
Sets customized video resolution array according to channel handle.
MWSetCustomVideoTimingsArray
MW_RESULT LIBMWCAPTURE_API MWSetCustomVideoTimingsArray(HCHANNEL hChannel, MWCAP_VIDEO_CUSTOM_TIMING *pVideoCustomTiming, DWORD dwCount)
Sets customized video timing array according to channel handle.
MWClearEvent
MW_RESULT LIBMWCAPTURE_API MWClearEvent(MWCAP_PTR hEvent)
Resets the event.
MWSetPostReconfig
MW_RESULT LIBMWCAPTURE_API MWSetPostReconfig(HCHANNEL hChannel, DWORD dwDelayMS)
Sends instructions for rereading configurations to delay the execution.
MWStartVideoCapture
MW_RESULT LIBMWCAPTURE_API MWStartVideoCapture(HCHANNEL hChannel, MWHANDLE hEvent)
Starts video capture.
MWGetCustomVideoTimingsArray
MW_RESULT LIBMWCAPTURE_API MWGetCustomVideoTimingsArray(HCHANNEL hChannel, MWCAP_VIDEO_CUSTOM_TIMING *pVideoCustomTiming, DWORD *pdwCount)
Gets customized video timing array according to channel handle.
MWGetVideoFrameInfo
MW_RESULT LIBMWCAPTURE_API MWGetVideoFrameInfo(HCHANNEL hChannel, BYTE i, MWCAP_VIDEO_FRAME_INFO *pVideoFrameInfo)
Gets video frame information.
MWStopVideoCapture
MW_RESULT LIBMWCAPTURE_API MWStopVideoCapture(HCHANNEL hChannel)
Stops the video capture.
MWStopAudioCapture
MW_RESULT LIBMWCAPTURE_API MWStopAudioCapture(HCHANNEL hChannel)
Stops audio capturing of specified channel.
MWSetVideoSamplingPhaseAutoAdjust
MW_RESULT LIBMWCAPTURE_API MWSetVideoSamplingPhaseAutoAdjust(HCHANNEL hChannel, BOOLEAN bAuto)
Sets whether the video sampling phase is automatically adjusted according to channel handle.
MWStartAudioCapture
MW_RESULT LIBMWCAPTURE_API MWStartAudioCapture(HCHANNEL hChannel)
Starts audio capturing of specified channel.
MWRegulateDeviceTime
MW_RESULT LIBMWCAPTURE_API MWRegulateDeviceTime(HCHANNEL hChannel, LONGLONG llTime)
Adjusts time of capture channel.
MWCaptureAudioFrame
MW_RESULT LIBMWCAPTURE_API MWCaptureAudioFrame(HCHANNEL hChannel, MWCAP_AUDIO_CAPTURE_FRAME *pAudioCaptureFrame)
Captures an audio frame.
MWGetVideoSamplingPhase
MW_RESULT LIBMWCAPTURE_API MWGetVideoSamplingPhase(HCHANNEL hChannel, BYTE *pbyValue)
Gets the sampling phase according to channel handle.
MWSetVideoSamplingPhase
MW_RESULT LIBMWCAPTURE_API MWSetVideoSamplingPhase(HCHANNEL hChannel, BYTE byValue)
Sets the sampling phase according to channel handle.
MWSetVideoTiming
MW_RESULT LIBMWCAPTURE_API MWSetVideoTiming(HCHANNEL hChannel, MWCAP_VIDEO_TIMING videoTiming)
Sets the video timing according to channel handle.
MWGetCustomVideoResolutionsCount
MW_RESULT LIBMWCAPTURE_API MWGetCustomVideoResolutionsCount(HCHANNEL hChannel, DWORD *pdwCount)
Gets the number of customized video resolution according to channel handle.
MWGetTemperature
MW_RESULT LIBMWCAPTURE_API MWGetTemperature(HCHANNEL hChannel, unsigned int *pnTemp)
‍**
MWScheduleTimer
MW_RESULT LIBMWCAPTURE_API MWScheduleTimer(HCHANNEL hChannel, HTIMER hTimer, LONGLONG llExpireTime)
Schedules time event objects.
MWSetDeviceTime
MW_RESULT LIBMWCAPTURE_API MWSetDeviceTime(HCHANNEL hChannel, LONGLONG llTime)
Sets time of capture channel.
MWUnregisterNotify
MW_RESULT LIBMWCAPTURE_API MWUnregisterNotify(HCHANNEL hChannel, HNOTIFY hNotify)
Unregisters an event notification object.
MWGetVideoSamplingPhaseAutoAdjust
MW_RESULT LIBMWCAPTURE_API MWGetVideoSamplingPhaseAutoAdjust(HCHANNEL hChannel, BOOLEAN *pbAuto)
Gets whether the video sampling phase is automatically adjusted according to channel handle.
MWSetEvent
MW_RESULT LIBMWCAPTURE_API MWSetEvent(MWCAP_PTR hEvent)
Triggers the event.
MWMultiWaitEvent
DWORD LIBMWCAPTURE_API MWMultiWaitEvent(MWCAP_PTR *hEvents, int nCount, int nTimeout)
Waits for the events.
MWRegisterTimer
HTIMER LIBMWCAPTURE_API MWRegisterTimer(HCHANNEL hChannel, MWHANDLE hEvent)
Registers a time event object.
MWOpenChannel
HCHANNEL LIBMWCAPTURE_API MWOpenChannel(int nBoardValue, int nChannelIndex)
Opens capture channel by the rotary number and channel number.
MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE
enum _MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE
MWCAP_VIDEO_ASPECT_RATIO_CONVERT_MODE.
MWCAP_VIDEO_DEINTERLACE_MODE
enum _MWCAP_VIDEO_DEINTERLACE_MODE MWCAP_VIDEO_DEINTERLACE_MODE
MWCAP_VIDEO_DEINTERLACE_MODE.
MWCAP_VIDEO_QUANTIZATION_RANGE
enum _MWCAP_VIDEO_QUANTIZATION_RANGE MWCAP_VIDEO_QUANTIZATION_RANGE
MWCAP_VIDEO_QUANTIZATION_RANGE.
MWCAP_VIDEO_COLOR_FORMAT
enum _MWCAP_VIDEO_COLOR_FORMAT MWCAP_VIDEO_COLOR_FORMAT
MWCAP_VIDEO_COLOR_FORMAT.
MWCAP_VIDEO_SATURATION_RANGE
enum _MWCAP_VIDEO_SATURATION_RANGE MWCAP_VIDEO_SATURATION_RANGE
MWCAP_VIDEO_SATURATION_RANGE.
_MWCAP_AUDIO_CAPTURE_FRAME
MWCAP_AUDIO_CAPTURE_FRAME.
Definition: MWCaptureExtension.h:1343
_MWCAP_SIZE
Definition: MWCaptureExtension.h:367
_MWCAP_VIDEO_BUFFER_INFO
MWCAP_VIDEO_BUFFER_INFO.
Definition: MWCaptureExtension.h:1116
_MWCAP_VIDEO_CAPTURE_STATUS
MWCAP_VIDEO_CAPTURE_STATUS.
Definition: MWCaptureExtension.h:1301
_MWCAP_VIDEO_CUSTOM_TIMING
MWCAP_VIDEO_CUSTOM_TIMING.
Definition: MWCaptureExtension.h:1547
_MWCAP_VIDEO_FRAME_INFO
MWCAP_VIDEO_FRAME_INFO.
Definition: MWCaptureExtension.h:1136
_MWCAP_VIDEO_TIMING
MWCAP_VIDEO_TIMING.
Definition: MWCaptureExtension.h:330
_RECT
Definition: WinTypes.h:62