  • 法律声明
  • 首页
  • 更新记录
  • 编程引导
  • 接口函数
  • 结构体定义
  • 示例程序
  • 错误码定义
法律声明

在法律允许的最大范围内，本文档是“按照现状”提供，可能存在瑕疵或错误。本公司不对本文档提供任何形式的明示或默示保证，包括但不限于适销性、质量满意度、适合特定目的、不侵犯第三方权利等保证；亦不对使用或是分发本文档导致的任何特殊、附带、偶然或间接的损害进行赔偿，包括但不限于商业利润损失、系统故障、数据或文档丢失产生的损失。


  • 接口函数
  • 结构体定义
  • 示例程序
  • 错误码定义
工业采集卡SDK开发指南V2.1.0（C）

概述

工业采集卡SDK开发指南主要对API的使用进行说明。API库为所有采集卡提供统一的访问控制接口，可简化接口调用，支持多种类型卡同时使用。
目前支持GigE Vision采集卡、CoaXPress采集卡和Camera Link采集卡，其接口主要分为采集卡接口、设备接口、流接口、缓存接口、图像处理和参数控制接口六个部分，为用户使用软件设计提供较高的自由度。

开始使用

SDK版本更新记录 | 记录SDK各版本的主要更新情况。
编程引导 | 介绍C接口使用流程。
接口函数 | 介绍C接口的接口函数，宏定义和类型定义。
结构体定义 | 介绍接口函数内结构体的定义。
示例程序 | 介绍常见用例和接口基本的使用方法。
错误码 | 介绍接口函数返回的错误码定义，方便程序出现问题时进行排查。

运行环境

GigE Vision采集卡
硬件配置：PCI-E gen2 × 4
软件环境：Windows 7/10 32/64bits操作系统
CoaXPress采集卡
硬件配置：PCI-E gen2 × 8（CoaXPress-6采集卡）、PCI-E gen3 × 8（CoaXPress-12采集卡）
软件环境：Windows 7/10 32/64bits操作系统
Camera Link采集卡
硬件配置：PCI-E gen2 × 4
软件环境：Windows 7/10 32/64bits操作系统


SDK版本更新记录
更新版本 | 更新说明
V2.1.0 | 新增通过采集卡ID打开采集卡，可指定采集卡权限： MV_FG_OpenInterfaceByID()
 | 新增通过设备ID打开设备： MV_FG_OpenDeviceByID()
 | 修改注册帧缓存信息回调函数(SDK内部申请缓存方式)备注： MV_FG_RegisterFrameCallBack()
 | 修改刷新缓存队列的备注： MV_FG_FlushQueue()
 | 新增保存TIFF图像： MV_FG_SaveTiffToFile()
 | 新增保存PNG图像： MV_FG_SavePngToFile()
 | 修改重组图像的备注： MV_FG_ReconstructImage()
 | 新增无损解码： MV_FG_HB_Decode()
 | 修改获取XML文件的备注： MV_FG_GetXMLFile()
 | 新增注册事件回调函数： MV_FG_RegisterEventCallBack()
 | 新增保存TIFF图像信息结构体： MV_FG_SAVE_TIFF_TO_FILE_INFO
 | 新增保存PNG图像信息结构体： MV_FG_SAVE_PNG_TO_FILE_INFO
 | 更新枚举类型定义
 | 示例程序章节，新增获取采集卡事件
V2.0.0
 | 修改首页概述内容
 | 修改编程引导内容
 | 新增释放指定类型的采集卡资源接口函数： MV_FG_ReleaseTLayerResource()
 | 新增打开采集卡，指定采集卡属性节点接口函数： MV_FG_OpenInterfaceEx()
 | 新增设置SDK内部缓存数量接口函数： MV_FG_SetBufferNum()
 | 新增注册帧缓存信息回调函数(SDK内部申请缓存方式)接口函数： MV_FG_RegisterFrameCallBack()
 | 新增释放缓存信息(SDK内部申请缓存方式)接口函数： MV_FG_ReleaseFrameBuffer()
 | 新增获取缓存内的ChunkData信息接口函数： MV_FG_GetBufferChunkData()
 | 新增获取一帧图像的缓存信息(用户向流通道注册缓存方式)接口函数： MV_FG_GetFrameBuffer()
 | 新增图像处理大类，包含显示一帧图像、保存BMP图像、保存JPEG图像、像素格式转换、重组图像接口函数
 | 新增配置自定义的整型值接口函数： MV_FG_SetConfigIntValue()
 | 新增注册异常信息回调函数接口函数： MV_FG_RegisterExceptionCallBack()
 | 修改部分结构体内容
 | 新增 MV_FG_CHUNK_DATA_INFO 结构体、 MV_FG_INPUT_IMAGE_INFO 结构体、 MV_FG_OUTPUT_IMAGE_INFO 结构体、 MV_FG_SAVE_BITMAP_INFO 结构体、 MV_FG_SAVE_JPEG_INFO 结构体、 MV_FG_GAMMA_INFO 结构体、 MV_FG_CCM_INFO 结构体、 MV_FG_CONVERT_PIXEL_INFO 结构体、 MV_FG_RECONSTRUCT_INFO 结构体、 MV_FG_EVENT_INFO 结构体
 | 新增示例程序，包含获取Chunk数据、像素格式转换、动态库加载、主动取图、回调取图、用户注册缓存取图
 | 新增图像处理错误码
V1.1.2 | 新增支持Camera Link采集卡，修改概述内容
 | 修改运行环境
 | 修改 MV_FG_AnnounceBuffer()接口函数备注
 | 新增保存设备属性接口函数： MV_FG_FeatureSave()
 | 新增导入设备属性接口函数： MV_FG_FeatureLoad()
 | 新增 MV_CML_DEVICE_INFO 结构体
 | 新增 MV_CML_INTERFACE_INFO 结构体
 | 修改示例程序内容
V1.1.1 | 修改概述内容
 | 修改运行环境
 | 修改接口函数基本使用流程流程图
 | 调整接口函数分类，相机操作划分为采集卡接口和相机接口，图像采集划分为流接口和缓存接口
 | 修改 MV_FG_DEVICE_INFO 结构体类成员变量说明
 | 修改部分错误码 说明
V1.1.0 | 修改接口函数基本使用流程流程图
 | 修改获取设备数量接口名称为 MV_FG_UpdateDeviceList()
 | 新增宏定义MV_FG_GEV_IFCONFIG_LLA_BIT、MV_FG_GEV_IFCONFIG_DHCP_BIT、MV_FG_GEV_IFCONFIG_PERSISTENT_BIT、MV_FG_GEV_IFCONFIG_PR_BIT和MV_FG_GEV_IFCONFIG_PG_BIT
 | 新增宏定义MV_FG_GEV_DEVICE、MV_FG_U3V_DEVICE、MV_FG_CAMERALINK_DEVICE和MV_FG_CXP_DEVICE
 | 新增 MV_GEV_DEVICE_INFO 结构体
 | 新增 MV_GEV_INTERFACE_INFO 结构体
V1.0.0 | 提供采集卡枚举接口 MV_FG_UpdateInterfaceList() 、打开接口 MV_FG_OpenInterface() 和关闭接口 MV_FG_CloseInterface()
 | 提供相机枚举接口 MV_FG_UpdateDeviceList() 、打开接口 MV_FG_OpenDevice() 和关闭接口 MV_FG_CloseDevice()
 | 提供流通道的打开接口 MV_FG_OpenStream() 、关闭接口 MV_FG_CloseStream() 和流通道的PayloadSize接口 MV_FG_GetPayloadSize()
 | 提供开始取流接口 MV_FG_StartAcquisition() 、停止取流接口 MV_FG_StopAcquisition() 和取图相关接口 MV_FG_GetImageBuffer() 、 MV_FG_GetBufferInfo()
 | 提供缓存管理相关接口 MV_FG_AnnounceBuffer() 、 MV_FG_RevokeBuffer() 、 MV_FG_FlushQueue() 、 MV_FG_QueueBuffer()
 | 提供XML解析接口 MV_FG_GetXMLFile() 和参数配置相关接口 MV_FG_GetIntValue() 、 MV_FG_SetIntValue()


接口函数基本使用流程
本章节介绍了C接口取图流程和取图方式。其中白色区域为采集卡相关接口，蓝色区域为相机相关接口，橙色区域为流相关接口，绿色区域为取图方式。
SDK获取图像有主动取图和回调取图两种方式（两种方式不能同时使用）：
• 主动取图：调用 MV_FG_StartAcquisition() 开始取流，然后调用 MV_FG_GetFrameBuffer() 获取图像缓存信息，再调用 MV_FG_ReleaseFrameBuffer() 释放图像缓存。
• 回调取图：使用 MV_FG_RegisterFrameCallBack() 接口注册自定义的回调函数，然后调用 MV_FG_StartAcquisition() 开始取流。
• 注意事项：
a、两种取图方式不能同时使用。
b、回调函数中不建议有耗时操作、线程锁等，容易造成回调阻塞。
c、图像缓存结构内的图像数据是一个地址指针，建议在回调取图方式中将里面的数据拷贝出来另建线程使用。


接口函数
这里列出了所有模块:
版本信息 | 获取SDK版本信息接口
采集卡接口 | 包含采集卡的枚举、信息获取、打开和关闭等接口
相机接口 | 包含相机的枚举、信息获取、打开和关闭等接口
流接口 | 包含流的信息获取、打开和关闭等接口
缓存接口 | 包含缓存的管理接口、信息获取、注册/撤销缓存等接口
图像处理 | 包含显示一帧图像、保存BMP、JPEG图像、TIFF图像、PNG图像、像素格式转换等接口
参数控制 | 包含获取采集卡和相机的XML文件接口、设置和获取设备参数的万能接口、加载和保存接口
通用接口 | 包含注册事件回调函数和注册异常信息回调函数接口
宏定义 |
枚举类型定义 |


函数
版本信息

获取SDK版本信息接口 更多...

函数

MV_FGCTRL_API unsigned char *__stdcall MV_FG_GetSDKVersion ()
获取SDK版本信息 更多...

详细描述

获取SDK版本信息接口

函数说明

◆ MV_FG_GetSDKVersion()

MV_FGCTRL_API unsigned char* __stdcall MV_FG_GetSDKVersion ( )

获取SDK版本信息

返回
以字符串形式返回SDK版本信息
备注
格式：“版本 + 类型 + 编译时间”


函数
采集卡接口

包含采集卡的枚举、信息获取、打开和关闭等接口 更多...

函数

MV_FGCTRL_API int __stdcall | MV_FG_UpdateInterfaceList (IN unsigned int nTLayerType, OUT bool8_t *pbChanged)
更新采集卡列表 更多...
MV_FGCTRL_API int __stdcall | MV_FG_ReleaseTLayerResource (IN unsigned int nTLayerType)
释放指定类型的采集卡资源 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetNumInterfaces (OUT unsigned int *pnNumIfaces)
获取采集卡数量 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetInterfaceInfo (IN unsigned int nIndex, OUT MV_FG_INTERFACE_INFO *pstIfaceInfo)
根据索引获取采集卡信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_OpenInterface (IN unsigned int nIndex, OUT IFHANDLE *phIface)
打开采集卡 更多...
MV_FGCTRL_API int __stdcall | MV_FG_OpenInterfaceEx (IN unsigned int nIndex, IN int nAccess, OUT IFHANDLE *phIface)
通过索引下标打开采集卡，可指定采集卡权限 更多...
MV_FGCTRL_API int __stdcall | MV_FG_OpenInterfaceByID (IN char *pcInterfaceID, IN int nAccess, OUT IFHANDLE *phIface)
通过采集卡ID打开采集卡，可指定采集卡权限 更多...
MV_FGCTRL_API int __stdcall | MV_FG_CloseInterface (IN IFHANDLE hIface)
关闭采集卡 更多...

详细描述

包含采集卡的枚举、信息获取、打开和关闭等接口

函数说明

◆ MV_FG_UpdateInterfaceList()

MV_FGCTRL_API int __stdcall MV_FG_UpdateInterfaceList | ( | IN unsigned int | nTLayerType,
 |  | OUT bool8_t * | pbChanged
 | ) |  |

更新采集卡列表

参数
nTLayerType | [IN] 采集卡类型
pbChanged | [OUT] 采集卡列表是否改变
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
进行采集卡操作之前必须调用该接口，只有在调用该接口时内部采集卡列表才会更新。

◆ MV_FG_ReleaseTLayerResource()

MV_FGCTRL_API int __stdcall MV_FG_ReleaseTLayerResource ( IN unsigned int nTLayerType )

释放指定类型的采集卡资源

参数
nTLayerType [IN] 采集卡类型
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
调用该接口之前必须关闭所有该类型的采集卡。通过FreeLibrary函数释放该库前需要调用该接口释放所有采集卡资源。

◆ MV_FG_GetNumInterfaces()

MV_FGCTRL_API int __stdcall MV_FG_GetNumInterfaces ( OUT unsigned int * pnNumIfaces )

获取采集卡数量

参数
pnNumIfaces [OUT] 采集卡数量
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_GetInterfaceInfo()

MV_FGCTRL_API int __stdcall MV_FG_GetInterfaceInfo | ( | IN unsigned int | nIndex,
 |  | OUT MV_FG_INTERFACE_INFO * | pstIfaceInfo
 | ) |  |

根据索引获取采集卡信息

参数
nIndex | [IN] 采集卡索引，从0开始
pstIfaceInfo | [OUT] 采集卡信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_OpenInterface()

MV_FGCTRL_API int __stdcall MV_FG_OpenInterface | ( | IN unsigned int | nIndex,
 |  | OUT IFHANDLE * | phIface
 | ) |  |

打开采集卡

参数
nIndex | [IN] 采集卡索引，从0开始
phIface | [OUT] 采集卡句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_OpenInterfaceEx()

MV_FGCTRL_API int __stdcall MV_FG_OpenInterfaceEx | ( | IN unsigned int | nIndex,
 |  | IN int | nAccess,
 |  | OUT IFHANDLE * | phIface
 | ) |  |

通过索引下标打开采集卡，可指定采集卡权限

参数
nIndex | [IN] 采集卡索引，从0开始
nAccess | [IN] 权限
phIface | [OUT] 采集卡句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
有MV_FG_ACCESS_UNKNOWN、 MV_FG_ACCESS_READONLY、MV_FG_ACCESS_CONTROL三种权限类型。
CoaXPress和Camera Link采集卡只能以 MV_FG_ACCESS_CONTROL权限打开。

◆ MV_FG_OpenInterfaceByID()

MV_FGCTRL_API int __stdcall MV_FG_OpenInterfaceByID | ( | IN char * | pcInterfaceID,
 |  | IN int | nAccess,
 |  | OUT IFHANDLE * | phIface
 | ) |  |

通过采集卡ID打开采集卡，可指定采集卡权限

参数
pcInterfaceID | [IN] 采集卡ID
nAccess | [IN] 权限
phIface | [OUT] 采集卡句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
有MV_FG_ACCESS_UNKNOWN、MV_FG_ACCESS_READONLY、MV_FG_ACCESS_CONTROL三种权限类型。
CoaXPress和Camera Link采集卡只能以 MV_FG_ACCESS_CONTROL权限打开。

◆ MV_FG_CloseInterface()

MV_FGCTRL_API int __stdcall MV_FG_CloseInterface ( IN IFHANDLE hIface )

关闭采集卡

参数
hIface [IN] 采集卡句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


函数
相机接口

包含相机的枚举、信息获取、打开和关闭等接口 更多...

函数

MV_FGCTRL_API int __stdcall | MV_FG_UpdateDeviceList (IN IFHANDLE hIface, OUT bool8_t *pbChanged)
更新指定采集卡下的设备列表 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetNumDevices (IN IFHANDLE hIface, OUT unsigned int *pnNumDevices)
获取指定采集卡下的设备数量 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetDeviceInfo (IN IFHANDLE hIface, IN unsigned int nIndex, OUT MV_FG_DEVICE_INFO *pstDevInfo)
获取设备信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_OpenDevice (IN IFHANDLE hIface, IN unsigned int nIndex, OUT DEVHANDLE *phDevice)
通过索引下标打开设备 更多...
MV_FGCTRL_API int __stdcall | MV_FG_OpenDeviceByID (IN IFHANDLE hIface, IN char *pcDeviceID, OUT DEVHANDLE *phDevice)
通过设备ID打开设备 更多...
MV_FGCTRL_API int __stdcall | MV_FG_CloseDevice (IN DEVHANDLE hDevice)
关闭设备 更多...

详细描述

包含相机的枚举、信息获取、打开和关闭等接口

函数说明

◆ MV_FG_UpdateDeviceList()

MV_FGCTRL_API int __stdcall MV_FG_UpdateDeviceList | ( | IN IFHANDLE | hIface,
 |  | OUT bool8_t * | pbChanged
 | ) |  |

更新指定采集卡下的设备列表

参数
hIface | [IN] 采集卡句柄
pbChanged | [OUT] 设备列表是否改变
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
仅在调用该接口时内部设备列表才可更新。

◆ MV_FG_GetNumDevices()

MV_FGCTRL_API int __stdcall MV_FG_GetNumDevices | ( | IN IFHANDLE | hIface,
 |  | OUT unsigned int * | pnNumDevices
 | ) |  |

获取指定采集卡下的设备数量

参数
hIface | [IN] 采集卡句柄
pnNumDevices | [OUT] 设备数量
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_GetDeviceInfo()

MV_FGCTRL_API int __stdcall MV_FG_GetDeviceInfo | ( | IN IFHANDLE | hIface,
 |  | IN unsigned int | nIndex,
 |  | OUT MV_FG_DEVICE_INFO * | pstDevInfo
 | ) |  |

获取设备信息

参数
hIface | [IN] 采集卡句柄
nIndex | [IN] 设备索引，从0开始
pstDevInfo | [OUT] 设备信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_OpenDevice()

MV_FGCTRL_API int __stdcall MV_FG_OpenDevice | ( | IN IFHANDLE | hIface,
 |  | IN unsigned int | nIndex,
 |  | OUT DEVHANDLE * | phDevice
 | ) |  |

通过索引下标打开设备

参数
hIface | [IN] 采集卡句柄
nIndex | [IN] 设备索引，从0开始
phDevice | [OUT] 设备句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_OpenDeviceByID()

MV_FGCTRL_API int __stdcall MV_FG_OpenDeviceByID | ( | IN IFHANDLE | hIface,
 |  | IN char * | pcDeviceID,
 |  | OUT DEVHANDLE * | phDevice
 | ) |  |

通过设备ID打开设备

参数
hIface | [IN] 采集卡句柄
pcDeviceID | [IN] 设备ID
phDevice | [OUT] 设备句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_CloseDevice()

MV_FGCTRL_API int __stdcall MV_FG_CloseDevice ( IN DEVHANDLE hDevice )

关闭设备

参数
hDevice [IN] 设备句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


函数
流接口

包含流的信息获取、打开和关闭等接口 更多...

函数

MV_FGCTRL_API int __stdcall | MV_FG_GetNumStreams (IN DEVHANDLE hDevice, OUT unsigned int *pnNumStreams)
获取流通道数量 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetPayloadSize (IN STREAMHANDLE hStream, OUT unsigned int *pnPayloadSize)
获取流通道的图像大小 更多...
MV_FGCTRL_API int __stdcall | MV_FG_OpenStream (IN DEVHANDLE hDevice, IN unsigned int nIndex, OUT STREAMHANDLE *phStream)
打开流通道 更多...
MV_FGCTRL_API int __stdcall | MV_FG_CloseStream (IN STREAMHANDLE hStream)
关闭流通道 更多...
MV_FGCTRL_API int __stdcall | MV_FG_StartAcquisition (IN STREAMHANDLE hStream)
开始取流 更多...
MV_FGCTRL_API int __stdcall | MV_FG_StopAcquisition (IN STREAMHANDLE hStream)
停止取流 更多...

详细描述

包含流的信息获取、打开和关闭等接口

函数说明

◆ MV_FG_GetNumStreams()

MV_FGCTRL_API int __stdcall MV_FG_GetNumStreams | ( | IN DEVHANDLE | hDevice,
 |  | OUT unsigned int * | pnNumStreams
 | ) |  |

获取流通道数量

参数
hDevice | [IN] 设备句柄
pnNumStreams | [OUT] 流通道数量
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_GetPayloadSize()

MV_FGCTRL_API int __stdcall MV_FG_GetPayloadSize | ( | IN STREAMHANDLE | hStream,
 |  | OUT unsigned int * | pnPayloadSize
 | ) |  |

获取流通道的图像大小

参数
hStream | [IN] 流通道句柄
pnPayloadSize | [OUT] 流通道的图像大小
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
修改相机图像相关参数如宽高、像素格式等参数后需要重新获取流通道的图像大小。

◆ MV_FG_OpenStream()

MV_FGCTRL_API int __stdcall MV_FG_OpenStream | ( | IN DEVHANDLE | hDevice,
 |  | IN unsigned int | nIndex,
 |  | OUT STREAMHANDLE * | phStream
 | ) |  |

打开流通道

参数
hDevice | [IN] 设备句柄
nIndex | [IN] 流通道索引
phStream | [OUT] 流通道句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_CloseStream()

MV_FGCTRL_API int __stdcall MV_FG_CloseStream ( IN STREAMHANDLE hStream )

关闭流通道

参数
hStream [IN] 流通道句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_StartAcquisition()

MV_FGCTRL_API int __stdcall MV_FG_StartAcquisition ( IN STREAMHANDLE hStream )

开始取流

参数
hStream [IN] 流通道句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_StopAcquisition()

MV_FGCTRL_API int __stdcall MV_FG_StopAcquisition ( IN STREAMHANDLE hStream )

停止取流

参数
hStream [IN] 流通道句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


函数
缓存接口

包含缓存的管理接口、信息获取、注册/撤销缓存等接口 更多...

函数

MV_FGCTRL_API int __stdcall | MV_FG_SetBufferNum (IN STREAMHANDLE hStream, IN unsigned int nBufferNum)
设置SDK内部缓存数量 更多...
MV_FGCTRL_API int __stdcall | MV_FG_RegisterFrameCallBack (IN STREAMHANDLE hStream, IN MV_FG_FrameCallBack cbFrame, IN void *pUser)
注册帧缓存信息回调函数(SDK内部申请缓存方式) 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetFrameBuffer (IN STREAMHANDLE hStream, OUT MV_FG_BUFFER_INFO *pstBufferInfo, IN unsigned int nTimeout)
获取一帧图像的缓存信息(SDK内部申请缓存方式) 更多...
MV_FGCTRL_API int __stdcall | MV_FG_ReleaseFrameBuffer (IN STREAMHANDLE hStream, IN MV_FG_BUFFER_INFO *pstBufferInfo)
释放缓存信息(SDK内部申请缓存方式) 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetBufferChunkData (IN STREAMHANDLE hStream, IN MV_FG_BUFFER_INFO *pstBufferInfo, IN unsigned int nIndex, OUT MV_FG_CHUNK_DATA_INFO *pstChunkDataInfo)
获取缓存内的ChunkData信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_AnnounceBuffer (IN STREAMHANDLE hStream, IN void *pBuffer, IN unsigned int nSize, IN void *pPrivate, OUT BUFFERHANDLE *phBuffer)
向流通道中注册缓存(必须在开始取流前注册缓存) 更多...
MV_FGCTRL_API int __stdcall | MV_FG_RevokeBuffer (IN STREAMHANDLE hStream, IN BUFFERHANDLE hBuffer, OUT void **pBuffer, OUT void **pPrivate)
从流通道中撤销缓存 更多...
MV_FGCTRL_API int __stdcall | MV_FG_FlushQueue (IN STREAMHANDLE hStream, IN MV_FG_BUFFER_QUEUE_TYPE enQueueType)
刷新缓存队列 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetImageBuffer (IN STREAMHANDLE hStream, OUT BUFFERHANDLE *phBuffer, IN unsigned int nTimeout)
获取一帧图像的缓存信息(用户向流通道注册缓存方式) 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetBufferInfo (IN BUFFERHANDLE hBuffer, OUT MV_FG_BUFFER_INFO *pstBufferInfo)
通过缓存句柄获取缓存信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_QueueBuffer (IN BUFFERHANDLE hBuffer)
将队列外的缓存句柄放回输入队列 更多...

详细描述

包含缓存的管理接口、信息获取、注册/撤销缓存等接口

函数说明

◆ MV_FG_SetBufferNum()

MV_FGCTRL_API int __stdcall MV_FG_SetBufferNum | ( | IN STREAMHANDLE | hStream,
 |  | IN unsigned int | nBufferNum
 | ) |  |

设置SDK内部缓存数量

参数
hStream | [IN] 流通道句柄
nBufferNum | [IN] 缓存数量
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
当未调用该接口或者nBufferNum参数设置为0时，表示SDK内部无缓存，此时需要用户申请缓存并向流通道注册缓存，否则无法开始取流。
当nBufferNum参数设置大于0时，表示缓存由SDK内部进行申请，此时不允许用户向流通道注册缓存。

◆ MV_FG_RegisterFrameCallBack()

MV_FGCTRL_API int __stdcall MV_FG_RegisterFrameCallBack | ( | IN STREAMHANDLE | hStream,
 |  | IN MV_FG_FrameCallBack | cbFrame,
 |  | IN void * | pUser
 | ) |  |

注册帧缓存信息回调函数(SDK内部申请缓存方式)

参数
hStream | [IN] 流通道句柄
cbFrame | [IN] 帧缓存信息回调函数
pUser | [IN] 用户自定义数据
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
在回调函数中处理耗时操作会阻塞后续帧信息获取。
注册回调方式和 MV_FG_GetFrameBuffer() 互斥。
必须在调用 MV_FG_StartAcquisition() 前注册回调函数。

◆ MV_FG_GetFrameBuffer()

MV_FGCTRL_API int __stdcall MV_FG_GetFrameBuffer | ( | IN STREAMHANDLE | hStream,
 |  | OUT MV_FG_BUFFER_INFO * | pstBufferInfo,
 |  | IN unsigned int | nTimeout
 | ) |  |

获取一帧图像的缓存信息(SDK内部申请缓存方式)

参数
hStream | [IN] 流通道句柄
pstBufferInfo | [OUT] 缓存信息
nTimeout | [IN] 超时时间，以毫秒为单位
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
需要调用 MV_FG_ReleaseFrameBuffer() 接口进行缓存信息的释放。

◆ MV_FG_ReleaseFrameBuffer()

MV_FGCTRL_API int __stdcall MV_FG_ReleaseFrameBuffer | ( | IN STREAMHANDLE | hStream,
 |  | IN MV_FG_BUFFER_INFO * | pstBufferInfo
 | ) |  |

释放缓存信息(SDK内部申请缓存方式)

参数
hStream | [IN] 流通道句柄
pstBufferInfo | [IN] 缓存信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
该接口用于释放不再使用的图像缓存，与 MV_FG_GetFrameBuffer() 配套使用。使用 MV_FG_GetFrameBuffer() 接口取到的图像数据pstBufferInfo，需要用 MV_FG_ReleaseFrameBuffer() 接口进行权限释放。

◆ MV_FG_GetBufferChunkData()

MV_FGCTRL_API int __stdcall MV_FG_GetBufferChunkData | ( | IN STREAMHANDLE | hStream,
 |  | IN MV_FG_BUFFER_INFO * | pstBufferInfo,
 |  | IN unsigned int | nIndex,
 |  | OUT MV_FG_CHUNK_DATA_INFO * | pstChunkDataInfo
 | ) |  |

获取缓存内的ChunkData信息

参数
hStream | [IN] 流通道句柄
pstBufferInfo | [IN] 缓存信息
nIndex | [IN] ChunkData索引
pstChunkDataInfo | [OUT] ChunkData信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
在获取到缓存信息之后，调用 MV_FG_ReleaseFrameBuffer() 或者 MV_FG_QueueBuffer() 之前调用该接口才能得到有效信息。

◆ MV_FG_AnnounceBuffer()

MV_FGCTRL_API int __stdcall MV_FG_AnnounceBuffer | ( | IN STREAMHANDLE | hStream,
 |  | IN void * | pBuffer,
 |  | IN unsigned int | nSize,
 |  | IN void * | pPrivate,
 |  | OUT BUFFERHANDLE * | phBuffer
 | ) |  |

向流通道中注册缓存(必须在开始取流前注册缓存)

参数
hStream | [IN] 流通道句柄
pBuffer | [IN] 图像缓存地址
nSize | [IN] 图像缓存大小
pPrivate | [IN] 私有信息地址
phBuffer | [OUT] 缓存句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
图像缓存大小通过 MV_FG_GetPayloadSize() 接口获取；私有信息由用户自定义。

◆ MV_FG_RevokeBuffer()

MV_FGCTRL_API int __stdcall MV_FG_RevokeBuffer | ( | IN STREAMHANDLE | hStream,
 |  | IN BUFFERHANDLE | hBuffer,
 |  | OUT void ** | pBuffer,
 |  | OUT void ** | pPrivate
 | ) |  |

从流通道中撤销缓存

参数
hStream | [IN] 流通道句柄
hBuffer | [IN] 缓存句柄
pBuffer | [OUT] 图像缓存地址
pPrivate | [OUT] 私有信息地址
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
只能撤销未使用队列中的缓存，可通过 MV_FG_FlushQueue() 接口将缓存放到未使用队列。

◆ MV_FG_FlushQueue()

MV_FGCTRL_API int __stdcall MV_FG_FlushQueue | ( | IN STREAMHANDLE | hStream,
 |  | IN MV_FG_BUFFER_QUEUE_TYPE | enQueueType
 | ) |  |

刷新缓存队列

参数
hStream | [IN] 流通道句柄
enQueueType | [IN] 队列类型
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
取流过程中不支持MV_FG_BUFFER_QUEUE_INPUT_TO_OUTPUT、MV_FG_BUFFER_QUEUE_ALL_DISCARD。

◆ MV_FG_GetImageBuffer()

MV_FGCTRL_API int __stdcall MV_FG_GetImageBuffer | ( | IN STREAMHANDLE | hStream,
 |  | OUT BUFFERHANDLE * | phBuffer,
 |  | IN unsigned int | nTimeout
 | ) |  |

获取一帧图像的缓存信息(用户向流通道注册缓存方式)

参数
hStream | [IN] 流通道句柄
phBuffer | [OUT] 缓存句柄
nTimeout | [IN] 超时时间，以毫秒为单位
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
通过 MV_FG_GetBufferInfo() 接口根据缓存句柄获取图像信息。

◆ MV_FG_GetBufferInfo()

MV_FGCTRL_API int __stdcall MV_FG_GetBufferInfo | ( | IN BUFFERHANDLE | hBuffer,
 |  | OUT MV_FG_BUFFER_INFO * | pstBufferInfo
 | ) |  |

通过缓存句柄获取缓存信息

参数
hBuffer | [IN] 缓存句柄
pstBufferInfo | [OUT] 缓存信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_QueueBuffer()

MV_FGCTRL_API int __stdcall MV_FG_QueueBuffer ( IN BUFFERHANDLE hBuffer )

将队列外的缓存句柄放回输入队列

参数
hBuffer [IN] 缓存句柄
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码


函数
图像处理

包含显示一帧图像、保存BMP、JPEG图像、TIFF图像、PNG图像、像素格式转换等接口 更多...

函数

MV_FGCTRL_API int __stdcall | MV_FG_DisplayOneFrame (IN IMAGEHANDLE hImage, IN void *hWnd, IN MV_FG_DISPLAY_FRAME_INFO *pstDisplayFrameInfo)
显示一帧图像 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SaveBitmap (IN IMAGEHANDLE hImage, IN OUT MV_FG_SAVE_BITMAP_INFO *pstSaveBitmapInfo)
保存BMP图像 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SaveJpeg (IN IMAGEHANDLE hImage, IN OUT MV_FG_SAVE_JPEG_INFO *pstSaveJpegInfo)
保存JPEG图像 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SaveTiffToFile (IN IMAGEHANDLE hImage, IN OUT MV_FG_SAVE_TIFF_TO_FILE_INFO *pstSaveTiffInfo)
保存TIFF图像 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SavePngToFile (IN IMAGEHANDLE hImage, IN OUT MV_FG_SAVE_PNG_TO_FILE_INFO *pstSavePngInfo)
保存PNG图像 更多...
MV_FGCTRL_API int __stdcall | MV_FG_ConvertPixelType (IN IMAGEHANDLE hImage, IN OUT MV_FG_CONVERT_PIXEL_INFO *pstConvertPixelInfo)
像素格式转换 更多...
MV_FGCTRL_API int __stdcall | MV_FG_ReconstructImage (IN IMAGEHANDLE hImage, IN OUT MV_FG_RECONSTRUCT_INFO *pstReconstructInfo)
重组图像 更多...
MV_FGCTRL_API int __stdcall | MV_FG_HB_Decode (IN IMAGEHANDLE hImage, IN OUT MV_FG_HB_DECODE_PARAM *pstDecodeParam)
无损解码 更多...

详细描述

包含显示一帧图像、保存BMP、JPEG图像、TIFF图像、PNG图像、像素格式转换等接口

函数说明

◆ MV_FG_DisplayOneFrame()

MV_FGCTRL_API int __stdcall MV_FG_DisplayOneFrame | ( | IN IMAGEHANDLE | hImage,
 |  | IN void * | hWnd,
 |  | IN MV_FG_DISPLAY_FRAME_INFO * | pstDisplayFrameInfo
 | ) |  |

显示一帧图像

参数
hImage | [IN] 图像句柄(可以使用采集卡/设备/流句柄)
hWnd | [IN] 窗口句柄
pstDisplayFrameInfo | [IN] 显示的图像信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SaveBitmap()

MV_FGCTRL_API int __stdcall MV_FG_SaveBitmap | ( | IN IMAGEHANDLE | hImage,
 |  | IN OUT MV_FG_SAVE_BITMAP_INFO * | pstSaveBitmapInfo
 | ) |  |

保存BMP图像

参数
hImage | [IN] 图像句柄(可以使用采集卡/设备/流句柄)
pstSaveBitmapInfo | [IN][OUT] BMP图像信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SaveJpeg()

MV_FGCTRL_API int __stdcall MV_FG_SaveJpeg | ( | IN IMAGEHANDLE | hImage,
 |  | IN OUT MV_FG_SAVE_JPEG_INFO * | pstSaveJpegInfo
 | ) |  |

保存JPEG图像

参数
hImage | [IN] 图像句柄(可以使用采集卡/设备/流句柄)
pstSaveJpegInfo | [IN][OUT] JPEG图像信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SaveTiffToFile()

MV_FGCTRL_API int __stdcall MV_FG_SaveTiffToFile | ( | IN IMAGEHANDLE | hImage,
 |  | IN OUT MV_FG_SAVE_TIFF_TO_FILE_INFO * | pstSaveTiffInfo
 | ) |  |

保存TIFF图像

参数
hImage | [IN] 图像句柄(可以使用采集卡/设备/流句柄)
pstSaveTiffInfo | [IN][OUT] TIFF图像信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SavePngToFile()

MV_FGCTRL_API int __stdcall MV_FG_SavePngToFile | ( | IN IMAGEHANDLE | hImage,
 |  | IN OUT MV_FG_SAVE_PNG_TO_FILE_INFO * | pstSavePngInfo
 | ) |  |

保存PNG图像

参数
hImage | [IN] 图像句柄(可以使用采集卡/设备/流句柄)
pstSavePngInfo | [IN][OUT] PNG图像信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_ConvertPixelType()

MV_FGCTRL_API int __stdcall MV_FG_ConvertPixelType | ( | IN IMAGEHANDLE | hImage,
 |  | IN OUT MV_FG_CONVERT_PIXEL_INFO * | pstConvertPixelInfo
 | ) |  |

像素格式转换

参数
hImage | [IN] 图像句柄(可以使用采集卡/设备/流句柄)
pstConvertPixelInfo | [IN][OUT] 像素格式转换信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_ReconstructImage()

MV_FGCTRL_API int __stdcall MV_FG_ReconstructImage | ( | IN IMAGEHANDLE | hImage,
 |  | IN OUT MV_FG_RECONSTRUCT_INFO * | pstReconstructInfo
 | ) |  |

重组图像

参数
hImage | [IN] 图像句柄(可以使用采集卡/设备/流句柄)
pstReconstructInfo | [IN][OUT] 重组信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
图像旋转和图像翻转支持的像素格式为MV_FG_PIXEL_TYPE_Mono8、MV_FG_PIXEL_TYPE_RGB8_Packed和MV_FG_PIXEL_TYPE_BGR8_Packed。
图像分割支持任意格式，图像分割应与线阵相机的“MultiLightControl”节点搭配使用，该节点可设置多个不同的曝光值，
如MultiLightControl=2，相机会将两个不同曝光值所对应的两张图像交叠合并为一张图像(实际高度为两张图像的高度)发送给上层应用程序，
调用该接口并传入重组方式为RECONSTRUCT_MODE_SPLIT_BY_LINE_2，可将相机发送的一张图像分割为2张图像，这两张图像分别对应一个曝光值。
若使用普通相机或未打开线阵相机的“MultiLightControl”节点，则图像分割无意义，只是将图像按行分割为2，3，4张图像，
每张图像的高度变为原图像的1/2，1/3，1/4(由enReconstructMode决定)。

◆ MV_FG_HB_Decode()

MV_FGCTRL_API int __stdcall MV_FG_HB_Decode | ( | IN IMAGEHANDLE | hImage,
 |  | IN OUT MV_FG_HB_DECODE_PARAM * | pstDecodeParam
 | ) |  |

无损解码

参数
hImage | [IN] 图像句柄(可以使用采集卡/设备/流句柄)
pstDecodeParam | [IN][OUT] 无损解码参数结构体
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
将从相机中取到的无损压缩码流解码成裸数据，同时支持解析当前相机实时图像的水印信息（如果输入的无损码流不是当前相机或者不是实时取流的，则水印解析可能异常）。
必须传入当前相机的设备句柄才能解析出图像的水印信息，传入采集卡句柄或流句柄只能进行无损解码。


函数
参数控制

包含获取采集卡和相机的XML文件接口、设置和获取设备参数的万能接口、加载和保存接口 更多...

函数

MV_FGCTRL_API int __stdcall | MV_FG_GetXMLFile (IN PORTHANDLE hPort, IN OUT unsigned char *pData, IN unsigned int nDataSize, OUT unsigned int *pnDataLen)
获取XML文件 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetNodeAccessMode (IN PORTHANDLE hPort, IN const char *strName, OUT MV_FG_NODE_ACCESS_MODE *penAccessMode)
获得节点的访问模式 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetNodeInterfaceType (IN PORTHANDLE hPort, IN const char *strName, OUT MV_FG_NODE_INTERFACE_TYPE *penInterfaceType)
获得节点的类型 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetIntValue (IN PORTHANDLE hPort, IN const char *strKey, OUT MV_FG_INTVALUE *pstIntValue)
获取整型节点信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SetIntValue (IN PORTHANDLE hPort, IN const char *strKey, IN int64_t nValue)
设置整型节点信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetEnumValue (IN PORTHANDLE hPort, IN const char *strKey, OUT MV_FG_ENUMVALUE *pstEnumValue)
获取枚举类型节点的信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SetEnumValue (IN PORTHANDLE hPort, IN const char *strKey, IN unsigned int nValue)
设置枚举类型节点的信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SetEnumValueByString (IN PORTHANDLE hPort, IN const char *strKey, IN const char *strValue)
通过字符串设置枚举类型节点的信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetFloatValue (IN PORTHANDLE hPort, IN const char *strKey, OUT MV_FG_FLOATVALUE *pstFloatValue)
获取单精度浮点型节点的信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SetFloatValue (IN PORTHANDLE hPort, IN const char *strKey, IN float fValue)
设置单精度浮点型节点的信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetBoolValue (IN PORTHANDLE hPort, IN const char *strKey, OUT bool8_t *pbValue)
获取布尔型节点的信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SetBoolValue (IN PORTHANDLE hPort, IN const char *strKey, IN bool8_t bValue)
设置布尔类型节点的信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_GetStringValue (IN PORTHANDLE hPort, IN const char *strKey, OUT MV_FG_STRINGVALUE *pstStringValue)
获取字符串型节点的信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SetStringValue (IN PORTHANDLE hPort, IN const char *strKey, IN const char *strValue)
设置字符串型节点的信息 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SetCommandValue (IN PORTHANDLE hPort, IN const char *strKey)
执行命令型节点的命令 更多...
MV_FGCTRL_API int __stdcall | MV_FG_SetConfigIntValue (IN PORTHANDLE hPort, IN MV_FG_CONFIG_CMD enConfigCmd, IN int64_t nValue)
配置自定义的整型值 更多...
MV_FGCTRL_API int __stdcall | MV_FG_FeatureSave (IN PORTHANDLE hPort, IN const char *strFileName)
保存设备属性 更多...
MV_FGCTRL_API int __stdcall | MV_FG_FeatureLoad (IN PORTHANDLE hPort, IN const char *strFileName)
导入设备属性 更多...

详细描述

包含获取采集卡和相机的XML文件接口、设置和获取设备参数的万能接口、加载和保存接口

函数说明

◆ MV_FG_GetXMLFile()

MV_FGCTRL_API int __stdcall MV_FG_GetXMLFile | ( | IN PORTHANDLE | hPort,
 |  | IN OUT unsigned char * | pData,
 |  | IN unsigned int | nDataSize,
 |  | OUT unsigned int * | pnDataLen
 | ) |  |

获取XML文件

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
pData | [IN][OUT] 存放XML文件的缓存地址
nDataSize | [IN] 存放XML文件的缓存大小
pnDataLen | [OUT] XML文件长度
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_GetNodeAccessMode()

MV_FGCTRL_API int __stdcall MV_FG_GetNodeAccessMode | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strName,
 |  | OUT MV_FG_NODE_ACCESS_MODE * | penAccessMode
 | ) |  |

获得节点的访问模式

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strName | [IN] 节点名称
penAccessMode | [OUT] 节点访问模式
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
获取EnumEntry类型节点的访问模式，strName应传入EnumEntry_NodeName_EnumEntryName。
如获取PixelFormat枚举类型下的EnumEntry节点Mono8，strName格式为“EnumEntry_PixelFormat_Mono8”。

◆ MV_FG_GetNodeInterfaceType()

MV_FGCTRL_API int __stdcall MV_FG_GetNodeInterfaceType | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strName,
 |  | OUT MV_FG_NODE_INTERFACE_TYPE * | penInterfaceType
 | ) |  |

获得节点的类型

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strName | [IN] 节点名称
penInterfaceType | [OUT] 节点类型
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_GetIntValue()

MV_FGCTRL_API int __stdcall MV_FG_GetIntValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | OUT MV_FG_INTVALUE * | pstIntValue
 | ) |  |

获取整型节点信息

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
pstIntValue | [OUT] 整型节点信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SetIntValue()

MV_FGCTRL_API int __stdcall MV_FG_SetIntValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | IN int64_t | nValue
 | ) |  |

设置整型节点信息

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
nValue | [IN] 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_GetEnumValue()

MV_FGCTRL_API int __stdcall MV_FG_GetEnumValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | OUT MV_FG_ENUMVALUE * | pstEnumValue
 | ) |  |

获取枚举类型节点的信息

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
pstEnumValue | [OUT] 枚举类型节点信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SetEnumValue()

MV_FGCTRL_API int __stdcall MV_FG_SetEnumValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | IN unsigned int | nValue
 | ) |  |

设置枚举类型节点的信息

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
nValue | [IN] 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SetEnumValueByString()

MV_FGCTRL_API int __stdcall MV_FG_SetEnumValueByString | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | IN const char * | strValue
 | ) |  |

通过字符串设置枚举类型节点的信息

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
strValue | [IN] 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_GetFloatValue()

MV_FGCTRL_API int __stdcall MV_FG_GetFloatValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | OUT MV_FG_FLOATVALUE * | pstFloatValue
 | ) |  |

获取单精度浮点型节点的信息

参数
hPort | [IN] 参数所属对象句柄
strKey | [IN] 节点名称
pstFloatValue | [OUT] 单精度浮点型节点信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SetFloatValue()

MV_FGCTRL_API int __stdcall MV_FG_SetFloatValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | IN float | fValue
 | ) |  |

设置单精度浮点型节点的信息

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
fValue | [IN] 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_GetBoolValue()

MV_FGCTRL_API int __stdcall MV_FG_GetBoolValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | OUT bool8_t * | pbValue
 | ) |  |

获取布尔型节点的信息

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
pbValue | [OUT] 布尔型节点信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SetBoolValue()

MV_FGCTRL_API int __stdcall MV_FG_SetBoolValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | IN bool8_t | bValue
 | ) |  |

设置布尔类型节点的信息

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
bValue | [IN] 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_GetStringValue()

MV_FGCTRL_API int __stdcall MV_FG_GetStringValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | OUT MV_FG_STRINGVALUE * | pstStringValue
 | ) |  |

获取字符串型节点的信息

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
pstStringValue | [OUT] 字符串型节点信息
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SetStringValue()

MV_FGCTRL_API int __stdcall MV_FG_SetStringValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey,
 |  | IN const char * | strValue
 | ) |  |

设置字符串型节点的信息

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
strValue | [IN] 要设置的值
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SetCommandValue()

MV_FGCTRL_API int __stdcall MV_FG_SetCommandValue | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strKey
 | ) |  |

执行命令型节点的命令

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strKey | [IN] 节点名称
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码

◆ MV_FG_SetConfigIntValue()

MV_FGCTRL_API int __stdcall MV_FG_SetConfigIntValue | ( | IN PORTHANDLE | hPort,
 |  | IN MV_FG_CONFIG_CMD | enConfigCmd,
 |  | IN int64_t | nValue
 | ) |  |

配置自定义的整型值

参数
hPort | [IN] 参数句柄(只能使用设备句柄)
enConfigCmd | [IN] 配置指令
nValue | [IN] 要配置的值, 范围MV_FG_BAUDRATE_9600 ~ MV_FG_BAUDRATE_AUTOMAX;默认值MV_FG_BAUDRATE_115200
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
仅支持Camera Link相机

◆ MV_FG_FeatureSave()

MV_FGCTRL_API int __stdcall MV_FG_FeatureSave | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strFileName
 | ) |  |

保存设备属性

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strFileName | [IN] 属性文件名，不支持中文路径
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
不支持CameraLink相机

◆ MV_FG_FeatureLoad()

MV_FGCTRL_API int __stdcall MV_FG_FeatureLoad | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strFileName
 | ) |  |

导入设备属性

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备句柄)
strFileName | [IN] 属性文件名，不支持中文路径
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
不支持CameraLink相机


函数
通用接口

包含注册事件回调函数和注册异常信息回调函数接口 更多...

函数

MV_FGCTRL_API int __stdcall | MV_FG_RegisterEventCallBack (IN PORTHANDLE hPort, IN const char *strEventName, IN MV_FG_EventCallBack cbEvent, IN void *pUser)
注册事件回调函数 更多...
MV_FGCTRL_API int __stdcall | MV_FG_RegisterExceptionCallBack (IN PORTHANDLE hPort, IN MV_FG_ExceptionCallBack cbException, IN void *pUser)
注册异常信息回调函数 更多...

详细描述

包含注册事件回调函数和注册异常信息回调函数接口

函数说明

◆ MV_FG_RegisterEventCallBack()

MV_FGCTRL_API int __stdcall MV_FG_RegisterEventCallBack | ( | IN PORTHANDLE | hPort,
 |  | IN const char * | strEventName,
 |  | IN MV_FG_EventCallBack | cbEvent,
 |  | IN void * | pUser
 | ) |  |

注册事件回调函数

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备/流句柄)
strEventName | [IN] 事件名称
cbEvent | [IN] 事件回调函数
pUser | [IN] 用户自定义数据
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
在回调函数中处理耗时操作会阻塞后续事件信息的获取。
该接口适用用采集卡、设备和流事件回调，通过传入不同句柄进行注册。

◆ MV_FG_RegisterExceptionCallBack()

MV_FGCTRL_API int __stdcall MV_FG_RegisterExceptionCallBack | ( | IN PORTHANDLE | hPort,
 |  | IN MV_FG_ExceptionCallBack | cbException,
 |  | IN void * | pUser
 | ) |  |

注册异常信息回调函数

参数
hPort | [IN] 参数句柄(可以使用采集卡/设备/流句柄)
cbException | [IN] 异常信息回调函数
pUser | [IN] 用户自定义数据
返回
成功，返回MV_FG_SUCCESS；失败，返回错误码
备注
在回调函数中处理耗时操作会阻塞后续异常信息的获取。
该接口适用采集卡、设备异常回调，通过传入不同句柄进行注册。
目前不支持采集卡的掉线事件，采集卡不支持热插拔，不会出现掉线的情况；采集卡升级后必须要重启PC才能使用，已给出友好提示。


类 | 宏定义 | 类型定义
宏定义

类

struct | MV_CXP_INTERFACE_INFO
CoaXPress采集卡信息 更多...
struct | MV_GEV_INTERFACE_INFO
GigE Vision采集卡信息 更多...
struct | MV_CML_INTERFACE_INFO
Camera Link采集卡信息 更多...
struct | MV_FG_INTERFACE_INFO
采集卡信息 更多...
struct | MV_CXP_DEVICE_INFO
CoaXPress设备信息 更多...
struct | MV_GEV_DEVICE_INFO
GigE Vision设备信息 更多...
struct | MV_CML_DEVICE_INFO
Camera Link设备信息 更多...
struct | MV_FG_DEVICE_INFO
设备信息 更多...

宏定义

#define | MV_FG_GEV_INTERFACE 0x00000001
GigE Vision采集卡 更多...
#define | MV_FG_U3V_INTERFACE 0x00000002
U3V采集卡 更多...
#define | MV_FG_CAMERALINK_INTERFACE 0x00000004
Camera Link采集卡 更多...
#define | MV_FG_CXP_INTERFACE 0x00000008
CoaXPress采集卡 更多...
#define | MV_FG_GEV_DEVICE 0x00000001
GigE Vision设备 更多...
#define | MV_FG_U3V_DEVICE 0x00000002
U3V设备 更多...
#define | MV_FG_CAMERALINK_DEVICE 0x00000003
Camera Link设备 更多...
#define | MV_FG_CXP_DEVICE 0x00000004
CoaXPress设备 更多...
#define | MV_FG_MAX_IF_INFO_SIZE 64
卡信息的字符串最大长度 更多...
#define | MV_FG_ACCESS_UNKNOWN 0x0
权限未定义 更多...
#define | MV_FG_ACCESS_READONLY 0x1
只读权限，无法设置或者获取节点值 更多...
#define | MV_FG_ACCESS_CONTROL 0x2
控制权限 更多...
#define | MV_FG_MAX_SPLIT_NUM 8
最多将源图像拆分的个数 更多...
#define | MV_FG_ROTATE_MODE 0x1000
旋转方式 更多...
#define | MV_FG_FLIP_MODE 0x2000
翻转方式 更多...
#define | MV_FG_SPLIT_BY_LINE_MODE 0x3000
按行拆分方式 更多...
#define | MV_FG_MAX_EVENT_NAME_SIZE 128
事件名称最大长度 更多...
#define | MV_FG_MAX_SYMBOLIC_NUM 64
XML描述文件中的最大符号数 更多...
#define | MV_FG_MAX_SYMBOLIC_STRLEN 64
XML描述文件的符号最大长度 更多...
#define | MV_FG_BAUDRATE_9600 0x00000001
9600 更多...
#define | MV_FG_BAUDRATE_19200 0x00000002
19200 更多...
#define | MV_FG_BAUDRATE_38400 0x00000004
38400 更多...
#define | MV_FG_BAUDRATE_57600 0x00000008
57600 更多...
#define | MV_FG_BAUDRATE_115200 0x00000010
115200 更多...
#define | MV_FG_BAUDRATE_230400 0x00000020
230400 更多...
#define | MV_FG_BAUDRATE_460800 0x00000040
460800 更多...
#define | MV_FG_BAUDRATE_921600 0x00000080
921600 更多...
#define | MV_FG_BAUDRATE_AUTOMAX 0x40000000
自动协商至相机支持的最大值 更多...
#define | MV_FG_PIXEL_MONO 0x01000000
Mono格式 更多...
#define | MV_FG_PIXEL_COLOR 0x02000000
彩色格式 更多...
#define | MV_FG_PIXEL_CUSTOM 0x80000000
自定义 更多...
#define | MV_FG_PIXEL_BIT_COUNT(n) ((n) << 16)
位个数所在位置 更多...
#define | MV_FG_GEV_IFCONFIG_LLA_BIT 0x00000004
GigE Vision设备LLA使能标志位 更多...
#define | MV_FG_GEV_IFCONFIG_LLA_BIT 0x00000004
GigE Vision设备LLA使能标志位 更多...
#define | MV_FG_GEV_IFCONFIG_DHCP_BIT 0x00000002
GigE Vision设备DHCP使能标志位 更多...
#define | MV_FG_GEV_IFCONFIG_DHCP_BIT 0x00000002
GigE Vision设备DHCP使能标志位 更多...
#define | MV_FG_GEV_IFCONFIG_PERSISTENT_BIT 0x00000001
GigE Vision设备静态IP使能标志位 更多...
#define | MV_FG_GEV_IFCONFIG_PERSISTENT_BIT 0x00000001
GigE Vision设备静态IP使能标志位 更多...
#define | MV_FG_GEV_IFCONFIG_PR_BIT 0x80000000
GigE Vision设备能否处理PAUSE帧标志位 更多...
#define | MV_FG_GEV_IFCONFIG_PR_BIT 0x80000000
GigE Vision设备能否处理PAUSE帧标志位 更多...
#define | MV_FG_GEV_IFCONFIG_PG_BIT 0x40000000
GigE Vision设备能否生成PAUSE帧标志位 更多...
#define | MV_FG_GEV_IFCONFIG_PG_BIT 0x40000000
GigE Vision设备能否生成PAUSE帧标志位 更多...
#define | MV_FG_MAX_DEV_INFO_SIZE 64
设备信息的最大长度 更多...

类型定义

typedef void * | IFHANDLE
采集卡句柄 更多...
typedef void * | DEVHANDLE
设备句柄 更多...
typedef void * | STREAMHANDLE
取流句柄 更多...
typedef void * | BUFFERHANDLE
缓存句柄 更多...
typedef void * | PORTHANDLE
参数句柄，可以使用采集卡/设备/流句柄 更多...
typedef void * | IMAGEHANDLE
图像句柄，可以使用采集卡/设备/流句柄 更多...
typedef void(__stdcall * | MV_FG_FrameCallBack) (MV_FG_BUFFER_INFO *pstBufferInfo, void *pUser)
帧缓存信息回调函数 更多...
typedef void(__stdcall * | MV_FG_ExceptionCallBack) (MV_FG_EXCEPTION_TYPE enExceptionType, void *pUser)
异常信息回调函数 更多...
typedef void(__stdcall * | MV_FG_EventCallBack) (MV_FG_EVENT_INFO *pstEventInfo, void *pUser)
事件回调函数 更多...
typedef struct MV_CXP_INTERFACE_INFO | MV_CXP_INTERFACE_INFO
CoaXPress采集卡信息 更多...
typedef struct MV_GEV_INTERFACE_INFO | MV_GEV_INTERFACE_INFO
GigE Vision采集卡信息 更多...
typedef struct MV_CML_INTERFACE_INFO | MV_CML_INTERFACE_INFO
Camera Link采集卡信息 更多...
typedef struct MV_FG_INTERFACE_INFO | MV_FG_INTERFACE_INFO
采集卡信息 更多...
typedef struct MV_CXP_DEVICE_INFO | MV_CXP_DEVICE_INFO
CoaXPress设备信息 更多...
typedef struct MV_GEV_DEVICE_INFO | MV_GEV_DEVICE_INFO
GigE Vision设备信息 更多...
typedef struct MV_CML_DEVICE_INFO | MV_CML_DEVICE_INFO
Camera Link设备信息 更多...
typedef struct MV_FG_DEVICE_INFO | MV_FG_DEVICE_INFO
设备信息 更多...

详细描述

宏定义说明

◆ MV_FG_GEV_INTERFACE

#define MV_FG_GEV_INTERFACE 0x00000001

GigE Vision采集卡

◆ MV_FG_U3V_INTERFACE

#define MV_FG_U3V_INTERFACE 0x00000002

U3V采集卡

◆ MV_FG_CAMERALINK_INTERFACE

#define MV_FG_CAMERALINK_INTERFACE 0x00000004

Camera Link采集卡

◆ MV_FG_CXP_INTERFACE

#define MV_FG_CXP_INTERFACE 0x00000008

CoaXPress采集卡

◆ MV_FG_GEV_DEVICE

#define MV_FG_GEV_DEVICE 0x00000001

GigE Vision设备

◆ MV_FG_U3V_DEVICE

#define MV_FG_U3V_DEVICE 0x00000002

U3V设备

◆ MV_FG_CAMERALINK_DEVICE

#define MV_FG_CAMERALINK_DEVICE 0x00000003

Camera Link设备

◆ MV_FG_CXP_DEVICE

#define MV_FG_CXP_DEVICE 0x00000004

CoaXPress设备

◆ MV_FG_MAX_IF_INFO_SIZE

#define MV_FG_MAX_IF_INFO_SIZE 64

卡信息的字符串最大长度

◆ MV_FG_ACCESS_UNKNOWN

#define MV_FG_ACCESS_UNKNOWN 0x0

权限未定义

◆ MV_FG_ACCESS_READONLY

#define MV_FG_ACCESS_READONLY 0x1

只读权限，无法设置或者获取节点值

◆ MV_FG_ACCESS_CONTROL

#define MV_FG_ACCESS_CONTROL 0x2

控制权限

◆ MV_FG_MAX_SPLIT_NUM

#define MV_FG_MAX_SPLIT_NUM 8

最多将源图像拆分的个数

◆ MV_FG_ROTATE_MODE

#define MV_FG_ROTATE_MODE 0x1000

旋转方式

◆ MV_FG_FLIP_MODE

#define MV_FG_FLIP_MODE 0x2000

翻转方式

◆ MV_FG_SPLIT_BY_LINE_MODE

#define MV_FG_SPLIT_BY_LINE_MODE 0x3000

按行拆分方式

◆ MV_FG_MAX_EVENT_NAME_SIZE

#define MV_FG_MAX_EVENT_NAME_SIZE 128

事件名称最大长度

◆ MV_FG_MAX_SYMBOLIC_NUM

#define MV_FG_MAX_SYMBOLIC_NUM 64

XML描述文件中的最大符号数

◆ MV_FG_MAX_SYMBOLIC_STRLEN

#define MV_FG_MAX_SYMBOLIC_STRLEN 64

XML描述文件的符号最大长度

◆ MV_FG_BAUDRATE_9600

#define MV_FG_BAUDRATE_9600 0x00000001

9600

◆ MV_FG_BAUDRATE_19200

#define MV_FG_BAUDRATE_19200 0x00000002

19200

◆ MV_FG_BAUDRATE_38400

#define MV_FG_BAUDRATE_38400 0x00000004

38400

◆ MV_FG_BAUDRATE_57600

#define MV_FG_BAUDRATE_57600 0x00000008

57600

◆ MV_FG_BAUDRATE_115200

#define MV_FG_BAUDRATE_115200 0x00000010

115200

◆ MV_FG_BAUDRATE_230400

#define MV_FG_BAUDRATE_230400 0x00000020

230400

◆ MV_FG_BAUDRATE_460800

#define MV_FG_BAUDRATE_460800 0x00000040

460800

◆ MV_FG_BAUDRATE_921600

#define MV_FG_BAUDRATE_921600 0x00000080

921600

◆ MV_FG_BAUDRATE_AUTOMAX

#define MV_FG_BAUDRATE_AUTOMAX 0x40000000

自动协商至相机支持的最大值

◆ MV_FG_PIXEL_MONO

#define MV_FG_PIXEL_MONO 0x01000000

Mono格式

◆ MV_FG_PIXEL_COLOR

#define MV_FG_PIXEL_COLOR 0x02000000

彩色格式

◆ MV_FG_PIXEL_CUSTOM

#define MV_FG_PIXEL_CUSTOM 0x80000000

自定义

◆ MV_FG_PIXEL_BIT_COUNT

#define MV_FG_PIXEL_BIT_COUNT ( n ) ((n) << 16)

位个数所在位置

◆ MV_FG_GEV_IFCONFIG_LLA_BIT [1/2]

#define MV_FG_GEV_IFCONFIG_LLA_BIT 0x00000004

GigE Vision设备LLA使能标志位

◆ MV_FG_GEV_IFCONFIG_LLA_BIT [2/2]

#define MV_FG_GEV_IFCONFIG_LLA_BIT 0x00000004

GigE Vision设备LLA使能标志位

◆ MV_FG_GEV_IFCONFIG_DHCP_BIT [1/2]

#define MV_FG_GEV_IFCONFIG_DHCP_BIT 0x00000002

GigE Vision设备DHCP使能标志位

◆ MV_FG_GEV_IFCONFIG_DHCP_BIT [2/2]

#define MV_FG_GEV_IFCONFIG_DHCP_BIT 0x00000002

GigE Vision设备DHCP使能标志位

◆ MV_FG_GEV_IFCONFIG_PERSISTENT_BIT [1/2]

#define MV_FG_GEV_IFCONFIG_PERSISTENT_BIT 0x00000001

GigE Vision设备静态IP使能标志位

◆ MV_FG_GEV_IFCONFIG_PERSISTENT_BIT [2/2]

#define MV_FG_GEV_IFCONFIG_PERSISTENT_BIT 0x00000001

GigE Vision设备静态IP使能标志位

◆ MV_FG_GEV_IFCONFIG_PR_BIT [1/2]

#define MV_FG_GEV_IFCONFIG_PR_BIT 0x80000000

GigE Vision设备能否处理PAUSE帧标志位

◆ MV_FG_GEV_IFCONFIG_PR_BIT [2/2]

#define MV_FG_GEV_IFCONFIG_PR_BIT 0x80000000

GigE Vision设备能否处理PAUSE帧标志位

◆ MV_FG_GEV_IFCONFIG_PG_BIT [1/2]

#define MV_FG_GEV_IFCONFIG_PG_BIT 0x40000000

GigE Vision设备能否生成PAUSE帧标志位

◆ MV_FG_GEV_IFCONFIG_PG_BIT [2/2]

#define MV_FG_GEV_IFCONFIG_PG_BIT 0x40000000

GigE Vision设备能否生成PAUSE帧标志位

◆ MV_FG_MAX_DEV_INFO_SIZE

#define MV_FG_MAX_DEV_INFO_SIZE 64

设备信息的最大长度

类型定义说明

◆ IFHANDLE

typedef void* IFHANDLE

采集卡句柄

◆ DEVHANDLE

typedef void* DEVHANDLE

设备句柄

◆ STREAMHANDLE

typedef void* STREAMHANDLE

取流句柄

◆ BUFFERHANDLE

typedef void* BUFFERHANDLE

缓存句柄

◆ PORTHANDLE

typedef void* PORTHANDLE

参数句柄，可以使用采集卡/设备/流句柄

◆ IMAGEHANDLE

typedef void* IMAGEHANDLE

图像句柄，可以使用采集卡/设备/流句柄

◆ MV_FG_FrameCallBack

typedef void(__stdcall * MV_FG_FrameCallBack) (MV_FG_BUFFER_INFO *pstBufferInfo, void *pUser)

帧缓存信息回调函数

◆ MV_FG_ExceptionCallBack

typedef void(__stdcall * MV_FG_ExceptionCallBack) (MV_FG_EXCEPTION_TYPE enExceptionType, void *pUser)

异常信息回调函数

◆ MV_FG_EventCallBack

typedef void(__stdcall * MV_FG_EventCallBack) (MV_FG_EVENT_INFO *pstEventInfo, void *pUser)

事件回调函数

◆ MV_CXP_INTERFACE_INFO

typedef struct MV_CXP_INTERFACE_INFO MV_CXP_INTERFACE_INFO

CoaXPress采集卡信息

◆ MV_GEV_INTERFACE_INFO

typedef struct MV_GEV_INTERFACE_INFO MV_GEV_INTERFACE_INFO

GigE Vision采集卡信息

◆ MV_CML_INTERFACE_INFO

typedef struct MV_CML_INTERFACE_INFO MV_CML_INTERFACE_INFO

Camera Link采集卡信息

◆ MV_FG_INTERFACE_INFO

typedef struct MV_FG_INTERFACE_INFO MV_FG_INTERFACE_INFO

采集卡信息

◆ MV_CXP_DEVICE_INFO

typedef struct MV_CXP_DEVICE_INFO MV_CXP_DEVICE_INFO

CoaXPress设备信息

◆ MV_GEV_DEVICE_INFO

typedef struct MV_GEV_DEVICE_INFO MV_GEV_DEVICE_INFO

GigE Vision设备信息

◆ MV_CML_DEVICE_INFO

typedef struct MV_CML_DEVICE_INFO MV_CML_DEVICE_INFO

Camera Link设备信息

◆ MV_FG_DEVICE_INFO

typedef struct MV_FG_DEVICE_INFO MV_FG_DEVICE_INFO

设备信息


Public 属性 | 所有成员列表
MV_CXP_INTERFACE_INFO结构体 参考
宏定义

CoaXPress采集卡信息 更多...

Public 属性

unsigned char | chInterfaceID [MV_FG_MAX_IF_INFO_SIZE]
采集卡ID 更多...
unsigned char | chDisplayName [MV_FG_MAX_IF_INFO_SIZE]
显示名称 更多...
unsigned char | chSerialNumber [MV_FG_MAX_IF_INFO_SIZE]
序列号 更多...
unsigned int | nPCIEInfo
采集卡的PCIE插槽信息 更多...
unsigned int | nReserved [64]
保留字段 更多...

详细描述

CoaXPress采集卡信息

类成员变量说明

◆ chInterfaceID

unsigned char MV_CXP_INTERFACE_INFO::chInterfaceID[MV_FG_MAX_IF_INFO_SIZE]

采集卡ID

◆ chDisplayName

unsigned char MV_CXP_INTERFACE_INFO::chDisplayName[MV_FG_MAX_IF_INFO_SIZE]

显示名称

◆ chSerialNumber

unsigned char MV_CXP_INTERFACE_INFO::chSerialNumber[MV_FG_MAX_IF_INFO_SIZE]

序列号

◆ nPCIEInfo

unsigned int MV_CXP_INTERFACE_INFO::nPCIEInfo

采集卡的PCIE插槽信息

◆ nReserved

unsigned int MV_CXP_INTERFACE_INFO::nReserved[64]

保留字段


Public 属性 | 所有成员列表
MV_GEV_INTERFACE_INFO结构体 参考
宏定义

GigE Vision采集卡信息 更多...

Public 属性

unsigned char | chInterfaceID [MV_FG_MAX_IF_INFO_SIZE]
采集卡ID 更多...
unsigned char | chDisplayName [MV_FG_MAX_IF_INFO_SIZE]
显示名称 更多...
unsigned char | chSerialNumber [MV_FG_MAX_IF_INFO_SIZE]
序列号 更多...
unsigned int | nPCIEInfo
采集卡的PCIE插槽信息 更多...
unsigned int | nReserved [64]
保留字段 更多...

详细描述

GigE Vision采集卡信息

类成员变量说明

◆ chInterfaceID

unsigned char MV_GEV_INTERFACE_INFO::chInterfaceID[MV_FG_MAX_IF_INFO_SIZE]

采集卡ID

◆ chDisplayName

unsigned char MV_GEV_INTERFACE_INFO::chDisplayName[MV_FG_MAX_IF_INFO_SIZE]

显示名称

◆ chSerialNumber

unsigned char MV_GEV_INTERFACE_INFO::chSerialNumber[MV_FG_MAX_IF_INFO_SIZE]

序列号

◆ nPCIEInfo

unsigned int MV_GEV_INTERFACE_INFO::nPCIEInfo

采集卡的PCIE插槽信息

◆ nReserved

unsigned int MV_GEV_INTERFACE_INFO::nReserved[64]

保留字段


Public 属性 | 所有成员列表
MV_CML_INTERFACE_INFO结构体 参考
宏定义

Camera Link采集卡信息 更多...

Public 属性

unsigned char | chInterfaceID [MV_FG_MAX_IF_INFO_SIZE]
采集卡ID 更多...
unsigned char | chDisplayName [MV_FG_MAX_IF_INFO_SIZE]
显示名称 更多...
unsigned char | chSerialNumber [MV_FG_MAX_IF_INFO_SIZE]
序列号 更多...
unsigned int | nPCIEInfo
采集卡的PCIE插槽信息 更多...
unsigned int | nReserved [64]
预留 更多...

详细描述

Camera Link采集卡信息

类成员变量说明

◆ chInterfaceID

unsigned char MV_CML_INTERFACE_INFO::chInterfaceID[MV_FG_MAX_IF_INFO_SIZE]

采集卡ID

◆ chDisplayName

unsigned char MV_CML_INTERFACE_INFO::chDisplayName[MV_FG_MAX_IF_INFO_SIZE]

显示名称

◆ chSerialNumber

unsigned char MV_CML_INTERFACE_INFO::chSerialNumber[MV_FG_MAX_IF_INFO_SIZE]

序列号

◆ nPCIEInfo

unsigned int MV_CML_INTERFACE_INFO::nPCIEInfo

采集卡的PCIE插槽信息

◆ nReserved

unsigned int MV_CML_INTERFACE_INFO::nReserved[64]

预留


Public 属性 | 所有成员列表
MV_FG_INTERFACE_INFO结构体 参考
宏定义

采集卡信息 更多...

Public 属性

unsigned int | nTLayerType
采集卡类型 更多...
unsigned int | nReserved [4]
保留字段 更多...
union {
MV_CXP_INTERFACE_INFO stCXPIfaceInfo
CoaXPress采集卡信息 更多...
MV_GEV_INTERFACE_INFO stGEVIfaceInfo
GigE Vision采集卡信息 更多...
MV_CML_INTERFACE_INFO stCMLIfaceInfo
Camera Link采集卡信息 更多...
unsigned int nReserved [256]
保留字段 更多...
} IfaceInfo

详细描述

采集卡信息

类成员变量说明

◆ nTLayerType

unsigned int MV_FG_INTERFACE_INFO::nTLayerType

采集卡类型

◆ nReserved

unsigned int MV_FG_INTERFACE_INFO::nReserved[256]

保留字段

◆ stCXPIfaceInfo

MV_CXP_INTERFACE_INFO MV_FG_INTERFACE_INFO::stCXPIfaceInfo

CoaXPress采集卡信息

◆ stGEVIfaceInfo

MV_GEV_INTERFACE_INFO MV_FG_INTERFACE_INFO::stGEVIfaceInfo

GigE Vision采集卡信息

◆ stCMLIfaceInfo

MV_CML_INTERFACE_INFO MV_FG_INTERFACE_INFO::stCMLIfaceInfo

Camera Link采集卡信息

◆ IfaceInfo

union { ... } MV_FG_INTERFACE_INFO::IfaceInfo


Public 属性 | 所有成员列表
MV_CXP_DEVICE_INFO结构体 参考
宏定义

CoaXPress设备信息 更多...

Public 属性

unsigned char | chVendorName [MV_FG_MAX_DEV_INFO_SIZE]
供应商名字 更多...
unsigned char | chModelName [MV_FG_MAX_DEV_INFO_SIZE]
型号名字 更多...
unsigned char | chManufacturerInfo [MV_FG_MAX_DEV_INFO_SIZE]
厂商信息 更多...
unsigned char | chDeviceVersion [MV_FG_MAX_DEV_INFO_SIZE]
设备版本 更多...
unsigned char | chSerialNumber [MV_FG_MAX_DEV_INFO_SIZE]
序列号 更多...
unsigned char | chUserDefinedName [MV_FG_MAX_DEV_INFO_SIZE]
用户自定义名字 更多...
unsigned char | chDeviceID [MV_FG_MAX_DEV_INFO_SIZE]
设备ID 更多...
unsigned int | nReserved [48]
保留字段 更多...

详细描述

CoaXPress设备信息

类成员变量说明

◆ chVendorName

unsigned char MV_CXP_DEVICE_INFO::chVendorName[MV_FG_MAX_DEV_INFO_SIZE]

供应商名字

◆ chModelName

unsigned char MV_CXP_DEVICE_INFO::chModelName[MV_FG_MAX_DEV_INFO_SIZE]

型号名字

◆ chManufacturerInfo

unsigned char MV_CXP_DEVICE_INFO::chManufacturerInfo[MV_FG_MAX_DEV_INFO_SIZE]

厂商信息

◆ chDeviceVersion

unsigned char MV_CXP_DEVICE_INFO::chDeviceVersion[MV_FG_MAX_DEV_INFO_SIZE]

设备版本

◆ chSerialNumber

unsigned char MV_CXP_DEVICE_INFO::chSerialNumber[MV_FG_MAX_DEV_INFO_SIZE]

序列号

◆ chUserDefinedName

unsigned char MV_CXP_DEVICE_INFO::chUserDefinedName[MV_FG_MAX_DEV_INFO_SIZE]

用户自定义名字

◆ chDeviceID

unsigned char MV_CXP_DEVICE_INFO::chDeviceID[MV_FG_MAX_DEV_INFO_SIZE]

设备ID

◆ nReserved

unsigned int MV_CXP_DEVICE_INFO::nReserved[48]

保留字段


Public 属性 | 所有成员列表
MV_GEV_DEVICE_INFO结构体 参考
宏定义

GigE Vision设备信息 更多...

Public 属性

unsigned int | nIpCfgOption
支持的IP配置 更多...
unsigned int | nIpCfgCurrent
当前IP配置，参考支持的IP配置说明 更多...
unsigned int | nCurrentIp
当前IP地址 更多...
unsigned int | nCurrentSubNetMask
当前子网掩码 更多...
unsigned int | nDefultGateWay
当前网关 更多...
unsigned int | nNetExport
网口IP地址 更多...
uint64_t | nMacAddress
MAC地址 更多...
unsigned char | chVendorName [MV_FG_MAX_DEV_INFO_SIZE]
供应商名字 更多...
unsigned char | chModelName [MV_FG_MAX_DEV_INFO_SIZE]
型号名字 更多...
unsigned char | chManufacturerInfo [MV_FG_MAX_DEV_INFO_SIZE]
厂商信息 更多...
unsigned char | chDeviceVersion [MV_FG_MAX_DEV_INFO_SIZE]
设备版本 更多...
unsigned char | chSerialNumber [MV_FG_MAX_DEV_INFO_SIZE]
序列号 更多...
unsigned char | chUserDefinedName [MV_FG_MAX_DEV_INFO_SIZE]
用户自定义名字 更多...
unsigned char | chDeviceID [MV_FG_MAX_DEV_INFO_SIZE]
设备ID 更多...
unsigned int | nReserved [48]
保留字段 更多...

详细描述

GigE Vision设备信息

类成员变量说明

◆ nIpCfgOption

unsigned int MV_GEV_DEVICE_INFO::nIpCfgOption

支持的IP配置

◆ nIpCfgCurrent

unsigned int MV_GEV_DEVICE_INFO::nIpCfgCurrent

当前IP配置，参考支持的IP配置说明

◆ nCurrentIp

unsigned int MV_GEV_DEVICE_INFO::nCurrentIp

当前IP地址

◆ nCurrentSubNetMask

unsigned int MV_GEV_DEVICE_INFO::nCurrentSubNetMask

当前子网掩码

◆ nDefultGateWay

unsigned int MV_GEV_DEVICE_INFO::nDefultGateWay

当前网关

◆ nNetExport

unsigned int MV_GEV_DEVICE_INFO::nNetExport

网口IP地址

◆ nMacAddress

uint64_t MV_GEV_DEVICE_INFO::nMacAddress

MAC地址

◆ chVendorName

unsigned char MV_GEV_DEVICE_INFO::chVendorName[MV_FG_MAX_DEV_INFO_SIZE]

供应商名字

◆ chModelName

unsigned char MV_GEV_DEVICE_INFO::chModelName[MV_FG_MAX_DEV_INFO_SIZE]

型号名字

◆ chManufacturerInfo

unsigned char MV_GEV_DEVICE_INFO::chManufacturerInfo[MV_FG_MAX_DEV_INFO_SIZE]

厂商信息

◆ chDeviceVersion

unsigned char MV_GEV_DEVICE_INFO::chDeviceVersion[MV_FG_MAX_DEV_INFO_SIZE]

设备版本

◆ chSerialNumber

unsigned char MV_GEV_DEVICE_INFO::chSerialNumber[MV_FG_MAX_DEV_INFO_SIZE]

序列号

◆ chUserDefinedName

unsigned char MV_GEV_DEVICE_INFO::chUserDefinedName[MV_FG_MAX_DEV_INFO_SIZE]

用户自定义名字

◆ chDeviceID

unsigned char MV_GEV_DEVICE_INFO::chDeviceID[MV_FG_MAX_DEV_INFO_SIZE]

设备ID

◆ nReserved

unsigned int MV_GEV_DEVICE_INFO::nReserved[48]

保留字段


Public 属性 | 所有成员列表
MV_CML_DEVICE_INFO结构体 参考
宏定义

Camera Link设备信息 更多...

Public 属性

unsigned char | chVendorName [MV_FG_MAX_DEV_INFO_SIZE]
供应商名字 更多...
unsigned char | chModelName [MV_FG_MAX_DEV_INFO_SIZE]
型号名字 更多...
unsigned char | chManufacturerInfo [MV_FG_MAX_DEV_INFO_SIZE]
厂商信息 更多...
unsigned char | chDeviceVersion [MV_FG_MAX_DEV_INFO_SIZE]
设备版本 更多...
unsigned char | chSerialNumber [MV_FG_MAX_DEV_INFO_SIZE]
序列号 更多...
unsigned char | chUserDefinedName [MV_FG_MAX_DEV_INFO_SIZE]
用户自定义名字 更多...
unsigned char | chDeviceID [MV_FG_MAX_DEV_INFO_SIZE]
设备ID 更多...
unsigned int | nReserved [48]
保留字段 更多...

详细描述

Camera Link设备信息

类成员变量说明

◆ chVendorName

unsigned char MV_CML_DEVICE_INFO::chVendorName[MV_FG_MAX_DEV_INFO_SIZE]

供应商名字

◆ chModelName

unsigned char MV_CML_DEVICE_INFO::chModelName[MV_FG_MAX_DEV_INFO_SIZE]

型号名字

◆ chManufacturerInfo

unsigned char MV_CML_DEVICE_INFO::chManufacturerInfo[MV_FG_MAX_DEV_INFO_SIZE]

厂商信息

◆ chDeviceVersion

unsigned char MV_CML_DEVICE_INFO::chDeviceVersion[MV_FG_MAX_DEV_INFO_SIZE]

设备版本

◆ chSerialNumber

unsigned char MV_CML_DEVICE_INFO::chSerialNumber[MV_FG_MAX_DEV_INFO_SIZE]

序列号

◆ chUserDefinedName

unsigned char MV_CML_DEVICE_INFO::chUserDefinedName[MV_FG_MAX_DEV_INFO_SIZE]

用户自定义名字

◆ chDeviceID

unsigned char MV_CML_DEVICE_INFO::chDeviceID[MV_FG_MAX_DEV_INFO_SIZE]

设备ID

◆ nReserved

unsigned int MV_CML_DEVICE_INFO::nReserved[48]

保留字段


Public 属性 | 所有成员列表
MV_FG_DEVICE_INFO结构体 参考
宏定义

设备信息 更多...

Public 属性

unsigned int | nDevType
设备类型 更多...
unsigned int | nReserved [3]
保留字段 更多...
union {
MV_CXP_DEVICE_INFO stCXPDevInfo
CoaXPress设备信息 更多...
MV_GEV_DEVICE_INFO stGEVDevInfo
GEV设备信息 更多...
MV_CML_DEVICE_INFO stCMLDevInfo
Camera Link设备信息 更多...
unsigned int nReserved [256]
保留字段 更多...
} DevInfo
设备信息联合体，根据nDevType来确定要使用的字段 更多...

详细描述

设备信息

类成员变量说明

◆ nDevType

unsigned int MV_FG_DEVICE_INFO::nDevType

设备类型

◆ nReserved

unsigned int MV_FG_DEVICE_INFO::nReserved[256]

保留字段

◆ stCXPDevInfo

MV_CXP_DEVICE_INFO MV_FG_DEVICE_INFO::stCXPDevInfo

CoaXPress设备信息

◆ stGEVDevInfo

MV_GEV_DEVICE_INFO MV_FG_DEVICE_INFO::stGEVDevInfo

GEV设备信息

◆ stCMLDevInfo

MV_CML_DEVICE_INFO MV_FG_DEVICE_INFO::stCMLDevInfo

Camera Link设备信息

◆ DevInfo

union { ... } MV_FG_DEVICE_INFO::DevInfo

设备信息联合体，根据nDevType来确定要使用的字段


类型定义 | 枚举
枚举类型定义

类型定义

typedef enum MV_FG_BUFFER_QUEUE_TYPE | MV_FG_BUFFER_QUEUE_TYPE
缓存队列类型 更多...
typedef enum MV_FG_PIXEL_TYPE | MV_FG_PIXEL_TYPE
像素格式 更多...
typedef enum MV_FG_CFA_METHOD | MV_FG_CFA_METHOD
插值方法 更多...
typedef enum MV_FG_GAMMA_TYPE | MV_FG_GAMMA_TYPE
Gamma类型 更多...
typedef enum MV_FG_RECONSTRUCT_MODE | MV_FG_RECONSTRUCT_MODE
typedef enum MV_FG_NODE_ACCESS_MODE | MV_FG_NODE_ACCESS_MODE
节点权限 更多...
typedef enum MV_FG_NODE_INTERFACE_TYPE | MV_FG_NODE_INTERFACE_TYPE
节点类型 更多...
typedef enum MV_FG_CONFIG_CMD | MV_FG_CONFIG_CMD
配置指令 更多...
typedef enum MV_FG_EXCEPTION_TYPE | MV_FG_EXCEPTION_TYPE
异常信息类型 更多...

枚举

enum MV_FG_BUFFER_QUEUE_TYPE {
MV_FG_BUFFER_QUEUE_INPUT_TO_OUTPUT = 0,
MV_FG_BUFFER_QUEUE_OUTPUT_DISCARD = 1,
MV_FG_BUFFER_QUEUE_ALL_TO_INPUT = 2,
MV_FG_BUFFER_QUEUE_UNQUEUED_TO_INPUT = 3,
MV_FG_BUFFER_QUEUE_ALL_DISCARD = 4
}
缓存队列类型 更多...
enum MV_FG_PIXEL_TYPE {
MV_FG_PIXEL_TYPE_Undefined = 0xFFFFFFFF,
MV_FG_PIXEL_TYPE_Mono8 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(8) | 0x0001),
MV_FG_PIXEL_TYPE_Mono10 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x0003),
MV_FG_PIXEL_TYPE_Mono10_Packed = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(12) | 0x0004),
MV_FG_PIXEL_TYPE_Mono12 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x0005),
MV_FG_PIXEL_TYPE_Mono12_Packed = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(12) | 0x0006),
MV_FG_PIXEL_TYPE_Mono16 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x0007),
MV_FG_PIXEL_TYPE_BayerGR8 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(8) | 0x0008),
MV_FG_PIXEL_TYPE_BayerRG8 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(8) | 0x0009),
MV_FG_PIXEL_TYPE_BayerGB8 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(8) | 0x000A),
MV_FG_PIXEL_TYPE_BayerBG8 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(8) | 0x000B),
MV_FG_PIXEL_TYPE_BayerGR10 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x000C),
MV_FG_PIXEL_TYPE_BayerRG10 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x000D),
MV_FG_PIXEL_TYPE_BayerGB10 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x000E),
MV_FG_PIXEL_TYPE_BayerBG10 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x000F),
MV_FG_PIXEL_TYPE_BayerGR12 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x0010),
MV_FG_PIXEL_TYPE_BayerRG12 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x0011),
MV_FG_PIXEL_TYPE_BayerGB12 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x0012),
MV_FG_PIXEL_TYPE_BayerBG12 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x0013),
MV_FG_PIXEL_TYPE_BayerGR10_Packed = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(12) | 0x0026),
MV_FG_PIXEL_TYPE_BayerRG10_Packed = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(12) | 0x0027),
MV_FG_PIXEL_TYPE_BayerGB10_Packed = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(12) | 0x0028),
MV_FG_PIXEL_TYPE_BayerBG10_Packed = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(12) | 0x0029),
MV_FG_PIXEL_TYPE_BayerGR12_Packed = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(12) | 0x002A),
MV_FG_PIXEL_TYPE_BayerRG12_Packed = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(12) | 0x002B),
MV_FG_PIXEL_TYPE_BayerGB12_Packed = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(12) | 0x002C),
MV_FG_PIXEL_TYPE_BayerBG12_Packed = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(12) | 0x002D),
MV_FG_PIXEL_TYPE_BayerGR16 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x002E),
MV_FG_PIXEL_TYPE_BayerRG16 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x002F),
MV_FG_PIXEL_TYPE_BayerGB16 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x0030),
MV_FG_PIXEL_TYPE_BayerBG16 = (MV_FG_PIXEL_MONO | MV_FG_PIXEL_BIT_COUNT(16) | 0x0031),
MV_FG_PIXEL_TYPE_RGB8_Packed = (MV_FG_PIXEL_COLOR | MV_FG_PIXEL_BIT_COUNT(24) | 0x0014),
MV_FG_PIXEL_TYPE_BGR8_Packed = (MV_FG_PIXEL_COLOR | MV_FG_PIXEL_BIT_COUNT(24) | 0x0015),
MV_FG_PIXEL_TYPE_RGBA8_Packed = (MV_FG_PIXEL_COLOR | MV_FG_PIXEL_BIT_COUNT(32) | 0x0016),
MV_FG_PIXEL_TYPE_BGRA8_Packed = (MV_FG_PIXEL_COLOR | MV_FG_PIXEL_BIT_COUNT(32) | 0x0017),
MV_FG_PIXEL_TYPE_RGB16_Packed = (MV_FG_PIXEL_COLOR | MV_FG_PIXEL_BIT_COUNT(48) | 0x0033),
MV_FG_PIXEL_TYPE_YUV422_Packed = (MV_FG_PIXEL_COLOR | MV_FG_PIXEL_BIT_COUNT(16) | 0x001F),
MV_FG_PIXEL_TYPE_YUV422_YUYV_Packed = (MV_FG_PIXEL_COLOR | MV_FG_PIXEL_BIT_COUNT(16) | 0x0032)
}
像素格式 更多...
enum MV_FG_CFA_METHOD {
MV_FG_CFA_METHOD_QUICK = 0,
MV_FG_CFA_METHOD_BALANCE = 1,
MV_FG_CFA_METHOD_OPTIMAL = 2
}
插值方法 更多...
enum MV_FG_GAMMA_TYPE {
MV_FG_GAMMA_TYPE_NONE = 0,
MV_FG_GAMMA_TYPE_VALUE = 1,
MV_FG_GAMMA_TYPE_USER_CURVE = 2,
MV_FG_GAMMA_TYPE_LRGB2SRGB = 3,
MV_FG_GAMMA_TYPE_SRGB2LRGB = 4
}
Gamma类型 更多...
enum MV_FG_RECONSTRUCT_MODE {
RECONSTRUCT_MODE_ROTATE_90 = (MV_FG_ROTATE_MODE | 0x0001),
RECONSTRUCT_MODE_ROTATE_180 = (MV_FG_ROTATE_MODE | 0x0002),
RECONSTRUCT_MODE_ROTATE_270 = (MV_FG_ROTATE_MODE | 0x0003),
RECONSTRUCT_MODE_FLIP_VERTICAL = (MV_FG_FLIP_MODE | 0x0001),
RECONSTRUCT_MODE_FLIP_HORIZONTAL = (MV_FG_FLIP_MODE | 0x0002),
RECONSTRUCT_MODE_SPLIT_BY_LINE_2 = (MV_FG_SPLIT_BY_LINE_MODE | 0x0002),
RECONSTRUCT_MODE_SPLIT_BY_LINE_3 = (MV_FG_SPLIT_BY_LINE_MODE | 0x0003),
RECONSTRUCT_MODE_SPLIT_BY_LINE_4 = (MV_FG_SPLIT_BY_LINE_MODE | 0x0004)
}
enum MV_FG_NODE_ACCESS_MODE {
ACCESS_MODE_NI = 0,
ACCESS_MODE_NA = 1,
ACCESS_MODE_WO = 2,
ACCESS_MODE_RO = 3,
ACCESS_MODE_RW = 4,
ACCESS_MODE_UNDEFINED = 5
}
节点权限 更多...
enum MV_FG_NODE_INTERFACE_TYPE {
INTERFACE_TYPE_Value = 0,
INTERFACE_TYPE_Base = 1,
INTERFACE_TYPE_Integer = 2,
INTERFACE_TYPE_Boolean = 3,
INTERFACE_TYPE_Command = 4,
INTERFACE_TYPE_Float = 5,
INTERFACE_TYPE_String = 6,
INTERFACE_TYPE_Register = 7,
INTERFACE_TYPE_Category = 8,
INTERFACE_TYPE_Enumeration = 9,
INTERFACE_TYPE_EnumEntry = 10,
INTERFACE_TYPE_Port = 11
}
节点类型 更多...
enum MV_FG_CONFIG_CMD { CONFIG_CMD_INT64_BAUDRATE = 1 }
配置指令 更多...
enum MV_FG_EXCEPTION_TYPE {
EXCEPTION_TYPE_SYSTEM_TEMPERATURE_UPLIMIT = 0x0080,
EXCEPTION_TYPE_SYSTEM_TEMPERATURE_LOWLIMIT = 0x0081,
EXCEPTION_TYPE_SYSTEM_DDR_INIT = 0x0082,
EXCEPTION_TYPE_CARD_PACKETBUF_ERR = 0x0180,
EXCEPTION_TYPE_CARD_ACKPACKETBUF_ERR = 0x0181,
EXCEPTION_TYPE_LINK0_STREAM_CRC_ERR = 0x1080,
EXCEPTION_TYPE_LINK0_STREAM_PACKET_RESEND = 0x1081,
EXCEPTION_TYPE_LINK0_STREAM_CTRLPACKET_ERR = 0x1082,
EXCEPTION_TYPE_LINK0_PRETREATBUF_ERR = 0x1090,
EXCEPTION_TYPE_LINK0_CAM_ACK_RECVBUF_ERR = 0x1091,
EXCEPTION_TYPE_LINK0_CAM_ACK_TRANSMITBUF_ERR = 0x1092,
EXCEPTION_TYPE_LINK1_STREAM_CRC_ERR = 0x1180,
EXCEPTION_TYPE_LINK1_STREAM_PACKET_RESEND = 0x1181,
EXCEPTION_TYPE_LINK1_STREAM_CTRLPACKET_ERR = 0x1182,
EXCEPTION_TYPE_LINK1_PRETREATBUF_ERR = 0x1190,
EXCEPTION_TYPE_LINK1_CAM_ACK_RECVBUF_ERR = 0x1191,
EXCEPTION_TYPE_LINK1_CAM_ACK_TRANSMITBUF_ERR = 0x1192,
EXCEPTION_TYPE_LINK2_STREAM_CRC_ERR = 0x1280,
EXCEPTION_TYPE_LINK2_STREAM_PACKET_RESEND = 0x1281,
EXCEPTION_TYPE_LINK2_STREAM_CTRLPACKET_ERR = 0x1282,
EXCEPTION_TYPE_LINK2_PRETREATBUF_ERR = 0x1290,
EXCEPTION_TYPE_LINK2_CAM_ACK_RECVBUF_ERR = 0x1291,
EXCEPTION_TYPE_LINK2_CAM_ACK_TRANSMITBUF_ERR = 0x1292,
EXCEPTION_TYPE_LINK3_STREAM_CRC_ERR = 0x1380,
EXCEPTION_TYPE_LINK3_STREAM_PACKET_RESEND = 0x1381,
EXCEPTION_TYPE_LINK3_STREAM_CTRLPACKET_ERR = 0x1382,
EXCEPTION_TYPE_LINK3_PRETREATBUF_ERR = 0x1390,
EXCEPTION_TYPE_LINK3_CAM_ACK_RECVBUF_ERR = 0x1391,
EXCEPTION_TYPE_LINK3_CAM_ACK_TRANSMITBUF_ERR = 0x1392,
EXCEPTION_TYPE_STREAM0_DROP_FRAME_IMAGE = 0x2080,
EXCEPTION_TYPE_STREAM0_IMAGE_DATACOUNT_ERR = 0x2081,
EXCEPTION_TYPE_STREAM0_DROP_FRAME_TRIGGER = 0x2082,
EXCEPTION_TYPE_STREAM0_QUEUEBUF_ERR = 0x2090,
EXCEPTION_TYPE_STREAM0_WDMABUF_ERR = 0x2091,
EXCEPTION_TYPE_STREAM0_RDMABUF_ERR = 0x2092,
EXCEPTION_TYPE_STREAM0_PACKETBUF_ERR = 0x2093,
EXCEPTION_TYPE_STREAM0_WDMALENGTH_ERR = 0x2094,
EXCEPTION_TYPE_STREAM0_RDMALENGTH_ERR = 0x2095,
EXCEPTION_TYPE_STREAM1_DROP_FRAME_IMAGE = 0x2180,
EXCEPTION_TYPE_STREAM1_IMAGE_DATACOUNT_ERR = 0x2181,
EXCEPTION_TYPE_STREAM1_DROP_FRAME_TRIGGER = 0x2182,
EXCEPTION_TYPE_STREAM1_QUEUEBUF_ERR = 0x2190,
EXCEPTION_TYPE_STREAM1_WDMABUF_ERR = 0x2191,
EXCEPTION_TYPE_STREAM1_RDMABUF_ERR = 0x2192,
EXCEPTION_TYPE_STREAM1_PACKETBUF_ERR = 0x2193,
EXCEPTION_TYPE_STREAM1_WDMALENGTH_ERR = 0x2194,
EXCEPTION_TYPE_STREAM1_RDMALENGTH_ERR = 0x2195,
EXCEPTION_TYPE_STREAM2_DROP_FRAME_IMAGE = 0x2280,
EXCEPTION_TYPE_STREAM2_IMAGE_DATACOUNT_ERR = 0x2281,
EXCEPTION_TYPE_STREAM2_DROP_FRAME_TRIGGER = 0x2282,
EXCEPTION_TYPE_STREAM2_QUEUEBUF_ERR = 0x2290,
EXCEPTION_TYPE_STREAM2_WDMABUF_ERR = 0x2291,
EXCEPTION_TYPE_STREAM2_RDMABUF_ERR = 0x2292,
EXCEPTION_TYPE_STREAM2_PACKETBUF_ERR = 0x2293,
EXCEPTION_TYPE_STREAM2_WDMALENGTH_ERR = 0x2294,
EXCEPTION_TYPE_STREAM2_RDMALENGTH_ERR = 0x2295,
EXCEPTION_TYPE_STREAM3_DROP_FRAME_IMAGE = 0x2380,
EXCEPTION_TYPE_STREAM3_IMAGE_DATACOUNT_ERR = 0x2381,
EXCEPTION_TYPE_STREAM3_DROP_FRAME_TRIGGER = 0x2382,
EXCEPTION_TYPE_STREAM3_QUEUEBUF_ERR = 0x2390,
EXCEPTION_TYPE_STREAM3_WDMABUF_ERR = 0x2391,
EXCEPTION_TYPE_STREAM3_RDMABUF_ERR = 0x2392,
EXCEPTION_TYPE_STREAM3_PACKETBUF_ERR = 0x2393,
EXCEPTION_TYPE_STREAM3_WDMALENGTH_ERR = 0x2394,
EXCEPTION_TYPE_STREAM3_RDMALENGTH_ERR = 0x2395,
EXCEPTION_TYPE_PCIE_SCHEDULEBUF_ERR = 0x3088,
EXCEPTION_TYPE_PCIE_SCHEDULE_ERR = 0x3089,
EXCEPTION_TYPE_PCIE_LINK0_RECVBUF_ERR = 0x3180,
EXCEPTION_TYPE_PCIE_LINK0_LENGTH_ERR = 0x3181,
EXCEPTION_TYPE_PCIE_LINK0_SOFT_RECVBUF_ERR = 0x3280,
EXCEPTION_TYPE_PCIE_LINK0_SOFT_LENGTH_ERR = 0x3281,
EXCEPTION_TYPE_PCIE_LINK1_RECVBUF_ERR = 0x3188,
EXCEPTION_TYPE_PCIE_LINK1_LENGTH_ERR = 0x3189,
EXCEPTION_TYPE_PCIE_LINK1_SOFT_RECVBUF_ERR = 0x3288,
EXCEPTION_TYPE_PCIE_LINK1_SOFT_LENGTH_ERR = 0x3289,
EXCEPTION_TYPE_PCIE_LINK2_RECVBUF_ERR = 0x3190,
EXCEPTION_TYPE_PCIE_LINK2_LENGTH_ERR = 0x3191,
EXCEPTION_TYPE_PCIE_LINK2_SOFT_RECVBUF_ERR = 0x3290,
EXCEPTION_TYPE_PCIE_LINK2_SOFT_LENGTH_ERR = 0x3291,
EXCEPTION_TYPE_PCIE_LINK3_RECVBUF_ERR = 0x3198,
EXCEPTION_TYPE_PCIE_LINK3_LENGTH_ERR = 0x3199,
EXCEPTION_TYPE_PCIE_LINK3_SOFT_RECVBUF_ERR = 0x3298,
EXCEPTION_TYPE_PCIE_LINK3_SOFT_LENGTH_ERR = 0x3299,
EXCEPTION_TYPE_PCIE_STREAM0_RECVBUF_ERR = 0x3382,
EXCEPTION_TYPE_PCIE_STREAM0_LIST_ERR = 0x3383,
EXCEPTION_TYPE_PCIE_STREAM0_SIZE_ERR = 0x3384,
EXCEPTION_TYPE_PCIE_STREAM1_RECVBUF_ERR = 0x338A,
EXCEPTION_TYPE_PCIE_STREAM1_LIST_ERR = 0x338B,
EXCEPTION_TYPE_PCIE_STREAM1_SIZE_ERR = 0x338C,
EXCEPTION_TYPE_PCIE_STREAM2_RECVBUF_ERR = 0x3392,
EXCEPTION_TYPE_PCIE_STREAM2_LIST_ERR = 0x3393,
EXCEPTION_TYPE_PCIE_STREAM2_SIZE_ERR = 0x3394,
EXCEPTION_TYPE_PCIE_STREAM3_RECVBUF_ERR = 0x339A,
EXCEPTION_TYPE_PCIE_STREAM3_LIST_ERR = 0x339B,
EXCEPTION_TYPE_PCIE_STREAM3_SIZE_ERR = 0x339C,
EXCEPTION_TYPE_CAMERA_DISCONNECT_ERR = 0x10000001
}
异常信息类型 更多...

详细描述

类型定义说明

◆ MV_FG_BUFFER_QUEUE_TYPE

typedef enum MV_FG_BUFFER_QUEUE_TYPE MV_FG_BUFFER_QUEUE_TYPE

缓存队列类型

◆ MV_FG_PIXEL_TYPE

typedef enum MV_FG_PIXEL_TYPE MV_FG_PIXEL_TYPE

像素格式

◆ MV_FG_CFA_METHOD

typedef enum MV_FG_CFA_METHOD MV_FG_CFA_METHOD

插值方法

◆ MV_FG_GAMMA_TYPE

typedef enum MV_FG_GAMMA_TYPE MV_FG_GAMMA_TYPE

Gamma类型

◆ MV_FG_RECONSTRUCT_MODE

typedef enum MV_FG_RECONSTRUCT_MODE MV_FG_RECONSTRUCT_MODE

重组方式

旋转和翻转只支持MV_FG_PIXEL_TYPE_Mono8、MV_FG_PIXEL_TYPE_RGB8_Packed、MV_FG_PIXEL_TYPE_BGR8_Packed三种像素格式

◆ MV_FG_NODE_ACCESS_MODE

typedef enum MV_FG_NODE_ACCESS_MODE MV_FG_NODE_ACCESS_MODE

节点权限

◆ MV_FG_NODE_INTERFACE_TYPE

typedef enum MV_FG_NODE_INTERFACE_TYPE MV_FG_NODE_INTERFACE_TYPE

节点类型

◆ MV_FG_CONFIG_CMD

typedef enum MV_FG_CONFIG_CMD MV_FG_CONFIG_CMD

配置指令

◆ MV_FG_EXCEPTION_TYPE

typedef enum MV_FG_EXCEPTION_TYPE MV_FG_EXCEPTION_TYPE

异常信息类型

枚举类型说明

◆ MV_FG_BUFFER_QUEUE_TYPE

enum MV_FG_BUFFER_QUEUE_TYPE

缓存队列类型

枚举值
MV_FG_BUFFER_QUEUE_INPUT_TO_OUTPUT | 将输入队列的BUFFER放到输出队列
MV_FG_BUFFER_QUEUE_OUTPUT_DISCARD | 放弃输出队列的BUFFER
MV_FG_BUFFER_QUEUE_ALL_TO_INPUT | 将所有的BUFFER(包括输出队列)放到输入队列
MV_FG_BUFFER_QUEUE_UNQUEUED_TO_INPUT | 将未使用的BUFFER放到输入队列
MV_FG_BUFFER_QUEUE_ALL_DISCARD | 放弃输入和输出队列中的BUFFER

◆ MV_FG_PIXEL_TYPE

enum MV_FG_PIXEL_TYPE

像素格式

枚举值
MV_FG_PIXEL_TYPE_Undefined | 未定义格式
MV_FG_PIXEL_TYPE_Mono8 | Mono8
MV_FG_PIXEL_TYPE_Mono10 | Mono10
MV_FG_PIXEL_TYPE_Mono10_Packed | Mono10_Packed
MV_FG_PIXEL_TYPE_Mono12 | Mono12
MV_FG_PIXEL_TYPE_Mono12_Packed | Mono12_Packed
MV_FG_PIXEL_TYPE_Mono16 | Mono16
MV_FG_PIXEL_TYPE_BayerGR8 | BayerGR8
MV_FG_PIXEL_TYPE_BayerRG8 | BayerRG8
MV_FG_PIXEL_TYPE_BayerGB8 | BayerGB8
MV_FG_PIXEL_TYPE_BayerBG8 | BayerBG8
MV_FG_PIXEL_TYPE_BayerGR10 | BayerGR10
MV_FG_PIXEL_TYPE_BayerRG10 | BayerRG10
MV_FG_PIXEL_TYPE_BayerGB10 | BayerGB10
MV_FG_PIXEL_TYPE_BayerBG10 | BayerBG10
MV_FG_PIXEL_TYPE_BayerGR12 | BayerGR12
MV_FG_PIXEL_TYPE_BayerRG12 | BayerRG12
MV_FG_PIXEL_TYPE_BayerGB12 | BayerGB12
MV_FG_PIXEL_TYPE_BayerBG12 | BayerBG12
MV_FG_PIXEL_TYPE_BayerGR10_Packed | BayerGR10_Packed
MV_FG_PIXEL_TYPE_BayerRG10_Packed | BayerRG10_Packed
MV_FG_PIXEL_TYPE_BayerGB10_Packed | BayerGB10_Packed
MV_FG_PIXEL_TYPE_BayerBG10_Packed | BayerBG10_Packed
MV_FG_PIXEL_TYPE_BayerGR12_Packed | BayerGR12_Packed
MV_FG_PIXEL_TYPE_BayerRG12_Packed | BayerRG12_Packed
MV_FG_PIXEL_TYPE_BayerGB12_Packed | BayerGB12_Packed
MV_FG_PIXEL_TYPE_BayerBG12_Packed | BayerBG12_Packed
MV_FG_PIXEL_TYPE_BayerGR16 | BayerGR16
MV_FG_PIXEL_TYPE_BayerRG16 | BayerRG16
MV_FG_PIXEL_TYPE_BayerGB16 | BayerGB16
MV_FG_PIXEL_TYPE_BayerBG16 | BayerBG16
MV_FG_PIXEL_TYPE_RGB8_Packed | RGB8_Packed
MV_FG_PIXEL_TYPE_BGR8_Packed | BGR8_Packed
MV_FG_PIXEL_TYPE_RGBA8_Packed | RGBA8_Packed
MV_FG_PIXEL_TYPE_BGRA8_Packed | BGRA8_Packed
MV_FG_PIXEL_TYPE_RGB16_Packed | RGB16_Packed
MV_FG_PIXEL_TYPE_YUV422_Packed | YUV422_Packed
MV_FG_PIXEL_TYPE_YUV422_YUYV_Packed | YUV422_YUYV_Packed

◆ MV_FG_CFA_METHOD

enum MV_FG_CFA_METHOD

插值方法

枚举值
MV_FG_CFA_METHOD_QUICK | 快速
MV_FG_CFA_METHOD_BALANCE | 均衡
MV_FG_CFA_METHOD_OPTIMAL | 最优

◆ MV_FG_GAMMA_TYPE

enum MV_FG_GAMMA_TYPE

Gamma类型

枚举值
MV_FG_GAMMA_TYPE_NONE | 不启用
MV_FG_GAMMA_TYPE_VALUE | Gamma值
MV_FG_GAMMA_TYPE_USER_CURVE | Gamma曲线 8位,长度：256*sizeof(unsigned char) 10位,长度：1024*sizeof(unsigned short) 12位,长度：4096*sizeof(unsigned short) 16位,长度：65536*sizeof(unsigned short)
MV_FG_GAMMA_TYPE_LRGB2SRGB | linear RGB to sRGB
MV_FG_GAMMA_TYPE_SRGB2LRGB | sRGB to linear RGB(仅色彩插值时支持，色彩校正时无效)

◆ MV_FG_RECONSTRUCT_MODE

enum MV_FG_RECONSTRUCT_MODE

重组方式

旋转和翻转只支持MV_FG_PIXEL_TYPE_Mono8、MV_FG_PIXEL_TYPE_RGB8_Packed、MV_FG_PIXEL_TYPE_BGR8_Packed三种像素格式

枚举值
RECONSTRUCT_MODE_ROTATE_90 | 旋转90度
RECONSTRUCT_MODE_ROTATE_180 | 旋转180度
RECONSTRUCT_MODE_ROTATE_270 | 旋转270度
RECONSTRUCT_MODE_FLIP_VERTICAL | 垂直翻转
RECONSTRUCT_MODE_FLIP_HORIZONTAL | 水平翻转
RECONSTRUCT_MODE_SPLIT_BY_LINE_2 | 按行拆分只支持对线阵相机采集的图像进行拆分 按行拆分成2张图像
RECONSTRUCT_MODE_SPLIT_BY_LINE_3 | 按行拆分成3张图像
RECONSTRUCT_MODE_SPLIT_BY_LINE_4 | 按行拆分成4张图像

◆ MV_FG_NODE_ACCESS_MODE

enum MV_FG_NODE_ACCESS_MODE

节点权限

枚举值
ACCESS_MODE_NI | Value不可实现
ACCESS_MODE_NA | Value不可用
ACCESS_MODE_WO | Value只写
ACCESS_MODE_RO | Value只读
ACCESS_MODE_RW | Value读写
ACCESS_MODE_UNDEFINED | Value未定义

◆ MV_FG_NODE_INTERFACE_TYPE

enum MV_FG_NODE_INTERFACE_TYPE

节点类型

枚举值
INTERFACE_TYPE_Value | Value
INTERFACE_TYPE_Base | Base
INTERFACE_TYPE_Integer | Integer
INTERFACE_TYPE_Boolean | Boolean
INTERFACE_TYPE_Command | Command
INTERFACE_TYPE_Float | Float
INTERFACE_TYPE_String | String
INTERFACE_TYPE_Register | Register
INTERFACE_TYPE_Category | Category
INTERFACE_TYPE_Enumeration | Enumeration
INTERFACE_TYPE_EnumEntry | EnumEntry
INTERFACE_TYPE_Port | Port

◆ MV_FG_CONFIG_CMD

enum MV_FG_CONFIG_CMD

配置指令

枚举值
CONFIG_CMD_INT64_BAUDRATE

波特率，整型

◆ MV_FG_EXCEPTION_TYPE

enum MV_FG_EXCEPTION_TYPE

异常信息类型

枚举值
EXCEPTION_TYPE_SYSTEM_TEMPERATURE_UPLIMIT | 温度上限
EXCEPTION_TYPE_SYSTEM_TEMPERATURE_LOWLIMIT | 温度下限限
EXCEPTION_TYPE_SYSTEM_DDR_INIT | DDR初始化失败
EXCEPTION_TYPE_CARD_PACKETBUF_ERR | 包缓存错误
EXCEPTION_TYPE_CARD_ACKPACKETBUF_ERR | 响应包缓存错误
EXCEPTION_TYPE_LINK0_STREAM_CRC_ERR | Link0 流CRC校验错误
EXCEPTION_TYPE_LINK0_STREAM_PACKET_RESEND | Link0 流重发包
EXCEPTION_TYPE_LINK0_STREAM_CTRLPACKET_ERR | Link0 控制包错误
EXCEPTION_TYPE_LINK0_PRETREATBUF_ERR | Link0 预处理缓存错误
EXCEPTION_TYPE_LINK0_CAM_ACK_RECVBUF_ERR | Link0 相机回包接收缓存错误
EXCEPTION_TYPE_LINK0_CAM_ACK_TRANSMITBUF_ERR | Link0 相机回包发送缓存错误
EXCEPTION_TYPE_LINK1_STREAM_CRC_ERR | Link1 流CRC校验错误
EXCEPTION_TYPE_LINK1_STREAM_PACKET_RESEND | Link1 流重发包
EXCEPTION_TYPE_LINK1_STREAM_CTRLPACKET_ERR | Link1 控制包错误
EXCEPTION_TYPE_LINK1_PRETREATBUF_ERR | Link1 预处理缓存错误
EXCEPTION_TYPE_LINK1_CAM_ACK_RECVBUF_ERR | Link1 相机回包接收缓存错误
EXCEPTION_TYPE_LINK1_CAM_ACK_TRANSMITBUF_ERR | Link1 相机回包发送缓存错误
EXCEPTION_TYPE_LINK2_STREAM_CRC_ERR | Link2 流CRC校验错误
EXCEPTION_TYPE_LINK2_STREAM_PACKET_RESEND | Link2 流重发包
EXCEPTION_TYPE_LINK2_STREAM_CTRLPACKET_ERR | Link2 控制包错误
EXCEPTION_TYPE_LINK2_PRETREATBUF_ERR | Link2 预处理缓存错误
EXCEPTION_TYPE_LINK2_CAM_ACK_RECVBUF_ERR | Link2 相机回包接收缓存错误
EXCEPTION_TYPE_LINK2_CAM_ACK_TRANSMITBUF_ERR | Link2 相机回包发送缓存错误
EXCEPTION_TYPE_LINK3_STREAM_CRC_ERR | Link3 流CRC校验错误
EXCEPTION_TYPE_LINK3_STREAM_PACKET_RESEND | Link3 流重发包
EXCEPTION_TYPE_LINK3_STREAM_CTRLPACKET_ERR | Link3 控制包错误
EXCEPTION_TYPE_LINK3_PRETREATBUF_ERR | Link3 预处理缓存错误
EXCEPTION_TYPE_LINK3_CAM_ACK_RECVBUF_ERR | Link3 相机回包接收缓存错误
EXCEPTION_TYPE_LINK3_CAM_ACK_TRANSMITBUF_ERR | Link3 相机回包发送缓存错误
EXCEPTION_TYPE_STREAM0_DROP_FRAME_IMAGE | STREAM0 卡端图像帧缓存丢弃
EXCEPTION_TYPE_STREAM0_IMAGE_DATACOUNT_ERR | STREAM0 接收图像（大小）计数异常
EXCEPTION_TYPE_STREAM0_DROP_FRAME_TRIGGER | STREAM0 卡端帧触发丢弃
EXCEPTION_TYPE_STREAM0_QUEUEBUF_ERR | STREAM0 QUEUE缓存异常
EXCEPTION_TYPE_STREAM0_WDMABUF_ERR | STREAM0 WDMA缓存异常
EXCEPTION_TYPE_STREAM0_RDMABUF_ERR | STREAM0 RDMA缓存异常
EXCEPTION_TYPE_STREAM0_PACKETBUF_ERR | STREAM0 PACKET缓存异常
EXCEPTION_TYPE_STREAM0_WDMALENGTH_ERR | STREAM0 WDMA长度异常
EXCEPTION_TYPE_STREAM0_RDMALENGTH_ERR | STREAM0 RDMA长度异常
EXCEPTION_TYPE_STREAM1_DROP_FRAME_IMAGE | STREAM1 卡端图像帧缓存丢弃
EXCEPTION_TYPE_STREAM1_IMAGE_DATACOUNT_ERR | STREAM1 接收图像（大小）计数异常
EXCEPTION_TYPE_STREAM1_DROP_FRAME_TRIGGER | STREAM1 卡端帧触发丢弃
EXCEPTION_TYPE_STREAM1_QUEUEBUF_ERR | STREAM1 QUEUE缓存异常
EXCEPTION_TYPE_STREAM1_WDMABUF_ERR | STREAM1 WDMA缓存异常
EXCEPTION_TYPE_STREAM1_RDMABUF_ERR | STREAM1 RDMA缓存异常
EXCEPTION_TYPE_STREAM1_PACKETBUF_ERR | STREAM1 PACKET缓存异常
EXCEPTION_TYPE_STREAM1_WDMALENGTH_ERR | STREAM1 WDMA长度异常
EXCEPTION_TYPE_STREAM1_RDMALENGTH_ERR | STREAM1 RDMA长度异常
EXCEPTION_TYPE_STREAM2_DROP_FRAME_IMAGE | STREAM2 卡端图像帧缓存丢弃
EXCEPTION_TYPE_STREAM2_IMAGE_DATACOUNT_ERR | STREAM2 接收图像（大小）计数异常
EXCEPTION_TYPE_STREAM2_DROP_FRAME_TRIGGER | STREAM2 卡端帧触发丢弃
EXCEPTION_TYPE_STREAM2_QUEUEBUF_ERR | STREAM2 QUEUE缓存异常
EXCEPTION_TYPE_STREAM2_WDMABUF_ERR | STREAM2 WDMA缓存异常
EXCEPTION_TYPE_STREAM2_RDMABUF_ERR | STREAM2 RDMA缓存异常
EXCEPTION_TYPE_STREAM2_PACKETBUF_ERR | STREAM2 PACKET缓存异常
EXCEPTION_TYPE_STREAM2_WDMALENGTH_ERR | STREAM2 WDMA长度异常
EXCEPTION_TYPE_STREAM2_RDMALENGTH_ERR | STREAM2 RDMA长度异常
EXCEPTION_TYPE_STREAM3_DROP_FRAME_IMAGE | STREAM3 卡端图像帧缓存丢弃
EXCEPTION_TYPE_STREAM3_IMAGE_DATACOUNT_ERR | STREAM3 接收图像（大小）计数异常
EXCEPTION_TYPE_STREAM3_DROP_FRAME_TRIGGER | STREAM3 卡端帧触发丢弃
EXCEPTION_TYPE_STREAM3_QUEUEBUF_ERR | STREAM3 QUEUE缓存异常
EXCEPTION_TYPE_STREAM3_WDMABUF_ERR | STREAM3 WDMA缓存异常
EXCEPTION_TYPE_STREAM3_RDMABUF_ERR | STREAM3 RDMA缓存异常
EXCEPTION_TYPE_STREAM3_PACKETBUF_ERR | STREAM3 PACKET缓存异常
EXCEPTION_TYPE_STREAM3_WDMALENGTH_ERR | STREAM3 WDMA长度异常
EXCEPTION_TYPE_STREAM3_RDMALENGTH_ERR | STREAM3 RDMA长度异常
EXCEPTION_TYPE_PCIE_SCHEDULEBUF_ERR | 调度模块缓存异常
EXCEPTION_TYPE_PCIE_SCHEDULE_ERR | 调度结果到异常值
EXCEPTION_TYPE_PCIE_LINK0_RECVBUF_ERR | Link0 缓存Link的buffer异常
EXCEPTION_TYPE_PCIE_LINK0_LENGTH_ERR | Link0 控制包长度异常
EXCEPTION_TYPE_PCIE_LINK0_SOFT_RECVBUF_ERR | Link0 缓存Link的buffer异常
EXCEPTION_TYPE_PCIE_LINK0_SOFT_LENGTH_ERR | Link0 控制包长度异常
EXCEPTION_TYPE_PCIE_LINK1_RECVBUF_ERR | Link1 缓存Link的buffer异常
EXCEPTION_TYPE_PCIE_LINK1_LENGTH_ERR | Link1 控制包长度异常
EXCEPTION_TYPE_PCIE_LINK1_SOFT_RECVBUF_ERR | Link1 缓存Link的buffer异常
EXCEPTION_TYPE_PCIE_LINK1_SOFT_LENGTH_ERR | Link1 控制包长度异常
EXCEPTION_TYPE_PCIE_LINK2_RECVBUF_ERR | Link2 缓存Link的buffer异常
EXCEPTION_TYPE_PCIE_LINK2_LENGTH_ERR | Link2 控制包长度异常
EXCEPTION_TYPE_PCIE_LINK2_SOFT_RECVBUF_ERR | Link2 缓存Link的buffer异常
EXCEPTION_TYPE_PCIE_LINK2_SOFT_LENGTH_ERR | Link2 控制包长度异常
EXCEPTION_TYPE_PCIE_LINK3_RECVBUF_ERR | Link3 缓存Link的buffer异常
EXCEPTION_TYPE_PCIE_LINK3_LENGTH_ERR | Link3 控制包长度异常
EXCEPTION_TYPE_PCIE_LINK3_SOFT_RECVBUF_ERR | Link3 缓存Link的buffer异常
EXCEPTION_TYPE_PCIE_LINK3_SOFT_LENGTH_ERR | Link3 控制包长度异常
EXCEPTION_TYPE_PCIE_STREAM0_RECVBUF_ERR | STREAM0 缓存Stream的fifo异常
EXCEPTION_TYPE_PCIE_STREAM0_LIST_ERR | STREAM0 链表格式错误
EXCEPTION_TYPE_PCIE_STREAM0_SIZE_ERR | STREAM0 图像大小与内存不匹配
EXCEPTION_TYPE_PCIE_STREAM1_RECVBUF_ERR | STREAM1 缓存Stream的fifo异常
EXCEPTION_TYPE_PCIE_STREAM1_LIST_ERR | STREAM1 链表格式错误
EXCEPTION_TYPE_PCIE_STREAM1_SIZE_ERR | STREAM1 图像大小与内存不匹配
EXCEPTION_TYPE_PCIE_STREAM2_RECVBUF_ERR | STREAM2 缓存Stream的fifo异常
EXCEPTION_TYPE_PCIE_STREAM2_LIST_ERR | STREAM2 链表格式错误
EXCEPTION_TYPE_PCIE_STREAM2_SIZE_ERR | STREAM2 图像大小与内存不匹配
EXCEPTION_TYPE_PCIE_STREAM3_RECVBUF_ERR | STREAM3 缓存Stream的fifo异常
EXCEPTION_TYPE_PCIE_STREAM3_LIST_ERR | STREAM3 链表格式错误
EXCEPTION_TYPE_PCIE_STREAM3_SIZE_ERR | STREAM3 图像大小与内存不匹配
EXCEPTION_TYPE_CAMERA_DISCONNECT_ERR | CAMERA 相机掉线错误


结构体定义
这里列出了所有类、结构、联合以及接口定义等，并附带简要说明:
C MV_CML_DEVICE_INFO | Camera Link设备信息
C MV_CML_INTERFACE_INFO | Camera Link采集卡信息
C MV_CXP_DEVICE_INFO | CoaXPress设备信息
C MV_CXP_INTERFACE_INFO | CoaXPress采集卡信息
C MV_FG_BUFFER_INFO | 输出的帧缓存信息
C MV_FG_CCM_INFO | CCM信息
C MV_FG_CHUNK_DATA_INFO | Chunk信息
C MV_FG_CONVERT_PIXEL_INFO | 像素格式转换信息
C MV_FG_DEVICE_INFO | 设备信息
C MV_FG_ENUMVALUE | 枚举类型信息
C MV_FG_EVENT_INFO | 事件信息
C MV_FG_FLOATVALUE | Float类型信息
C MV_FG_FRAME_SPEC_INFO | 水印信息
C MV_FG_GAMMA_INFO | Gamma信息
C MV_FG_HB_DECODE_PARAM_T | 无损解码参数
C MV_FG_INPUT_IMAGE_INFO | 输入的图像信息
C MV_FG_INTERFACE_INFO | 采集卡信息
C MV_FG_INTVALUE | Int类型信息
C MV_FG_OUTPUT_IMAGE_INFO | 输出的图像信息
C MV_FG_RECONSTRUCT_INFO | 重组信息
C MV_FG_SAVE_BITMAP_INFO | 保存BMP图像信息
C MV_FG_SAVE_JPEG_INFO | 保存JPEG图像信息
C MV_FG_SAVE_PNG_TO_FILE_INFO | 保存PNG图像信息
C MV_FG_SAVE_TIFF_TO_FILE_INFO | 保存TIFF图像信息
C MV_FG_STRINGVALUE | String类型信息
C MV_GEV_DEVICE_INFO | GigE Vision设备信息
C MV_GEV_INTERFACE_INFO | GigE Vision采集卡信息


Public 属性 | 所有成员列表
MV_FG_BUFFER_INFO结构体 参考

输出的帧缓存信息 更多...

Public 属性

void * | pBuffer
[OUT] 图像缓存地址 更多...
unsigned int | nSize
[OUT] 地址大小 更多...
unsigned int | nFilledSize
[OUT] 图像长度 更多...
void * | pPrivate
[OUT] 私有数据 更多...
unsigned int | nWidth
[OUT] 宽度 更多...
unsigned int | nHeight
[OUT] 高度 更多...
MV_FG_PIXEL_TYPE enPixelType
[OUT] 像素格式 更多...
bool | bNewData
[OUT] 是否是新图像到来 更多...
bool | bQueued
[OUT] 是否在取图队列中 更多...
bool | bAcquiring
[OUT] 是否在取图 更多...
bool | bIncomplete
[OUT] 是否未完成 更多...
int64_t | nFrameID
[OUT] 帧号 更多...
int64_t | nDevTimeStamp
[OUT] 设备时间戳 更多...
int64_t | nHostTimeStamp
[OUT] 主机时间戳 更多...
unsigned int | nNumChunks
[OUT] Chunk个数 更多...
unsigned int | nChunkPayloadSize
[OUT] Chunk负载长度 更多...
unsigned int | nSecondCount
[OUT] 秒数(时标) 更多...
unsigned int | nCycleCount
[OUT] 周期数(时标) 更多...
unsigned int | nCycleOffset
[OUT] 周期偏移量(时标) 更多...
float | fGain
[OUT] 增益 更多...
float | fExposureTime
[OUT] 曝光时间 更多...
unsigned int | nAverageBrightness
[OUT] 平均亮度 更多...
unsigned int | nFrameCounter
[OUT] 总帧数 更多...
unsigned int | nTriggerIndex
[OUT] 触发计数 更多...
unsigned int | nInput
[OUT] 输入 更多...
unsigned int | nOutput
[OUT] 输出 更多...
unsigned int | nRed
[OUT] 红色(白平衡) 更多...
unsigned int | nGreen
[OUT] 绿色(白平衡) 更多...
unsigned int | nBlue
[OUT] 蓝色(白平衡) 更多...
unsigned int | nOffsetX
[OUT] 水平偏移量(ROI位置) 更多...
unsigned int | nOffsetY
[OUT] 垂直偏移量(ROI位置) 更多...
unsigned int | nChunkWidth
[OUT] 宽度(ROI位置) 更多...
unsigned int | nChunkHeight
[OUT] 高度(ROI位置) 更多...
unsigned int | nReserved [45]
保留字段 更多...

详细描述

输出的帧缓存信息

类成员变量说明

◆ pBuffer

void* MV_FG_BUFFER_INFO::pBuffer

[OUT] 图像缓存地址

◆ nSize

unsigned int MV_FG_BUFFER_INFO::nSize

[OUT] 地址大小

◆ nFilledSize

unsigned int MV_FG_BUFFER_INFO::nFilledSize

[OUT] 图像长度

◆ pPrivate

void* MV_FG_BUFFER_INFO::pPrivate

[OUT] 私有数据

◆ nWidth

unsigned int MV_FG_BUFFER_INFO::nWidth

[OUT] 宽度

◆ nHeight

unsigned int MV_FG_BUFFER_INFO::nHeight

[OUT] 高度

◆ enPixelType

MV_FG_PIXEL_TYPE MV_FG_BUFFER_INFO::enPixelType

[OUT] 像素格式

◆ bNewData

bool MV_FG_BUFFER_INFO::bNewData

[OUT] 是否是新图像到来

◆ bQueued

bool MV_FG_BUFFER_INFO::bQueued

[OUT] 是否在取图队列中

◆ bAcquiring

bool MV_FG_BUFFER_INFO::bAcquiring

[OUT] 是否在取图

◆ bIncomplete

bool MV_FG_BUFFER_INFO::bIncomplete

[OUT] 是否未完成

◆ nFrameID

int64_t MV_FG_BUFFER_INFO::nFrameID

[OUT] 帧号

◆ nDevTimeStamp

int64_t MV_FG_BUFFER_INFO::nDevTimeStamp

[OUT] 设备时间戳

◆ nHostTimeStamp

int64_t MV_FG_BUFFER_INFO::nHostTimeStamp

[OUT] 主机时间戳

◆ nNumChunks

unsigned int MV_FG_BUFFER_INFO::nNumChunks

[OUT] Chunk个数

◆ nChunkPayloadSize

unsigned int MV_FG_BUFFER_INFO::nChunkPayloadSize

[OUT] Chunk负载长度

◆ nSecondCount

unsigned int MV_FG_BUFFER_INFO::nSecondCount

[OUT] 秒数(时标)

◆ nCycleCount

unsigned int MV_FG_BUFFER_INFO::nCycleCount

[OUT] 周期数(时标)

◆ nCycleOffset

unsigned int MV_FG_BUFFER_INFO::nCycleOffset

[OUT] 周期偏移量(时标)

◆ fGain

float MV_FG_BUFFER_INFO::fGain

[OUT] 增益

◆ fExposureTime

float MV_FG_BUFFER_INFO::fExposureTime

[OUT] 曝光时间

◆ nAverageBrightness

unsigned int MV_FG_BUFFER_INFO::nAverageBrightness

[OUT] 平均亮度

◆ nFrameCounter

unsigned int MV_FG_BUFFER_INFO::nFrameCounter

[OUT] 总帧数

◆ nTriggerIndex

unsigned int MV_FG_BUFFER_INFO::nTriggerIndex

[OUT] 触发计数

◆ nInput

unsigned int MV_FG_BUFFER_INFO::nInput

[OUT] 输入

◆ nOutput

unsigned int MV_FG_BUFFER_INFO::nOutput

[OUT] 输出

◆ nRed

unsigned int MV_FG_BUFFER_INFO::nRed

[OUT] 红色(白平衡)

◆ nGreen

unsigned int MV_FG_BUFFER_INFO::nGreen

[OUT] 绿色(白平衡)

◆ nBlue

unsigned int MV_FG_BUFFER_INFO::nBlue

[OUT] 蓝色(白平衡)

◆ nOffsetX

unsigned int MV_FG_BUFFER_INFO::nOffsetX

[OUT] 水平偏移量(ROI位置)

◆ nOffsetY

unsigned int MV_FG_BUFFER_INFO::nOffsetY

[OUT] 垂直偏移量(ROI位置)

◆ nChunkWidth

unsigned int MV_FG_BUFFER_INFO::nChunkWidth

[OUT] 宽度(ROI位置)

◆ nChunkHeight

unsigned int MV_FG_BUFFER_INFO::nChunkHeight

[OUT] 高度(ROI位置)

◆ nReserved

unsigned int MV_FG_BUFFER_INFO::nReserved[45]

保留字段


Public 属性 | 所有成员列表
MV_FG_CCM_INFO结构体 参考

CCM信息 更多...

Public 属性

bool32_t | bCCMEnable
[IN] 是否启用CCM 更多...
int | nCCMat [9]
[IN] CCM矩阵(-65536~65536) 更多...
unsigned int | nCCMScale
[IN] 量化系数（2的整数幂,最大65536） 更多...
unsigned int | nReserved [4]
预留字段 更多...

详细描述

CCM信息

类成员变量说明

◆ bCCMEnable

bool32_t MV_FG_CCM_INFO::bCCMEnable

[IN] 是否启用CCM

◆ nCCMat

int MV_FG_CCM_INFO::nCCMat[9]

[IN] CCM矩阵(-65536~65536)

◆ nCCMScale

unsigned int MV_FG_CCM_INFO::nCCMScale

[IN] 量化系数（2的整数幂,最大65536）

◆ nReserved

unsigned int MV_FG_CCM_INFO::nReserved[4]

预留字段


Public 属性 | 所有成员列表
MV_FG_CHUNK_DATA_INFO结构体 参考

Chunk信息 更多...

Public 属性

unsigned char * | pChunkData
[OUT] Chunk数据 更多...
unsigned int | nChunkID
[OUT] Chunk ID 更多...
unsigned int | nChunkLen
[OUT] Chunk的长度 更多...
unsigned int | nReserved [4]
保留字段 更多...

详细描述

Chunk信息

类成员变量说明

◆ pChunkData

unsigned char* MV_FG_CHUNK_DATA_INFO::pChunkData

[OUT] Chunk数据

◆ nChunkID

unsigned int MV_FG_CHUNK_DATA_INFO::nChunkID

[OUT] Chunk ID

◆ nChunkLen

unsigned int MV_FG_CHUNK_DATA_INFO::nChunkLen

[OUT] Chunk的长度

◆ nReserved

unsigned int MV_FG_CHUNK_DATA_INFO::nReserved[4]

保留字段


Public 属性 | 所有成员列表
MV_FG_CONVERT_PIXEL_INFO结构体 参考

像素格式转换信息 更多...

Public 属性

MV_FG_INPUT_IMAGE_INFO stInputImageInfo
[IN] 输入图片信息 更多...
MV_FG_OUTPUT_IMAGE_INFO stOutputImageInfo
[IN][OUT] 输出图片信息 更多...
MV_FG_CFA_METHOD enCfaMethod
[IN] 插值方法 更多...
bool32_t | bFilterEnable
[IN] 平滑使能 更多...
MV_FG_GAMMA_INFO stGammaInfo
[IN] Gamma信息 更多...
MV_FG_CCM_INFO stCCMInfo
[IN] CCM信息 更多...
unsigned int | nReserved [4]
预留字段 更多...

详细描述

像素格式转换信息

类成员变量说明

◆ stInputImageInfo

MV_FG_INPUT_IMAGE_INFO MV_FG_CONVERT_PIXEL_INFO::stInputImageInfo

[IN] 输入图片信息

◆ stOutputImageInfo

MV_FG_OUTPUT_IMAGE_INFO MV_FG_CONVERT_PIXEL_INFO::stOutputImageInfo

[IN][OUT] 输出图片信息

◆ enCfaMethod

MV_FG_CFA_METHOD MV_FG_CONVERT_PIXEL_INFO::enCfaMethod

[IN] 插值方法

◆ bFilterEnable

bool32_t MV_FG_CONVERT_PIXEL_INFO::bFilterEnable

[IN] 平滑使能

◆ stGammaInfo

MV_FG_GAMMA_INFO MV_FG_CONVERT_PIXEL_INFO::stGammaInfo

[IN] Gamma信息

◆ stCCMInfo

MV_FG_CCM_INFO MV_FG_CONVERT_PIXEL_INFO::stCCMInfo

[IN] CCM信息

◆ nReserved

unsigned int MV_FG_CONVERT_PIXEL_INFO::nReserved[4]

预留字段


Public 属性 | 所有成员列表
MV_FG_ENUMVALUE结构体 参考

枚举类型信息 更多...

Public 属性

unsigned int | nCurValue
[OUT] 当前值 更多...
char | strCurSymbolic [MV_FG_MAX_SYMBOLIC_STRLEN]
[OUT] 当前值的符号名称 更多...
unsigned int | nSupportedNum
[OUT] 支持的枚举类型个数 更多...
unsigned int | nSupportValue [MV_FG_MAX_SYMBOLIC_NUM]
[OUT] 支持的枚举类型的值 更多...
char | strSymbolic [MV_FG_MAX_SYMBOLIC_NUM][MV_FG_MAX_SYMBOLIC_STRLEN]
[OUT] 支持的枚举类型的符号名称 更多...
unsigned int | nReserved [4]
保留字段 更多...

详细描述

枚举类型信息

类成员变量说明

◆ nCurValue

unsigned int MV_FG_ENUMVALUE::nCurValue

[OUT] 当前值

◆ strCurSymbolic

char MV_FG_ENUMVALUE::strCurSymbolic[MV_FG_MAX_SYMBOLIC_STRLEN]

[OUT] 当前值的符号名称

◆ nSupportedNum

unsigned int MV_FG_ENUMVALUE::nSupportedNum

[OUT] 支持的枚举类型个数

◆ nSupportValue

unsigned int MV_FG_ENUMVALUE::nSupportValue[MV_FG_MAX_SYMBOLIC_NUM]

[OUT] 支持的枚举类型的值

◆ strSymbolic

char MV_FG_ENUMVALUE::strSymbolic[MV_FG_MAX_SYMBOLIC_NUM][MV_FG_MAX_SYMBOLIC_STRLEN]

[OUT] 支持的枚举类型的符号名称

◆ nReserved

unsigned int MV_FG_ENUMVALUE::nReserved[4]

保留字段


Public 属性 | 所有成员列表
MV_FG_EVENT_INFO结构体 参考

事件信息 更多...

Public 属性

char | EventName [MV_FG_MAX_EVENT_NAME_SIZE]
[OUT] 事件名称 更多...
unsigned int | nEventID
[OUT] 事件号 更多...
uint64_t | nBlockID
[OUT] 帧号，流事件有效 更多...
uint64_t | nTimestamp
[OUT] 时间戳 更多...
void * | pEventData
[OUT] 事件数据，内部缓存，需要及时进行数据处理 更多...
unsigned int | nEventDataSize
[OUT] 事件数据长度 更多...
unsigned int | nReserved [4]
预留 更多...

详细描述

事件信息

类成员变量说明

◆ EventName

char MV_FG_EVENT_INFO::EventName[MV_FG_MAX_EVENT_NAME_SIZE]

[OUT] 事件名称

◆ nEventID

unsigned int MV_FG_EVENT_INFO::nEventID

[OUT] 事件号

◆ nBlockID

uint64_t MV_FG_EVENT_INFO::nBlockID

[OUT] 帧号，流事件有效

◆ nTimestamp

uint64_t MV_FG_EVENT_INFO::nTimestamp

[OUT] 时间戳

◆ pEventData

void* MV_FG_EVENT_INFO::pEventData

[OUT] 事件数据，内部缓存，需要及时进行数据处理

◆ nEventDataSize

unsigned int MV_FG_EVENT_INFO::nEventDataSize

[OUT] 事件数据长度

◆ nReserved

unsigned int MV_FG_EVENT_INFO::nReserved[4]

预留


Public 属性 | 所有成员列表
MV_FG_FLOATVALUE结构体 参考

Float类型信息 更多...

Public 属性

float | fCurValue
[OUT] 当前值 更多...
float | fMax
[OUT] 最大值 更多...
float | fMin
[OUT] 最小值 更多...
unsigned int | nReserved [4]
保留字段 更多...

详细描述

Float类型信息

类成员变量说明

◆ fCurValue

float MV_FG_FLOATVALUE::fCurValue

[OUT] 当前值

◆ fMax

float MV_FG_FLOATVALUE::fMax

[OUT] 最大值

◆ fMin

float MV_FG_FLOATVALUE::fMin

[OUT] 最小值

◆ nReserved

unsigned int MV_FG_FLOATVALUE::nReserved[4]

保留字段


Public 属性 | 所有成员列表
MV_FG_FRAME_SPEC_INFO结构体 参考

水印信息 更多...

Public 属性

unsigned int | nSecondCount
设备水印时标 更多...
unsigned int | nCycleCount
[OUT] 周期数 更多...
unsigned int | nCycleOffset
[OUT] 周期偏移量 更多...
float | fGain
[OUT] 增益 更多...
float | fExposureTime
[OUT] 曝光时间 更多...
unsigned int | nAverageBrightness
[OUT] 平均亮度 更多...
unsigned int | nRed
白平衡相关 更多...
unsigned int | nGreen
[OUT] 绿色 更多...
unsigned int | nBlue
[OUT] 蓝色 更多...
unsigned int | nFrameCounter
[OUT] 总帧数 更多...
unsigned int | nTriggerIndex
[OUT] 触发计数 更多...
unsigned int | nInput
[OUT] 输入 更多...
unsigned int | nOutput
[OUT] 输出 更多...
unsigned short | nOffsetX
ROI区域 更多...
unsigned short | nOffsetY
[OUT] 垂直偏移量 更多...
unsigned short | nFrameWidth
[OUT] 水印宽 更多...
unsigned short | nFrameHeight
[OUT] 水印高 更多...
unsigned int | nReserved [16]
预留 更多...

详细描述

水印信息

类成员变量说明

◆ nSecondCount

unsigned int MV_FG_FRAME_SPEC_INFO::nSecondCount

设备水印时标

[OUT] 秒数

◆ nCycleCount

unsigned int MV_FG_FRAME_SPEC_INFO::nCycleCount

[OUT] 周期数

◆ nCycleOffset

unsigned int MV_FG_FRAME_SPEC_INFO::nCycleOffset

[OUT] 周期偏移量

◆ fGain

float MV_FG_FRAME_SPEC_INFO::fGain

[OUT] 增益

◆ fExposureTime

float MV_FG_FRAME_SPEC_INFO::fExposureTime

[OUT] 曝光时间

◆ nAverageBrightness

unsigned int MV_FG_FRAME_SPEC_INFO::nAverageBrightness

[OUT] 平均亮度

◆ nRed

unsigned int MV_FG_FRAME_SPEC_INFO::nRed

白平衡相关

[OUT] 红色

◆ nGreen

unsigned int MV_FG_FRAME_SPEC_INFO::nGreen

[OUT] 绿色

◆ nBlue

unsigned int MV_FG_FRAME_SPEC_INFO::nBlue

[OUT] 蓝色

◆ nFrameCounter

unsigned int MV_FG_FRAME_SPEC_INFO::nFrameCounter

[OUT] 总帧数

◆ nTriggerIndex

unsigned int MV_FG_FRAME_SPEC_INFO::nTriggerIndex

[OUT] 触发计数

◆ nInput

unsigned int MV_FG_FRAME_SPEC_INFO::nInput

[OUT] 输入

◆ nOutput

unsigned int MV_FG_FRAME_SPEC_INFO::nOutput

[OUT] 输出

◆ nOffsetX

unsigned short MV_FG_FRAME_SPEC_INFO::nOffsetX

ROI区域

[OUT] 水平偏移量

◆ nOffsetY

unsigned short MV_FG_FRAME_SPEC_INFO::nOffsetY

[OUT] 垂直偏移量

◆ nFrameWidth

unsigned short MV_FG_FRAME_SPEC_INFO::nFrameWidth

[OUT] 水印宽

◆ nFrameHeight

unsigned short MV_FG_FRAME_SPEC_INFO::nFrameHeight

[OUT] 水印高

◆ nReserved

unsigned int MV_FG_FRAME_SPEC_INFO::nReserved[16]

预留


Public 属性 | 所有成员列表
MV_FG_GAMMA_INFO结构体 参考

Gamma信息 更多...

Public 属性

MV_FG_GAMMA_TYPE enGammaType
[IN] Gamma类型 更多...
float | fGammaValue
[IN] Gamma值[0.1,4.0] 更多...
unsigned char * | pGammaCurveBuf
[IN] Gamma曲线缓存 更多...
unsigned int | nGammaCurveBufLen
[IN] Gamma曲线长度 更多...
unsigned int | nReserved [4]
预留字段 更多...

详细描述

Gamma信息

类成员变量说明

◆ enGammaType

MV_FG_GAMMA_TYPE MV_FG_GAMMA_INFO::enGammaType

[IN] Gamma类型

◆ fGammaValue

float MV_FG_GAMMA_INFO::fGammaValue

[IN] Gamma值[0.1,4.0]

◆ pGammaCurveBuf

unsigned char* MV_FG_GAMMA_INFO::pGammaCurveBuf

[IN] Gamma曲线缓存

◆ nGammaCurveBufLen

unsigned int MV_FG_GAMMA_INFO::nGammaCurveBufLen

[IN] Gamma曲线长度

◆ nReserved

unsigned int MV_FG_GAMMA_INFO::nReserved[4]

预留字段


Public 属性 | 所有成员列表
MV_FG_HB_DECODE_PARAM_T结构体 参考

无损解码参数 更多...

Public 属性

unsigned char * | pSrcBuf
[IN] 输入数据缓存 更多...
unsigned int | nSrcLen
[IN] 输入数据大小 更多...
MV_FG_OUTPUT_IMAGE_INFO stOutputImageInfo
[IN][OUT] 输出图片信息 更多...
MV_FG_FRAME_SPEC_INFO stFrameSpecInfo
[OUT] 水印信息（暂不支持） 更多...
unsigned int | nRes [8]
预留 更多...

详细描述

无损解码参数

类成员变量说明

◆ pSrcBuf

unsigned char* MV_FG_HB_DECODE_PARAM_T::pSrcBuf

[IN] 输入数据缓存

◆ nSrcLen

unsigned int MV_FG_HB_DECODE_PARAM_T::nSrcLen

[IN] 输入数据大小

◆ stOutputImageInfo

MV_FG_OUTPUT_IMAGE_INFO MV_FG_HB_DECODE_PARAM_T::stOutputImageInfo

[IN][OUT] 输出图片信息

◆ stFrameSpecInfo

MV_FG_FRAME_SPEC_INFO MV_FG_HB_DECODE_PARAM_T::stFrameSpecInfo

[OUT] 水印信息（暂不支持）

◆ nRes

unsigned int MV_FG_HB_DECODE_PARAM_T::nRes[8]

预留


Public 属性 | 所有成员列表
MV_FG_INPUT_IMAGE_INFO结构体 参考

输入的图像信息 更多...

Public 属性

unsigned int | nWidth
[IN] 图像宽 更多...
unsigned int | nHeight
[IN] 图像高 更多...
MV_FG_PIXEL_TYPE enPixelType
[IN] 像素格式 更多...
unsigned char * | pImageBuf
[IN] 输入图像缓存 更多...
unsigned int | nImageBufLen
[IN] 输入图像长度 更多...
unsigned int | nReserved [4]
预留字段 更多...

详细描述

输入的图像信息

类成员变量说明

◆ nWidth

unsigned int MV_FG_INPUT_IMAGE_INFO::nWidth

[IN] 图像宽

◆ nHeight

unsigned int MV_FG_INPUT_IMAGE_INFO::nHeight

[IN] 图像高

◆ enPixelType

MV_FG_PIXEL_TYPE MV_FG_INPUT_IMAGE_INFO::enPixelType

[IN] 像素格式

◆ pImageBuf

unsigned char* MV_FG_INPUT_IMAGE_INFO::pImageBuf

[IN] 输入图像缓存

◆ nImageBufLen

unsigned int MV_FG_INPUT_IMAGE_INFO::nImageBufLen

[IN] 输入图像长度

◆ nReserved

unsigned int MV_FG_INPUT_IMAGE_INFO::nReserved[4]

预留字段


Public 属性 | 所有成员列表
MV_FG_INTVALUE结构体 参考

Int类型信息 更多...

Public 属性

int64_t | nCurValue
[OUT] 当前值 更多...
int64_t | nMax
[OUT] 最大值 更多...
int64_t | nMin
[OUT] 最小值 更多...
int64_t | nInc
[OUT] 步长 更多...
unsigned int | nReserved [16]
保留字段 更多...

详细描述

Int类型信息

类成员变量说明

◆ nCurValue

int64_t MV_FG_INTVALUE::nCurValue

[OUT] 当前值

◆ nMax

int64_t MV_FG_INTVALUE::nMax

[OUT] 最大值

◆ nMin

int64_t MV_FG_INTVALUE::nMin

[OUT] 最小值

◆ nInc

int64_t MV_FG_INTVALUE::nInc

[OUT] 步长

◆ nReserved

unsigned int MV_FG_INTVALUE::nReserved[16]

保留字段


Public 属性 | 所有成员列表
MV_FG_OUTPUT_IMAGE_INFO结构体 参考

输出的图像信息 更多...

Public 属性

unsigned int | nWidth
[OUT] 图像宽 更多...
unsigned int | nHeight
[OUT] 图像高 更多...
MV_FG_PIXEL_TYPE enPixelType
[IN] 像素格式 更多...
unsigned char * | pImageBuf
[IN][OUT] 数据缓存 更多...
unsigned int | nImageBufSize
[IN] 数据缓冲大小 更多...
unsigned int | nImageBufLen
[OUT] 图像长度 更多...
unsigned int | nReserved [4]
预留字段 更多...

详细描述

输出的图像信息

类成员变量说明

◆ nWidth

unsigned int MV_FG_OUTPUT_IMAGE_INFO::nWidth

[OUT] 图像宽

◆ nHeight

unsigned int MV_FG_OUTPUT_IMAGE_INFO::nHeight

[OUT] 图像高

◆ enPixelType

MV_FG_PIXEL_TYPE MV_FG_OUTPUT_IMAGE_INFO::enPixelType

[IN] 像素格式

◆ pImageBuf

unsigned char* MV_FG_OUTPUT_IMAGE_INFO::pImageBuf

[IN][OUT] 数据缓存

◆ nImageBufSize

unsigned int MV_FG_OUTPUT_IMAGE_INFO::nImageBufSize

[IN] 数据缓冲大小

◆ nImageBufLen

unsigned int MV_FG_OUTPUT_IMAGE_INFO::nImageBufLen

[OUT] 图像长度

◆ nReserved

unsigned int MV_FG_OUTPUT_IMAGE_INFO::nReserved[4]

预留字段


Public 属性 | 所有成员列表
MV_FG_RECONSTRUCT_INFO结构体 参考

重组信息 更多...

Public 属性

MV_FG_INPUT_IMAGE_INFO stInputImageInfo
[IN] 输入图片信息 更多...
MV_FG_OUTPUT_IMAGE_INFO stOutputImageInfo [MV_FG_MAX_SPLIT_NUM]
[IN][OUT] 输出图片信息 更多...
MV_FG_RECONSTRUCT_MODE enReconstructMode
[IN] 重组方式 更多...
unsigned int nReserved [4]
预留字段 更多...

详细描述

重组信息

类成员变量说明

◆ stInputImageInfo

MV_FG_INPUT_IMAGE_INFO MV_FG_RECONSTRUCT_INFO::stInputImageInfo

[IN] 输入图片信息

◆ stOutputImageInfo

MV_FG_OUTPUT_IMAGE_INFO MV_FG_RECONSTRUCT_INFO::stOutputImageInfo[MV_FG_MAX_SPLIT_NUM]

[IN][OUT] 输出图片信息

◆ enReconstructMode

MV_FG_RECONSTRUCT_MODE MV_FG_RECONSTRUCT_INFO::enReconstructMode

[IN] 重组方式

◆ nReserved

unsigned int MV_FG_RECONSTRUCT_INFO::nReserved[4]

预留字段


Public 属性 | 所有成员列表
MV_FG_SAVE_BITMAP_INFO结构体 参考

保存BMP图像信息 更多...

Public 属性

MV_FG_INPUT_IMAGE_INFO stInputImageInfo
[IN] 输入图片信息 更多...
unsigned char * | pBmpBuf
[IN][OUT] 输出的BMP图片缓存 更多...
unsigned int | nBmpBufSize
[IN] 输出的缓冲区大小 更多...
unsigned int | nBmpBufLen
[OUT] 输出的BMP图片长度 更多...
MV_FG_CFA_METHOD enCfaMethod
[IN] 插值方法 更多...
unsigned int | nReserved [4]
预留字段 更多...

详细描述

保存BMP图像信息

类成员变量说明

◆ stInputImageInfo

MV_FG_INPUT_IMAGE_INFO MV_FG_SAVE_BITMAP_INFO::stInputImageInfo

[IN] 输入图片信息

◆ pBmpBuf

unsigned char* MV_FG_SAVE_BITMAP_INFO::pBmpBuf

[IN][OUT] 输出的BMP图片缓存

◆ nBmpBufSize

unsigned int MV_FG_SAVE_BITMAP_INFO::nBmpBufSize

[IN] 输出的缓冲区大小

◆ nBmpBufLen

unsigned int MV_FG_SAVE_BITMAP_INFO::nBmpBufLen

[OUT] 输出的BMP图片长度

◆ enCfaMethod

MV_FG_CFA_METHOD MV_FG_SAVE_BITMAP_INFO::enCfaMethod

[IN] 插值方法

◆ nReserved

unsigned int MV_FG_SAVE_BITMAP_INFO::nReserved[4]

预留字段


Public 属性 | 所有成员列表
MV_FG_SAVE_JPEG_INFO结构体 参考

保存JPEG图像信息 更多...

Public 属性

MV_FG_INPUT_IMAGE_INFO stInputImageInfo
[IN] 输入图片信息 更多...
unsigned char * | pJpgBuf
[IN][OUT] 输出的JPEG图片缓存 更多...
unsigned int | nJpgBufSize
[IN] 输出的缓冲区大小 更多...
unsigned int | nJpgBufLen
[OUT] 输出的JPEG图片长度 更多...
unsigned int | nJpgQuality
[IN] 编码质量, (0-100] 更多...
MV_FG_CFA_METHOD enCfaMethod
[IN] 插值方法 更多...
unsigned int | nReserved [4]
预留字段 更多...

详细描述

保存JPEG图像信息

类成员变量说明

◆ stInputImageInfo

MV_FG_INPUT_IMAGE_INFO MV_FG_SAVE_JPEG_INFO::stInputImageInfo

[IN] 输入图片信息

◆ pJpgBuf

unsigned char* MV_FG_SAVE_JPEG_INFO::pJpgBuf

[IN][OUT] 输出的JPEG图片缓存

◆ nJpgBufSize

unsigned int MV_FG_SAVE_JPEG_INFO::nJpgBufSize

[IN] 输出的缓冲区大小

◆ nJpgBufLen

unsigned int MV_FG_SAVE_JPEG_INFO::nJpgBufLen

[OUT] 输出的JPEG图片长度

◆ nJpgQuality

unsigned int MV_FG_SAVE_JPEG_INFO::nJpgQuality

[IN] 编码质量, (0-100]

◆ enCfaMethod

MV_FG_CFA_METHOD MV_FG_SAVE_JPEG_INFO::enCfaMethod

[IN] 插值方法

◆ nReserved

unsigned int MV_FG_SAVE_JPEG_INFO::nReserved[4]

预留字段


Public 属性 | 所有成员列表
MV_FG_SAVE_PNG_TO_FILE_INFO结构体 参考

保存PNG图像信息 更多...

Public 属性

MV_FG_INPUT_IMAGE_INFO stInputImageInfo
[IN] 输入图片信息 更多...
char * | pcImagePath
[IN] 输入文件路径 更多...
unsigned int | nPngCompression
[IN] 编码压缩率, [0-9] 更多...
MV_FG_CFA_METHOD enCfaMethod
[IN] 插值方法 更多...
unsigned int | nReserved [4]
预留字段 更多...

详细描述

保存PNG图像信息

类成员变量说明

◆ stInputImageInfo

MV_FG_INPUT_IMAGE_INFO MV_FG_SAVE_PNG_TO_FILE_INFO::stInputImageInfo

[IN] 输入图片信息

◆ pcImagePath

char* MV_FG_SAVE_PNG_TO_FILE_INFO::pcImagePath

[IN] 输入文件路径

◆ nPngCompression

unsigned int MV_FG_SAVE_PNG_TO_FILE_INFO::nPngCompression

[IN] 编码压缩率, [0-9]

◆ enCfaMethod

MV_FG_CFA_METHOD MV_FG_SAVE_PNG_TO_FILE_INFO::enCfaMethod

[IN] 插值方法

◆ nReserved

unsigned int MV_FG_SAVE_PNG_TO_FILE_INFO::nReserved[4]

预留字段


Public 属性 | 所有成员列表
MV_FG_SAVE_TIFF_TO_FILE_INFO结构体 参考

保存TIFF图像信息 更多...

Public 属性

MV_FG_INPUT_IMAGE_INFO stInputImageInfo
[IN] 输入图片信息 更多...
char * | pcImagePath
[IN] 输入文件路径 更多...
float | fXResolution
[IN] 水平分辨率 更多...
float | fYResolution
[IN] 垂直分辨率 更多...
MV_FG_RESOLUTION_UNIT | enResolutionUnit
[IN] 分辨率单位 更多...
MV_FG_CFA_METHOD enCfaMethod
[IN] 插值方法 更多...
unsigned int | nReserved [4]
预留字段 更多...

详细描述

保存TIFF图像信息

类成员变量说明

◆ stInputImageInfo

MV_FG_INPUT_IMAGE_INFO MV_FG_SAVE_TIFF_TO_FILE_INFO::stInputImageInfo

[IN] 输入图片信息

◆ pcImagePath

char* MV_FG_SAVE_TIFF_TO_FILE_INFO::pcImagePath

[IN] 输入文件路径

◆ fXResolution

float MV_FG_SAVE_TIFF_TO_FILE_INFO::fXResolution

[IN] 水平分辨率

◆ fYResolution

float MV_FG_SAVE_TIFF_TO_FILE_INFO::fYResolution

[IN] 垂直分辨率

◆ enResolutionUnit

MV_FG_RESOLUTION_UNIT MV_FG_SAVE_TIFF_TO_FILE_INFO::enResolutionUnit

[IN] 分辨率单位

◆ enCfaMethod

MV_FG_CFA_METHOD MV_FG_SAVE_TIFF_TO_FILE_INFO::enCfaMethod

[IN] 插值方法

◆ nReserved

unsigned int MV_FG_SAVE_TIFF_TO_FILE_INFO::nReserved[4]

预留字段


Public 属性 | 所有成员列表
MV_FG_STRINGVALUE结构体 参考

String类型信息 更多...

Public 属性

char | strCurValue [256]
[OUT] 当前值 更多...
int64_t | nMaxLength
[OUT] 最大长度 更多...
unsigned int | nReserved [4]
保留字段 更多...

详细描述

String类型信息

类成员变量说明

◆ strCurValue

char MV_FG_STRINGVALUE::strCurValue[256]

[OUT] 当前值

◆ nMaxLength

int64_t MV_FG_STRINGVALUE::nMaxLength

[OUT] 最大长度

◆ nReserved

unsigned int MV_FG_STRINGVALUE::nReserved[4]

保留字段


  • 获取Chunk数据
  • 像素格式转换
  • 动态库加载
  • 主动取图
  • 回调取图
  • 用户注册缓存取图
  • 获取采集卡事件
示例程序
  • 获取Chunk数据
  • 像素格式转换
  • 动态库加载
  • 主动取图
  • 回调取图
  • 用户注册缓存取图
  • 获取采集卡事件


获取Chunk数据

该示例程序展示如何打开ChunkData功能、如何配置ChunkData以及如何获取这些ChunkData信息。
#include <stdio.h>
#include <Windows.h>
#include <process.h>
#include <conio.h>
#include "MVFGControl.h"
#define BUFFER_NUMBER 3 // ch:申请的缓存个数 | en:Number of requested buffer
#define CHUNK_ID_TIMESTAMP_LITTLE 0xa5a50101 // ch:时间戳 | en:Timestamp
#define CHUNK_ID_EXPOSURE_LITTLE 0xa5a50103 // ch:曝光 | en:Exposure
// ch:等待按键输入 | en:Wait for key press
void WaitForKeyPress(void)
{
while(!_kbhit())
{
Sleep(10);
}
_getch();
}
// ch:清空标准输入中的残留数据 | en:Flush stdin
void ClearStdin(void)
{
char c = '\0';
while (1)
{
c = getchar();
if ('\n' == c || EOF == c)
{
break;
}
}
}
// ch:帧信息回调函数 | en:Frame info callback
void __stdcall FrameCb(MV_FG_BUFFER_INFO* pstBufferInfo, void* pUser)
{
if (pstBufferInfo)
{
// ch:打印图像信息 | en:Print image info
printf("FrameNumber:%2I64d%, Width:%d, Height:%d, Chunk Num:%d\n",
pstBufferInfo->nFrameID, pstBufferInfo->nWidth, pstBufferInfo->nHeight, pstBufferInfo->nNumChunks);
int nRet = 0;
STREAMHANDLE hStream = (STREAMHANDLE)pUser;
unsigned int nChunkNum = pstBufferInfo->nNumChunks; // Chunk个数
MV_FG_CHUNK_DATA_INFO stChunkDataInfo = { 0 }; // Chunk信息
// ch:打印chunk信息 | en:Print chunk info
printf("********************\n");
for (unsigned int i = 0; i < nChunkNum; i++)
{
memset(&stChunkDataInfo, 0, sizeof(MV_FG_CHUNK_DATA_INFO));
nRet = MV_FG_GetBufferChunkData(hStream, pstBufferInfo, i, &stChunkDataInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get No.%d chunk data failed! %#x\n", i, nRet);
printf("********************\n");
return;
}
switch (stChunkDataInfo.nChunkID)
{
case CHUNK_ID_TIMESTAMP_LITTLE:
printf("Chunk ID[%#x], Chunk length[%d], Chunk data[%d]\n",
stChunkDataInfo.nChunkID, stChunkDataInfo.nChunkLen, *((uint32_t*)stChunkDataInfo.pChunkData));
break;
case CHUNK_ID_EXPOSURE_LITTLE:
printf("Chunk ID[%#x], Chunk length[%d], Chunk data[%f]\n",
stChunkDataInfo.nChunkID, stChunkDataInfo.nChunkLen, *((float*)stChunkDataInfo.pChunkData));
break;
default:
break;
}
}
printf("********************\n");
}
}
// ch:打印采集卡信息 | en:Print interface info
bool PrintInterfaceInfo(unsigned int nInterfaceNum)
{
int nRet = 0;
for (unsigned int i = 0; i < nInterfaceNum; i++)
{
MV_FG_INTERFACE_INFO stInterfaceInfo = { 0 };
nRet = MV_FG_GetInterfaceInfo(i, &stInterfaceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d interface failed! %#x\n", i, nRet);
return false;
}
switch (stInterfaceInfo.nTLayerType)
{
case MV_FG_CXP_INTERFACE:
{
printf("[CXP]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chSerialNumber);
break;
}
case MV_FG_GEV_INTERFACE:
{
printf("[GEV]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_INTERFACE:
{
printf("[CML]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown interface type.\n");
return false;
}
}
}
return true;
}
// ch:打印设备信息 | en:Print device info
bool PrintDeviceInfo(IFHANDLE hInterface, unsigned int nDeviceNum)
{
int nRet = 0;
for (unsigned int i = 0; i < nDeviceNum; i++)
{
MV_FG_DEVICE_INFO stDeviceInfo = { 0 };
nRet = MV_FG_GetDeviceInfo(hInterface, i, &stDeviceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d device failed! %#x\n", i, nRet);
return false;
}
switch (stDeviceInfo.nDevType)
{
case MV_FG_CXP_DEVICE:
{
printf("[CXP]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCXPDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCXPDevInfo.chModelName,
stDeviceInfo.DevInfo.stCXPDevInfo.chSerialNumber);
break;
}
case MV_FG_GEV_DEVICE:
{
printf("[GEV]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stGEVDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stGEVDevInfo.chModelName,
stDeviceInfo.DevInfo.stGEVDevInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_DEVICE:
{
printf("[CML]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCMLDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCMLDevInfo.chModelName,
stDeviceInfo.DevInfo.stCMLDevInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown device type.\n");
return false;
}
}
}
return true;
}
int main()
{
int nRet = 0;
IFHANDLE hInterface = NULL;
DEVHANDLE hDevice = NULL;
STREAMHANDLE hStream = NULL;
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
nRet = MV_FG_UpdateInterfaceList(MV_FG_CXP_INTERFACE | MV_FG_GEV_INTERFACE | MV_FG_CAMERALINK_INTERFACE, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update interface list failed! %#x\n", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
unsigned int nInterfaceNum = 0;
nRet = MV_FG_GetNumInterfaces(&nInterfaceNum);
if (MV_FG_SUCCESS != nRet || 0 == nInterfaceNum)
{
printf("No interface found! return = %d, number = %d\n", nRet, nInterfaceNum);
break;
}
// ch:显示采集卡信息 | en:Show interface info
if (false == PrintInterfaceInfo(nInterfaceNum))
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
printf("Select an interface: ");
scanf_s("%d", &nInterfaceIndex);
ClearStdin();
if (nInterfaceIndex < 0 || nInterfaceIndex >= (int)nInterfaceNum)
{
printf("Invalid interface index.\nQuit.\n");
break;
}
// ch:打开采集卡，获得采集卡句柄 | en:Open interface, get handle
nRet = MV_FG_OpenInterface((unsigned int)nInterfaceIndex, &hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d interface failed! %#x\n", nInterfaceIndex, nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
nRet = MV_FG_UpdateDeviceList(hInterface, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update device list failed! %#x\n", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
unsigned int nDeviceNum = 0;
nRet = MV_FG_GetNumDevices(hInterface, &nDeviceNum);
if (MV_FG_SUCCESS != nRet || 0 == nDeviceNum)
{
printf("No device found! return = %d, number = %d\n", nRet, nDeviceNum);
break;
}
// ch:显示设备信息 | en:Show device info
if (false == PrintDeviceInfo(hInterface, nDeviceNum))
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
printf("Select a device: ");
scanf_s("%d", &nDeviceIndex);
ClearStdin();
if (nDeviceIndex < 0 || nDeviceIndex >= (int)nDeviceNum)
{
printf("Invalid device index.\nQuit.\n");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
nRet = MV_FG_OpenDevice(hInterface, (unsigned int)nDeviceIndex, &hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d device failed! %#x\n", nDeviceIndex, nRet);
hDevice = NULL;
break;
}
// ch:开启Chunk Mode | en:Open Chunk Mode
nRet = MV_FG_SetBoolValue(hDevice, "ChunkModeActive", true);
if (MV_FG_SUCCESS != nRet)
{
printf("Set chunk mode failed! %#x\n", nRet);
break;
}
// ch:Chunk Selector设为Exposure | en: Chunk Selector set as Exposure
nRet = MV_FG_SetEnumValueByString(hDevice, "ChunkSelector", "Exposure");
if (MV_FG_SUCCESS != nRet)
{
printf("Set exposure chunk failed! %#x\n", nRet);
break;
}
// ch:开启Chunk Enable | en:Open Chunk Enable
nRet = MV_FG_SetBoolValue(hDevice, "ChunkEnable", true);
if (MV_FG_SUCCESS != nRet)
{
printf("Set exposure chunk enable failed! %#x\n", nRet);
break;
}
// ch:Chunk Selector设为Timestamp | en: Chunk Selector set as Timestamp
nRet = MV_FG_SetEnumValueByString(hDevice, "ChunkSelector", "Timestamp");
if (MV_FG_SUCCESS != nRet)
{
printf("Set timestamp chunk failed! %#x\n", nRet);
break;
}
// ch:开启Chunk Enable | en:Open Chunk Enable
nRet = MV_FG_SetBoolValue(hDevice, "ChunkEnable", true);
if (MV_FG_SUCCESS != nRet)
{
printf("Set timestamp chunk enable failed! %#x\n", nRet);
break;
}
// ch:关闭触发模式 | en:Close trigger mode
nRet = MV_FG_SetEnumValueByString(hDevice, "TriggerMode", "Off");
if (MV_FG_SUCCESS != nRet)
{
printf("Turn off trigger mode failed! %#x\n", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
unsigned int nStreamNum = 0;
nRet = MV_FG_GetNumStreams(hDevice, &nStreamNum);
if (MV_FG_SUCCESS != nRet || 0 == nStreamNum)
{
printf("No stream available! return = %d, number = %d\n", nRet, nStreamNum);
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
nRet = MV_FG_OpenStream(hDevice, 0, &hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Open stream failed! %#x\n", nRet);
break;
}
// ch:设置SDK内部缓存数量 | en:Set internal buffer number
nRet = MV_FG_SetBufferNum(hStream, BUFFER_NUMBER);
if (MV_FG_SUCCESS != nRet)
{
printf("Set buffer number failed! %#x\n", nRet);
break;
}
// ch:注册帧缓存信息回调函数 | en:Register frame info callback
nRet = MV_FG_RegisterFrameCallBack(hStream, FrameCb, hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Register frame callback failed! %#x\n", nRet);
break;
}
// ch:开始取流 | en:Start Acquisition
nRet = MV_FG_StartAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Start acquistion failed! %#x\n", nRet);
break;
}
printf("Press any key to stop acquisition.\n");
WaitForKeyPress();
// ch:停止取流 | en:Stop Acquisition
nRet = MV_FG_StopAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Stop acquisition failed! %#x\n", nRet);
break;
}
} while (0);
// ch:关闭流通道 | en:Close Stream
if (NULL != hStream)
{
nRet = MV_FG_CloseStream(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Close stream failed! %#x\n", nRet);
}
hStream = NULL;
}
// ch:关闭设备 | en:Close device
if (NULL != hDevice)
{
nRet = MV_FG_CloseDevice(hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Close device failed! %#x\n", nRet);
}
hDevice = NULL;
}
// ch:关闭采集卡 | en:Close interface
if (NULL != hInterface)
{
nRet = MV_FG_CloseInterface(hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Close interface failed! %#x\n", nRet);
}
hInterface = NULL;
}
printf("Press any key to exit.\n");
WaitForKeyPress();
return 0;
}


像素格式转换

该示例程序通过图像转换接口将相机取图的图像格式转换为用户需要的格式。
#include <stdio.h>
#include <Windows.h>
#include <process.h>
#include <conio.h>
#include "MVFGControl.h"
#define BUFFER_NUMBER 3 // ch:申请的缓存个数 | en:Number of requested buffer
#define FILE_NAME_LEN 256 // ch:最大文件名长度 | en:Max of file name length
#define SAVE_IMAGE_NUM 10 // ch:最大存储图像数量 | en:Max number of stored images
#define TIMEOUT 1000 // ch:超时时间，单位毫秒 | en:Timeout, unit ms
bool g_bExit = false; // ch:停止取流 | en:Stop grabbing
// ch:等待按键输入 | en:Wait for key press
void WaitForKeyPress(void)
{
while(!_kbhit())
{
Sleep(10);
}
_getch();
}
// ch:清空标准输入中的残留数据 | en:Flush stdin
void ClearStdin(void)
{
char c = '\0';
while (1)
{
c = getchar();
if ('\n' == c || EOF == c)
{
break;
}
}
}
bool IsColorPixelFormat(MV_FG_PIXEL_TYPE enPixelType)
{
switch(enPixelType)
{
case MV_FG_PIXEL_TYPE_RGBA8_Packed:
case MV_FG_PIXEL_TYPE_BGRA8_Packed:
case MV_FG_PIXEL_TYPE_BayerGR8:
case MV_FG_PIXEL_TYPE_BayerRG8:
case MV_FG_PIXEL_TYPE_BayerGB8:
case MV_FG_PIXEL_TYPE_BayerBG8:
case MV_FG_PIXEL_TYPE_BayerGB10:
case MV_FG_PIXEL_TYPE_BayerGB10_Packed:
case MV_FG_PIXEL_TYPE_BayerBG10:
case MV_FG_PIXEL_TYPE_BayerBG10_Packed:
case MV_FG_PIXEL_TYPE_BayerRG10:
case MV_FG_PIXEL_TYPE_BayerRG10_Packed:
case MV_FG_PIXEL_TYPE_BayerGR10:
case MV_FG_PIXEL_TYPE_BayerGR10_Packed:
case MV_FG_PIXEL_TYPE_BayerGB12:
case MV_FG_PIXEL_TYPE_BayerGB12_Packed:
case MV_FG_PIXEL_TYPE_BayerBG12:
case MV_FG_PIXEL_TYPE_BayerBG12_Packed:
case MV_FG_PIXEL_TYPE_BayerRG12:
case MV_FG_PIXEL_TYPE_BayerRG12_Packed:
case MV_FG_PIXEL_TYPE_BayerGR12:
case MV_FG_PIXEL_TYPE_BayerGR12_Packed:
case MV_FG_PIXEL_TYPE_BayerGR16:
case MV_FG_PIXEL_TYPE_BayerRG16:
case MV_FG_PIXEL_TYPE_BayerGB16:
case MV_FG_PIXEL_TYPE_BayerBG16:
case MV_FG_PIXEL_TYPE_YUV422_Packed:
case MV_FG_PIXEL_TYPE_YUV422_YUYV_Packed:
return true;
default:
return false;
}
}
// 判断黑白格式图像
bool IsMonoPixelFormat(MV_FG_PIXEL_TYPE enPixelType)
{
switch(enPixelType)
{
case MV_FG_PIXEL_TYPE_Mono10:
case MV_FG_PIXEL_TYPE_Mono10_Packed:
case MV_FG_PIXEL_TYPE_Mono12:
case MV_FG_PIXEL_TYPE_Mono12_Packed:
case MV_FG_PIXEL_TYPE_Mono16:
return true;
default:
return false;
}
}
// ch:取流线程 | en:Grabbing image data thread
unsigned int __stdcall GrabbingThread(void* pUser)
{
if (pUser)
{
STREAMHANDLE hStream = (STREAMHANDLE)pUser;
MV_FG_BUFFER_INFO stFrameInfo = { 0 }; // 图像信息
int nRet = 0;
MV_FG_CONVERT_PIXEL_INFO stConvertPixelInfo = {0}; // 图像转换信息
memset(&stConvertPixelInfo, 0, sizeof(MV_FG_CONVERT_PIXEL_INFO));
// ch:开始取流 | en:Start Acquisition
nRet = MV_FG_StartAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Start acquistion failed! %#x\n", nRet);
return nRet;
}
g_bExit = false;
while (!g_bExit)
{
// ch:获取一帧图像缓存信息 | en:Get one frame buffer's info
nRet = MV_FG_GetFrameBuffer(hStream, &stFrameInfo, TIMEOUT);
if (MV_FG_SUCCESS != nRet)
{
printf("Get frame buffer info failed! %#x\n", nRet);
continue;
}
else
{
printf("FrameNumber:%2I64d%, Width:%d, Height:%d\n", stFrameInfo.nFrameID, stFrameInfo.nWidth, stFrameInfo.nHeight);
if ((stFrameInfo.pBuffer) && (0 < stFrameInfo.nFilledSize))
{
MV_FG_PIXEL_TYPE enDstPixelType = MV_FG_PIXEL_TYPE_Undefined;
unsigned int nChannelNum = 0;
char szFileName[FILE_NAME_LEN] = { 0 };
FILE* pImageFile = NULL;
SYSTEMTIME sys;
GetLocalTime(&sys);
//如果是彩色则转成RGB8
if (IsColorPixelFormat(stFrameInfo.enPixelType))
{
nChannelNum = 3;
enDstPixelType = MV_FG_PIXEL_TYPE_RGB8_Packed;
sprintf_s(szFileName, FILE_NAME_LEN, "After_%04d%02d%02d%02d%02d%02d%03d.rgb", sys.wYear, sys.wMonth,
sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds);
}
//如果是黑白则转换成Mono8
else if (IsMonoPixelFormat(stFrameInfo.enPixelType))
{
nChannelNum = 1;
enDstPixelType = MV_FG_PIXEL_TYPE_Mono8;
sprintf_s(szFileName, FILE_NAME_LEN, "After_%04d%02d%02d%02d%02d%02d%03d.gray", sys.wYear, sys.wMonth,
sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds);
}
else
{
printf("Don't need to convert!\n");
}
if (enDstPixelType != MV_FG_PIXEL_TYPE_Undefined)
{
stConvertPixelInfo.stInputImageInfo.pImageBuf = (unsigned char*)stFrameInfo.pBuffer;
stConvertPixelInfo.stInputImageInfo.nImageBufLen = stFrameInfo.nFilledSize;
stConvertPixelInfo.stInputImageInfo.nHeight = stFrameInfo.nHeight;
stConvertPixelInfo.stInputImageInfo.nWidth = stFrameInfo.nWidth;
stConvertPixelInfo.stInputImageInfo.enPixelType = stFrameInfo.enPixelType;
unsigned int nSize = stFrameInfo.nHeight * stFrameInfo.nWidth * nChannelNum;
if (nSize > stConvertPixelInfo.stOutputImageInfo.nImageBufSize)
{
if (stConvertPixelInfo.stOutputImageInfo.pImageBuf)
{
free(stConvertPixelInfo.stOutputImageInfo.pImageBuf);
stConvertPixelInfo.stOutputImageInfo.pImageBuf = NULL;
}
stConvertPixelInfo.stOutputImageInfo.pImageBuf = (unsigned char*)malloc(nSize);
if (NULL == stConvertPixelInfo.stOutputImageInfo.pImageBuf)
{
printf("malloc pConvertData fail!\n");
nRet = MV_FG_ERR_RESOURCE_EXHAUSTED;
break;
}
stConvertPixelInfo.stOutputImageInfo.nImageBufSize = nSize;
}
stConvertPixelInfo.stOutputImageInfo.nImageBufLen = 0;
stConvertPixelInfo.stOutputImageInfo.enPixelType = enDstPixelType;
stConvertPixelInfo.enCfaMethod = MV_FG_CFA_METHOD_OPTIMAL;
nRet = MV_FG_ConvertPixelType(hStream, &stConvertPixelInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Convert Pixel Type fail! nRet [0x%x]\n", nRet);
continue;
}
if ((0 != fopen_s(&pImageFile, szFileName, "wb")) || (NULL == pImageFile))
{
continue;
}
fwrite(stConvertPixelInfo.stOutputImageInfo.pImageBuf, 1, stConvertPixelInfo.stOutputImageInfo.nImageBufLen, pImageFile);
fclose(pImageFile);
printf("Convert pixeltype succeed\n");
}
}
}
// ch:将缓存放回输入队列 | en:Put the buffer back into the input queue
nRet = MV_FG_ReleaseFrameBuffer(hStream, &stFrameInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Release frame buffer failed! %#x\n", nRet);
break;
}
}
if (stConvertPixelInfo.stOutputImageInfo.pImageBuf)
{
free(stConvertPixelInfo.stOutputImageInfo.pImageBuf);
stConvertPixelInfo.stOutputImageInfo.pImageBuf = NULL;
}
// ch:停止取流 | en:Stop Acquisition
nRet = MV_FG_StopAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Stop acquisition failed! %#x\n", nRet);
return nRet;
}
}
return MV_FG_SUCCESS;
}
// ch:打印采集卡信息 | en:Print interface info
bool PrintInterfaceInfo(unsigned int nInterfaceNum)
{
int nRet = 0;
for (unsigned int i = 0; i < nInterfaceNum; i++)
{
MV_FG_INTERFACE_INFO stInterfaceInfo = { 0 };
nRet = MV_FG_GetInterfaceInfo(i, &stInterfaceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d interface failed! %#x\n", i, nRet);
return false;
}
switch (stInterfaceInfo.nTLayerType)
{
case MV_FG_CXP_INTERFACE:
{
printf("[CXP]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chSerialNumber);
break;
}
case MV_FG_GEV_INTERFACE:
{
printf("[GEV]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_INTERFACE:
{
printf("[CML]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown interface type.\n");
return false;
}
}
}
return true;
}
// ch:打印设备信息 | en:Print device info
bool PrintDeviceInfo(IFHANDLE hInterface, unsigned int nDeviceNum)
{
int nRet = 0;
for (unsigned int i = 0; i < nDeviceNum; i++)
{
MV_FG_DEVICE_INFO stDeviceInfo = { 0 };
nRet = MV_FG_GetDeviceInfo(hInterface, i, &stDeviceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d device failed! %#x\n", i, nRet);
return false;
}
switch (stDeviceInfo.nDevType)
{
case MV_FG_CXP_DEVICE:
{
printf("[CXP]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCXPDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCXPDevInfo.chModelName,
stDeviceInfo.DevInfo.stCXPDevInfo.chSerialNumber);
break;
}
case MV_FG_GEV_DEVICE:
{
printf("[GEV]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stGEVDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stGEVDevInfo.chModelName,
stDeviceInfo.DevInfo.stGEVDevInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_DEVICE:
{
printf("[CML]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCMLDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCMLDevInfo.chModelName,
stDeviceInfo.DevInfo.stCMLDevInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown device type.\n");
return false;
}
}
}
return true;
}
int main()
{
int nRet = 0;
IFHANDLE hInterface = NULL;
DEVHANDLE hDevice = NULL;
STREAMHANDLE hStream = NULL;
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
nRet = MV_FG_UpdateInterfaceList(MV_FG_CXP_INTERFACE | MV_FG_GEV_INTERFACE | MV_FG_CAMERALINK_INTERFACE, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update interface list failed! %#x\n", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
unsigned int nInterfaceNum = 0;
nRet = MV_FG_GetNumInterfaces(&nInterfaceNum);
if (MV_FG_SUCCESS != nRet || 0 == nInterfaceNum)
{
printf("No interface found! return = %d, number = %d\n", nRet, nInterfaceNum);
break;
}
// ch:显示采集卡信息 | en:Show interface info
if (false == PrintInterfaceInfo(nInterfaceNum))
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
printf("Select an interface: ");
scanf_s("%d", &nInterfaceIndex);
ClearStdin();
if (nInterfaceIndex < 0 || nInterfaceIndex >= (int)nInterfaceNum)
{
printf("Invalid interface index.\nQuit.\n");
break;
}
// ch:以指定权限打开采集卡，获得采集卡句柄 | en:Open interface with specified permissions, get handle
nRet = MV_FG_OpenInterface((unsigned int)nInterfaceIndex, &hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d interface failed! %#x\n", nInterfaceIndex, nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
nRet = MV_FG_UpdateDeviceList(hInterface, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update device list failed! %#x\n", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
unsigned int nDeviceNum = 0;
nRet = MV_FG_GetNumDevices(hInterface, &nDeviceNum);
if (MV_FG_SUCCESS != nRet || 0 == nDeviceNum)
{
printf("No device found! return = %d, number = %d\n", nRet, nDeviceNum);
break;
}
// ch:显示设备信息 | en:Show device info
if (false == PrintDeviceInfo(hInterface, nDeviceNum))
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
printf("Select a device: ");
scanf_s("%d", &nDeviceIndex);
ClearStdin();
if (nDeviceIndex < 0 || nDeviceIndex >= (int)nDeviceNum)
{
printf("Invalid device index.\nQuit.\n");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
nRet = MV_FG_OpenDevice(hInterface, (unsigned int)nDeviceIndex, &hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d device failed! %#x\n", nDeviceIndex, nRet);
hDevice = NULL;
break;
}
// ch:关闭触发模式 | en:Close trigger mode
nRet = MV_FG_SetEnumValueByString(hDevice, "TriggerMode", "Off");
if (MV_FG_SUCCESS != nRet)
{
printf("Turn off trigger mode failed! %#x\n", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
unsigned int nStreamNum = 0;
nRet = MV_FG_GetNumStreams(hDevice, &nStreamNum);
if (MV_FG_SUCCESS != nRet || 0 == nStreamNum)
{
printf("No stream available! return = %d, number = %d\n", nRet, nStreamNum);
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
nRet = MV_FG_OpenStream(hDevice, 0, &hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Open stream failed! %#x\n", nRet);
break;
}
// ch:设置SDK内部缓存数量 | en:Set internal buffer number
nRet = MV_FG_SetBufferNum(hStream, BUFFER_NUMBER);
if (MV_FG_SUCCESS != nRet)
{
printf("Set buffer number failed! %#x\n", nRet);
break;
}
// ch:创建取流线程 | en:Create acquistion thread
void* hThreadHandle = (void*)_beginthreadex(NULL, 0, GrabbingThread, hStream, 0, NULL);
if (NULL == hThreadHandle)
{
printf("Create thread failed!\n");
break;
}
printf("Press any key to stop acquisition.\n");
WaitForKeyPress();
// ch:关闭取流线程 | en:Close acquistion thread
g_bExit = true;
WaitForSingleObject(hThreadHandle, INFINITE);
CloseHandle(hThreadHandle);
hThreadHandle = NULL;
} while (0);
// ch:关闭流通道 | en:Close Stream
if (NULL != hStream)
{
nRet = MV_FG_CloseStream(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Close stream failed! %#x\n", nRet);
}
hStream = NULL;
}
// ch:关闭设备 | en:Close device
if (NULL != hDevice)
{
nRet = MV_FG_CloseDevice(hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Close device failed! %#x\n", nRet);
}
hDevice = NULL;
}
// ch:关闭采集卡 | en:Close interface
if (NULL != hInterface)
{
nRet = MV_FG_CloseInterface(hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Close interface failed! %#x\n", nRet);
}
hInterface = NULL;
}
printf("Press any key to exit.\n");
WaitForKeyPress();
return 0;
}


动态库加载

该示例程序说明了按照动态调用的方式演示使用工业采集卡SDK。
#include <stdio.h>
#include <Windows.h>
#include <process.h>
#include <conio.h>
#include "MVFGDefines.h"
#include "MVFGErrorDefine.h"
#define BUFFER_NUMBER 3 // ch:申请的缓存个数 | en:Number of requested buffer
#define FILE_NAME_LEN 256 // ch:最大文件名长度 | en:Max of file name length
#define SAVE_IMAGE_NUM 10 // ch:最大存储图像数量 | en:Max number of stored images
#define TIMEOUT 1000 // ch:超时时间，单位毫秒 | en:Timeout, unit ms
typedef unsigned char* (__stdcall * DLL_GetSDKVersion) ();
typedef int (__stdcall * DLL_UpdateInterfaceList) (IN unsigned int nTLayerType, OUT bool8_t *pbChanged);
typedef int (__stdcall * DLL_GetNumInterfaces) (OUT unsigned int *pnNumIfaces);
typedef int (__stdcall * DLL_GetInterfaceInfo) (IN unsigned int nIndex, OUT MV_FG_INTERFACE_INFO *pstIfaceInfo);
typedef int (__stdcall * DLL_OpenInterface) (IN unsigned int nIndex, OUT IFHANDLE* phIface);
typedef int (__stdcall * DLL_OpenInterfaceEx) (IN unsigned int nIndex, IN int nAccess, OUT IFHANDLE* phIface);
typedef int (__stdcall * DLL_CloseInterface) (IN IFHANDLE hIface);
typedef int (__stdcall * DLL_UpdateDeviceList) (IN IFHANDLE hIface, OUT bool8_t *pbChanged);
typedef int (__stdcall * DLL_GetNumDevices) (IN IFHANDLE hIface, OUT unsigned int *pnNumDevices);
typedef int (__stdcall * DLL_GetDeviceInfo) (IN IFHANDLE hIface, IN unsigned int nIndex, OUT MV_FG_DEVICE_INFO *pstDevInfo);
typedef int (__stdcall * DLL_OpenDevice) (IN IFHANDLE hIface, IN unsigned int nIndex, OUT DEVHANDLE* phDevice);
typedef int (__stdcall * DLL_CloseDevice) (IN DEVHANDLE hDevice);
typedef int (__stdcall * DLL_GetNumStreams) (IN DEVHANDLE hDevice, OUT unsigned int *pnNumStreams);
typedef int (__stdcall * DLL_OpenStream) (IN DEVHANDLE hDevice, IN unsigned int nIndex, OUT STREAMHANDLE* phStream);
typedef int (__stdcall * DLL_CloseStream) (IN STREAMHANDLE hStream);
typedef int (__stdcall * DLL_SetBufferNum) (IN STREAMHANDLE hStream, IN unsigned int nBufferNum);
typedef int (__stdcall * DLL_RegisterFrameCallBack) (IN STREAMHANDLE hStream, IN MV_FG_FrameCallBack cbFrame, IN void* pUser);
typedef int (__stdcall * DLL_GetFrameBuffer) (IN STREAMHANDLE hStream, OUT MV_FG_BUFFER_INFO* pstBufferInfo, IN unsigned int nTimeout);
typedef int (__stdcall * DLL_ReleaseFrameBuffer) (IN STREAMHANDLE hStream, IN MV_FG_BUFFER_INFO* pstBufferInfo);
typedef int (__stdcall * DLL_GetBufferChunkData) (IN STREAMHANDLE hStream, IN MV_FG_BUFFER_INFO* pstBufferInfo, IN unsigned int nIndex, OUT MV_FG_CHUNK_DATA_INFO* pstChunkDataInfo);
typedef int (__stdcall * DLL_GetPayloadSize) (IN STREAMHANDLE hStream, OUT unsigned int* pnPayloadSize);
typedef int (__stdcall * DLL_AnnounceBuffer) (IN STREAMHANDLE hStream, IN void *pBuffer, IN unsigned int nSize, IN void *pPrivate, OUT BUFFERHANDLE *phBuffer);
typedef int (__stdcall * DLL_RevokeBuffer) (IN STREAMHANDLE hStream, IN BUFFERHANDLE hBuffer, OUT void **pBuffer, OUT void **pPrivate);
typedef int (__stdcall * DLL_FlushQueue) (IN STREAMHANDLE hStream, IN MV_FG_BUFFER_QUEUE_TYPE enQueueType);
typedef int (__stdcall * DLL_StartAcquisition) (IN STREAMHANDLE hStream);
typedef int (__stdcall * DLL_StopAcquisition) (IN STREAMHANDLE hStream);
typedef int (__stdcall * DLL_GetImageBuffer) (IN STREAMHANDLE hStream, OUT BUFFERHANDLE *phBuffer, IN unsigned int nTimeout);
typedef int (__stdcall * DLL_GetBufferInfo) (IN BUFFERHANDLE hBuffer, OUT MV_FG_BUFFER_INFO* pstBufferInfo);
typedef int (__stdcall * DLL_QueueBuffer) (IN BUFFERHANDLE hBuffer);
typedef int (__stdcall * DLL_GetXMLFile) (IN PORTHANDLE hPort, IN OUT unsigned char* pData, IN unsigned int nDataSize, OUT unsigned int* pnDataLen);
typedef int (__stdcall * DLL_GetNodeAccessMode) (IN PORTHANDLE hPort, IN const char * strName, OUT MV_FG_NODE_ACCESS_MODE *penAccessMode);
typedef int (__stdcall * DLL_GetNodeInterfaceType) (IN PORTHANDLE hPort, IN const char * strName, OUT MV_FG_NODE_INTERFACE_TYPE *penInterfaceType);
typedef int (__stdcall * DLL_GetIntValue) (IN PORTHANDLE hPort, IN const char* strKey, OUT MV_FG_INTVALUE *pstIntValue);
typedef int (__stdcall * DLL_SetIntValue) (IN PORTHANDLE hPort, IN const char* strKey, IN int64_t nValue);
typedef int (__stdcall * DLL_GetEnumValue) (IN PORTHANDLE hPort, IN const char* strKey, OUT MV_FG_ENUMVALUE *pstEnumValue);
typedef int (__stdcall * DLL_SetEnumValue) (IN PORTHANDLE hPort, IN const char* strKey, IN unsigned int nValue);
typedef int (__stdcall * DLL_SetEnumValueByString) (IN PORTHANDLE hPort, IN const char* strKey, IN const char* strValue);
typedef int (__stdcall * DLL_GetFloatValue) (IN PORTHANDLE hPort, IN const char* strKey, OUT MV_FG_FLOATVALUE *pstFloatValue);
typedef int (__stdcall * DLL_SetFloatValue) (IN PORTHANDLE hPort, IN const char* strKey, IN float fValue);
typedef int (__stdcall * DLL_GetBoolValue) (IN PORTHANDLE hPort, IN const char* strKey, OUT bool8_t *pbValue);
typedef int (__stdcall * DLL_SetBoolValue) (IN PORTHANDLE hPort, IN const char* strKey, IN bool8_t bValue);
typedef int (__stdcall * DLL_GetStringValue) (IN PORTHANDLE hPort, IN const char* strKey, OUT MV_FG_STRINGVALUE *pstStringValue);
typedef int (__stdcall * DLL_SetStringValue) (IN PORTHANDLE hPort, IN const char* strKey, IN const char* strValue);
typedef int (__stdcall * DLL_SetCommandValue) (IN PORTHANDLE hPort, IN const char* strKey);
typedef int (__stdcall * DLL_FeatureSave) (IN PORTHANDLE hPort, IN const char* strFileName);
typedef int (__stdcall * DLL_FeatureLoad) (IN PORTHANDLE hPort, IN const char* strFileName);
typedef int (__stdcall * DLL_RegisterExceptionCallBack)(IN PORTHANDLE hPort, IN MV_FG_ExceptionCallBack cbException, IN void* pUser);
typedef int (__stdcall * DLL_ReleaseTLayerResource) (IN unsigned int nTLayerType);
bool g_bExit = false; // ch:停止取流 | en:Stop grabbing
// ch:线程参数 | en:Thread parameter
struct MultiThrParam
{
void* pUser; // ch:用户传入的参数 | en:User param
HINSTANCE hDll; // ch:Dll句柄 | en:Dll handle
};
// ch:等待按键输入 | en:Wait for key press
void WaitForKeyPress(void)
{
while(!_kbhit())
{
Sleep(10);
}
_getch();
}
// ch:清空标准输入中的残留数据 | en:Flush stdin
void ClearStdin(void)
{
char c = '\0';
while (1)
{
c = getchar();
if ('\n' == c || EOF == c)
{
break;
}
}
}
// ch:保存图像原始数据 | en:Save original image data
void SaveRawImage(int nImageNo, MV_FG_BUFFER_INFO* pstImageInfo)
{
if (pstImageInfo)
{
char szFileName[FILE_NAME_LEN] = { 0 };
sprintf_s(szFileName, FILE_NAME_LEN, "Image_w%d_h%d_n%d.raw", pstImageInfo->nWidth, pstImageInfo->nHeight, nImageNo);
FILE* pImageFile = NULL;
if ((0 != fopen_s(&pImageFile, szFileName, "wb")) || (NULL == pImageFile))
{
return;
}
fwrite(pstImageInfo->pBuffer, 1, pstImageInfo->nFilledSize, pImageFile);
fclose(pImageFile);
}
}
// ch:取流线程 | en:Grabbing image data thread
unsigned int __stdcall GrabbingThread(void* pUser)
{
if (pUser)
{
MultiThrParam* pstThreadParam = (MultiThrParam*)pUser;
MV_FG_BUFFER_INFO stFrameInfo = { 0 }; // 图像信息
int nSaveImage = 0; // 保存的图像数量
int nRet = 0;
DLL_StartAcquisition DLLStartAcquisition = (DLL_StartAcquisition)GetProcAddress(pstThreadParam->hDll, "MV_FG_StartAcquisition");
DLL_GetFrameBuffer DLLGetFrameBuffer = (DLL_GetFrameBuffer)GetProcAddress(pstThreadParam->hDll, "MV_FG_GetFrameBuffer");
DLL_ReleaseFrameBuffer DLLReleaseFrameBuffer = (DLL_ReleaseFrameBuffer)GetProcAddress(pstThreadParam->hDll, "MV_FG_ReleaseFrameBuffer");
DLL_StopAcquisition DLLStopAcquisition = (DLL_StopAcquisition)GetProcAddress(pstThreadParam->hDll, "MV_FG_StopAcquisition");
// ch:开始取流 | en:Start Acquisition
nRet = DLLStartAcquisition(pstThreadParam->pUser);
if (MV_FG_SUCCESS != nRet)
{
printf("Start acquistion failed! %#x\n", nRet);
return nRet;
}
g_bExit = false;
while (!g_bExit)
{
// ch:获取一帧图像缓存信息 | en:Get one frame buffer's info
nRet = DLLGetFrameBuffer(pstThreadParam->pUser, &stFrameInfo, TIMEOUT);
if (MV_FG_SUCCESS != nRet)
{
printf("Get frame buffer info failed! %#x\n", nRet);
continue;
}
else
{
printf("FrameNumber:%2I64d%, Width:%d, Height:%d\n", stFrameInfo.nFrameID, stFrameInfo.nWidth, stFrameInfo.nHeight);
if (nSaveImage < SAVE_IMAGE_NUM)
{
SaveRawImage(++nSaveImage, &stFrameInfo);
}
}
// ch:将缓存放回输入队列 | en:Put the buffer back into the input queue
nRet = DLLReleaseFrameBuffer(pstThreadParam->pUser, &stFrameInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Release frame buffer failed! %#x\n", nRet);
break;
}
}
// ch:停止取流 | en:Stop Acquisition
nRet = DLLStopAcquisition(pstThreadParam->pUser);
if (MV_FG_SUCCESS != nRet)
{
printf("Stop acquisition failed! %#x\n", nRet);
return nRet;
}
}
return MV_FG_SUCCESS;
}
// ch:打印采集卡信息 | en:Print interface info
bool PrintInterfaceInfo(HINSTANCE hDll, unsigned int nInterfaceNum)
{
if (NULL == hDll)
{
printf("Parameter error!\n");
return false;
}
int nRet = 0;
DLL_GetInterfaceInfo DLLGetInterfaceInfo = (DLL_GetInterfaceInfo)GetProcAddress(hDll, "MV_FG_GetInterfaceInfo");
for (unsigned int i = 0; i < nInterfaceNum; i++)
{
MV_FG_INTERFACE_INFO stInterfaceInfo = { 0 };
nRet = DLLGetInterfaceInfo(i, &stInterfaceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d interface failed! %#x\n", i, nRet);
return false;
}
switch (stInterfaceInfo.nTLayerType)
{
case MV_FG_CXP_INTERFACE:
{
printf("[CXP]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chSerialNumber);
break;
}
case MV_FG_GEV_INTERFACE:
{
printf("[GEV]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_INTERFACE:
{
printf("[CML]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown interface type.\n");
return false;
}
}
}
return true;
}
// ch:打印设备信息 | en:Print device info
bool PrintDeviceInfo(HINSTANCE hDll, IFHANDLE hInterface, unsigned int nDeviceNum)
{
if (NULL == hDll)
{
printf("Parameter error!\n");
return false;
}
int nRet = 0;
DLL_GetDeviceInfo DLLGetDeviceInfo = (DLL_GetDeviceInfo)GetProcAddress(hDll, "MV_FG_GetDeviceInfo");
for (unsigned int i = 0; i < nDeviceNum; i++)
{
MV_FG_DEVICE_INFO stDeviceInfo = { 0 };
nRet = DLLGetDeviceInfo(hInterface, i, &stDeviceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d device failed! %#x\n", i, nRet);
return false;
}
switch (stDeviceInfo.nDevType)
{
case MV_FG_CXP_DEVICE:
{
printf("[CXP]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCXPDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCXPDevInfo.chModelName,
stDeviceInfo.DevInfo.stCXPDevInfo.chSerialNumber);
break;
}
case MV_FG_GEV_DEVICE:
{
printf("[GEV]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stGEVDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stGEVDevInfo.chModelName,
stDeviceInfo.DevInfo.stGEVDevInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_DEVICE:
{
printf("[CML]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCMLDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCMLDevInfo.chModelName,
stDeviceInfo.DevInfo.stCMLDevInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown device type.\n");
return false;
}
}
}
return true;
}
int main()
{
HINSTANCE MVFGCtrlDll = NULL; // ch:MVFGControl.dll的句柄 | en:Handle of MVFGControl.dll
// ch:dll默认路径为：系统盘:\Program Files (x86)\Common Files\MVS\Runtime
// en:Dynamic link library default path:System Disk:\Program Files (x86)\Common Files\MVS\Runtime
MVFGCtrlDll = LoadLibrary("MVFGControl.dll");
if (NULL == MVFGCtrlDll)
{
DWORD errCode = GetLastError();
printf("Error code! [%ld]\n",errCode);
printf("Press any key to exit.\n");
WaitForKeyPress();
return -1;
}
int nRet = 0;
IFHANDLE hInterface = NULL;
DEVHANDLE hDevice = NULL;
STREAMHANDLE hStream = NULL;
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
DLL_UpdateInterfaceList DLLUpdateInterfaceList = (DLL_UpdateInterfaceList)GetProcAddress(MVFGCtrlDll, "MV_FG_UpdateInterfaceList");
nRet = DLLUpdateInterfaceList(MV_FG_CXP_INTERFACE | MV_FG_GEV_INTERFACE | MV_FG_CAMERALINK_INTERFACE, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update interface list failed! %#x\n", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
unsigned int nInterfaceNum = 0;
DLL_GetNumInterfaces DLLGetNumInterfaces = (DLL_GetNumInterfaces)GetProcAddress(MVFGCtrlDll, "MV_FG_GetNumInterfaces");
nRet = DLLGetNumInterfaces(&nInterfaceNum);
if (MV_FG_SUCCESS != nRet || 0 == nInterfaceNum)
{
printf("No interface found! return = %d, number = %d\n", nRet, nInterfaceNum);
break;
}
// ch:显示采集卡信息 | en:Show interface info
if (false == PrintInterfaceInfo(MVFGCtrlDll, nInterfaceNum))
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
printf("Select an interface: ");
scanf_s("%d", &nInterfaceIndex);
ClearStdin();
if (nInterfaceIndex < 0 || nInterfaceIndex >= (int)nInterfaceNum)
{
printf("Invalid interface index.\nQuit.\n");
break;
}
// ch:以指定权限打开采集卡，获得采集卡句柄 | en:Open interface with specified permissions, get handle
DLL_OpenInterfaceEx DLLOpenInterfaceEx = (DLL_OpenInterfaceEx)GetProcAddress(MVFGCtrlDll, "MV_FG_OpenInterfaceEx");
nRet = DLLOpenInterfaceEx((unsigned int)nInterfaceIndex, MV_FG_ACCESS_CONTROL, &hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d interface failed! %#x\n", nInterfaceIndex, nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
DLL_UpdateDeviceList DLLUpdateDeviceList = (DLL_UpdateDeviceList)GetProcAddress(MVFGCtrlDll, "MV_FG_UpdateDeviceList");
nRet = DLLUpdateDeviceList(hInterface, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update device list failed! %#x\n", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
unsigned int nDeviceNum = 0;
DLL_GetNumDevices DLLGetNumDevices = (DLL_GetNumDevices)GetProcAddress(MVFGCtrlDll, "MV_FG_GetNumDevices");
nRet = DLLGetNumDevices(hInterface, &nDeviceNum);
if (MV_FG_SUCCESS != nRet || 0 == nDeviceNum)
{
printf("No device found! return = %d, number = %d\n", nRet, nDeviceNum);
break;
}
// ch:显示设备信息 | en:Show device info
if (false == PrintDeviceInfo(MVFGCtrlDll, hInterface, nDeviceNum))
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
printf("Select a device: ");
scanf_s("%d", &nDeviceIndex);
ClearStdin();
if (nDeviceIndex < 0 || nDeviceIndex >= (int)nDeviceNum)
{
printf("Invalid device index.\nQuit.\n");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
DLL_OpenDevice DLLOpenDevice = (DLL_OpenDevice)GetProcAddress(MVFGCtrlDll, "MV_FG_OpenDevice");
nRet = DLLOpenDevice(hInterface, (unsigned int)nDeviceIndex, &hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d device failed! %#x\n", nDeviceIndex, nRet);
hDevice = NULL;
break;
}
// ch:关闭触发模式 | en:Close trigger mode
DLL_SetEnumValueByString DLLSetEnumValueByString = (DLL_SetEnumValueByString)GetProcAddress(MVFGCtrlDll, "MV_FG_SetEnumValueByString");
nRet = DLLSetEnumValueByString(hDevice, "TriggerMode", "Off");
if (MV_FG_SUCCESS != nRet)
{
printf("Turn off trigger mode failed! %#x\n", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
unsigned int nStreamNum = 0;
DLL_GetNumStreams DLLGetNumStreams = (DLL_GetNumStreams)GetProcAddress(MVFGCtrlDll, "MV_FG_GetNumStreams");
nRet = DLLGetNumStreams(hDevice, &nStreamNum);
if (MV_FG_SUCCESS != nRet || 0 == nStreamNum)
{
printf("No stream available! return = %d, number = %d\n", nRet, nStreamNum);
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
DLL_OpenStream DLLOpenStream = (DLL_OpenStream)GetProcAddress(MVFGCtrlDll, "MV_FG_OpenStream");
nRet = DLLOpenStream(hDevice, 0, &hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Open stream failed! %#x\n", nRet);
break;
}
// ch:设置SDK内部缓存数量 | en:Set internal buffer number
DLL_SetBufferNum DLLSetBufferNum = (DLL_SetBufferNum)GetProcAddress(MVFGCtrlDll, "MV_FG_SetBufferNum");
nRet = DLLSetBufferNum(hStream, BUFFER_NUMBER);
if (MV_FG_SUCCESS != nRet)
{
printf("Set buffer number failed! %#x\n", nRet);
break;
}
// ch:创建取流线程 | en:Create acquistion thread
MultiThrParam stThreadParam = { 0 };
stThreadParam.pUser = hStream;
stThreadParam.hDll = MVFGCtrlDll;
void* hThreadHandle = (void*)_beginthreadex(NULL, 0, GrabbingThread, (void*)&stThreadParam, 0, NULL);
if (NULL == hThreadHandle)
{
printf("Create thread failed!\n");
break;
}
printf("Press any key to stop acquisition.\n");
WaitForKeyPress();
// ch:关闭取流线程 | en:Close acquistion thread
g_bExit = true;
WaitForSingleObject(hThreadHandle, INFINITE);
CloseHandle(hThreadHandle);
hThreadHandle = NULL;
} while (0);
// ch:关闭流通道 | en:Close Stream
if (NULL != hStream)
{
DLL_CloseStream DLLCloseStream = (DLL_CloseStream)GetProcAddress(MVFGCtrlDll, "MV_FG_CloseStream");
nRet = DLLCloseStream(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Close stream failed! %#x\n", nRet);
}
hStream = NULL;
}
// ch:关闭设备 | en:Close device
if (NULL != hDevice)
{
DLL_CloseDevice DLLCloseDevice = (DLL_CloseDevice)GetProcAddress(MVFGCtrlDll, "MV_FG_CloseDevice");
nRet = DLLCloseDevice(hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Close device failed! %#x\n", nRet);
}
hDevice = NULL;
}
// ch:关闭采集卡 | en:Close interface
if (NULL != hInterface)
{
DLL_CloseInterface DLLCloseInterface = (DLL_CloseInterface)GetProcAddress(MVFGCtrlDll, "MV_FG_CloseInterface");
nRet = DLLCloseInterface(hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Close interface failed! %#x\n", nRet);
}
hInterface = NULL;
}
FreeLibrary(MVFGCtrlDll);
printf("Press any key to exit.\n");
WaitForKeyPress();
return 0;
}


主动取图

该示例程序说明如何通过主动取图的方式获取相机图像。打开采集卡，打开相机，打开流通道，设置内部缓存数量，创建取流线程，开始取流，停止取流，关闭流通道，关闭相机，关闭采集卡。
#include <stdio.h>
#include <Windows.h>
#include <process.h>
#include <conio.h>
#include "MVFGControl.h"
#define BUFFER_NUMBER 3 // ch:申请的缓存个数 | en:Number of requested buffer
#define FILE_NAME_LEN 256 // ch:最大文件名长度 | en:Max of file name length
#define SAVE_IMAGE_NUM 10 // ch:最大存储图像数量 | en:Max number of stored images
#define TIMEOUT 1000 // ch:超时时间，单位毫秒 | en:Timeout, unit ms
bool g_bExit = false; // ch:停止取流 | en:Stop grabbing
// ch:等待按键输入 | en:Wait for key press
void WaitForKeyPress(void)
{
while(!_kbhit())
{
Sleep(10);
}
_getch();
}
// ch:清空标准输入中的残留数据 | en:Flush stdin
void ClearStdin(void)
{
char c = '\0';
while (1)
{
c = getchar();
if ('\n' == c || EOF == c)
{
break;
}
}
}
// ch:保存BMP图像原始数据 | en:Save bmp image data
void SaveBitImage(unsigned char* pBitMapBuf, unsigned int nBufferSize)
{
if (NULL != pBitMapBuf && 0 < nBufferSize)
{
char szFileName[FILE_NAME_LEN] = { 0 };
FILE* pImageFile = NULL;
SYSTEMTIME sys;
GetLocalTime(&sys);
sprintf_s(szFileName, FILE_NAME_LEN, "Image_%04d%02d%02d%02d%02d%02d%04d.bmp", sys.wYear, sys.wMonth,
sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds);
if ((0 != fopen_s(&pImageFile, szFileName, "wb")) || (NULL == pImageFile))
{
return;
}
fwrite(pBitMapBuf, 1, nBufferSize, pImageFile);
fclose(pImageFile);
}
}
// ch:取流线程 | en:Grabbing image data thread
unsigned int __stdcall GrabbingThread(void* pUser)
{
if (pUser)
{
STREAMHANDLE hStream = (STREAMHANDLE)pUser;
MV_FG_BUFFER_INFO stFrameInfo = { 0 }; // 图像信息
int nRet = 0;
MV_FG_SAVE_BITMAP_INFO stSaveBitmapInfo = {0}; // 图像保存信息
memset(&stSaveBitmapInfo, 0, sizeof(MV_FG_SAVE_BITMAP_INFO));
// ch:开始取流 | en:Start Acquisition
nRet = MV_FG_StartAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Start acquistion failed! %#x\n", nRet);
return nRet;
}
g_bExit = false;
while (!g_bExit)
{
// ch:获取一帧图像缓存信息 | en:Get one frame buffer's info
nRet = MV_FG_GetFrameBuffer(hStream, &stFrameInfo, TIMEOUT);
if (MV_FG_SUCCESS != nRet)
{
printf("Get frame buffer info failed! %#x\n", nRet);
continue;
}
else
{
printf("FrameNumber:%2I64d%, Width:%d, Height:%d\n", stFrameInfo.nFrameID, stFrameInfo.nWidth, stFrameInfo.nHeight);
if ((stFrameInfo.pBuffer) && (0 < stFrameInfo.nFilledSize))
{
stSaveBitmapInfo.stInputImageInfo.pImageBuf = (unsigned char*)stFrameInfo.pBuffer;
stSaveBitmapInfo.stInputImageInfo.nImageBufLen = stFrameInfo.nFilledSize;
stSaveBitmapInfo.stInputImageInfo.nHeight = stFrameInfo.nHeight;
stSaveBitmapInfo.stInputImageInfo.nWidth = stFrameInfo.nWidth;
stSaveBitmapInfo.stInputImageInfo.enPixelType = stFrameInfo.enPixelType;
unsigned int nSize = stFrameInfo.nHeight * stFrameInfo.nWidth * 4;
if (stSaveBitmapInfo.nBmpBufSize < nSize)
{
if (stSaveBitmapInfo.pBmpBuf)
{
free (stSaveBitmapInfo.pBmpBuf);
stSaveBitmapInfo.pBmpBuf = NULL;
}
stSaveBitmapInfo.pBmpBuf = (unsigned char*)malloc(nSize);
if (NULL == stSaveBitmapInfo.pBmpBuf)
{
printf("malloc pConvertData fail!\n");
nRet = MV_FG_ERR_RESOURCE_EXHAUSTED;
break;
}
stSaveBitmapInfo.nBmpBufSize = nSize;
}
stSaveBitmapInfo.nBmpBufLen = 0;
stSaveBitmapInfo.enCfaMethod = MV_FG_CFA_METHOD_OPTIMAL;
nRet = MV_FG_SaveBitmap(hStream, &stSaveBitmapInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("MV_FG_SaveBitmap info failed! %#x\n", nRet);
}
else
{
SaveBitImage(stSaveBitmapInfo.pBmpBuf, stSaveBitmapInfo.nBmpBufLen);
}
}
}
// ch:将缓存放回输入队列 | en:Put the buffer back into the input queue
nRet = MV_FG_ReleaseFrameBuffer(hStream, &stFrameInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Release frame buffer failed! %#x\n", nRet);
break;
}
}
if (stSaveBitmapInfo.pBmpBuf)
{
free(stSaveBitmapInfo.pBmpBuf);
stSaveBitmapInfo.pBmpBuf = NULL;
}
// ch:停止取流 | en:Stop Acquisition
nRet = MV_FG_StopAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Stop acquisition failed! %#x\n", nRet);
return nRet;
}
}
return MV_FG_SUCCESS;
}
// ch:打印采集卡信息 | en:Print interface info
bool PrintInterfaceInfo(unsigned int nInterfaceNum)
{
int nRet = 0;
for (unsigned int i = 0; i < nInterfaceNum; i++)
{
MV_FG_INTERFACE_INFO stInterfaceInfo = { 0 };
nRet = MV_FG_GetInterfaceInfo(i, &stInterfaceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d interface failed! %#x\n", i, nRet);
return false;
}
switch (stInterfaceInfo.nTLayerType)
{
case MV_FG_CXP_INTERFACE:
{
printf("[CXP]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chSerialNumber);
break;
}
case MV_FG_GEV_INTERFACE:
{
printf("[GEV]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_INTERFACE:
{
printf("[CML]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown interface type.\n");
return false;
}
}
}
return true;
}
// ch:打印设备信息 | en:Print device info
bool PrintDeviceInfo(IFHANDLE hInterface, unsigned int nDeviceNum)
{
int nRet = 0;
for (unsigned int i = 0; i < nDeviceNum; i++)
{
MV_FG_DEVICE_INFO stDeviceInfo = { 0 };
nRet = MV_FG_GetDeviceInfo(hInterface, i, &stDeviceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d device failed! %#x\n", i, nRet);
return false;
}
switch (stDeviceInfo.nDevType)
{
case MV_FG_CXP_DEVICE:
{
printf("[CXP]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCXPDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCXPDevInfo.chModelName,
stDeviceInfo.DevInfo.stCXPDevInfo.chSerialNumber);
break;
}
case MV_FG_GEV_DEVICE:
{
printf("[GEV]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stGEVDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stGEVDevInfo.chModelName,
stDeviceInfo.DevInfo.stGEVDevInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_DEVICE:
{
printf("[CML]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCMLDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCMLDevInfo.chModelName,
stDeviceInfo.DevInfo.stCMLDevInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown device type.\n");
return false;
}
}
}
return true;
}
int main()
{
int nRet = 0;
IFHANDLE hInterface = NULL;
DEVHANDLE hDevice = NULL;
STREAMHANDLE hStream = NULL;
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
nRet = MV_FG_UpdateInterfaceList(MV_FG_CXP_INTERFACE | MV_FG_GEV_INTERFACE | MV_FG_CAMERALINK_INTERFACE, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update interface list failed! %#x\n", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
unsigned int nInterfaceNum = 0;
nRet = MV_FG_GetNumInterfaces(&nInterfaceNum);
if (MV_FG_SUCCESS != nRet || 0 == nInterfaceNum)
{
printf("No interface found! return = %d, number = %d\n", nRet, nInterfaceNum);
break;
}
// ch:显示采集卡信息 | en:Show interface info
if (false == PrintInterfaceInfo(nInterfaceNum))
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
printf("Select an interface: ");
scanf_s("%d", &nInterfaceIndex);
ClearStdin();
if (nInterfaceIndex < 0 || nInterfaceIndex >= (int)nInterfaceNum)
{
printf("Invalid interface index.\nQuit.\n");
break;
}
// ch:以指定权限打开采集卡，获得采集卡句柄 | en:Open interface with specified permissions, get handle
nRet = MV_FG_OpenInterface((unsigned int)nInterfaceIndex, &hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d interface failed! %#x\n", nInterfaceIndex, nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
nRet = MV_FG_UpdateDeviceList(hInterface, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update device list failed! %#x\n", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
unsigned int nDeviceNum = 0;
nRet = MV_FG_GetNumDevices(hInterface, &nDeviceNum);
if (MV_FG_SUCCESS != nRet || 0 == nDeviceNum)
{
printf("No device found! return = %d, number = %d\n", nRet, nDeviceNum);
break;
}
// ch:显示设备信息 | en:Show device info
if (false == PrintDeviceInfo(hInterface, nDeviceNum))
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
printf("Select a device: ");
scanf_s("%d", &nDeviceIndex);
ClearStdin();
if (nDeviceIndex < 0 || nDeviceIndex >= (int)nDeviceNum)
{
printf("Invalid device index.\nQuit.\n");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
nRet = MV_FG_OpenDevice(hInterface, (unsigned int)nDeviceIndex, &hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d device failed! %#x\n", nDeviceIndex, nRet);
hDevice = NULL;
break;
}
// ch:关闭触发模式 | en:Close trigger mode
nRet = MV_FG_SetEnumValueByString(hDevice, "TriggerMode", "Off");
if (MV_FG_SUCCESS != nRet)
{
printf("Turn off trigger mode failed! %#x\n", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
unsigned int nStreamNum = 0;
nRet = MV_FG_GetNumStreams(hDevice, &nStreamNum);
if (MV_FG_SUCCESS != nRet || 0 == nStreamNum)
{
printf("No stream available! return = %d, number = %d\n", nRet, nStreamNum);
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
nRet = MV_FG_OpenStream(hDevice, 0, &hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Open stream failed! %#x\n", nRet);
break;
}
// ch:设置SDK内部缓存数量 | en:Set internal buffer number
nRet = MV_FG_SetBufferNum(hStream, BUFFER_NUMBER);
if (MV_FG_SUCCESS != nRet)
{
printf("Set buffer number failed! %#x\n", nRet);
break;
}
// ch:创建取流线程 | en:Create acquistion thread
void* hThreadHandle = (void*)_beginthreadex(NULL, 0, GrabbingThread, hStream, 0, NULL);
if (NULL == hThreadHandle)
{
printf("Create thread failed!\n");
break;
}
printf("Press any key to stop acquisition.\n");
WaitForKeyPress();
// ch:关闭取流线程 | en:Close acquistion thread
g_bExit = true;
WaitForSingleObject(hThreadHandle, INFINITE);
CloseHandle(hThreadHandle);
hThreadHandle = NULL;
} while (0);
// ch:关闭流通道 | en:Close Stream
if (NULL != hStream)
{
nRet = MV_FG_CloseStream(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Close stream failed! %#x\n", nRet);
}
hStream = NULL;
}
// ch:关闭设备 | en:Close device
if (NULL != hDevice)
{
nRet = MV_FG_CloseDevice(hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Close device failed! %#x\n", nRet);
}
hDevice = NULL;
}
// ch:关闭采集卡 | en:Close interface
if (NULL != hInterface)
{
nRet = MV_FG_CloseInterface(hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Close interface failed! %#x\n", nRet);
}
hInterface = NULL;
}
printf("Press any key to exit.\n");
WaitForKeyPress();
return 0;
}


回调取图

该示例程序说明如何通过回调取图的方式获取相机图像。打开采集卡，打开相机，打开流通道，设置内部缓存数量，注册回调函数，开始取流，停止取流，关闭流通道，关闭相机，关闭采集卡。
#include <stdio.h>
#include <Windows.h>
#include <process.h>
#include <conio.h>
#include "MVFGControl.h"
#define BUFFER_NUMBER 3 // ch:申请的缓存个数 | en:Number of requested buffer
#define FILE_NAME_LEN 256 // ch:最大文件名长度 | en:Max of file name length
// User自定义参数
typedef struct _Callback_UserParam_
{
DEVHANDLE hDevice; // 设备句柄
MV_FG_SAVE_JPEG_INFO stSaveJpegInfo; // 图像保存信息
}Callback_User;
// ch:等待按键输入 | en:Wait for key press
void WaitForKeyPress(void)
{
while(!_kbhit())
{
Sleep(10);
}
_getch();
}
// ch:清空标准输入中的残留数据 | en:Flush stdin
void ClearStdin(void)
{
char c = '\0';
while (1)
{
c = getchar();
if ('\n' == c || EOF == c)
{
break;
}
}
}
// ch:保存图像为JPEG | en:Save original image data
void SaveJpegImage(unsigned char* pJpgBuf, unsigned int nJpegSize)
{
if (NULL != pJpgBuf && 0 < nJpegSize)
{
char szFileName[FILE_NAME_LEN] = { 0 };
SYSTEMTIME sys;
GetLocalTime(&sys);
sprintf_s(szFileName, FILE_NAME_LEN, "Image_%04d%02d%02d%02d%02d%02d%04d.jpg", sys.wYear, sys.wMonth,
sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds);
FILE* pImageFile = NULL;
if ((0 != fopen_s(&pImageFile, szFileName, "wb")) || (NULL == pImageFile))
{
return;
}
fwrite(pJpgBuf, 1, nJpegSize, pImageFile);
fclose(pImageFile);
}
}
// ch:帧信息回调函数 | en:Frame info callback
void __stdcall FrameCb(MV_FG_BUFFER_INFO* pstBufferInfo, void* pUser)
{
if (pstBufferInfo && pUser)
{
Callback_User* pstUser = (Callback_User*)pUser;
int nRet = 0;
DEVHANDLE hDevice = pstUser->hDevice;
MV_FG_SAVE_JPEG_INFO stSaveJpegInfo = pstUser->stSaveJpegInfo;
printf("FrameNumber:%2I64d%, Width:%d, Height:%d\n", pstBufferInfo->nFrameID, pstBufferInfo->nWidth, pstBufferInfo->nHeight);
stSaveJpegInfo.stInputImageInfo.pImageBuf = (unsigned char*)pstBufferInfo->pBuffer;
stSaveJpegInfo.stInputImageInfo.nImageBufLen = pstBufferInfo->nFilledSize;
stSaveJpegInfo.stInputImageInfo.nHeight = pstBufferInfo->nHeight;
stSaveJpegInfo.stInputImageInfo.nWidth = pstBufferInfo->nWidth;
stSaveJpegInfo.stInputImageInfo.enPixelType = pstBufferInfo->enPixelType;
unsigned int nSize = pstBufferInfo->nHeight * pstBufferInfo->nWidth * 2;
if (stSaveJpegInfo.nJpgBufSize < nSize)
{
if (stSaveJpegInfo.pJpgBuf)
{
free (stSaveJpegInfo.pJpgBuf);
stSaveJpegInfo.pJpgBuf = NULL;
}
stSaveJpegInfo.pJpgBuf = (unsigned char*)malloc(nSize);
if (NULL == stSaveJpegInfo.pJpgBuf)
{
printf("malloc pConvertData fail!\n");
nRet = MV_FG_ERR_RESOURCE_EXHAUSTED;
return;
}
stSaveJpegInfo.nJpgBufSize = nSize;
}
stSaveJpegInfo.nJpgBufLen = 0;
stSaveJpegInfo.enCfaMethod = MV_FG_CFA_METHOD_OPTIMAL;
stSaveJpegInfo.nJpgQuality = 60;
nRet = MV_FG_SaveJpeg(hDevice, &stSaveJpegInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Save Jpeg failed! %#x\n", nRet);
}
else
{
SaveJpegImage(stSaveJpegInfo.pJpgBuf, stSaveJpegInfo.nJpgBufLen);
}
}
return;
}
// ch:打印采集卡信息 | en:Print interface info
bool PrintInterfaceInfo(unsigned int nInterfaceNum)
{
int nRet = 0;
for (unsigned int i = 0; i < nInterfaceNum; i++)
{
MV_FG_INTERFACE_INFO stInterfaceInfo = { 0 };
nRet = MV_FG_GetInterfaceInfo(i, &stInterfaceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d interface failed! %#x\n", i, nRet);
return false;
}
switch (stInterfaceInfo.nTLayerType)
{
case MV_FG_CXP_INTERFACE:
{
printf("[CXP]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chSerialNumber);
break;
}
case MV_FG_GEV_INTERFACE:
{
printf("[GEV]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_INTERFACE:
{
printf("[CML]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown interface type.\n");
return false;
}
}
}
return true;
}
// ch:打印设备信息 | en:Print device info
bool PrintDeviceInfo(IFHANDLE hInterface, unsigned int nDeviceNum)
{
int nRet = 0;
for (unsigned int i = 0; i < nDeviceNum; i++)
{
MV_FG_DEVICE_INFO stDeviceInfo = { 0 };
nRet = MV_FG_GetDeviceInfo(hInterface, i, &stDeviceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d device failed! %#x\n", i, nRet);
return false;
}
switch (stDeviceInfo.nDevType)
{
case MV_FG_CXP_DEVICE:
{
printf("[CXP]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCXPDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCXPDevInfo.chModelName,
stDeviceInfo.DevInfo.stCXPDevInfo.chSerialNumber);
break;
}
case MV_FG_GEV_DEVICE:
{
printf("[GEV]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stGEVDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stGEVDevInfo.chModelName,
stDeviceInfo.DevInfo.stGEVDevInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_DEVICE:
{
printf("[CML]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCMLDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCMLDevInfo.chModelName,
stDeviceInfo.DevInfo.stCMLDevInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown device type.\n");
return false;
}
}
}
return true;
}
int main()
{
int nRet = 0;
IFHANDLE hInterface = NULL;
DEVHANDLE hDevice = NULL;
STREAMHANDLE hStream = NULL;
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
nRet = MV_FG_UpdateInterfaceList(MV_FG_CXP_INTERFACE | MV_FG_GEV_INTERFACE | MV_FG_CAMERALINK_INTERFACE, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update interface list failed! %#x\n", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
unsigned int nInterfaceNum = 0;
nRet = MV_FG_GetNumInterfaces(&nInterfaceNum);
if (MV_FG_SUCCESS != nRet || 0 == nInterfaceNum)
{
printf("No interface found! return = %d, number = %d\n", nRet, nInterfaceNum);
break;
}
// ch:显示采集卡信息 | en:Show interface info
if (false == PrintInterfaceInfo(nInterfaceNum))
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
printf("Select an interface: ");
scanf_s("%d", &nInterfaceIndex);
ClearStdin();
if (nInterfaceIndex < 0 || nInterfaceIndex >= (int)nInterfaceNum)
{
printf("Invalid interface index.\nQuit.\n");
break;
}
// ch:以指定权限打开采集卡，获得采集卡句柄 | en:Open interface with specified permissions, get handle
nRet = MV_FG_OpenInterface((unsigned int)nInterfaceIndex, &hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d interface failed! %#x\n", nInterfaceIndex, nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
nRet = MV_FG_UpdateDeviceList(hInterface, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update device list failed! %#x\n", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
unsigned int nDeviceNum = 0;
nRet = MV_FG_GetNumDevices(hInterface, &nDeviceNum);
if (MV_FG_SUCCESS != nRet || 0 == nDeviceNum)
{
printf("No device found! return = %d, number = %d\n", nRet, nDeviceNum);
break;
}
// ch:显示设备信息 | en:Show device info
if (false == PrintDeviceInfo(hInterface, nDeviceNum))
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
printf("Select a device: ");
scanf_s("%d", &nDeviceIndex);
ClearStdin();
if (nDeviceIndex < 0 || nDeviceIndex >= (int)nDeviceNum)
{
printf("Invalid device index.\nQuit.\n");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
nRet = MV_FG_OpenDevice(hInterface, (unsigned int)nDeviceIndex, &hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d device failed! %#x\n", nDeviceIndex, nRet);
hDevice = NULL;
break;
}
// ch:关闭触发模式 | en:Close trigger mode
nRet = MV_FG_SetEnumValueByString(hDevice, "TriggerMode", "Off");
if (MV_FG_SUCCESS != nRet)
{
printf("Turn off trigger mode failed! %#x\n", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
unsigned int nStreamNum = 0;
nRet = MV_FG_GetNumStreams(hDevice, &nStreamNum);
if (MV_FG_SUCCESS != nRet || 0 == nStreamNum)
{
printf("No stream available! return = %d, number = %d\n", nRet, nStreamNum);
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
nRet = MV_FG_OpenStream(hDevice, 0, &hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Open stream failed! %#x\n", nRet);
break;
}
// ch:设置SDK内部缓存数量 | en:Set internal buffer number
nRet = MV_FG_SetBufferNum(hStream, BUFFER_NUMBER);
if (MV_FG_SUCCESS != nRet)
{
printf("Set buffer number failed! %#x\n", nRet);
break;
}
Callback_User stUerParam;
memset(&stUerParam, 0, sizeof(Callback_User));
stUerParam.hDevice = hDevice;
// ch:注册帧缓存信息回调函数 | en:Register frame info callback
nRet = MV_FG_RegisterFrameCallBack(hStream, FrameCb, &stUerParam);
if (MV_FG_SUCCESS != nRet)
{
printf("Register frame callback failed! %#x\n", nRet);
break;
}
// ch:开始取流 | en:Start Acquisition
nRet = MV_FG_StartAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Start acquistion failed! %#x\n", nRet);
break;
}
printf("Press any key to stop acquisition.\n");
WaitForKeyPress();
// ch:停止取流 | en:Stop Acquisition
nRet = MV_FG_StopAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Stop acquisition failed! %#x\n", nRet);
if (stUerParam.stSaveJpegInfo.pJpgBuf)
{
free(stUerParam.stSaveJpegInfo.pJpgBuf);
stUerParam.stSaveJpegInfo.pJpgBuf = NULL;
}
break;
}
if (stUerParam.stSaveJpegInfo.pJpgBuf)
{
free(stUerParam.stSaveJpegInfo.pJpgBuf);
stUerParam.stSaveJpegInfo.pJpgBuf = NULL;
}
} while (0);
// ch:关闭流通道 | en:Close Stream
if (NULL != hStream)
{
nRet = MV_FG_CloseStream(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Close stream failed! %#x\n", nRet);
}
hStream = NULL;
}
// ch:关闭设备 | en:Close device
if (NULL != hDevice)
{
nRet = MV_FG_CloseDevice(hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Close device failed! %#x\n", nRet);
}
hDevice = NULL;
}
// ch:关闭采集卡 | en:Close interface
if (NULL != hInterface)
{
nRet = MV_FG_CloseInterface(hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Close interface failed! %#x\n", nRet);
}
hInterface = NULL;
}
printf("Press any key to exit.\n");
WaitForKeyPress();
return 0;
}


用户注册缓存取图

该示例程序说明了用户如何通过注册缓存的方式获取相机图像。打开采集卡，打开相机，打开流通道，获取流通道图像大小，注册缓存，刷新缓存队列，创建取流线程，开始取流，停止取流，清空缓存队列，撤销注册的缓存，关闭流通道，关闭相机，关闭采集卡。
#include <stdio.h>
#include <Windows.h>
#include <process.h>
#include <conio.h>
#include "MVFGControl.h"
#define BUFFER_NUMBER 3 // ch:申请的缓存个数 | en:Number of requested buffer
#define FILE_NAME_LEN 256 // ch:最大文件名长度 | en:Max of file name length
#define SAVE_IMAGE_NUM 10 // ch:最大存储图像数量 | en:Max number of stored images
#define TIMEOUT 1000 // ch:超时时间，单位毫秒 | en:Timeout, unit ms
bool g_bExit = false; // ch:停止取流 | en:Stop grabbing
// ch:等待按键输入 | en:Wait for key press
void WaitForKeyPress(void)
{
while(!_kbhit())
{
Sleep(10);
}
_getch();
}
// ch:清空标准输入中的残留数据 | en:Flush stdin
void ClearStdin(void)
{
char c = '\0';
while (1)
{
c = getchar();
if ('\n' == c || EOF == c)
{
break;
}
}
}
// ch:保存图像原始数据 | en:Save original image data
void SaveRawImage(int nImageNo, MV_FG_BUFFER_INFO* pstImageInfo)
{
if (pstImageInfo)
{
char szFileName[FILE_NAME_LEN] = { 0 };
sprintf_s(szFileName, FILE_NAME_LEN, "Image_w%d_h%d_n%d.raw", pstImageInfo->nWidth, pstImageInfo->nHeight, nImageNo);
FILE* pImageFile = NULL;
if ((0 != fopen_s(&pImageFile, szFileName, "wb")) || (NULL == pImageFile))
{
return;
}
fwrite(pstImageInfo->pBuffer, 1, pstImageInfo->nFilledSize, pImageFile);
fclose(pImageFile);
}
}
// ch:取流线程 | en:Grabbing image data thread
unsigned int __stdcall GrabbingThread(void* pUser)
{
if (pUser)
{
STREAMHANDLE hStream = (STREAMHANDLE)pUser;
BUFFERHANDLE hBuffer = NULL;
MV_FG_BUFFER_INFO stFrameInfo = { 0 }; // 图像信息
int nSaveImage = 0; // 保存的图像数量
int nRet = 0;
// ch:开始取流 | en:Start Acquisition
nRet = MV_FG_StartAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Start acquistion failed! %#x\n", nRet);
return nRet;
}
g_bExit = false;
while (!g_bExit)
{
// ch:获取图像缓存 | en:Get image buffer
nRet = MV_FG_GetImageBuffer(hStream, &hBuffer, TIMEOUT);
if (MV_FG_SUCCESS != nRet)
{
printf("Get image buffer failed! %#x\n", nRet);
continue;
}
// ch:获取图像信息和数据 | en:Get image info and data
nRet = MV_FG_GetBufferInfo(hBuffer, &stFrameInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get image info failed! %#x\n", nRet);
}
else
{
printf("FrameNumber:%2I64d%, Width:%d, Height:%d\n", stFrameInfo.nFrameID, stFrameInfo.nWidth, stFrameInfo.nHeight);
if (nSaveImage < SAVE_IMAGE_NUM)
{
SaveRawImage(++nSaveImage, &stFrameInfo);
}
}
// ch:将缓存放回输入队列 | en:Put the buffer back into the input queue
nRet = MV_FG_QueueBuffer(hBuffer);
if (MV_FG_SUCCESS != nRet)
{
printf("Queue buffer failed! %#x\n", nRet);
break;
}
}
// ch:停止取流 | en:Stop Acquisition
nRet = MV_FG_StopAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Stop acquisition failed! %#x\n", nRet);
return nRet;
}
}
return MV_FG_SUCCESS;
}
// ch:打印采集卡信息 | en:Print interface info
bool PrintInterfaceInfo(unsigned int nInterfaceNum)
{
int nRet = 0;
for (unsigned int i = 0; i < nInterfaceNum; i++)
{
MV_FG_INTERFACE_INFO stInterfaceInfo = { 0 };
nRet = MV_FG_GetInterfaceInfo(i, &stInterfaceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d interface failed! %#x\n", i, nRet);
return false;
}
switch (stInterfaceInfo.nTLayerType)
{
case MV_FG_CXP_INTERFACE:
{
printf("[CXP]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chSerialNumber);
break;
}
case MV_FG_GEV_INTERFACE:
{
printf("[GEV]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_INTERFACE:
{
printf("[CML]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown interface type.\n");
return false;
}
}
}
return true;
}
// ch:打印设备信息 | en:Print device info
bool PrintDeviceInfo(IFHANDLE hInterface, unsigned int nDeviceNum)
{
int nRet = 0;
for (unsigned int i = 0; i < nDeviceNum; i++)
{
MV_FG_DEVICE_INFO stDeviceInfo = { 0 };
nRet = MV_FG_GetDeviceInfo(hInterface, i, &stDeviceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d device failed! %#x\n", i, nRet);
return false;
}
switch (stDeviceInfo.nDevType)
{
case MV_FG_CXP_DEVICE:
{
printf("[CXP]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCXPDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCXPDevInfo.chModelName,
stDeviceInfo.DevInfo.stCXPDevInfo.chSerialNumber);
break;
}
case MV_FG_GEV_DEVICE:
{
printf("[GEV]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stGEVDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stGEVDevInfo.chModelName,
stDeviceInfo.DevInfo.stGEVDevInfo.chSerialNumber);
break;
}
case MV_FG_CAMERALINK_DEVICE:
{
printf("[CML]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCMLDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCMLDevInfo.chModelName,
stDeviceInfo.DevInfo.stCMLDevInfo.chSerialNumber);
break;
}
default:
{
printf("Unknown device type.\n");
return false;
}
}
}
return true;
}
int main()
{
int nRet = 0;
IFHANDLE hInterface = NULL;
DEVHANDLE hDevice = NULL;
STREAMHANDLE hStream = NULL;
BUFFERHANDLE hBuffer[BUFFER_NUMBER] = { 0 };
void* pBuffer[BUFFER_NUMBER] = { 0 };
do
{
// ch:枚举采集卡 | en:Enum interface
bool bChanged = false;
nRet = MV_FG_UpdateInterfaceList(MV_FG_CXP_INTERFACE | MV_FG_GEV_INTERFACE | MV_FG_CAMERALINK_INTERFACE, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update interface list failed! %#x\n", nRet);
break;
}
// ch:获取采集卡数量 | en:Get interface num
unsigned int nInterfaceNum = 0;
nRet = MV_FG_GetNumInterfaces(&nInterfaceNum);
if (MV_FG_SUCCESS != nRet || 0 == nInterfaceNum)
{
printf("No interface found! return = %d, number = %d\n", nRet, nInterfaceNum);
break;
}
// ch:显示采集卡信息 | en:Show interface info
if (false == PrintInterfaceInfo(nInterfaceNum))
{
break;
}
// ch:选择采集卡 | en:Select interface
int nInterfaceIndex = -1;
printf("Select an interface: ");
scanf_s("%d", &nInterfaceIndex);
ClearStdin();
if (nInterfaceIndex < 0 || nInterfaceIndex >= (int)nInterfaceNum)
{
printf("Invalid interface index.\nQuit.\n");
break;
}
// ch:打开采集卡，获得采集卡句柄 | en:Open interface, get handle
nRet = MV_FG_OpenInterface((unsigned int)nInterfaceIndex, &hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d interface failed! %#x\n", nInterfaceIndex, nRet);
break;
}
// ch:枚举采集卡上的相机 | en:Enum camera of interface
nRet = MV_FG_UpdateDeviceList(hInterface, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update device list failed! %#x\n", nRet);
break;
}
// ch:获取设备数量 | en:Get device number
unsigned int nDeviceNum = 0;
nRet = MV_FG_GetNumDevices(hInterface, &nDeviceNum);
if (MV_FG_SUCCESS != nRet || 0 == nDeviceNum)
{
printf("No device found! return = %d, number = %d\n", nRet, nDeviceNum);
break;
}
// ch:显示设备信息 | en:Show device info
if (false == PrintDeviceInfo(hInterface, nDeviceNum))
{
break;
}
// ch:选择设备 | en:Select device
int nDeviceIndex = -1;
printf("Select a device: ");
scanf_s("%d", &nDeviceIndex);
ClearStdin();
if (nDeviceIndex < 0 || nDeviceIndex >= (int)nDeviceNum)
{
printf("Invalid device index.\nQuit.\n");
break;
}
// ch:打开设备，获得设备句柄 | en:Open device, get handle
nRet = MV_FG_OpenDevice(hInterface, (unsigned int)nDeviceIndex, &hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d device failed! %#x\n", nDeviceIndex, nRet);
hDevice = NULL;
break;
}
// ch:关闭触发模式 | en:Close trigger mode
nRet = MV_FG_SetEnumValueByString(hDevice, "TriggerMode", "Off");
if (MV_FG_SUCCESS != nRet)
{
printf("Turn off trigger mode failed! %#x\n", nRet);
break;
}
// ch:获取流通道个数 | en:Get number of stream
unsigned int nStreamNum = 0;
nRet = MV_FG_GetNumStreams(hDevice, &nStreamNum);
if (MV_FG_SUCCESS != nRet || 0 == nStreamNum)
{
printf("No stream available! return = %d, number = %d\n", nRet, nStreamNum);
break;
}
// ch:打开流通道(目前只支持单个通道) | en:Open stream(Only a single stream is supported now)
nRet = MV_FG_OpenStream(hDevice, 0, &hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Open stream failed! %#x\n", nRet);
break;
}
// ch:获取流通道图像大小 | en:Get payload size of stream
unsigned int nPayloadSize = 0;
nRet = MV_FG_GetPayloadSize(hStream, &nPayloadSize);
if (MV_FG_SUCCESS != nRet)
{
printf("Get payload size failed! %#x\n", nRet);
break;
}
// ch:注册缓存 | en:Announce buffer
for (unsigned int i = 0; i < BUFFER_NUMBER; i++)
{
// ch:分配图像缓存 | en:Allocate image memory
pBuffer[i] = malloc(nPayloadSize);
if (NULL == pBuffer[i])
{
printf("Allocate buffer failed!\n");
nRet = MV_FG_ERR_OUT_OF_MEMORY;
break;
}
// ch:向SDK注册缓存 | en:Announce buffer for SDK
nRet = MV_FG_AnnounceBuffer(hStream, pBuffer[i], nPayloadSize, NULL, &(hBuffer[i]));
if (MV_FG_SUCCESS != nRet)
{
printf("Announce buffer failed! %#x\n", nRet);
break;
}
}
if (MV_FG_SUCCESS != nRet)
{
break;
}
// ch:刷新缓存队列，用于取流 | en:Flush buffer for grabbing image
nRet = MV_FG_FlushQueue(hStream, MV_FG_BUFFER_QUEUE_ALL_TO_INPUT);
if (MV_FG_SUCCESS != nRet)
{
printf("Flush queue: all to input failed! %#x\n", nRet);
break;
}
// ch:创建取流线程 | en:Create acquistion thread
void* hThreadHandle = (void*)_beginthreadex(NULL, 0, GrabbingThread, hStream, 0, NULL);
if (NULL == hThreadHandle)
{
printf("Create thread failed!\n");
break;
}
printf("Press any key to stop acquisition.\n");
WaitForKeyPress();
// ch:关闭取流线程 | en:Close acquistion thread
g_bExit = true;
WaitForSingleObject(hThreadHandle, INFINITE);
CloseHandle(hThreadHandle);
hThreadHandle = NULL;
} while (0);
// ch:释放资源 | en:Release resource
if (NULL != hStream)
{
// ch:清空缓存队列 | en:Flush buffer queue
nRet = MV_FG_FlushQueue(hStream, MV_FG_BUFFER_QUEUE_ALL_DISCARD);
if (MV_FG_SUCCESS != nRet)
{
printf("Flush buffer queue failed! %#x\n", nRet);
}
// ch:撤销并释放注册的缓存 | en:Revoke and release buffer
for (unsigned int i = 0; i < BUFFER_NUMBER; i++)
{
if (NULL != hBuffer[i])
{
nRet = MV_FG_RevokeBuffer(hStream, hBuffer[i], NULL, NULL);
if (MV_FG_SUCCESS != nRet)
{
printf("Revoke No.%d buffer failed! %#x\n", i, nRet);
}
hBuffer[i] = NULL;
}
if (NULL != pBuffer[i])
{
free(pBuffer[i]);
pBuffer[i] = NULL;
}
}
// ch:关闭流通道 | en:Close stream
nRet = MV_FG_CloseStream(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Close stream failed! %#x\n", nRet);
}
hStream = NULL;
}
// ch:关闭设备 | en:Close device
if (NULL != hDevice)
{
nRet = MV_FG_CloseDevice(hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Close device failed! %#x\n", nRet);
}
hDevice = NULL;
}
// ch:关闭采集卡 | en:Close interface
if (NULL != hInterface)
{
nRet = MV_FG_CloseInterface(hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Close interface failed! %#x\n", nRet);
}
hInterface = NULL;
}
printf("Press any key to exit.\n");
WaitForKeyPress();
return 0;
}


获取采集卡事件

该示例程序说明了如何配置采集卡事件功能、如何注册事件回调以及如何在事件回调函数中处理获取到的事件信息。Event事件例如：ReceiveImageFrameStart0。
#include <Windows.h>
#include <conio.h>
#include <stdio.h>
#include <process.h>
#include "MVFGControl.h"
bool g_bExit = FALSE;
#define BUFFER_NUMBER 3 // 申请的缓存个数
void __stdcall EventCallBack(MV_FG_EVENT_INFO* pstEventInfo, void* pUser)
{
static int nEventNum = 0;
nEventNum++;
if (NULL != pstEventInfo)
{
printf("%d Event: name %s id 0x%x time %lld \r\n", nEventNum, pstEventInfo->EventName, pstEventInfo->nEventID, pstEventInfo->nTimestamp);
}
}
// 等待按键输入
void WaitForKeyPress(void)
{
while(!_kbhit())
{
Sleep(10);
}
_getch();
}
// 清空标准输入中的残留数据
void ClearStdin(void)
{
char c = '0';
do
{
c = getchar();
if (c == '\n' ||c == EOF)
{
break;
}
}
while(TRUE);
}
// 取流线程例程
unsigned int __stdcall GrabbingThread(void* pUser)
{
if (pUser)
{
STREAMHANDLE hStream = (STREAMHANDLE)pUser;
BUFFERHANDLE hBuffer = NULL;
MV_FG_BUFFER_INFO stFrameInfo = {0};
int nSaveImage = 10;
int nFrameNum = 0;
// 开启取流
int nRet = MV_FG_StartAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Start Acquisition failed, %#x\n", nRet);
return nRet;
}
while(!g_bExit)
{
// 获取图片缓存
nRet = MV_FG_GetImageBuffer(hStream, &hBuffer, 1000);
if (MV_FG_SUCCESS == nRet)
{
nRet = MV_FG_GetBufferInfo(hBuffer, &stFrameInfo);
if (MV_FG_SUCCESS == nRet)
{
nFrameNum++;
printf("FrameNumber %8d: %-8I64d\tWidth: %d\tHeight: %d\n", nFrameNum, stFrameInfo.nFrameID, stFrameInfo.nWidth, stFrameInfo.nHeight);
}
// 将图像缓存放回SDK内部队列
nRet = MV_FG_QueueBuffer(hBuffer);
if (MV_FG_SUCCESS != nRet)
{
printf("Queue Buffer error, %#x\n", nRet);
break;
}
}
else
{
printf("Get image buffer failed, %#x\n", nRet);
}
}
// 停止取流
nRet = MV_FG_StopAcquisition(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Stop Acquisition failed, %#x\n", nRet);
return nRet;
}
}
return MV_FG_SUCCESS;
}
int main(int argc, char** argv)
{
int nRet = MV_FG_SUCCESS;
IFHANDLE hInterface = NULL;
DEVHANDLE hDevice = NULL;
STREAMHANDLE hStream = NULL;
BUFFERHANDLE hBuffer[BUFFER_NUMBER] = {0};
void* pBuffer[BUFFER_NUMBER] = {0};
do
{
// 枚举采集卡
bool bChanged = false;
nRet = MV_FG_UpdateInterfaceList(MV_FG_CXP_INTERFACE | MV_FG_GEV_INTERFACE | MV_FG_CAMERALINK_INTERFACE, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update Interface List error, %#x\n", nRet);
break;
}
// 获取采集卡个数
unsigned int nInterfaceNumber = 0;
nRet = MV_FG_GetNumInterfaces(&nInterfaceNumber);
if (MV_FG_SUCCESS != nRet || 0 == nInterfaceNumber)
{
printf("No Interface found\n");
break;
}
// 打印采集卡信息
for (unsigned int i = 0; i < nInterfaceNumber; i++)
{
MV_FG_INTERFACE_INFO stInterfaceInfo = {0};
nRet = MV_FG_GetInterfaceInfo(i, &stInterfaceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get info of No.%d Interface error, %#x\n", i, nRet);
break;
}
if (stInterfaceInfo.nTLayerType == MV_FG_CXP_INTERFACE)
{
printf("[CXP]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCXPIfaceInfo.chSerialNumber);
}
else if (stInterfaceInfo.nTLayerType == MV_FG_GEV_INTERFACE)
{
printf("[GEV]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stGEVIfaceInfo.chSerialNumber);
}
else if (stInterfaceInfo.nTLayerType == MV_FG_CAMERALINK_INTERFACE)
{
printf("[CML]No.%d Interface: \n\tDisplayName: %s\n\tInterfaceID: %s\n\tSerialNumber:%s\n", i,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chDisplayName,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chInterfaceID,
stInterfaceInfo.IfaceInfo.stCMLIfaceInfo.chSerialNumber);
}
}
if (MV_FG_SUCCESS != nRet)
{
break;
}
// 让用户选择采集卡，获取采集卡下标
int nSelectedInterfaceIndex = -1;
printf("Select an interface: ");
scanf_s("%d", &nSelectedInterfaceIndex);
ClearStdin();
if ((nSelectedInterfaceIndex < 0) || (nSelectedInterfaceIndex >= (int)nInterfaceNumber))
{
printf("invalid interface index, Quit\n");
break;
}
// 打开采集卡，返回采集卡句柄
nRet = MV_FG_OpenInterface(nSelectedInterfaceIndex, &hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Open No.%d Interface error, %#x\n", nSelectedInterfaceIndex, nRet);
break;
}
// 注册采集卡帧开始事件回调
nRet = MV_FG_RegisterEventCallBack(hInterface, "ReceiveImageFrameStart0", EventCallBack, NULL);
if (MV_FG_SUCCESS != nRet)
{
printf("MV_FG_RegisterEventCallBack event %s error, %#x\n", "ReceiveImageFrameStart0", nRet);
break;
}
// 设置事件类型为流事件(可自行设置EventCategory相机节点下的其他事件类型)
nRet = MV_FG_SetEnumValueByString(hInterface, "EventCategory", "StreamEvent");
if (MV_FG_SUCCESS != nRet)
{
printf("MV_FG_SetEnumValueByString EventCategory %s error, %#x\n", "StreamEvent", nRet);
break;
}
// 设置事件通道(Channel0-Channel3)
nRet = MV_FG_SetEnumValueByString(hInterface, "ChannelSelector", "Channel0");
if (MV_FG_SUCCESS != nRet)
{
printf("MV_FG_SetEnumValueByString ChannelSelector %s error, %#x\n", "Channel0", nRet);
break;
}
// 设置具体事件(可自行设置EventSelector相机节点下的其他具体事件)
nRet = MV_FG_SetEnumValueByString(hInterface, "EventSelector", "ReceiveImageFrameStart0");
if (MV_FG_SUCCESS != nRet)
{
printf("MV_FG_SetEnumValueByString EventSelector %s error, %#x\n", "ReceiveImageFrameStart0", nRet);
break;
}
// 打开事件通知
nRet = MV_FG_SetEnumValueByString(hInterface, "EventNotification", "On");
if (MV_FG_SUCCESS != nRet)
{
printf("MV_FG_SetEnumValueByString EventNotification %s error, %#x\n", "On", nRet);
break;
}
// 枚举采集卡上的相机
nRet = MV_FG_UpdateDeviceList(hInterface, &bChanged);
if (MV_FG_SUCCESS != nRet)
{
printf("Update Device list error, %#x\n", nRet);
break;
}
// 获取并打印设备信息
unsigned int nDeviceNumber = 0;
nRet = MV_FG_GetNumDevices(hInterface, &nDeviceNumber);
if (MV_FG_SUCCESS != nRet || 0 == nDeviceNumber)
{
printf("No devices found, %#x\n", nRet);
break;
}
for (unsigned int i = 0; i < nDeviceNumber; i++)
{
MV_FG_DEVICE_INFO stDeviceInfo = {0};
nRet = MV_FG_GetDeviceInfo(hInterface, i, &stDeviceInfo);
if (MV_FG_SUCCESS != nRet)
{
printf("Get Info of No.%u Device error, %#x\n", i, nRet);
break;
}
if (stDeviceInfo.nDevType == MV_FG_CXP_DEVICE)
{
printf("[CXP]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCXPDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCXPDevInfo.chModelName,
stDeviceInfo.DevInfo.stCXPDevInfo.chSerialNumber);
}
else if (stDeviceInfo.nDevType == MV_FG_GEV_DEVICE)
{
printf("[GEV]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stGEVDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stGEVDevInfo.chModelName,
stDeviceInfo.DevInfo.stGEVDevInfo.chSerialNumber);
}
else if (stDeviceInfo.nDevType == MV_FG_CAMERALINK_DEVICE)
{
printf("[CML]No.%d Device: \n\tUserDefinedName: %s\n\tModelName: %s\n\tSerialNumber: %s\n", i,
stDeviceInfo.DevInfo.stCMLDevInfo.chUserDefinedName,
stDeviceInfo.DevInfo.stCMLDevInfo.chModelName,
stDeviceInfo.DevInfo.stCMLDevInfo.chSerialNumber);
}
}
if (MV_FG_SUCCESS != nRet)
{
break;
}
// 让用户选择设备
int nSelectedDeviceIndex = -1;
printf("Select a device: ");
scanf_s("%d", &nSelectedDeviceIndex);
ClearStdin();
if ((nSelectedDeviceIndex < 0) || (nSelectedDeviceIndex >= (int)nDeviceNumber))
{
printf("invalid device index, Quit\n");
break;
}
// 打开设备，获取设备句柄
nRet = MV_FG_OpenDevice(hInterface, nSelectedDeviceIndex, &hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Open device error, %#x\n", nRet);
hDevice = NULL;
break;
}
// 关闭触发模式
nRet = MV_FG_SetEnumValueByString(hDevice, "TriggerMode", "Off");
if (MV_FG_SUCCESS != nRet)
{
printf("Turn off TriggerMode failed, %#x\n", nRet);
break;
}
// 获取流通道个数
unsigned int nStreamNumber = 0;
nRet = MV_FG_GetNumStreams(hDevice, &nStreamNumber);
if (MV_FG_SUCCESS != nRet || 0 == nStreamNumber)
{
printf("No Stream available\n");
break;
}
// 打开流通道(目前只支持单个流通道)
nRet = MV_FG_OpenStream(hDevice, 0, &hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Open Stream error, %#x\n", nRet);
break;
}
// 获取图像大小
unsigned int nImagePayloadSize = 0;
nRet = MV_FG_GetPayloadSize(hStream, &nImagePayloadSize);
if (MV_FG_SUCCESS != nRet)
{
printf("Get payload size error, %#x\n", nRet);
break;
}
// 分配并注册用于保存图片的缓存
for (unsigned int i = 0; i < BUFFER_NUMBER; i++)
{
// 分配图像缓存
pBuffer[i] = malloc(nImagePayloadSize);
if (NULL == pBuffer[i])
{
printf("Allocate Buffer error\n");
nRet = MV_FG_ERR_OUT_OF_MEMORY;
break;
}
// 注册缓存供SDK使用
nRet = MV_FG_AnnounceBuffer(hStream, pBuffer[i], nImagePayloadSize, NULL, &(hBuffer[i]));
if (MV_FG_SUCCESS != nRet)
{
printf("Announce Buffer error, %#x\n", nRet);
break;
}
}
if (MV_FG_SUCCESS != nRet)
{
break;
}
// 将所有缓存放入输入队列，已备取流使用
nRet = MV_FG_FlushQueue(hStream, MV_FG_BUFFER_QUEUE_ALL_TO_INPUT);
if (MV_FG_SUCCESS != nRet)
{
break;
}
// 创建线程进行取流
void* hThreadHandle = (void*) _beginthreadex(NULL , 0 , GrabbingThread , hStream, 0 , NULL);
if (NULL == hThreadHandle)
{
printf("Create Thread Error\n");
break;
}
printf("Press any key to stop acquisition.\n");
WaitForKeyPress();
g_bExit = true;
WaitForSingleObject(hThreadHandle, INFINITE);
CloseHandle(hThreadHandle);
hThreadHandle = NULL;
} while (0);
// 释放相关资源
if (NULL != hStream)
{
// 清空缓存队列
nRet = MV_FG_FlushQueue(hStream, MV_FG_BUFFER_QUEUE_ALL_DISCARD);
if (MV_FG_SUCCESS != nRet)
{
printf("Flush Buffer Queue error, %#x\n", nRet);
}
// 回收并释放注册的缓存
for (unsigned int i = 0; i < BUFFER_NUMBER; i++)
{
if (NULL != hBuffer[i])
{
nRet = MV_FG_RevokeBuffer(hStream, hBuffer[i], NULL, NULL);
if (MV_FG_SUCCESS != nRet)
{
printf("Revoke Buffer failed, %#x\n", nRet);
}
hBuffer[i] = NULL;
}
if (NULL != pBuffer[i])
{
free(pBuffer[i]);
pBuffer[i] = NULL;
}
}
// 关闭流通道
nRet = MV_FG_CloseStream(hStream);
if (MV_FG_SUCCESS != nRet)
{
printf("Close Stream error, %#x\n", nRet);
}
hStream = NULL;
}
// 关闭设备
if (NULL != hDevice)
{
nRet = MV_FG_CloseDevice(hDevice);
if (MV_FG_SUCCESS != nRet)
{
printf("Close device error, %#x\n", nRet);
}
hDevice = NULL;
}
// 关闭采集卡
if (NULL != hInterface)
{
nRet = MV_FG_CloseInterface(hInterface);
if (MV_FG_SUCCESS != nRet)
{
printf("Close Interface error, %#x\n", nRet);
}
hInterface = NULL;
}
printf("Press any key to exit.\n");
WaitForKeyPress();
return 0;
}


错误码定义
正确码
名称 | 值 | 说明
MV_FG_SUCCESS | 0x00000000 | 成功，无错误
通用错误码：范围0x80190001-0x801900FF
名称 | 值 | 说明
MV_FG_ERR_ERROR | 0x80190001 | 未知错误
MV_FG_ERR_NOT_INITIALIZED | 0x80190002 | 未初始化
MV_FG_ERR_NOT_IMPLEMENTED | 0x80190003 | 未实现
MV_FG_ERR_RESOURCE_IN_USE | 0x80190004 | 资源被占用
MV_FG_ERR_ACCESS_DENIED | 0x80190005 | 无权限
MV_FG_ERR_INVALID_HANDLE | 0x80190006 | 无效句柄
MV_FG_ERR_INVALID_ID | 0x80190007 | 无效ID
MV_FG_ERR_NO_DATA | 0x80190008 | 无数据
MV_FG_ERR_INVALID_PARAMETER | 0x80190009 | 无效参数
MV_FG_ERR_IO | 0x80190010 | IO错误
MV_FG_ERR_TIMEOUT | 0x80190011 | 超时
MV_FG_ERR_ABORT | 0x80190012 | 操作被中断
MV_FG_ERR_INVALID_BUFFER | 0x80190013 | 无效缓存
MV_FG_ERR_NOT_AVAILABLE | 0x80190014 | 不可达
MV_FG_ERR_INVALID_ADDRESS | 0x80190015 | 无效地址
MV_FG_ERR_BUFFER_TOO_SMALL | 0x80190016 | 缓存太小
MV_FG_ERR_INVALID_INDEX | 0x80190017 | 无效索引
MV_FG_ERR_PARSING_CHUNK_DATA | 0x80190018 | 解析Chunk失败
MV_FG_ERR_INVALID_VALUE | 0x80190019 | 无效的值
MV_FG_ERR_RESOURCE_EXHAUSTED | 0x80190020 | 资源耗尽
MV_FG_ERR_OUT_OF_MEMORY | 0x80190021 | 内存申请失败
MV_FG_ERR_BUSY | 0x80190022 | 忙碌
MV_FG_ERR_LOADLIBRARY | 0x80190023 | 动态库加载失败
MV_FG_ERR_CALLORDER | 0x80190024 | 函数调用错误
GenICam错误码：范围0x80190100-0x801901FF
名称 | 值 | 说明
MV_FG_ERR_GC_GENERIC | 0x80190100 | GenICam通用错误
MV_FG_ERR_GC_ARGUMENT | 0x80190101 | GenICam参数错误
MV_FG_ERR_GC_RANGE | 0x80190102 | GenICam参数范围错误
MV_FG_ERR_GC_PROPERTY | 0x80190103 | GenICam属性错误
MV_FG_ERR_GC_RUNTIME | 0x80190104 | GenICam运行环境错误
MV_FG_ERR_GC_LOGICAL | 0x80190105 | GenICam逻辑错误
MV_FG_ERR_GC_ACCESS | 0x80190106 | GenICam权限错误
MV_FG_ERR_GC_TIMEOUT | 0x80190107 | GenICam超时
MV_FG_ERR_GC_DYNAMICCAST | 0x80190108 | GenICam转换异常
MV_FG_ERR_GC_UNKNOW | 0x801901FF | GenICam未知错误
图像处理错误：范围0x80190200-0x801902FF
名称 | 值 | 说明
MV_FG_ERR_IMG_HANDLE | 0x80190200 | 图像处理库句柄错误
MV_FG_ERR_IMG_SUPPORT | 0x80190201 | 图像处理库不支持
MV_FG_ERR_IMG_PARAMETER | 0x80190202 | 图像处理库参数错误
MV_FG_ERR_IMG_OVERFLOW | 0x80190203 | 图像处理库内存溢出
MV_FG_ERR_IMG_INITIALIZED | 0x80190204 | 图像处理库操作未初始化
MV_FG_ERR_IMG_RESOURCE | 0x80190205 | 图像处理库资源申请释放失败
MV_FG_ERR_IMG_ENCRYPT | 0x80190206 | 图像加密错误
MV_FG_ERR_IMG_FORMAT | 0x80190207 | 图像格式不正确或者不支持
MV_FG_ERR_IMG_SIZE | 0x80190208 | 图像宽高不正确或者超出范围
MV_FG_ERR_IMG_STEP | 0x80190209 | 图像宽高与step参数不匹配
MV_FG_ERR_IMG_DATA_NULL | 0x80190210 | 图像数据存储地址为空(某个分量)
MV_FG_ERR_IMG_ABILITY_ARG | 0x80190211 | 图像算法ABILITY存在无效参数
MV_FG_ERR_IMG_UNKNOW | 0x801902FF | 图像处理未知错误


抠图参数

读码器SDK中可设置的抠图参数如下表所示。
参数名 | 参数说明 | 默认值 | 取值范围
KEY_WAYBILL_ABILITY | 算法能力集，1为含面单提取，2为图像增强，4为码提取，8为Box拷贝模块，16为面单提取模块 | 31 | 1-31


MV_CML_DEVICE_INFO 成员列表

成员的完整列表，这些成员属于 MV_CML_DEVICE_INFO,包括所有继承而来的类成员

chDeviceID | MV_CML_DEVICE_INFO
chDeviceVersion | MV_CML_DEVICE_INFO
chManufacturerInfo | MV_CML_DEVICE_INFO
chModelName | MV_CML_DEVICE_INFO
chSerialNumber | MV_CML_DEVICE_INFO
chUserDefinedName | MV_CML_DEVICE_INFO
chVendorName | MV_CML_DEVICE_INFO
nReserved | MV_CML_DEVICE_INFO


MV_CML_INTERFACE_INFO 成员列表

成员的完整列表，这些成员属于 MV_CML_INTERFACE_INFO,包括所有继承而来的类成员

chDisplayName | MV_CML_INTERFACE_INFO
chInterfaceID | MV_CML_INTERFACE_INFO
chSerialNumber | MV_CML_INTERFACE_INFO
nPCIEInfo | MV_CML_INTERFACE_INFO
nReserved | MV_CML_INTERFACE_INFO


MV_CXP_DEVICE_INFO 成员列表

成员的完整列表，这些成员属于 MV_CXP_DEVICE_INFO,包括所有继承而来的类成员

chDeviceID | MV_CXP_DEVICE_INFO
chDeviceVersion | MV_CXP_DEVICE_INFO
chManufacturerInfo | MV_CXP_DEVICE_INFO
chModelName | MV_CXP_DEVICE_INFO
chSerialNumber | MV_CXP_DEVICE_INFO
chUserDefinedName | MV_CXP_DEVICE_INFO
chVendorName | MV_CXP_DEVICE_INFO
nReserved | MV_CXP_DEVICE_INFO


MV_CXP_INTERFACE_INFO 成员列表

成员的完整列表，这些成员属于 MV_CXP_INTERFACE_INFO,包括所有继承而来的类成员

chDisplayName | MV_CXP_INTERFACE_INFO
chInterfaceID | MV_CXP_INTERFACE_INFO
chSerialNumber | MV_CXP_INTERFACE_INFO
nPCIEInfo | MV_CXP_INTERFACE_INFO
nReserved | MV_CXP_INTERFACE_INFO


MV_FG_BUFFER_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_BUFFER_INFO,包括所有继承而来的类成员

bAcquiring | MV_FG_BUFFER_INFO
bIncomplete | MV_FG_BUFFER_INFO
bNewData | MV_FG_BUFFER_INFO
bQueued | MV_FG_BUFFER_INFO
enPixelType | MV_FG_BUFFER_INFO
fExposureTime | MV_FG_BUFFER_INFO
fGain | MV_FG_BUFFER_INFO
nAverageBrightness | MV_FG_BUFFER_INFO
nBlue | MV_FG_BUFFER_INFO
nChunkHeight | MV_FG_BUFFER_INFO
nChunkPayloadSize | MV_FG_BUFFER_INFO
nChunkWidth | MV_FG_BUFFER_INFO
nCycleCount | MV_FG_BUFFER_INFO
nCycleOffset | MV_FG_BUFFER_INFO
nDevTimeStamp | MV_FG_BUFFER_INFO
nFilledSize | MV_FG_BUFFER_INFO
nFrameCounter | MV_FG_BUFFER_INFO
nFrameID | MV_FG_BUFFER_INFO
nGreen | MV_FG_BUFFER_INFO
nHeight | MV_FG_BUFFER_INFO
nHostTimeStamp | MV_FG_BUFFER_INFO
nInput | MV_FG_BUFFER_INFO
nNumChunks | MV_FG_BUFFER_INFO
nOffsetX | MV_FG_BUFFER_INFO
nOffsetY | MV_FG_BUFFER_INFO
nOutput | MV_FG_BUFFER_INFO
nRed | MV_FG_BUFFER_INFO
nReserved | MV_FG_BUFFER_INFO
nSecondCount | MV_FG_BUFFER_INFO
nSize | MV_FG_BUFFER_INFO
nTriggerIndex | MV_FG_BUFFER_INFO
nWidth | MV_FG_BUFFER_INFO
pBuffer | MV_FG_BUFFER_INFO
pPrivate | MV_FG_BUFFER_INFO


MV_FG_CCM_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_CCM_INFO,包括所有继承而来的类成员

bCCMEnable | MV_FG_CCM_INFO
nCCMat | MV_FG_CCM_INFO
nCCMScale | MV_FG_CCM_INFO
nReserved | MV_FG_CCM_INFO


MV_FG_CHUNK_DATA_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_CHUNK_DATA_INFO,包括所有继承而来的类成员

nChunkID | MV_FG_CHUNK_DATA_INFO
nChunkLen | MV_FG_CHUNK_DATA_INFO
nReserved | MV_FG_CHUNK_DATA_INFO
pChunkData | MV_FG_CHUNK_DATA_INFO


MV_FG_CONVERT_PIXEL_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_CONVERT_PIXEL_INFO,包括所有继承而来的类成员

bFilterEnable | MV_FG_CONVERT_PIXEL_INFO
enCfaMethod | MV_FG_CONVERT_PIXEL_INFO
nReserved | MV_FG_CONVERT_PIXEL_INFO
stCCMInfo | MV_FG_CONVERT_PIXEL_INFO
stGammaInfo | MV_FG_CONVERT_PIXEL_INFO
stInputImageInfo | MV_FG_CONVERT_PIXEL_INFO
stOutputImageInfo | MV_FG_CONVERT_PIXEL_INFO


MV_FG_DEVICE_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_DEVICE_INFO,包括所有继承而来的类成员

DevInfo | MV_FG_DEVICE_INFO
nDevType | MV_FG_DEVICE_INFO
nReserved | MV_FG_DEVICE_INFO
stCMLDevInfo | MV_FG_DEVICE_INFO
stCXPDevInfo | MV_FG_DEVICE_INFO
stGEVDevInfo | MV_FG_DEVICE_INFO


MV_FG_ENUMVALUE 成员列表

成员的完整列表，这些成员属于 MV_FG_ENUMVALUE,包括所有继承而来的类成员

nCurValue | MV_FG_ENUMVALUE
nReserved | MV_FG_ENUMVALUE
nSupportedNum | MV_FG_ENUMVALUE
nSupportValue | MV_FG_ENUMVALUE
strCurSymbolic | MV_FG_ENUMVALUE
strSymbolic | MV_FG_ENUMVALUE


MV_FG_EVENT_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_EVENT_INFO,包括所有继承而来的类成员

EventName | MV_FG_EVENT_INFO
nBlockID | MV_FG_EVENT_INFO
nEventDataSize | MV_FG_EVENT_INFO
nEventID | MV_FG_EVENT_INFO
nReserved | MV_FG_EVENT_INFO
nTimestamp | MV_FG_EVENT_INFO
pEventData | MV_FG_EVENT_INFO


MV_FG_FLOATVALUE 成员列表

成员的完整列表，这些成员属于 MV_FG_FLOATVALUE,包括所有继承而来的类成员

fCurValue | MV_FG_FLOATVALUE
fMax | MV_FG_FLOATVALUE
fMin | MV_FG_FLOATVALUE
nReserved | MV_FG_FLOATVALUE


MV_FG_FRAME_SPEC_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_FRAME_SPEC_INFO,包括所有继承而来的类成员

fExposureTime | MV_FG_FRAME_SPEC_INFO
fGain | MV_FG_FRAME_SPEC_INFO
nAverageBrightness | MV_FG_FRAME_SPEC_INFO
nBlue | MV_FG_FRAME_SPEC_INFO
nCycleCount | MV_FG_FRAME_SPEC_INFO
nCycleOffset | MV_FG_FRAME_SPEC_INFO
nFrameCounter | MV_FG_FRAME_SPEC_INFO
nFrameHeight | MV_FG_FRAME_SPEC_INFO
nFrameWidth | MV_FG_FRAME_SPEC_INFO
nGreen | MV_FG_FRAME_SPEC_INFO
nInput | MV_FG_FRAME_SPEC_INFO
nOffsetX | MV_FG_FRAME_SPEC_INFO
nOffsetY | MV_FG_FRAME_SPEC_INFO
nOutput | MV_FG_FRAME_SPEC_INFO
nRed | MV_FG_FRAME_SPEC_INFO
nReserved | MV_FG_FRAME_SPEC_INFO
nSecondCount | MV_FG_FRAME_SPEC_INFO
nTriggerIndex | MV_FG_FRAME_SPEC_INFO


MV_FG_GAMMA_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_GAMMA_INFO,包括所有继承而来的类成员

enGammaType | MV_FG_GAMMA_INFO
fGammaValue | MV_FG_GAMMA_INFO
nGammaCurveBufLen | MV_FG_GAMMA_INFO
nReserved | MV_FG_GAMMA_INFO
pGammaCurveBuf | MV_FG_GAMMA_INFO


MV_FG_HB_DECODE_PARAM_T 成员列表

成员的完整列表，这些成员属于 MV_FG_HB_DECODE_PARAM_T,包括所有继承而来的类成员

nRes | MV_FG_HB_DECODE_PARAM_T
nSrcLen | MV_FG_HB_DECODE_PARAM_T
pSrcBuf | MV_FG_HB_DECODE_PARAM_T
stFrameSpecInfo | MV_FG_HB_DECODE_PARAM_T
stOutputImageInfo | MV_FG_HB_DECODE_PARAM_T


MV_FG_INPUT_IMAGE_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_INPUT_IMAGE_INFO,包括所有继承而来的类成员

enPixelType | MV_FG_INPUT_IMAGE_INFO
nHeight | MV_FG_INPUT_IMAGE_INFO
nImageBufLen | MV_FG_INPUT_IMAGE_INFO
nReserved | MV_FG_INPUT_IMAGE_INFO
nWidth | MV_FG_INPUT_IMAGE_INFO
pImageBuf | MV_FG_INPUT_IMAGE_INFO


MV_FG_INTERFACE_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_INTERFACE_INFO,包括所有继承而来的类成员

IfaceInfo | MV_FG_INTERFACE_INFO
nReserved | MV_FG_INTERFACE_INFO
nTLayerType | MV_FG_INTERFACE_INFO
stCMLIfaceInfo | MV_FG_INTERFACE_INFO
stCXPIfaceInfo | MV_FG_INTERFACE_INFO
stGEVIfaceInfo | MV_FG_INTERFACE_INFO


MV_FG_INTVALUE 成员列表

成员的完整列表，这些成员属于 MV_FG_INTVALUE,包括所有继承而来的类成员

nCurValue | MV_FG_INTVALUE
nInc | MV_FG_INTVALUE
nMax | MV_FG_INTVALUE
nMin | MV_FG_INTVALUE
nReserved | MV_FG_INTVALUE


MV_FG_OUTPUT_IMAGE_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_OUTPUT_IMAGE_INFO,包括所有继承而来的类成员

enPixelType | MV_FG_OUTPUT_IMAGE_INFO
nHeight | MV_FG_OUTPUT_IMAGE_INFO
nImageBufLen | MV_FG_OUTPUT_IMAGE_INFO
nImageBufSize | MV_FG_OUTPUT_IMAGE_INFO
nReserved | MV_FG_OUTPUT_IMAGE_INFO
nWidth | MV_FG_OUTPUT_IMAGE_INFO
pImageBuf | MV_FG_OUTPUT_IMAGE_INFO


MV_FG_RECONSTRUCT_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_RECONSTRUCT_INFO,包括所有继承而来的类成员

enReconstructMode | MV_FG_RECONSTRUCT_INFO
nReserved | MV_FG_RECONSTRUCT_INFO
stInputImageInfo | MV_FG_RECONSTRUCT_INFO
stOutputImageInfo | MV_FG_RECONSTRUCT_INFO


MV_FG_SAVE_BITMAP_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_SAVE_BITMAP_INFO,包括所有继承而来的类成员

enCfaMethod | MV_FG_SAVE_BITMAP_INFO
nBmpBufLen | MV_FG_SAVE_BITMAP_INFO
nBmpBufSize | MV_FG_SAVE_BITMAP_INFO
nReserved | MV_FG_SAVE_BITMAP_INFO
pBmpBuf | MV_FG_SAVE_BITMAP_INFO
stInputImageInfo | MV_FG_SAVE_BITMAP_INFO


MV_FG_SAVE_JPEG_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_SAVE_JPEG_INFO,包括所有继承而来的类成员

enCfaMethod | MV_FG_SAVE_JPEG_INFO
nJpgBufLen | MV_FG_SAVE_JPEG_INFO
nJpgBufSize | MV_FG_SAVE_JPEG_INFO
nJpgQuality | MV_FG_SAVE_JPEG_INFO
nReserved | MV_FG_SAVE_JPEG_INFO
pJpgBuf | MV_FG_SAVE_JPEG_INFO
stInputImageInfo | MV_FG_SAVE_JPEG_INFO


MV_FG_SAVE_PNG_TO_FILE_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_SAVE_PNG_TO_FILE_INFO,包括所有继承而来的类成员

enCfaMethod | MV_FG_SAVE_PNG_TO_FILE_INFO
nPngCompression | MV_FG_SAVE_PNG_TO_FILE_INFO
nReserved | MV_FG_SAVE_PNG_TO_FILE_INFO
pcImagePath | MV_FG_SAVE_PNG_TO_FILE_INFO
stInputImageInfo | MV_FG_SAVE_PNG_TO_FILE_INFO


MV_FG_SAVE_TIFF_TO_FILE_INFO 成员列表

成员的完整列表，这些成员属于 MV_FG_SAVE_TIFF_TO_FILE_INFO,包括所有继承而来的类成员

enCfaMethod | MV_FG_SAVE_TIFF_TO_FILE_INFO
enResolutionUnit | MV_FG_SAVE_TIFF_TO_FILE_INFO
fXResolution | MV_FG_SAVE_TIFF_TO_FILE_INFO
fYResolution | MV_FG_SAVE_TIFF_TO_FILE_INFO
nReserved | MV_FG_SAVE_TIFF_TO_FILE_INFO
pcImagePath | MV_FG_SAVE_TIFF_TO_FILE_INFO
stInputImageInfo | MV_FG_SAVE_TIFF_TO_FILE_INFO


MV_FG_STRINGVALUE 成员列表

成员的完整列表，这些成员属于 MV_FG_STRINGVALUE,包括所有继承而来的类成员


MV_GEV_DEVICE_INFO 成员列表

成员的完整列表，这些成员属于 MV_GEV_DEVICE_INFO,包括所有继承而来的类成员

chDeviceID | MV_GEV_DEVICE_INFO
chDeviceVersion | MV_GEV_DEVICE_INFO
chManufacturerInfo | MV_GEV_DEVICE_INFO
chModelName | MV_GEV_DEVICE_INFO
chSerialNumber | MV_GEV_DEVICE_INFO
chUserDefinedName | MV_GEV_DEVICE_INFO
chVendorName | MV_GEV_DEVICE_INFO
nCurrentIp | MV_GEV_DEVICE_INFO
nCurrentSubNetMask | MV_GEV_DEVICE_INFO
nDefultGateWay | MV_GEV_DEVICE_INFO
nIpCfgCurrent | MV_GEV_DEVICE_INFO
nIpCfgOption | MV_GEV_DEVICE_INFO
nMacAddress | MV_GEV_DEVICE_INFO
nNetExport | MV_GEV_DEVICE_INFO
nReserved | MV_GEV_DEVICE_INFO


MV_GEV_INTERFACE_INFO 成员列表

成员的完整列表，这些成员属于 MV_GEV_INTERFACE_INFO,包括所有继承而来的类成员

chDisplayName | MV_GEV_INTERFACE_INFO
chInterfaceID | MV_GEV_INTERFACE_INFO
chSerialNumber | MV_GEV_INTERFACE_INFO
nPCIEInfo | MV_GEV_INTERFACE_INFO
nReserved | MV_GEV_INTERFACE_INFO