zhunk 11 месяцев назад
Родитель
Сommit
fba109437c
43 измененных файлов с 5412 добавлено и 7129 удалено
  1. 1006 479
      Lib/mvs/Includes/CameraParams.h
  2. 2573 1397
      Lib/mvs/Includes/MvCameraControl.h
  3. 68 53
      Lib/mvs/Includes/MvErrorDefine.h
  4. 79 74
      Lib/mvs/Includes/MvISPErrorDefine.h
  5. 821 525
      Lib/mvs/Includes/MvObsoleteInterfaces.h
  6. 0 3790
      Lib/mvs/Includes/MvSdkExport.h
  7. 366 271
      Lib/mvs/Includes/ObsoleteCamParams.h
  8. 152 138
      Lib/mvs/Includes/PixelType.h
  9. 26 5
      q6_felgo_iot/CMakeLists.txt
  10. 14 16
      q6_felgo_iot/CMakeLists.txt.user
  11. 6 1
      q6_felgo_iot/Readme.md
  12. 1 1
      q6_felgo_iot/android/build.gradle
  13. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libCppUnit_gcc49_v3_0.so
  14. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libGCBase_gcc49_v3_0.so
  15. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libGenApi_gcc49_v3_0.so
  16. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libLog_gcc49_v3_0.so
  17. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libMVGigEVisionSDK.so
  18. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libMathParser_gcc49_v3_0.so
  19. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libMediaProcess.so
  20. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libMvCameraControl.so
  21. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libMvCameraControlWrapper.so
  22. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libMvUsb3vTL.so
  23. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libNodeMapData_gcc49_v3_0.so
  24. BIN
      q6_felgo_iot/android/libs/arm64-v8a/libXmlParser_gcc49_v3_0.so
  25. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libCppUnit_gcc49_v3_0.so
  26. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libGCBase_gcc49_v3_0.so
  27. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libGenApi_gcc49_v3_0.so
  28. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libLog_gcc49_v3_0.so
  29. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libMVGigEVisionSDK.so
  30. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libMathParser_gcc49_v3_0.so
  31. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libMediaProcess.so
  32. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libMvCameraControl.so
  33. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libMvCameraControlWrapper.so
  34. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libMvUsb3vTL.so
  35. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libNodeMapData_gcc49_v3_0.so
  36. BIN
      q6_felgo_iot/android/libs/armeabi-v7a/libXmlParser_gcc49_v3_0.so
  37. 0 0
      q6_felgo_iot/android/libs/放在这里的库再编译时会打包到apk里.txt
  38. 57 46
      q6_felgo_iot/header/cameramanager.h
  39. 1 1
      q6_felgo_iot/header/main.h
  40. 39 3
      q6_felgo_iot/header/mserial.h
  41. 192 272
      q6_felgo_iot/src/cameramanager.cpp
  42. 2 2
      q6_felgo_iot/src/main.cpp
  43. 9 55
      q6_felgo_iot/src/mserial.cpp

Разница между файлами не показана из-за своего большого размера
+ 1006 - 479
Lib/mvs/Includes/CameraParams.h


Разница между файлами не показана из-за своего большого размера
+ 2573 - 1397
Lib/mvs/Includes/MvCameraControl.h


+ 68 - 53
Lib/mvs/Includes/MvErrorDefine.h

@@ -1,4 +1,4 @@
-
+
 #ifndef _MV_ERROR_DEFINE_H_
 #define _MV_ERROR_DEFINE_H_
 
@@ -6,102 +6,117 @@
 
 /********************************************************************/
 ///  \~chinese
-///  \name 正确码定义
+///  \name 正确码定义
 ///  @{
 ///  \~english
 ///  \name Definition of correct code
 ///  @{
-#define MV_OK                       0x00000000  ///< \~chinese 成功,无错误             \~english Successed, no error
+#define MV_OK                       0x00000000  ///< \~chinese 鎴愬姛锛屾棤閿欒�             \~english Successed, no error
 /// @}
 
 /********************************************************************/
 ///  \~chinese
-///  \name 通用错误码定义:范围0x80000000-0x800000FF
+///  \name 通用错误码定义:范围0x80000000-0x800000FF
 ///  @{
 ///  \~english
 ///  \name Definition of General error code
 ///  @{
-#define MV_E_HANDLE                 0x80000000  ///< \~chinese 错误或无效的句柄         \~english Error or invalid handle
-#define MV_E_SUPPORT                0x80000001  ///< \~chinese 不支持的功能             \~english Not supported function
-#define MV_E_BUFOVER                0x80000002  ///< \~chinese 缓存已满                 \~english Buffer overflow
-#define MV_E_CALLORDER              0x80000003  ///< \~chinese 函数调用顺序错误         \~english Function calling order error
-#define MV_E_PARAMETER              0x80000004  ///< \~chinese 错误的参数               \~english Incorrect parameter
-#define MV_E_RESOURCE               0x80000006  ///< \~chinese 资源申请失败             \~english Applying resource failed
-#define MV_E_NODATA                 0x80000007  ///< \~chinese 无数据                   \~english No data
-#define MV_E_PRECONDITION           0x80000008  ///< \~chinese 前置条件有误,或运行环境已发生变化   \~english Precondition error, or running environment changed
-#define MV_E_VERSION                0x80000009  ///< \~chinese 版本不匹配               \~english Version mismatches
-#define MV_E_NOENOUGH_BUF           0x8000000A  ///< \~chinese 传入的内存空间不足       \~english Insufficient memory
-#define MV_E_ABNORMAL_IMAGE         0x8000000B  ///< \~chinese 异常图像,可能是丢包导致图像不完整   \~english Abnormal image, maybe incomplete image because of lost packet
-#define MV_E_LOAD_LIBRARY           0x8000000C  ///< \~chinese 动态导入DLL失败          \~english Load library failed
-#define MV_E_NOOUTBUF               0x8000000D  ///< \~chinese 没有可输出的缓存         \~english No Avaliable Buffer
-#define MV_E_ENCRYPT                0x8000000E  ///< \~chinese 加密错误                 \~english Encryption error
-#define MV_E_UNKNOW                 0x800000FF  ///< \~chinese 未知的错误               \~english Unknown error
+#define MV_E_HANDLE                 0x80000000  ///< \~chinese 閿欒�鎴栨棤鏁堢殑鍙ユ焺         \~english Error or invalid handle
+#define MV_E_SUPPORT                0x80000001  ///< \~chinese 涓嶆敮鎸佺殑鍔熻兘             \~english Not supported function
+#define MV_E_BUFOVER                0x80000002  ///< \~chinese 缂撳瓨宸叉弧                 \~english Buffer overflow
+#define MV_E_CALLORDER              0x80000003  ///< \~chinese 鍑芥暟璋冪敤椤哄簭閿欒�         \~english Function calling order error
+#define MV_E_PARAMETER              0x80000004  ///< \~chinese 错误的参数               \~english Incorrect parameter
+#define MV_E_RESOURCE               0x80000006  ///< \~chinese 璧勬簮鐢宠�澶辫触             \~english Applying resource failed
+#define MV_E_NODATA                 0x80000007  ///< \~chinese 无数据                   \~english No data
+#define MV_E_PRECONDITION           0x80000008  ///< \~chinese 前置条件有误,或运行环境已发生变化   \~english Precondition error, or running environment changed
+#define MV_E_VERSION                0x80000009  ///< \~chinese 版本不匹配               \~english Version mismatches
+#define MV_E_NOENOUGH_BUF           0x8000000A  ///< \~chinese 传入的内存空间不足       \~english Insufficient memory
+#define MV_E_ABNORMAL_IMAGE         0x8000000B  ///< \~chinese 异常图像,可能是丢包导致图像不完整   \~english Abnormal image, maybe incomplete image because of lost packet
+#define MV_E_LOAD_LIBRARY           0x8000000C  ///< \~chinese 鍔ㄦ€佸�鍏�LL澶辫触          \~english Load library failed
+#define MV_E_NOOUTBUF               0x8000000D  ///< \~chinese 娌℃湁鍙�緭鍑虹殑缂撳瓨         \~english No Avaliable Buffer
+#define MV_E_ENCRYPT                0x8000000E  ///< \~chinese 鍔犲瘑閿欒�                 \~english Encryption error
+#define MV_E_OPENFILE               0x8000000F  ///< \~chinese 鎵撳紑鏂囦欢鍑虹幇閿欒�         \~english open file error
+#define MV_E_BUF_IN_USE             0x80000010  ///< \~chinese 缓存地址已使用           \~english Buffer already in use
+#define MV_E_BUF_INVALID            0x80000011  ///< \~chinese 鏃犳晥鐨勭紦瀛樺湴鍧€           \~english Buffer address invalid
+#define MV_E_NOALIGN_BUF            0x80000012  ///< \~chinese 缂撳瓨瀵归綈寮傚父             \~english Buffer alignmenterror error
+#define MV_E_NOENOUGH_BUF_NUM       0x80000013  ///< \~chinese 缂撳瓨涓�暟涓嶈冻             \~english Insufficient cache count
+#define MV_E_PORT_IN_USE            0x80000014  ///< \~chinese 串口被占用               \~english Port is in use
+#define MV_E_IMAGE_DECODEC          0x80000015  ///< \~chinese 瑙g爜閿欒�(SDK鏍¢獙鍥惧儚寮傚父)\~english Decoding error (SDK verification image exception)
+#define MV_E_UINT32_LIMIT           0x80000016  ///  \~chinese 鍥惧儚澶у皬瓒呰繃unsigned int杩斿洖锛屾帴鍙d笉鏀�寔   
+#define MV_E_IMAGE_HEIGHT           0x80000017  ///  \~chinese 鍥惧儚楂樺害寮傚父锛堟畫甯т涪寮冿級 \~english image height anomaly (discard incomplete images)
+#define MV_E_NOENOUGH_DDR           0x80000018  ///< \~chinese DDR缂撳瓨涓嶈冻              \~english The DDR cache is Insufficient
+#define MV_E_NOENOUGH_STREAM        0x80000019  ///< \~chinese 娴侀€氶亾涓嶈冻               \~english The stream channel is Insufficient
+#define MV_E_NORESPONSE             0x8000001A  ///< \~chinese 设备无响应               \~english No response from device
+
+#define MV_E_UNKNOW                 0x800000FF  ///< \~chinese 未知的错误               \~english Unknown error
 /// @}
 
 /********************************************************************/
 ///  \~chinese
-///  \name GenICam系列错误:范围0x80000100-0x800001FF
+///  \name GenICam绯诲垪閿欒�:鑼冨洿0x80000100-0x800001FF
 ///  @{
 ///  \~english
 ///  \name GenICam Series Error Codes: Range from 0x80000100 to 0x800001FF
 ///  @{
-#define MV_E_GC_GENERIC             0x80000100  ///< \~chinese 通用错误                 \~english General error
-#define MV_E_GC_ARGUMENT            0x80000101  ///< \~chinese 参数非法                 \~english Illegal parameters
-#define MV_E_GC_RANGE               0x80000102  ///< \~chinese 值超出范围               \~english The value is out of range
-#define MV_E_GC_PROPERTY            0x80000103  ///< \~chinese 属性                     \~english Property
-#define MV_E_GC_RUNTIME             0x80000104  ///< \~chinese 运行环境有问题           \~english Running environment error
-#define MV_E_GC_LOGICAL             0x80000105  ///< \~chinese 逻辑错误                 \~english Logical error
-#define MV_E_GC_ACCESS              0x80000106  ///< \~chinese 节点访问条件有误         \~english Node accessing condition error
-#define MV_E_GC_TIMEOUT             0x80000107  ///< \~chinese 超时                     \~english Timeout
-#define MV_E_GC_DYNAMICCAST         0x80000108  ///< \~chinese 转换异常                 \~english Transformation exception
-#define MV_E_GC_UNKNOW              0x800001FF  ///< \~chinese GenICam未知错误          \~english GenICam unknown error
+#define MV_E_GC_GENERIC             0x80000100  ///< \~chinese 閫氱敤閿欒�                 \~english General error
+#define MV_E_GC_ARGUMENT            0x80000101  ///< \~chinese 鍙傛暟闈炴硶                 \~english Illegal parameters
+#define MV_E_GC_RANGE               0x80000102  ///< \~chinese 值超出范围               \~english The value is out of range
+#define MV_E_GC_PROPERTY            0x80000103  ///< \~chinese 属性                     \~english Property
+#define MV_E_GC_RUNTIME             0x80000104  ///< \~chinese 运行环境有问题           \~english Running environment error
+#define MV_E_GC_LOGICAL             0x80000105  ///< \~chinese 閫昏緫閿欒�                 \~english Logical error
+#define MV_E_GC_ACCESS              0x80000106  ///< \~chinese 鑺傜偣璁块棶鏉′欢鏈夎�         \~english Node accessing condition error
+#define MV_E_GC_TIMEOUT             0x80000107  ///< \~chinese 瓒呮椂                     \~english Timeout
+#define MV_E_GC_DYNAMICCAST         0x80000108  ///< \~chinese 杞�崲寮傚父                 \~english Transformation exception
+#define MV_E_GC_UNKNOW              0x800001FF  ///< \~chinese GenICam鏈�煡閿欒�          \~english GenICam unknown error
 /// @}
 
 /********************************************************************/
 ///  \~chinese
-///  \name GigE_STATUS对应的错误码:范围0x80000200-0x800002FF
+///  \name GigE_STATUS瀵瑰簲鐨勯敊璇�爜:鑼冨洿0x80000200-0x800002FF
 ///  @{
 ///  \~english
 ///  \name GigE_STATUS Error Codes: Range from 0x80000200 to 0x800002FF
 ///  @{
-#define MV_E_NOT_IMPLEMENTED        0x80000200  ///< \~chinese 命令不被设备支持         \~english The command is not supported by device
-#define MV_E_INVALID_ADDRESS        0x80000201  ///< \~chinese 访问的目标地址不存在     \~english The target address being accessed does not exist
-#define MV_E_WRITE_PROTECT          0x80000202  ///< \~chinese 目标地址不可写           \~english The target address is not writable
-#define MV_E_ACCESS_DENIED          0x80000203  ///< \~chinese 设备无访问权限           \~english No permission
-#define MV_E_BUSY                   0x80000204  ///< \~chinese 设备忙,或网络断开       \~english Device is busy, or network disconnected
-#define MV_E_PACKET                 0x80000205  ///< \~chinese 网络包数据错误           \~english Network data packet error
-#define MV_E_NETER                  0x80000206  ///< \~chinese 网络相关错误             \~english Network error
-#define MV_E_IP_CONFLICT            0x80000221  ///< \~chinese 设备IP冲突               \~english Device IP conflict
+#define MV_E_NOT_IMPLEMENTED        0x80000200  ///< \~chinese 鍛戒护涓嶈�璁惧�鏀�寔         \~english The command is not supported by device
+#define MV_E_INVALID_ADDRESS        0x80000201  ///< \~chinese 访问的目标地址不存在     \~english The target address being accessed does not exist
+#define MV_E_WRITE_PROTECT          0x80000202  ///< \~chinese 目标地址不可写           \~english The target address is not writable
+#define MV_E_ACCESS_DENIED          0x80000203  ///< \~chinese 设备无访问权限           \~english No permission
+#define MV_E_BUSY                   0x80000204  ///< \~chinese 璁惧�蹇欙紝鎴栫綉缁滄柇寮€       \~english Device is busy, or network disconnected
+#define MV_E_PACKET                 0x80000205  ///< \~chinese 网络包数据错误           \~english Network data packet error
+#define MV_E_NETER                  0x80000206  ///< \~chinese 缃戠粶鐩稿叧閿欒�             \~english Network error
+#define MV_E_SUPPORT_MODIFY_DEVICE_IP   0x8000020E ///< 鍦ㄥ浐瀹欼P妯″紡涓嬩笉鏀�寔淇�敼璁惧�IP妯″紡  \~english Current Mode Not Support Modify Ip
+#define MV_E_KEY_VERIFICATION       0x8000020F  ///< \~chinese 绉橀挜鏍¢獙閿欒�              \~english SwitchKey error
+#define MV_E_IP_CONFLICT            0x80000221  ///< \~chinese 璁惧�IP鍐茬獊               \~english Device IP conflict
 /// @}
 
 /********************************************************************/
 ///  \~chinese
-///  \name USB_STATUS对应的错误码:范围0x80000300-0x800003FF
+///  \name USB_STATUS瀵瑰簲鐨勯敊璇�爜:鑼冨洿0x80000300-0x800003FF
 ///  @{
 ///  \~english
 ///  \name USB_STATUS Error Codes: Range from 0x80000300 to 0x800003FF
 ///  @{
-#define MV_E_USB_READ               0x80000300  ///< \~chinese 读usb出错                \~english Reading USB error
-#define MV_E_USB_WRITE              0x80000301  ///< \~chinese 写usb出错                \~english Writing USB error
-#define MV_E_USB_DEVICE             0x80000302  ///< \~chinese 设备异常                 \~english Device exception
-#define MV_E_USB_GENICAM            0x80000303  ///< \~chinese GenICam相关错误          \~english GenICam error
-#define MV_E_USB_BANDWIDTH          0x80000304  ///< \~chinese 带宽不足                 \~english Insufficient bandwidth
-#define MV_E_USB_DRIVER             0x80000305  ///< \~chinese 驱动不匹配或者未装驱动   \~english Driver mismatch or unmounted drive
-#define MV_E_USB_UNKNOW             0x800003FF  ///< \~chinese USB未知的错误            \~english USB unknown error
+#define MV_E_USB_READ               0x80000300  ///< \~chinese 璇籾sb鍑洪敊                \~english Reading USB error
+#define MV_E_USB_WRITE              0x80000301  ///< \~chinese 鍐檜sb鍑洪敊                \~english Writing USB error
+#define MV_E_USB_DEVICE             0x80000302  ///< \~chinese 璁惧�寮傚父                 \~english Device exception
+#define MV_E_USB_GENICAM            0x80000303  ///< \~chinese GenICam鐩稿叧閿欒�          \~english GenICam error
+#define MV_E_USB_BANDWIDTH          0x80000304  ///< \~chinese 甯﹀�涓嶈冻                 \~english Insufficient bandwidth
+#define MV_E_USB_DRIVER             0x80000305  ///< \~chinese 驱动不匹配或者未装驱动   \~english Driver mismatch or unmounted drive
+#define MV_E_USB_UNKNOW             0x800003FF  ///< \~chinese USB未知的错误            \~english USB unknown error
 /// @}
 
 /********************************************************************/
 ///  \~chinese
-///  \name 升级时对应的错误码:范围0x80000400-0x800004FF
+///  \name 升级时对应的错误码:范围0x80000400-0x800004FF
 ///  @{
 ///  \~english
 ///  \name Upgrade Error Codes: Range from 0x80000400 to 0x800004FF
 ///  @{
-#define MV_E_UPG_FILE_MISMATCH      0x80000400  ///< \~chinese 升级固件不匹配           \~english Firmware mismatches
-#define MV_E_UPG_LANGUSGE_MISMATCH  0x80000401  ///< \~chinese 升级固件语言不匹配       \~english Firmware language mismatches
-#define MV_E_UPG_CONFLICT           0x80000402  ///< \~chinese 升级冲突(设备已经在升级了再次请求升级即返回此错误) \~english Upgrading conflicted (repeated upgrading requests during device upgrade)
-#define MV_E_UPG_INNER_ERR          0x80000403  ///< \~chinese 升级时设备内部出现错误   \~english Camera internal error during upgrade
-#define MV_E_UPG_UNKNOW             0x800004FF  ///< \~chinese 升级时未知错误           \~english Unknown error during upgrade
+#define MV_E_UPG_FILE_MISMATCH      0x80000400  ///< \~chinese 升级固件不匹配           \~english Firmware mismatches
+#define MV_E_UPG_LANGUSGE_MISMATCH  0x80000401  ///< \~chinese 升级固件语言不匹配       \~english Firmware language mismatches
+#define MV_E_UPG_CONFLICT           0x80000402  ///< \~chinese 鍗囩骇鍐茬獊锛堣�澶囧凡缁忓湪鍗囩骇浜嗗啀娆¤�姹傚崌绾у嵆杩斿洖姝ら敊璇�級 \~english Upgrading conflicted (repeated upgrading requests during device upgrade)
+#define MV_E_UPG_INNER_ERR          0x80000403  ///< \~chinese 升级时设备内部出现错误   \~english Camera internal error during upgrade
+#define MV_E_UPG_UNKNOW             0x800004FF  ///< \~chinese 升级时未知错误           \~english Unknown error during upgrade
 /// @}
 
 #endif //_MV_ERROR_DEFINE_H_

+ 79 - 74
Lib/mvs/Includes/MvISPErrorDefine.h

@@ -1,93 +1,98 @@
-
+
 #ifndef _MV_ISP_ERROR_DEFINE_H_
 #define _MV_ISP_ERROR_DEFINE_H_
 
 /************************************************************************
-* 来自ISP算法库的错误码
+* 来自ISP算法库的错误码
 ************************************************************************/
-// 通用类型
-#define MV_ALG_OK                   0x00000000  //处理正确
-#define MV_ALG_ERR                  0x10000000  //不确定类型错误
+// 閫氱敤绫诲瀷
+#define MV_ALG_OK                   0x00000000  //澶勭悊姝g‘
+#define MV_ALG_ERR                  0x10000000  //不确定类型错误
+
+// 能力检查
+#define MV_ALG_E_ABILITY_ARG        0x10000001  //鑳藉姏闆嗕腑瀛樺湪鏃犳晥鍙傛暟
 
-// 能力检查
-#define MV_ALG_E_ABILITY_ARG        0x10000001  //能力集中存在无效参数
+// 内存检查
+#define MV_ALG_E_MEM_NULL           0x10000002  //鍐呭瓨鍦板潃涓虹┖
+#define MV_ALG_E_MEM_ALIGN          0x10000003  //内存对齐不满足要求
+#define MV_ALG_E_MEM_LACK           0x10000004  //鍐呭瓨绌洪棿澶у皬涓嶅�
+#define MV_ALG_E_MEM_SIZE_ALIGN     0x10000005  //内存空间大小不满足对齐要求
+#define MV_ALG_E_MEM_ADDR_ALIGN     0x10000006  //内存地址不满足对齐要求
 
-// 内存检查
-#define MV_ALG_E_MEM_NULL           0x10000002  //内存地址为空
-#define MV_ALG_E_MEM_ALIGN          0x10000003  //内存对齐不满足要求
-#define MV_ALG_E_MEM_LACK           0x10000004  //内存空间大小不够
-#define MV_ALG_E_MEM_SIZE_ALIGN     0x10000005  //内存空间大小不满足对齐要求
-#define MV_ALG_E_MEM_ADDR_ALIGN     0x10000006  //内存地址不满足对齐要求
+// 图像检查
+#define MV_ALG_E_IMG_FORMAT         0x10000007  //鍥惧儚鏍煎紡涓嶆�纭�垨鑰呬笉鏀�寔
+#define MV_ALG_E_IMG_SIZE           0x10000008  //图像宽高不正确或者超出范围
+#define MV_ALG_E_IMG_STEP           0x10000009  //图像宽高与step参数不匹配
+#define MV_ALG_E_IMG_DATA_NULL      0x1000000A  //鍥惧儚鏁版嵁瀛樺偍鍦板潃涓虹┖
 
-// 图像检查
-#define MV_ALG_E_IMG_FORMAT         0x10000007  //图像格式不正确或者不支持
-#define MV_ALG_E_IMG_SIZE           0x10000008  //图像宽高不正确或者超出范围
-#define MV_ALG_E_IMG_STEP           0x10000009  //图像宽高与step参数不匹配
-#define MV_ALG_E_IMG_DATA_NULL      0x1000000A  //图像数据存储地址为空
+// 输入输出参数检查
+#define MV_ALG_E_CFG_TYPE           0x1000000B  //璁剧疆鎴栬€呰幏鍙栧弬鏁扮被鍨嬩笉姝g‘
+#define MV_ALG_E_CFG_SIZE           0x1000000C  //设置或者获取参数的输入、输出结构体大小不正确
+#define MV_ALG_E_PRC_TYPE           0x1000000D  //处理类型不正确
+#define MV_ALG_E_PRC_SIZE           0x1000000E  //澶勭悊鏃惰緭鍏ャ€佽緭鍑哄弬鏁板ぇ灏忎笉姝g‘
+#define MV_ALG_E_FUNC_TYPE          0x1000000F  //瀛愬�鐞嗙被鍨嬩笉姝g‘
+#define MV_ALG_E_FUNC_SIZE          0x10000010  //瀛愬�鐞嗘椂杈撳叆銆佽緭鍑哄弬鏁板ぇ灏忎笉姝g‘
 
-// 输入输出参数检查
-#define MV_ALG_E_CFG_TYPE           0x1000000B  //设置或者获取参数类型不正确
-#define MV_ALG_E_CFG_SIZE           0x1000000C  //设置或者获取参数的输入、输出结构体大小不正确
-#define MV_ALG_E_PRC_TYPE           0x1000000D  //处理类型不正确
-#define MV_ALG_E_PRC_SIZE           0x1000000E  //处理时输入、输出参数大小不正确
-#define MV_ALG_E_FUNC_TYPE          0x1000000F  //子处理类型不正确
-#define MV_ALG_E_FUNC_SIZE          0x10000010  //子处理时输入、输出参数大小不正确
+// 运行参数检查
+#define MV_ALG_E_PARAM_INDEX        0x10000011  //index参数不正确
+#define MV_ALG_E_PARAM_VALUE        0x10000012  //value参数不正确或者超出范围
+#define MV_ALG_E_PARAM_NUM          0x10000013  //param_num参数不正确
 
-// 运行参数检查
-#define MV_ALG_E_PARAM_INDEX        0x10000011  //index参数不正确
-#define MV_ALG_E_PARAM_VALUE        0x10000012  //value参数不正确或者超出范围
-#define MV_ALG_E_PARAM_NUM          0x10000013  //param_num参数不正确
+// 接口调用检查
+#define MV_ALG_E_NULL_PTR           0x10000014  //鍑芥暟鍙傛暟鎸囬拡涓虹┖
+#define MV_ALG_E_OVER_MAX_MEM       0x10000015  //超过限定的最大内存
+#define MV_ALG_E_CALL_BACK          0x10000016  //鍥炶皟鍑芥暟鍑洪敊
 
-// 接口调用检查
-#define MV_ALG_E_NULL_PTR           0x10000014  //函数参数指针为空
-#define MV_ALG_E_OVER_MAX_MEM       0x10000015  //超过限定的最大内存
-#define MV_ALG_E_CALL_BACK          0x10000016  //回调函数出错
+// 算法库加密相关检查
+#define MV_ALG_E_ENCRYPT            0x10000017  //鍔犲瘑閿欒�
+#define MV_ALG_E_EXPIRE             0x10000018  //算法库使用期限错误
 
-// 算法库加密相关检查
-#define MV_ALG_E_ENCRYPT            0x10000017  //加密错误
-#define MV_ALG_E_EXPIRE             0x10000018  //算法库使用期限错误
+// 内部模块返回的基本错误类型
+#define MV_ALG_E_BAD_ARG            0x10000019  //参数范围不正确
+#define MV_ALG_E_DATA_SIZE          0x1000001A  //数据大小不正确
+#define MV_ALG_E_STEP               0x1000001B  //数据step不正确
 
-// 内部模块返回的基本错误类型
-#define MV_ALG_E_BAD_ARG            0x10000019  //参数范围不正确
-#define MV_ALG_E_DATA_SIZE          0x1000001A  //数据大小不正确
-#define MV_ALG_E_STEP               0x1000001B  //数据step不正确
+// cpu鎸囦护闆嗘敮鎸侀敊璇�爜
+#define MV_ALG_E_CPUID              0x1000001C  //cpu涓嶆敮鎸佷紭鍖栦唬鐮佷腑鐨勬寚浠ら泦
 
-// cpu指令集支持错误码
-#define MV_ALG_E_CPUID              0x1000001C  //cpu不支持优化代码中的指令集
+#define MV_ALG_WARNING              0x1000001D  //璀﹀憡
 
-#define MV_ALG_WARNING              0x1000001D  //警告
+#define MV_ALG_E_TIME_OUT           0x1000001E  //算法库超时
+#define MV_ALG_E_LIB_VERSION        0x1000001F  //算法版本号出错
+#define MV_ALG_E_MODEL_VERSION      0x10000020  //模型版本号出错
+#define MV_ALG_E_GPU_MEM_ALLOC      0x10000021  //GPU鍐呭瓨鍒嗛厤閿欒�
+#define MV_ALG_E_FILE_NON_EXIST     0x10000022  //文件不存在
+#define MV_ALG_E_NONE_STRING        0x10000023  //字符串为空
+#define MV_ALG_E_IMAGE_CODEC        0x10000024  //图像解码器错误
+#define MV_ALG_E_FILE_OPEN          0x10000025  //鎵撳紑鏂囦欢閿欒�
+#define MV_ALG_E_FILE_READ          0x10000026  //鏂囦欢璇诲彇閿欒�
+#define MV_ALG_E_FILE_WRITE         0x10000027  //文件写错误
+#define MV_ALG_E_FILE_READ_SIZE     0x10000028  //鏂囦欢璇诲彇澶у皬閿欒�
+#define MV_ALG_E_FILE_TYPE          0x10000029  //鏂囦欢绫诲瀷閿欒�
+#define MV_ALG_E_MODEL_TYPE         0x1000002A  //妯″瀷绫诲瀷閿欒�
+#define MV_ALG_E_MALLOC_MEM         0x1000002B  //鍒嗛厤鍐呭瓨閿欒�
+#define MV_ALG_E_BIND_CORE_FAILED   0x1000002C  //绾跨▼缁戞牳澶辫触
 
-#define MV_ALG_E_TIME_OUT           0x1000001E  //算法库超时
-#define MV_ALG_E_LIB_VERSION        0x1000001F  //算法版本号出错
-#define MV_ALG_E_MODEL_VERSION      0x10000020  //模型版本号出错
-#define MV_ALG_E_GPU_MEM_ALLOC      0x10000021  //GPU内存分配错误
-#define MV_ALG_E_FILE_NON_EXIST     0x10000022  //文件不存在
-#define MV_ALG_E_NONE_STRING        0x10000023  //字符串为空
-#define MV_ALG_E_IMAGE_CODEC        0x10000024  //图像解码器错误
-#define MV_ALG_E_FILE_OPEN          0x10000025  //打开文件错误
-#define MV_ALG_E_FILE_READ          0x10000026  //文件读取错误
-#define MV_ALG_E_FILE_WRITE         0x10000027  //文件写错误
-#define MV_ALG_E_FILE_READ_SIZE     0x10000028  //文件读取大小错误
-#define MV_ALG_E_FILE_TYPE          0x10000029  //文件类型错误
-#define MV_ALG_E_MODEL_TYPE         0x1000002A  //模型类型错误
-#define MV_ALG_E_MALLOC_MEM         0x1000002B  //分配内存错误
-#define MV_ALG_E_BIND_CORE_FAILED   0x1000002C  //线程绑核失败
+// 降噪特有错误码
+#define MV_ALG_E_DENOISE_NE_IMG_FORMAT       0x10402001  //噪声特性图像格式错误
+#define MV_ALG_E_DENOISE_NE_FEATURE_TYPE     0x10402002  //噪声特性类型错误
+#define MV_ALG_E_DENOISE_NE_PROFILE_NUM      0x10402003  //噪声特性个数错误
+#define MV_ALG_E_DENOISE_NE_GAIN_NUM         0x10402004  //噪声特性增益个数错误
+#define MV_ALG_E_DENOISE_NE_GAIN_VAL         0x10402005  //噪声曲线增益值输入错误
+#define MV_ALG_E_DENOISE_NE_BIN_NUM          0x10402006  //鍣�0鏇茬嚎鏌辨暟閿欒�
+#define MV_ALG_E_DENOISE_NE_INIT_GAIN        0x10402007  //噪声估计初始化增益设置错误
+#define MV_ALG_E_DENOISE_NE_NOT_INIT         0x10402008  //鍣�0浼拌�鏈�垵濮嬪寲
+#define MV_ALG_E_DENOISE_COLOR_MODE          0x10402009  //棰滆壊绌洪棿妯″紡閿欒�
+#define MV_ALG_E_DENOISE_ROI_NUM             0x1040200a  //鍥惧儚ROI涓�暟閿欒�
+#define MV_ALG_E_DENOISE_ROI_ORI_PT          0x1040200b  //鍥惧儚ROI鍘熺偣閿欒�
+#define MV_ALG_E_DENOISE_ROI_SIZE            0x1040200c  //鍥惧儚ROI澶у皬閿欒�
+#define MV_ALG_E_DENOISE_GAIN_NOT_EXIST      0x1040200d  //杈撳叆鐨勭浉鏈哄�鐩婁笉瀛樺湪(澧炵泭涓�暟宸茶揪涓婇檺)
+#define MV_ALG_E_DENOISE_GAIN_BEYOND_RANGE   0x1040200e  //杈撳叆鐨勭浉鏈哄�鐩婁笉鍦ㄨ寖鍥村唴
+#define MV_ALG_E_DENOISE_NP_BUF_SIZE         0x1040200f  //输入的噪声特性内存大小错误
 
-// 降噪特有错误码
-#define MV_ALG_E_DENOISE_NE_IMG_FORMAT       0x10402001  //噪声特性图像格式错误
-#define MV_ALG_E_DENOISE_NE_FEATURE_TYPE     0x10402002  //噪声特性类型错误
-#define MV_ALG_E_DENOISE_NE_PROFILE_NUM      0x10402003  //噪声特性个数错误
-#define MV_ALG_E_DENOISE_NE_GAIN_NUM         0x10402004  //噪声特性增益个数错误
-#define MV_ALG_E_DENOISE_NE_GAIN_VAL         0x10402005  //噪声曲线增益值输入错误
-#define MV_ALG_E_DENOISE_NE_BIN_NUM          0x10402006  //噪声曲线柱数错误
-#define MV_ALG_E_DENOISE_NE_INIT_GAIN        0x10402007  //噪声估计初始化增益设置错误
-#define MV_ALG_E_DENOISE_NE_NOT_INIT         0x10402008  //噪声估计未初始化
-#define MV_ALG_E_DENOISE_COLOR_MODE          0x10402009  //颜色空间模式错误
-#define MV_ALG_E_DENOISE_ROI_NUM             0x1040200a  //图像ROI个数错误
-#define MV_ALG_E_DENOISE_ROI_ORI_PT          0x1040200b  //图像ROI原点错误
-#define MV_ALG_E_DENOISE_ROI_SIZE            0x1040200c  //图像ROI大小错误
-#define MV_ALG_E_DENOISE_GAIN_NOT_EXIST      0x1040200d  //输入的相机增益不存在(增益个数已达上限)
-#define MV_ALG_E_DENOISE_GAIN_BEYOND_RANGE   0x1040200e  //输入的相机增益不在范围内
-#define MV_ALG_E_DENOISE_NP_BUF_SIZE         0x1040200f  //输入的噪声特性内存大小错误
+// 鍘荤传杈圭壒鏈夐敊璇�爜
+#define MV_ALG_E_PFC_ROI_PT                 0x10405000  //鍘荤传杈圭畻娉昍OI鍘熺偣閿欒�
+#define MV_ALG_E_PFC_ROI_SIZE               0x10405001  //鍘荤传杈圭畻娉昍OI澶у皬閿欒�
+#define MV_ALG_E_PFC_KERNEL_SIZE            0x10405002  //鍘荤传杈圭畻娉曟护娉㈡牳灏哄�閿欒�
 
 #endif //_MV_ISP_ERROR_DEFINE_H_

Разница между файлами не показана из-за своего большого размера
+ 821 - 525
Lib/mvs/Includes/MvObsoleteInterfaces.h


Разница между файлами не показана из-за своего большого размера
+ 0 - 3790
Lib/mvs/Includes/MvSdkExport.h


+ 366 - 271
Lib/mvs/Includes/ObsoleteCamParams.h

@@ -1,41 +1,41 @@
-
+
 #ifndef _MV_OBSOLETE_CAM_PARAMS_H_
 #define _MV_OBSOLETE_CAM_PARAMS_H_
 
 #include "PixelType.h"
 
-/// \~chinese 输出帧的信息             \~english Output Frame Information
+/// \~chinese 杈撳嚭甯х殑淇℃伅             \~english Output Frame Information
 typedef struct _MV_FRAME_OUT_INFO_
 {
-    unsigned short      nWidth;             ///< [OUT]  \~chinese 图像宽            \~english Image Width
-    unsigned short      nHeight;            ///< [OUT]  \~chinese 图像高            \~english Image Height
-    enum MvGvspPixelType    enPixelType;    ///< [OUT]  \~chinese 像素格式          \~english Pixel Type
+    unsigned short      nWidth;             ///< [OUT]  \~chinese 图像宽            \~english Image Width
+    unsigned short      nHeight;            ///< [OUT]  \~chinese 图像高            \~english Image Height
+    enum MvGvspPixelType    enPixelType;    ///< [OUT]  \~chinese 鍍忕礌鏍煎紡          \~english Pixel Type
 
-    unsigned int        nFrameNum;          ///< [OUT]  \~chinese 帧号              \~english Frame Number
-    unsigned int        nDevTimeStampHigh;  ///< [OUT]  \~chinese 时间戳高32位      \~english Timestamp high 32 bits
-    unsigned int        nDevTimeStampLow;   ///< [OUT]  \~chinese 时间戳低32位      \~english Timestamp low 32 bits
-    unsigned int        nReserved0;         ///< [OUT]  \~chinese 保留,8字节对齐   \~english Reserved, 8-byte aligned
-    int64_t             nHostTimeStamp;     ///< [OUT]  \~chinese 主机生成的时间戳  \~english Host-generated timestamp
+    unsigned int        nFrameNum;          ///< [OUT]  \~chinese 甯у彿              \~english Frame Number
+    unsigned int        nDevTimeStampHigh;  ///< [OUT]  \~chinese 时间戳高32位      \~english Timestamp high 32 bits
+    unsigned int        nDevTimeStampLow;   ///< [OUT]  \~chinese 时间戳低32位      \~english Timestamp low 32 bits
+    unsigned int        nReserved0;         ///< [OUT]  \~chinese 保留,8字节对齐   \~english Reserved, 8-byte aligned
+    int64_t             nHostTimeStamp;     ///< [OUT]  \~chinese 涓绘満鐢熸垚鐨勬椂闂存埑  \~english Host-generated timestamp
 
     unsigned int        nFrameLen;
 
-    unsigned int        nLostPacket;  // 本帧丢包数
+    unsigned int        nLostPacket;  // 本帧丢包数
     unsigned int        nReserved[2];
 }MV_FRAME_OUT_INFO;
 
-/// \~chinese 保存图片参数            \~english Save image type
+/// \~chinese 淇濆瓨鍥剧墖鍙傛暟            \~english Save image type
 typedef struct _MV_SAVE_IMAGE_PARAM_T_
 {
-    unsigned char*      pData;              ///< [IN]   \~chinese 输入数据缓存      \~english Input Data Buffer
-    unsigned int        nDataLen;           ///< [IN]   \~chinese 输入数据大小      \~english Input Data Size
-    enum MvGvspPixelType    enPixelType;    ///< [IN]   \~chinese 输入像素格式      \~english Input Data Pixel Format
-    unsigned short      nWidth;             ///< [IN]   \~chinese 图像宽            \~english Image Width
-    unsigned short      nHeight;            ///< [IN]   \~chinese 图像高            \~english Image Height
+    unsigned char*      pData;              ///< [IN]   \~chinese 杈撳叆鏁版嵁缂撳瓨      \~english Input Data Buffer
+    unsigned int        nDataLen;           ///< [IN]   \~chinese 杈撳叆鏁版嵁澶у皬      \~english Input Data Size
+    enum MvGvspPixelType    enPixelType;    ///< [IN]   \~chinese 杈撳叆鍍忕礌鏍煎紡      \~english Input Data Pixel Format
+    unsigned short      nWidth;             ///< [IN]   \~chinese 图像宽            \~english Image Width
+    unsigned short      nHeight;            ///< [IN]   \~chinese 图像高            \~english Image Height
 
-    unsigned char*      pImageBuffer;       ///< [OUT]  \~chinese 输出图片缓存      \~english Output Image Buffer
-    unsigned int        nImageLen;          ///< [OUT]  \~chinese 输出图片大小      \~english Output Image Size
-    unsigned int        nBufferSize;        ///< [IN]   \~chinese 提供的输出缓冲区大小  \~english Output buffer size provided
-    enum MV_SAVE_IAMGE_TYPE enImageType;    ///< [IN]   \~chinese 输出图片格式      \~english Output Image Format
+    unsigned char*      pImageBuffer;       ///< [OUT]  \~chinese 杈撳嚭鍥剧墖缂撳瓨      \~english Output Image Buffer
+    unsigned int        nImageLen;          ///< [OUT]  \~chinese 杈撳嚭鍥剧墖澶у皬      \~english Output Image Size
+    unsigned int        nBufferSize;        ///< [IN]   \~chinese 鎻愪緵鐨勮緭鍑虹紦鍐插尯澶у皬  \~english Output buffer size provided
+    enum MV_SAVE_IAMGE_TYPE enImageType;    ///< [IN]   \~chinese 杈撳嚭鍥剧墖鏍煎紡      \~english Output Image Format
 
 }MV_SAVE_IMAGE_PARAM;
 
@@ -55,291 +55,276 @@ typedef struct _MV_IMAGE_BASIC_INFO_
     float               fFrameRateMin;
     float               fFrameRateMax;
 
-    unsigned int        enPixelType;        ///< [OUT]  \~chinese 当前的像素格式    \~english Current pixel format
-    unsigned int        nSupportedPixelFmtNum;  ///< [OUT]  \~chinese 支持的像素格式种类    \~english Support pixel format
+    unsigned int        enPixelType;        ///< [OUT]  \~chinese 当前的像素格式    \~english Current pixel format
+    unsigned int        nSupportedPixelFmtNum;  ///< [OUT]  \~chinese 支持的像素格式种类    \~english Support pixel format
     unsigned int        enPixelList[MV_MAX_XML_SYMBOLIC_NUM];
     unsigned int        nReserved[8];
 
 }MV_IMAGE_BASIC_INFO;
 
 
-/// \~chinese 噪声特性类型    \~english Noise feature type
+/// \~chinese 噪声特性类型    \~english Noise feature type
 typedef enum _MV_CC_BAYER_NOISE_FEATURE_TYPE
 {
-    MV_CC_BAYER_NOISE_FEATURE_TYPE_INVALID = 0, ///<        \~chinese 无效值                        \~english Invalid
-    MV_CC_BAYER_NOISE_FEATURE_TYPE_PROFILE = 1, ///<        \~chinese 噪声曲线                      \~english Noise curve
-    MV_CC_BAYER_NOISE_FEATURE_TYPE_LEVEL   = 2, ///<        \~chinese 噪声水平                      \~english Noise level
-    MV_CC_BAYER_NOISE_FEATURE_TYPE_DEFAULT = 1, ///<        \~chinese 默认值                        \~english Default
+    MV_CC_BAYER_NOISE_FEATURE_TYPE_INVALID = 0, ///<        \~chinese 无效值                        \~english Invalid
+    MV_CC_BAYER_NOISE_FEATURE_TYPE_PROFILE = 1, ///<        \~chinese 鍣�0鏇茬嚎                      \~english Noise curve
+    MV_CC_BAYER_NOISE_FEATURE_TYPE_LEVEL   = 2, ///<        \~chinese 鍣�0姘村钩                      \~english Noise level
+    MV_CC_BAYER_NOISE_FEATURE_TYPE_DEFAULT = 1, ///<        \~chinese 默认值                        \~english Default
 
 }MV_CC_BAYER_NOISE_FEATURE_TYPE;
 
-/// \~chinese Bayer格式降噪特性信息    \~english Denoise profile info
+/// \~chinese Bayer格式降噪特性信息    \~english Denoise profile info
 typedef struct _MV_CC_BAYER_NOISE_PROFILE_INFO_T_
 {
-    unsigned int        nVersion;           ///<  \~chinese 版本                           \~english version
-    MV_CC_BAYER_NOISE_FEATURE_TYPE enNoiseFeatureType;  ///<  \~chinese 噪声特性类型       \~english noise feature type
-    enum MvGvspPixelType    enPixelType;    ///<  \~chinese 图像格式                       \~english image format
-    int                 nNoiseLevel;        ///<  \~chinese 平均噪声水平                   \~english noise level
-    unsigned int        nCurvePointNum;     ///<  \~chinese 曲线点数                       \~english curve point number
-    int*                nNoiseCurve;        ///<  \~chinese 噪声曲线                       \~english noise curve
-    int*                nLumCurve;          ///<  \~chinese 亮度曲线                       \~english luminance curve
+    unsigned int        nVersion;           ///<  \~chinese 鐗堟湰                           \~english version
+    MV_CC_BAYER_NOISE_FEATURE_TYPE enNoiseFeatureType;  ///<  \~chinese 噪声特性类型       \~english noise feature type
+    enum MvGvspPixelType    enPixelType;    ///<  \~chinese 鍥惧儚鏍煎紡                       \~english image format
+    int                 nNoiseLevel;        ///<  \~chinese 骞冲潎鍣�0姘村钩                   \~english noise level
+    unsigned int        nCurvePointNum;     ///<  \~chinese 鏇茬嚎鐐规暟                       \~english curve point number
+    int*                nNoiseCurve;        ///<  \~chinese 鍣�0鏇茬嚎                       \~english noise curve
+    int*                nLumCurve;          ///<  \~chinese 浜�害鏇茬嚎                       \~english luminance curve
 
-    unsigned int        nRes[8];            ///<       \~chinese 预留                           \~english Reserved
+    unsigned int        nRes[8];            ///<       \~chinese 棰勭暀                           \~english Reserved
 
 }MV_CC_BAYER_NOISE_PROFILE_INFO;
 
-/// \~chinese Bayer格式噪声估计参数    \~english Bayer noise estimate param
+/// \~chinese Bayer鏍煎紡鍣�0浼拌�鍙傛暟    \~english Bayer noise estimate param
 typedef struct _MV_CC_BAYER_NOISE_ESTIMATE_PARAM_T_
 {
-    unsigned int        nWidth;             ///< [IN]  \~chinese 图像宽(大于等于8)              \~english Width
-    unsigned int        nHeight;            ///< [IN]  \~chinese 图像高(大于等于8)              \~english Height
-    enum MvGvspPixelType    enPixelType;    ///< [IN]  \~chinese 像素格式                       \~english Pixel format
+    unsigned int        nWidth;             ///< [IN]  \~chinese 图像宽(大于等于8)              \~english Width
+    unsigned int        nHeight;            ///< [IN]  \~chinese 图像高(大于等于8)              \~english Height
+    enum MvGvspPixelType    enPixelType;    ///< [IN]  \~chinese 鍍忕礌鏍煎紡                       \~english Pixel format
 
-    unsigned char*      pSrcData;           ///< [IN]  \~chinese 输入数据缓存                   \~english Input data buffer
-    unsigned int        nSrcDataLen;        ///< [IN]  \~chinese 输入数据大小                   \~english Input data size
+    unsigned char*      pSrcData;           ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨                   \~english Input data buffer
+    unsigned int        nSrcDataLen;        ///< [IN]  \~chinese 杈撳叆鏁版嵁澶у皬                   \~english Input data size
 
-    unsigned int        nNoiseThreshold;    ///< [IN]  \~chinese 噪声阈值(0-4095)               \~english Noise Threshold
+    unsigned int        nNoiseThreshold;    ///< [IN]  \~chinese 噪声阈值(0-4095)               \~english Noise Threshold
 
-    unsigned char*      pCurveBuf;          ///< [IN]  \~chinese 用于存储噪声曲线和亮度曲线(需要外部分配,缓存大小:4096 * sizeof(int) * 2)     \~english Buffer used to store noise and brightness curves, size:4096 * sizeof(int) * 2)
-    MV_CC_BAYER_NOISE_PROFILE_INFO stNoiseProfile; ///< [OUT]  \~chinese 降噪特性信息               \~english Denoise profile
+    unsigned char*      pCurveBuf;          ///< [IN]  \~chinese 用于存储噪声曲线和亮度曲线(需要外部分配,缓存大小:4096 * sizeof(int) * 2)     \~english Buffer used to store noise and brightness curves, size:4096 * sizeof(int) * 2)
+    MV_CC_BAYER_NOISE_PROFILE_INFO stNoiseProfile; ///< [OUT]  \~chinese 降噪特性信息               \~english Denoise profile
 
-    unsigned int        nThreadNum;         ///< [IN]  \~chinese 线程数量,0表示算法库根据硬件自适应;1表示单线程(默认);大于1表示线程数目      \~english Thread number, 0 means that the library is adaptive to the hardware, 1 means single thread(Default value), Greater than 1 indicates the number of threads
+    unsigned int        nThreadNum;         ///< [IN]  \~chinese 线程数量,0表示算法库根据硬件自适应;1表示单线程(默认);大于1表示线程数目      \~english Thread number, 0 means that the library is adaptive to the hardware, 1 means single thread(Default value), Greater than 1 indicates the number of threads
 
-    unsigned int        nRes[8];            ///<       \~chinese 预留                           \~english Reserved
+    unsigned int        nRes[8];            ///<       \~chinese 棰勭暀                           \~english Reserved
 
 }MV_CC_BAYER_NOISE_ESTIMATE_PARAM;
 
-/// \~chinese Bayer格式空域降噪参数    \~english Bayer spatial Denoise param
+/// \~chinese Bayer鏍煎紡绌哄煙闄嶅櫔鍙傛暟    \~english Bayer spatial Denoise param
 typedef struct _MV_CC_BAYER_SPATIAL_DENOISE_PARAM_T_
 {
-    unsigned int        nWidth;             ///< [IN]  \~chinese 图像宽(大于等于8)              \~english Width
-    unsigned int        nHeight;            ///< [IN]  \~chinese 图像高(大于等于8)              \~english Height
-    enum MvGvspPixelType    enPixelType;        ///< [IN]  \~chinese 像素格式                       \~english Pixel format
+    unsigned int        nWidth;             ///< [IN]  \~chinese 图像宽(大于等于8)              \~english Width
+    unsigned int        nHeight;            ///< [IN]  \~chinese 图像高(大于等于8)              \~english Height
+    enum MvGvspPixelType    enPixelType;        ///< [IN]  \~chinese 鍍忕礌鏍煎紡                       \~english Pixel format
 
-    unsigned char*      pSrcData;           ///< [IN]  \~chinese 输入数据缓存                   \~english Input data buffer
-    unsigned int        nSrcDataLen;        ///< [IN]  \~chinese 输入数据大小                   \~english Input data size
+    unsigned char*      pSrcData;           ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨                   \~english Input data buffer
+    unsigned int        nSrcDataLen;        ///< [IN]  \~chinese 杈撳叆鏁版嵁澶у皬                   \~english Input data size
 
-    unsigned char*      pDstBuf;            ///< [OUT] \~chinese 输出降噪后的数据               \~english Output data buffer
-    unsigned int        nDstBufSize;        ///< [IN]  \~chinese 提供的输出缓冲区大小           \~english Provided output buffer size
-    unsigned int        nDstBufLen;         ///< [OUT] \~chinese 输出降噪后的数据长度           \~english Output data length
+    unsigned char*      pDstBuf;            ///< [OUT] \~chinese 杈撳嚭闄嶅櫔鍚庣殑鏁版嵁               \~english Output data buffer
+    unsigned int        nDstBufSize;        ///< [IN]  \~chinese 鎻愪緵鐨勮緭鍑虹紦鍐插尯澶у皬           \~english Provided output buffer size
+    unsigned int        nDstBufLen;         ///< [OUT] \~chinese 杈撳嚭闄嶅櫔鍚庣殑鏁版嵁闀垮害           \~english Output data length
 
-    MV_CC_BAYER_NOISE_PROFILE_INFO stNoiseProfile; ///< [IN]  \~chinese 降噪特性信息(来源于噪声估计)   \~english Denoise profile
-    unsigned int        nDenoiseStrength;   ///< [IN]  \~chinese 降噪强度(0-100)                \~english nDenoise Strength   
-    unsigned int        nSharpenStrength;   ///< [IN]  \~chinese 锐化强度(0-32)                 \~english Sharpen Strength
-    unsigned int        nNoiseCorrect;      ///< [IN]  \~chinese 噪声校正系数(0-1280)           \~english Noise Correct  
+    MV_CC_BAYER_NOISE_PROFILE_INFO stNoiseProfile; ///< [IN]  \~chinese 降噪特性信息(来源于噪声估计)   \~english Denoise profile
+    unsigned int        nDenoiseStrength;   ///< [IN]  \~chinese 闄嶅櫔寮哄害(0-100)                \~english nDenoise Strength   
+    unsigned int        nSharpenStrength;   ///< [IN]  \~chinese 閿愬寲寮哄害(0-32)                 \~english Sharpen Strength
+    unsigned int        nNoiseCorrect;      ///< [IN]  \~chinese 鍣�0鏍℃�绯绘暟(0-1280)           \~english Noise Correct  
 
-    unsigned int        nThreadNum;         ///< [IN]  \~chinese 线程数量,0表示算法库根据硬件自适应;1表示单线程(默认);大于1表示线程数目         \~english Thread number, 0 means that the library is adaptive to the hardware, 1 means single thread(Default value), Greater than 1 indicates the number of threads
+    unsigned int        nThreadNum;         ///< [IN]  \~chinese 线程数量,0表示算法库根据硬件自适应;1表示单线程(默认);大于1表示线程数目         \~english Thread number, 0 means that the library is adaptive to the hardware, 1 means single thread(Default value), Greater than 1 indicates the number of threads
 
-    unsigned int        nRes[8];            ///<       \~chinese 预留                           \~english Reserved
+    unsigned int        nRes[8];            ///<       \~chinese 棰勭暀                           \~english Reserved
 
 }MV_CC_BAYER_SPATIAL_DENOISE_PARAM;
 
-/// \~chinese CLUT参数                  \~english CLUT param
+/// \~chinese CLUT鍙傛暟                  \~english CLUT param
 typedef struct _MV_CC_CLUT_PARAM_T_
 {
-    bool                bCLUTEnable;                                ///< [IN]  \~chinese 是否启用CLUT           \~english CLUT enable
-    unsigned int        nCLUTScale;                                 ///< [IN]  \~chinese 量化系数(2的整数幂,最大65536)  \~english Quantitative scale(Integer power of 2, <= 65536)
-    unsigned int        nCLUTSize;                                  ///< [IN]  \~chinese CLUT大小,[17,33](建议值17)     \~english CLUT size[17,33](Recommended values of 17)
-    unsigned char*      pCLUTBuf;                                   ///< [IN]  \~chinese 量化CLUT表             \~english CLUT buffer
-    unsigned int        nCLUTBufLen;                                ///< [IN]  \~chinese 量化CLUT缓存大小(nCLUTSize*nCLUTSize*nCLUTSize*sizeof(int)*3)  \~english CLUT buffer length(nCLUTSize*nCLUTSize*nCLUTSize*sizeof(int)*3)
+    bool                bCLUTEnable;                                ///< [IN]  \~chinese 鏄�惁鍚�敤CLUT           \~english CLUT enable
+    unsigned int        nCLUTScale;                                 ///< [IN]  \~chinese 量化系数(2的整数幂,最大65536)  \~english Quantitative scale(Integer power of 2, <= 65536)
+    unsigned int        nCLUTSize;                                  ///< [IN]  \~chinese CLUT大小,目前仅支持17     \~english CLUT size, currently only supports 17
+    unsigned char*      pCLUTBuf;                                   ///< [IN]  \~chinese 量化CLUT表             \~english CLUT buffer
+    unsigned int        nCLUTBufLen;                                ///< [IN]  \~chinese 閲忓寲CLUT缂撳瓨澶у皬(nCLUTSize*nCLUTSize*nCLUTSize*sizeof(int)*3)  \~english CLUT buffer length(nCLUTSize*nCLUTSize*nCLUTSize*sizeof(int)*3)
 
-    unsigned int        nRes[8];                                    ///<       \~chinese 预留                   \~english Reserved
+    unsigned int        nRes[8];                                    ///<       \~chinese 棰勭暀                   \~english Reserved
 
 }MV_CC_CLUT_PARAM;
 
-/// \~chinese 对比度调节结构体          \~english Contrast structure
-typedef struct _MV_CC_CONTRAST_PARAM_T_
+/// \~chinese 锐化结构体                \~english Sharpen structure
+typedef struct _MV_CC_SHARPEN_PARAM_T_
 {
-    unsigned int            nWidth;                                 ///< [IN]  \~chinese 图像宽度(最小8)        \~english Image Width
-    unsigned int            nHeight;                                ///< [IN]  \~chinese 图像高度(最小8)        \~english Image Height
-    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 输入数据缓存           \~english Input data buffer
-    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 输入数据大小           \~english Input data length
-    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 像素格式               \~english Pixel format
-
-    unsigned char*          pDstBuf;                                ///< [OUT] \~chinese 输出数据缓存           \~english Output data buffer
-    unsigned int            nDstBufSize;                            ///< [IN]  \~chinese 提供的输出缓冲区大小   \~english Provided output buffer size
-    unsigned int            nDstBufLen;                             ///< [OUT] \~chinese 输出数据长度           \~english Output data length
+    unsigned int            nWidth;                                 ///< [IN]  \~chinese 图像宽度(最小8)        \~english Image Width
+    unsigned int            nHeight;                                ///< [IN]  \~chinese 图像高度(最小8)        \~english Image Height
+    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨           \~english Input data buffer
+    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 杈撳叆鏁版嵁澶у皬           \~english Input data length
+    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 鍍忕礌鏍煎紡               \~english Pixel format
 
-    unsigned int            nContrastFactor;                        ///< [IN]  \~chinese 对比度值,[1,10000]     \~english Contrast factor,[1,10000]
+    unsigned char*          pDstBuf;                                ///< [OUT] \~chinese 杈撳嚭鏁版嵁缂撳瓨           \~english Output data buffer
+    unsigned int            nDstBufSize;                            ///< [IN]  \~chinese 鎻愪緵鐨勮緭鍑虹紦鍐插尯澶у皬   \~english Provided output buffer size
+    unsigned int            nDstBufLen;                             ///< [OUT] \~chinese 杈撳嚭鏁版嵁闀垮害           \~english Output data length
 
-    unsigned int            nRes[8];                                ///<       \~chinese 预留                   \~english Reserved
-
-}MV_CC_CONTRAST_PARAM;
-
-/// \~chinese 锐化结构体                \~english Sharpen structure
-typedef struct _MV_CC_SHARPEN_PARAM_T_
-{
-    unsigned int            nWidth;                                 ///< [IN]  \~chinese 图像宽度(最小8)        \~english Image Width
-    unsigned int            nHeight;                                ///< [IN]  \~chinese 图像高度(最小8)        \~english Image Height
-    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 输入数据缓存           \~english Input data buffer
-    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 输入数据大小           \~english Input data length
-    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 像素格式               \~english Pixel format
+    unsigned int            nSharpenAmount;                         ///< [IN]  \~chinese 锐度调节强度,[0,500]  \~english Sharpen amount,[0,500]  //   [nSharpenAmount 作废, 使用 nSharpenPosAmount & nSharpenNegAmount 替代 ]
+    unsigned int            nSharpenRadius;                         ///< [IN]  \~chinese 閿愬害璋冭妭鍗婂緞(鍗婂緞瓒婂ぇ锛岃€楁椂瓒婇暱)锛孾1,21]   \~english Sharpen radius(The larger the radius, the longer it takes),[1,21]
+    unsigned int            nSharpenThreshold;                      ///< [IN]  \~chinese 閿愬害璋冭妭闃堝€硷紝[0,255]  \~english Sharpen threshold,[0,255]
 
-    unsigned char*          pDstBuf;                                ///< [OUT] \~chinese 输出数据缓存           \~english Output data buffer
-    unsigned int            nDstBufSize;                            ///< [IN]  \~chinese 提供的输出缓冲区大小   \~english Provided output buffer size
-    unsigned int            nDstBufLen;                             ///< [OUT] \~chinese 输出数据长度           \~english Output data length
 
-    unsigned int            nSharpenAmount;                         ///< [IN]  \~chinese 锐度调节强度,[0,500]  \~english Sharpen amount,[0,500]
-    unsigned int            nSharpenRadius;                         ///< [IN]  \~chinese 锐度调节半径(半径越大,耗时越长),[1,21]   \~english Sharpen radius(The larger the radius, the longer it takes),[1,21]
-    unsigned int            nSharpenThreshold;                      ///< [IN]  \~chinese 锐度调节阈值,[0,255]  \~english Sharpen threshold,[0,255]
+    unsigned int        nSharpenPosAmount;     // [IN]     锐度调节正向强度,范围:[0, 500]  
+    unsigned int        nSharpenNegAmount;     // [IN]     锐度调节负向强度,范围:[0, 500]    
 
-    unsigned int            nRes[8];                                ///<       \~chinese 预留                   \~english Reserved
+    unsigned int            nRes[6];                                ///<       \~chinese 棰勭暀                   \~english Reserved
 
 }MV_CC_SHARPEN_PARAM;
 
-/// \~chinese 色彩校正结构体            \~english Color correct structure
+/// \~chinese 色彩校正结构体            \~english Color correct structure
 typedef struct _MV_CC_COLOR_CORRECT_PARAM_T_
 {
-    unsigned int            nWidth;                                 ///< [IN]  \~chinese 图像宽度               \~english Image Width
-    unsigned int            nHeight;                                ///< [IN]  \~chinese 图像高度               \~english Image Height
-    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 输入数据缓存           \~english Input data buffer
-    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 输入数据大小           \~english Input data length
-    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 像素格式               \~english Pixel format
+    unsigned int            nWidth;                                 ///< [IN]  \~chinese 鍥惧儚瀹藉害               \~english Image Width
+    unsigned int            nHeight;                                ///< [IN]  \~chinese 鍥惧儚楂樺害               \~english Image Height
+    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨           \~english Input data buffer
+    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 杈撳叆鏁版嵁澶у皬           \~english Input data length
+    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 鍍忕礌鏍煎紡               \~english Pixel format
 
-    unsigned char*          pDstBuf;                                ///< [OUT] \~chinese 输出数据缓存           \~english Output data buffer
-    unsigned int            nDstBufSize;                            ///< [IN]  \~chinese 提供的输出缓冲区大小   \~english Provided output buffer size
-    unsigned int            nDstBufLen;                             ///< [OUT] \~chinese 输出数据长度           \~english Output data length
+    unsigned char*          pDstBuf;                                ///< [OUT] \~chinese 杈撳嚭鏁版嵁缂撳瓨           \~english Output data buffer
+    unsigned int            nDstBufSize;                            ///< [IN]  \~chinese 鎻愪緵鐨勮緭鍑虹紦鍐插尯澶у皬   \~english Provided output buffer size
+    unsigned int            nDstBufLen;                             ///< [OUT] \~chinese 杈撳嚭鏁版嵁闀垮害           \~english Output data length
 
-    unsigned int            nImageBit;                              ///< [IN]  \~chinese 有效图像位数(8,10,12,16)   \~english Image bit(8 or 10 or 12 or 16)
-    MV_CC_GAMMA_PARAM       stGammaParam;                           ///< [IN]  \~chinese Gamma信息              \~english Gamma info
-    MV_CC_CCM_PARAM_EX      stCCMParam;                             ///< [IN]  \~chinese CCM信息                \~english CCM info
-    MV_CC_CLUT_PARAM        stCLUTParam;                            ///< [IN]  \~chinese CLUT信息               \~english CLUT info
+    unsigned int            nImageBit;                              ///< [IN]  \~chinese 鏈夋晥鍥惧儚浣嶆暟(8,10,12,16)   \~english Image bit(8 or 10 or 12 or 16)
+    MV_CC_GAMMA_PARAM       stGammaParam;                           ///< [IN]  \~chinese Gamma淇℃伅              \~english Gamma info
+    MV_CC_CCM_PARAM_EX      stCCMParam;                             ///< [IN]  \~chinese CCM淇℃伅                \~english CCM info
+    MV_CC_CLUT_PARAM        stCLUTParam;                            ///< [IN]  \~chinese CLUT淇℃伅               \~english CLUT info
 
-    unsigned int            nRes[8];                                ///<       \~chinese 预留                   \~english Reserved
+    unsigned int            nRes[8];                                ///<       \~chinese 棰勭暀                   \~english Reserved
 
 }MV_CC_COLOR_CORRECT_PARAM;
 
-/// \~chinese 矩形ROI结构体             \~english Rect ROI structure
+/// \~chinese 矩形ROI结构体             \~english Rect ROI structure
 typedef struct _MV_CC_RECT_I_
 {
-    unsigned int nX;                                                ///< \~chinese 矩形左上角X轴坐标            \~english X Position
-    unsigned int nY;                                                ///< \~chinese 矩形左上角Y轴坐标            \~english Y Position
-    unsigned int nWidth;                                            ///< \~chinese 矩形宽度                     \~english Rect Width
-    unsigned int nHeight;                                           ///< \~chinese 矩形高度                     \~english Rect Height
+    unsigned int nX;                                                ///< \~chinese 矩形左上角X轴坐标            \~english X Position
+    unsigned int nY;                                                ///< \~chinese 矩形左上角Y轴坐标            \~english Y Position
+    unsigned int nWidth;                                            ///< \~chinese 鐭╁舰瀹藉害                     \~english Rect Width
+    unsigned int nHeight;                                           ///< \~chinese 鐭╁舰楂樺害                     \~english Rect Height
 
 }MV_CC_RECT_I;
 
-/// \~chinese 噪声估计结构体            \~english Noise estimate structure
+/// \~chinese 噪声估计结构体            \~english Noise estimate structure
 typedef struct _MV_CC_NOISE_ESTIMATE_PARAM_T_
 {
-    unsigned int            nWidth;                                 ///< [IN]  \~chinese 图像宽度(最小8)        \~english Image Width
-    unsigned int            nHeight;                                ///< [IN]  \~chinese 图像高度(最小8)        \~english Image Height
-    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 像素格式               \~english Pixel format
-    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 输入数据缓存           \~english Input data buffer
-    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 输入数据大小           \~english Input data length
+    unsigned int            nWidth;                                 ///< [IN]  \~chinese 图像宽度(最小8)        \~english Image Width
+    unsigned int            nHeight;                                ///< [IN]  \~chinese 图像高度(最小8)        \~english Image Height
+    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 鍍忕礌鏍煎紡               \~english Pixel format
+    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨           \~english Input data buffer
+    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 杈撳叆鏁版嵁澶у皬           \~english Input data length
 
-    MV_CC_RECT_I*           pstROIRect;                             ///< [IN]  \~chinese 图像ROI                \~english Image ROI
-    unsigned int            nROINum;                                ///< [IN]  \~chinese ROI个数                \~english ROI number
+    MV_CC_RECT_I*           pstROIRect;                             ///< [IN]  \~chinese 鍥惧儚ROI                \~english Image ROI
+    unsigned int            nROINum;                                ///< [IN]  \~chinese ROI涓�暟                \~english ROI number
 
-    ///< \~chinese Bayer域噪声估计参数,Mono8/RGB域无效     \~english Bayer Noise estimate param,Mono8/RGB formats are invalid
-    unsigned int            nNoiseThreshold;                        ///< [IN]  \~chinese 噪声阈值[0,4095]       \~english Noise threshold[0,4095]
-    ///< \~chinese 建议值:8bit,0xE0;10bit,0x380;12bit,0xE00     \~english Suggestive value:8bit,0xE0;10bit,0x380;12bit,0xE00
+    ///< \~chinese Bayer域噪声估计参数,Mono8/RGB域无效     \~english Bayer Noise estimate param,Mono8/RGB formats are invalid
+    unsigned int            nNoiseThreshold;                        ///< [IN]  \~chinese 鍣�0闃堝€糩0,4095]       \~english Noise threshold[0,4095]
+    ///< \~chinese 建议值:8bit,0xE0;10bit,0x380;12bit,0xE00     \~english Suggestive value:8bit,0xE0;10bit,0x380;12bit,0xE00
 
-    unsigned char*          pNoiseProfile;                          ///< [OUT] \~chinese 输出噪声特性           \~english Output Noise Profile
-    unsigned int            nNoiseProfileSize;                      ///< [IN]  \~chinese 提供的输出缓冲区大小   \~english Provided output buffer size
-    unsigned int            nNoiseProfileLen;                       ///< [OUT] \~chinese 输出噪声特性长度       \~english Output Noise Profile length
+    unsigned char*          pNoiseProfile;                          ///< [OUT] \~chinese 输出噪声特性           \~english Output Noise Profile
+    unsigned int            nNoiseProfileSize;                      ///< [IN]  \~chinese 鎻愪緵鐨勮緭鍑虹紦鍐插尯澶у皬   \~english Provided output buffer size
+    unsigned int            nNoiseProfileLen;                       ///< [OUT] \~chinese 输出噪声特性长度       \~english Output Noise Profile length
 
-    unsigned int            nRes[8];                                ///<       \~chinese 预留                   \~english Reserved
+    unsigned int            nRes[8];                                ///<       \~chinese 棰勭暀                   \~english Reserved
 
 }MV_CC_NOISE_ESTIMATE_PARAM;
 
-/// \~chinese 空域降噪结构体            \~english Spatial denoise structure
+/// \~chinese 空域降噪结构体            \~english Spatial denoise structure
 typedef struct _MV_CC_SPATIAL_DENOISE_PARAM_T_
 {
-    unsigned int            nWidth;                                 ///< [IN]  \~chinese 图像宽度(最小8)        \~english Image Width
-    unsigned int            nHeight;                                ///< [IN]  \~chinese 图像高度(最小8)        \~english Image Height
-    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 像素格式               \~english Pixel format
-    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 输入数据缓存           \~english Input data buffer
-    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 输入数据大小           \~english Input data length
+    unsigned int            nWidth;                                 ///< [IN]  \~chinese 图像宽度(最小8)        \~english Image Width
+    unsigned int            nHeight;                                ///< [IN]  \~chinese 图像高度(最小8)        \~english Image Height
+    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 鍍忕礌鏍煎紡               \~english Pixel format
+    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨           \~english Input data buffer
+    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 杈撳叆鏁版嵁澶у皬           \~english Input data length
 
-    unsigned char*          pDstBuf;                                ///< [OUT] \~chinese 输出降噪后的数据       \~english Output data buffer
-    unsigned int            nDstBufSize;                            ///< [IN]  \~chinese 提供的输出缓冲区大小   \~english Provided output buffer size
-    unsigned int            nDstBufLen;                             ///< [OUT] \~chinese 输出降噪后的数据长度   \~english Output data length
+    unsigned char*          pDstBuf;                                ///< [OUT] \~chinese 杈撳嚭闄嶅櫔鍚庣殑鏁版嵁       \~english Output data buffer
+    unsigned int            nDstBufSize;                            ///< [IN]  \~chinese 鎻愪緵鐨勮緭鍑虹紦鍐插尯澶у皬   \~english Provided output buffer size
+    unsigned int            nDstBufLen;                             ///< [OUT] \~chinese 杈撳嚭闄嶅櫔鍚庣殑鏁版嵁闀垮害   \~english Output data length
 
-    unsigned char*          pNoiseProfile;                          ///< [IN]  \~chinese 输入噪声特性           \~english Input Noise Profile
-    unsigned int            nNoiseProfileLen;                       ///< [IN]  \~chinese 输入噪声特性长度       \~english Input Noise Profile length
+    unsigned char*          pNoiseProfile;                          ///< [IN]  \~chinese 输入噪声特性           \~english Input Noise Profile
+    unsigned int            nNoiseProfileLen;                       ///< [IN]  \~chinese 输入噪声特性长度       \~english Input Noise Profile length
 
-    ///< \~chinese Bayer域空域降噪参数,Mono8/RGB域无效     \~english Bayer Spatial denoise param,Mono8/RGB formats are invalid
-    unsigned int            nBayerDenoiseStrength;                  ///< [IN]  \~chinese 降噪强度[0,100]        \~english Denoise Strength[0,100]
-    unsigned int            nBayerSharpenStrength;                  ///< [IN]  \~chinese 锐化强度[0,32]         \~english Sharpen Strength[0,32]
-    unsigned int            nBayerNoiseCorrect;                     ///< [IN]  \~chinese 噪声校正系数[0,1280]   \~english Noise Correct[0,1280]
+    ///< \~chinese Bayer域空域降噪参数,Mono8/RGB域无效     \~english Bayer Spatial denoise param,Mono8/RGB formats are invalid
+    unsigned int            nBayerDenoiseStrength;                  ///< [IN]  \~chinese 闄嶅櫔寮哄害[0,100]        \~english Denoise Strength[0,100]
+    unsigned int            nBayerSharpenStrength;                  ///< [IN]  \~chinese 閿愬寲寮哄害[0,32]         \~english Sharpen Strength[0,32]
+    unsigned int            nBayerNoiseCorrect;                     ///< [IN]  \~chinese 鍣�0鏍℃�绯绘暟[0,1280]   \~english Noise Correct[0,1280]
 
-    ///< \~chinese Mono8/RGB域空域降噪参数,Bayer域无效     \~english Mono8/RGB Spatial denoise param,Bayer formats are invalid
-    unsigned int            nNoiseCorrectLum;                       ///< [IN]  \~chinese 亮度校正系数[1,2000]   \~english Noise Correct Lum[1,2000]
-    unsigned int            nNoiseCorrectChrom;                     ///< [IN]  \~chinese 色调校正系数[1,2000]   \~english Noise Correct Chrom[1,2000]
-    unsigned int            nStrengthLum;                           ///< [IN]  \~chinese 亮度降噪强度[0,100]    \~english Strength Lum[0,100]
-    unsigned int            nStrengthChrom;                         ///< [IN]  \~chinese 色调降噪强度[0,100]    \~english Strength Chrom[0,100]
-    unsigned int            nStrengthSharpen;                       ///< [IN]  \~chinese 锐化强度[1,1000]       \~english Strength Sharpen[1,1000]
+    ///< \~chinese Mono8/RGB域空域降噪参数,Bayer域无效     \~english Mono8/RGB Spatial denoise param,Bayer formats are invalid
+    unsigned int            nNoiseCorrectLum;                       ///< [IN]  \~chinese 浜�害鏍℃�绯绘暟[1,2000]   \~english Noise Correct Lum[1,2000]
+    unsigned int            nNoiseCorrectChrom;                     ///< [IN]  \~chinese 鑹茶皟鏍℃�绯绘暟[1,2000]   \~english Noise Correct Chrom[1,2000]
+    unsigned int            nStrengthLum;                           ///< [IN]  \~chinese 浜�害闄嶅櫔寮哄害[0,100]    \~english Strength Lum[0,100]
+    unsigned int            nStrengthChrom;                         ///< [IN]  \~chinese 鑹茶皟闄嶅櫔寮哄害[0,100]    \~english Strength Chrom[0,100]
+    unsigned int            nStrengthSharpen;                       ///< [IN]  \~chinese 閿愬寲寮哄害[1,1000]       \~english Strength Sharpen[1,1000]
 
-    unsigned int            nRes[8];                                ///<       \~chinese 预留                   \~english Reserved
+    unsigned int            nRes[8];                                ///<       \~chinese 棰勭暀                   \~english Reserved
 
 }MV_CC_SPATIAL_DENOISE_PARAM;
 
-/// \~chinese LSC标定结构体             \~english LSC calib structure
+/// \~chinese LSC标定结构体             \~english LSC calib structure
 typedef struct _MV_CC_LSC_CALIB_PARAM_T_
 {
-    unsigned int            nWidth;                                 ///< [IN]  \~chinese 图像宽度[16,65535]     \~english Image Width
-    unsigned int            nHeight;                                ///< [IN]  \~chinese 图像高度[16-65535]     \~english Image Height
-    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 像素格式               \~english Pixel format
-    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 输入数据缓存           \~english Input data buffer
-    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 输入数据长度           \~english Input data length
+    unsigned int            nWidth;                                 ///< [IN]  \~chinese 鍥惧儚瀹藉害[16,65535]     \~english Image Width
+    unsigned int            nHeight;                                ///< [IN]  \~chinese 鍥惧儚楂樺害[16-65535]     \~english Image Height
+    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 鍍忕礌鏍煎紡               \~english Pixel format
+    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨           \~english Input data buffer
+    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 杈撳叆鏁版嵁闀垮害           \~english Input data length
 
-    unsigned char*          pCalibBuf;                              ///< [OUT] \~chinese 输出标定表缓存         \~english Output calib buffer
-    unsigned int            nCalibBufSize;                          ///< [IN]  \~chinese 提供的标定表缓冲大小(nWidth*nHeight*sizeof(unsigned short))    \~english Provided output buffer size
-    unsigned int            nCalibBufLen;                           ///< [OUT] \~chinese 输出标定表缓存长度     \~english Output calib buffer length
+    unsigned char*          pCalibBuf;                              ///< [OUT] \~chinese 输出标定表缓存         \~english Output calib buffer
+    unsigned int            nCalibBufSize;                          ///< [IN]  \~chinese 鎻愪緵鐨勬爣瀹氳〃缂撳啿澶у皬(nWidth*nHeight*sizeof(unsigned short))    \~english Provided output buffer size
+    unsigned int            nCalibBufLen;                           ///< [OUT] \~chinese 输出标定表缓存长度     \~english Output calib buffer length
 
-    unsigned int            nSecNumW;                               ///< [IN]  \~chinese 宽度分块数             \~english Width Sec num
-    unsigned int            nSecNumH;                               ///< [IN]  \~chinese 高度分块数             \~english Height Sec num
-    unsigned int            nPadCoef;                               ///< [IN]  \~chinese 边缘填充系数[1,5]      \~english Pad Coef[1,5]
-    unsigned int            nCalibMethod;                           ///< [IN]  \~chinese 标定方式(0-中心为基准;1-最亮区域为基准;2-目标亮度为基准) \~english Calib method
-    unsigned int            nTargetGray;                            ///< [IN]  \~chinese 目标亮度(标定方式为2时有效)    \~english Target Gray
-    ///< \~chinese 8位,范围:[0,255]            \~english 8bit,range:[0,255]
-    ///< \~chinese 10位,范围:[0,1023]          \~english 10bit,range:[0,1023]
-    ///< \~chinese 12位,范围:[0,4095]          \~english 12bit,range:[0,4095]
+    unsigned int            nSecNumW;                               ///< [IN]  \~chinese 宽度分块数             \~english Width Sec num
+    unsigned int            nSecNumH;                               ///< [IN]  \~chinese 高度分块数             \~english Height Sec num
+    unsigned int            nPadCoef;                               ///< [IN]  \~chinese 杈圭紭濉�厖绯绘暟[1,5]      \~english Pad Coef[1,5]
+    unsigned int            nCalibMethod;                           ///< [IN]  \~chinese 标定方式(0-中心为基准;1-最亮区域为基准;2-目标亮度为基准) \~english Calib method
+    unsigned int            nTargetGray;                            ///< [IN]  \~chinese 目标亮度(标定方式为2时有效)    \~english Target Gray
+    ///< \~chinese 8位,范围:[0,255]            \~english 8bit,range:[0,255]
+    ///< \~chinese 10位,范围:[0,1023]          \~english 10bit,range:[0,1023]
+    ///< \~chinese 12位,范围:[0,4095]          \~english 12bit,range:[0,4095]
 
-    unsigned int            nRes[8];                                ///<       \~chinese 预留                   \~english Reserved
+    unsigned int            nRes[8];                                ///<       \~chinese 棰勭暀                   \~english Reserved
 
 }MV_CC_LSC_CALIB_PARAM;
 
-/// \~chinese LSC校正结构体             \~english LSC correct structure
+/// \~chinese LSC校正结构体             \~english LSC correct structure
 typedef struct _MV_CC_LSC_CORRECT_PARAM_T_
 {
-    unsigned int            nWidth;                                 ///< [IN]  \~chinese 图像宽度[16,65535]     \~english Image Width
-    unsigned int            nHeight;                                ///< [IN]  \~chinese 图像高度[16,65535]     \~english Image Height
-    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 像素格式               \~english Pixel format
-    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 输入数据缓存           \~english Input data buffer
-    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 输入数据长度           \~english Input data length
+    unsigned int            nWidth;                                 ///< [IN]  \~chinese 鍥惧儚瀹藉害[16,65535]     \~english Image Width
+    unsigned int            nHeight;                                ///< [IN]  \~chinese 鍥惧儚楂樺害[16,65535]     \~english Image Height
+    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 鍍忕礌鏍煎紡               \~english Pixel format
+    unsigned char*          pSrcBuf;                                ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨           \~english Input data buffer
+    unsigned int            nSrcBufLen;                             ///< [IN]  \~chinese 杈撳叆鏁版嵁闀垮害           \~english Input data length
 
-    unsigned char*          pDstBuf;                                ///< [OUT] \~chinese 输出数据缓存           \~english Output data buffer
-    unsigned int            nDstBufSize;                            ///< [IN]  \~chinese 提供的输出缓冲区大小   \~english Provided output buffer size
-    unsigned int            nDstBufLen;                             ///< [OUT] \~chinese 输出数据长度           \~english Output data length
+    unsigned char*          pDstBuf;                                ///< [OUT] \~chinese 杈撳嚭鏁版嵁缂撳瓨           \~english Output data buffer
+    unsigned int            nDstBufSize;                            ///< [IN]  \~chinese 鎻愪緵鐨勮緭鍑虹紦鍐插尯澶у皬   \~english Provided output buffer size
+    unsigned int            nDstBufLen;                             ///< [OUT] \~chinese 杈撳嚭鏁版嵁闀垮害           \~english Output data length
 
-    unsigned char*          pCalibBuf;                              ///< [IN]  \~chinese 输入标定表缓存         \~english Input calib buffer
-    unsigned int            nCalibBufLen;                           ///< [IN]  \~chinese 输入标定表缓存长度     \~english Input calib buffer length
+    unsigned char*          pCalibBuf;                              ///< [IN]  \~chinese 输入标定表缓存         \~english Input calib buffer
+    unsigned int            nCalibBufLen;                           ///< [IN]  \~chinese 输入标定表缓存长度     \~english Input calib buffer length
 
-    unsigned int            nRes[8];                                ///<       \~chinese 预留                   \~english Reserved
+    unsigned int            nRes[8];                                ///<       \~chinese 棰勭暀                   \~english Reserved
 
 }MV_CC_LSC_CORRECT_PARAM;
 
-/// \~chinese 某个节点对应的子节点个数最大值    \~english The maximum number of child nodes corresponding to a node
+/// \~chinese 某个节点对应的子节点个数最大值    \~english The maximum number of child nodes corresponding to a node
 #define MV_MAX_XML_NODE_NUM_C       128
 
-/// \~chinese 节点名称字符串最大长度            \~english The maximum length of node name string
+/// \~chinese 节点名称字符串最大长度            \~english The maximum length of node name string
 #define MV_MAX_XML_NODE_STRLEN_C    64
 
-/// \~chinese 节点String值最大长度              \~english The maximum length of Node String
+/// \~chinese 节点String值最大长度              \~english The maximum length of Node String
 #define MV_MAX_XML_STRVALUE_STRLEN_C 64
 
-/// \~chinese 节点描述字段最大长度              \~english The maximum length of the node description field
+/// \~chinese 节点描述字段最大长度              \~english The maximum length of the node description field
 #define MV_MAX_XML_DISC_STRLEN_C    512
 
-/// \~chinese 最多的单元数                      \~english The maximum number of units
+/// \~chinese 最多的单元数                      \~english The maximum number of units
 #define MV_MAX_XML_ENTRY_NUM        10
 
-/// \~chinese 父节点个数上限                    \~english The maximum number of parent nodes
+/// \~chinese 父节点个数上限                    \~english The maximum number of parent nodes
 #define MV_MAX_XML_PARENTS_NUM      8
 
-/// \~chinese 每个已经实现单元的名称长度        \~english The length of the name of each unit that has been implemented
+/// \~chinese 每个已经实现单元的名称长度        \~english The length of the name of each unit that has been implemented
 #define MV_MAX_XML_SYMBOLIC_STRLEN_C 64
 
 enum MV_XML_Visibility
@@ -351,55 +336,55 @@ enum MV_XML_Visibility
     V_Undefined     = 99    ///< Object is not yet initialized
 };
 
-/// \~chinese 单个节点基本属性 | en:Single Node Basic Attributes
+/// \~chinese 单个节点基本属性 | en:Single Node Basic Attributes
 typedef struct _MV_XML_NODE_FEATURE_
 {
-    enum MV_XML_InterfaceType   enType;                             ///< \~chinese 节点类型         \~english Node Type
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Is visibility
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 节点描述,目前暂不支持   \~english Node Description, NOT SUPPORT NOW
-    char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];   ///< \~chinese 显示名称         \~english Display Name
-    char                strName[MV_MAX_XML_NODE_STRLEN_C];          ///< \~chinese 节点名           \~english Node Name
-    char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];       ///< \~chinese 提示             \~english Notice
+    enum MV_XML_InterfaceType   enType;                             ///< \~chinese 鑺傜偣绫诲瀷         \~english Node Type
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Is visibility
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鑺傜偣鎻忚堪,鐩�墠鏆備笉鏀�寔   \~english Node Description, NOT SUPPORT NOW
+    char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];   ///< \~chinese 鏄剧ず鍚嶇О         \~english Display Name
+    char                strName[MV_MAX_XML_NODE_STRLEN_C];          ///< \~chinese 节点名           \~english Node Name
+    char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];       ///< \~chinese 鎻愮ず             \~english Notice
 
     unsigned int        nReserved[4];
 }MV_XML_NODE_FEATURE;
 
-/// \~chinese 节点列表 | en:Node List
+/// \~chinese 鑺傜偣鍒楄〃 | en:Node List
 typedef struct _MV_XML_NODES_LIST_
 {
-    unsigned int        nNodeNum;       ///< \~chinese 节点个数             \~english Node Number
+    unsigned int        nNodeNum;       ///< \~chinese 鑺傜偣涓�暟             \~english Node Number
     MV_XML_NODE_FEATURE stNodes[MV_MAX_XML_NODE_NUM_C];
 }MV_XML_NODES_LIST;
 
 typedef struct _MV_XML_FEATURE_Value_
 {
-    enum MV_XML_InterfaceType   enType;                             ///< \~chinese 节点类型         \~english Node Type
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 节点描述,目前暂不支持   \~english Node Description, NOT SUPPORT NOW
-    char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];   ///< \~chinese 显示名称         \~english Display Name
-    char                strName[MV_MAX_XML_NODE_STRLEN_C];          ///< \~chinese 节点名           \~english Node Name
-    char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];       ///< \~chinese 提示             \~english Notice
+    enum MV_XML_InterfaceType   enType;                             ///< \~chinese 鑺傜偣绫诲瀷         \~english Node Type
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鑺傜偣鎻忚堪,鐩�墠鏆備笉鏀�寔   \~english Node Description, NOT SUPPORT NOW
+    char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];   ///< \~chinese 鏄剧ず鍚嶇О         \~english Display Name
+    char                strName[MV_MAX_XML_NODE_STRLEN_C];          ///< \~chinese 节点名           \~english Node Name
+    char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];       ///< \~chinese 鎻愮ず             \~english Notice
     unsigned int        nReserved[4];
 }MV_XML_FEATURE_Value;
 
 typedef struct _MV_XML_FEATURE_Base_
 {
-    enum MV_XML_AccessMode enAccessMode;                           ///< \~chinese 访问模式         \~english Access Mode
+    enum MV_XML_AccessMode enAccessMode;                           ///< \~chinese 璁块棶妯″紡         \~english Access Mode
 }MV_XML_FEATURE_Base;
 
 typedef struct _MV_XML_FEATURE_Integer_
 {
     char                strName[MV_MAX_XML_NODE_STRLEN_C];
     char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 目前暂不支持     \~english NOT SUPPORT NOW
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鐩�墠鏆備笉鏀�寔     \~english NOT SUPPORT NOW
     char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];
 
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Visible
-    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 访问模式         \~english Access Mode
-    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
-    int64_t             nValue;                                     ///< \~chinese 当前值           \~english Current Value
-    int64_t             nMinValue;                                  ///< \~chinese 最小值           \~english Min Value
-    int64_t             nMaxValue;                                  ///< \~chinese 最大值           \~english Max Value
-    int64_t             nIncrement;                                 ///< \~chinese 增量             \~english Increment
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Visible
+    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 璁块棶妯″紡         \~english Access Mode
+    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
+    int64_t             nValue;                                     ///< \~chinese 当前值           \~english Current Value
+    int64_t             nMinValue;                                  ///< \~chinese 最小值           \~english Min Value
+    int64_t             nMaxValue;                                  ///< \~chinese 最大值           \~english Max Value
+    int64_t             nIncrement;                                 ///< \~chinese 澧為噺             \~english Increment
 
     unsigned int        nReserved[4];
 
@@ -409,13 +394,13 @@ typedef struct _MV_XML_FEATURE_Boolean_
 {
     char                strName[MV_MAX_XML_NODE_STRLEN_C];
     char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 目前暂不支持     \~english NOT SUPPORT NOW
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鐩�墠鏆備笉鏀�寔     \~english NOT SUPPORT NOW
     char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];
 
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Visible
-    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 访问模式         \~english Access Mode
-    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
-    bool                bValue;                                     ///< \~chinese 当前值           \~english Current Value
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Visible
+    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 璁块棶妯″紡         \~english Access Mode
+    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
+    bool                bValue;                                     ///< \~chinese 当前值           \~english Current Value
 
     unsigned int        nReserved[4];
 }MV_XML_FEATURE_Boolean;
@@ -424,12 +409,12 @@ typedef struct _MV_XML_FEATURE_Command_
 {
     char                strName[MV_MAX_XML_NODE_STRLEN_C];
     char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 目前暂不支持     \~english NOT SUPPORT NOW
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鐩�墠鏆備笉鏀�寔     \~english NOT SUPPORT NOW
     char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];
 
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Visible
-    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 访问模式         \~english Access Mode
-    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Visible
+    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 璁块棶妯″紡         \~english Access Mode
+    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
 
     unsigned int        nReserved[4];
 }MV_XML_FEATURE_Command;
@@ -438,16 +423,16 @@ typedef struct _MV_XML_FEATURE_Float_
 {
     char                strName[MV_MAX_XML_NODE_STRLEN_C];
     char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 目前暂不支持     \~english NOT SUPPORT NOW
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鐩�墠鏆備笉鏀�寔     \~english NOT SUPPORT NOW
     char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];
 
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Visible
-    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 访问模式         \~english Access Mode
-    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
-    double              dfValue;                                    ///< \~chinese 当前值           \~english Current Value
-    double              dfMinValue;                                 ///< \~chinese 最小值           \~english Min Value
-    double              dfMaxValue;                                 ///< \~chinese 最大值           \~english Max Value
-    double              dfIncrement;                                ///< \~chinese 增量             \~english Increment
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Visible
+    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 璁块棶妯″紡         \~english Access Mode
+    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
+    double              dfValue;                                    ///< \~chinese 当前值           \~english Current Value
+    double              dfMinValue;                                 ///< \~chinese 最小值           \~english Min Value
+    double              dfMaxValue;                                 ///< \~chinese 最大值           \~english Max Value
+    double              dfIncrement;                                ///< \~chinese 澧為噺             \~english Increment
 
     unsigned int        nReserved[4];
 }MV_XML_FEATURE_Float;
@@ -456,13 +441,13 @@ typedef struct _MV_XML_FEATURE_String_
 {
     char                strName[MV_MAX_XML_NODE_STRLEN_C];
     char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 目前暂不支持     \~english NOT SUPPORT NOW
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鐩�墠鏆備笉鏀�寔     \~english NOT SUPPORT NOW
     char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];
 
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Visible
-    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 访问模式         \~english Access Mode
-    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
-    char                strValue[MV_MAX_XML_STRVALUE_STRLEN_C];     ///< \~chinese 当前值           \~english Current Value
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Visible
+    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 璁块棶妯″紡         \~english Access Mode
+    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
+    char                strValue[MV_MAX_XML_STRVALUE_STRLEN_C];     ///< \~chinese 当前值           \~english Current Value
 
     unsigned int        nReserved[4];
 }MV_XML_FEATURE_String;
@@ -471,25 +456,25 @@ typedef struct _MV_XML_FEATURE_Register_
 {
     char                strName[MV_MAX_XML_NODE_STRLEN_C];
     char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 目前暂不支持     \~english NOT SUPPORT NOW
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鐩�墠鏆備笉鏀�寔     \~english NOT SUPPORT NOW
     char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];
 
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Visible
-    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 访问模式         \~english Access Mode
-    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
-    int64_t             nAddrValue;                                 ///< \~chinese 当前值           \~english Current Value
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Visible
+    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 璁块棶妯″紡         \~english Access Mode
+    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
+    int64_t             nAddrValue;                                 ///< \~chinese 当前值           \~english Current Value
 
     unsigned int        nReserved[4];
 }MV_XML_FEATURE_Register;
 
 typedef struct _MV_XML_FEATURE_Category_
 {
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 节点描述 目前暂不支持    \~english Node Description, NOT SUPPORT NOW
-    char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];   ///< \~chinese 显示名称         \~english Display Name
-    char                strName[MV_MAX_XML_NODE_STRLEN_C];          ///< \~chinese 节点名           \~english Node Name
-    char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];       ///< \~chinese 提示             \~english Notice
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鑺傜偣鎻忚堪 鐩�墠鏆備笉鏀�寔    \~english Node Description, NOT SUPPORT NOW
+    char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];   ///< \~chinese 鏄剧ず鍚嶇О         \~english Display Name
+    char                strName[MV_MAX_XML_NODE_STRLEN_C];          ///< \~chinese 节点名           \~english Node Name
+    char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];       ///< \~chinese 鎻愮ず             \~english Notice
 
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Visible
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Visible
 
     unsigned int        nReserved[4];
 }MV_XML_FEATURE_Category;
@@ -498,48 +483,48 @@ typedef struct _MV_XML_FEATURE_EnumEntry_
 {
     char                strName[MV_MAX_XML_NODE_STRLEN_C];
     char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 目前暂不支持     \~english NOT SUPPORT NOW
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鐩�墠鏆備笉鏀�寔     \~english NOT SUPPORT NOW
     char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];
     int                 bIsImplemented;
     int                 nParentsNum;
     MV_XML_NODE_FEATURE stParentsList[MV_MAX_XML_PARENTS_NUM];
 
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Visible
-    int64_t             nValue;                                     ///< \~chinese 当前值           \~english Current Value
-    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 访问模式         \~english Access Mode
-    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Visible
+    int64_t             nValue;                                     ///< \~chinese 当前值           \~english Current Value
+    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 璁块棶妯″紡         \~english Access Mode
+    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
     int                 nReserved[8];
 
 }MV_XML_FEATURE_EnumEntry;
 
 typedef struct _MV_XML_FEATURE_Enumeration_
 {
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Visible
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 节点描述 目前暂不支持    \~english Node Description, NOT SUPPORT NOW
-    char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];   ///< \~chinese 显示名称         \~english Display Name
-    char                strName[MV_MAX_XML_NODE_STRLEN_C];          ///< \~chinese 节点名           \~english Node Name
-    char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];       ///< \~chinese 提示             \~english Notice
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Visible
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鑺傜偣鎻忚堪 鐩�墠鏆備笉鏀�寔    \~english Node Description, NOT SUPPORT NOW
+    char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];   ///< \~chinese 鏄剧ず鍚嶇О         \~english Display Name
+    char                strName[MV_MAX_XML_NODE_STRLEN_C];          ///< \~chinese 节点名           \~english Node Name
+    char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];       ///< \~chinese 鎻愮ず             \~english Notice
 
-    int                 nSymbolicNum;                               ///< \~chinese ymbolic数        \~english Symbolic Number
-    char                strCurrentSymbolic[MV_MAX_XML_SYMBOLIC_STRLEN_C];///< \~chinese 当前Symbolic索引    \~english Current Symbolic Index
+    int                 nSymbolicNum;                               ///< \~chinese ymbolic数        \~english Symbolic Number
+    char                strCurrentSymbolic[MV_MAX_XML_SYMBOLIC_STRLEN_C];///< \~chinese 褰撳墠Symbolic绱㈠紩    \~english Current Symbolic Index
     char                strSymbolic[MV_MAX_XML_SYMBOLIC_NUM][MV_MAX_XML_SYMBOLIC_STRLEN_C];
-    enum MV_XML_AccessMode   enAccessMode;                          ////< \~chinese 访问模式        \~english Access Mode
-    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
-    int64_t             nValue;                                     ///< \~chinese 当前值           \~english Current Value
+    enum MV_XML_AccessMode   enAccessMode;                          ////< \~chinese 璁块棶妯″紡        \~english Access Mode
+    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
+    int64_t             nValue;                                     ///< \~chinese 当前值           \~english Current Value
 
     unsigned int        nReserved[4];
 }MV_XML_FEATURE_Enumeration;
 
 typedef struct _MV_XML_FEATURE_Port_
 {
-    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 是否可见         \~english Visible
-    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 节点描述,目前暂不支持    \~english Node Description, NOT SUPPORT NOW
-    char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];   ///< \~chinese 显示名称         \~english Display Name
-    char                strName[MV_MAX_XML_NODE_STRLEN_C];          ///< \~chinese 节点名           \~english Node Name
-    char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];       ///< \~chinese 提示             \~english Notice
+    enum MV_XML_Visibility  enVisivility;                           ///< \~chinese 鏄�惁鍙��         \~english Visible
+    char                strDescription[MV_MAX_XML_DISC_STRLEN_C];   ///< \~chinese 鑺傜偣鎻忚堪,鐩�墠鏆備笉鏀�寔    \~english Node Description, NOT SUPPORT NOW
+    char                strDisplayName[MV_MAX_XML_NODE_STRLEN_C];   ///< \~chinese 鏄剧ず鍚嶇О         \~english Display Name
+    char                strName[MV_MAX_XML_NODE_STRLEN_C];          ///< \~chinese 节点名           \~english Node Name
+    char                strToolTip[MV_MAX_XML_DISC_STRLEN_C];       ///< \~chinese 鎻愮ず             \~english Notice
 
-    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 访问模式         \~english Access Mode
-    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
+    enum MV_XML_AccessMode  enAccessMode;                           ///< \~chinese 璁块棶妯″紡         \~english Access Mode
+    int                 bIsLocked;                                  ///< \~chinese 是否锁定。0-否;1-是,目前暂不支持    \~english Locked. 0-NO; 1-YES, NOT SUPPORT NOW
 
     unsigned int        nReserved[4];
 }MV_XML_FEATURE_Port;
@@ -557,4 +542,114 @@ typedef struct _MV_XML_CAMERA_FEATURE_
 
 }MV_XML_CAMERA_FEATURE;
 
+
+
+/// \~chinese 鍥剧墖淇濆瓨鍙傛暟              \~english Save Image Parameters
+typedef struct _MV_SAVE_IMAGE_PARAM_T_EX_
+{
+    unsigned char*          pData;                                  ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨           \~english Input Data Buffer
+    unsigned int            nDataLen;                               ///< [IN]  \~chinese 杈撳叆鏁版嵁闀垮害           \~english Input Data length
+    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese 输入数据的像素格式     \~english Input Data Pixel Format
+    unsigned short          nWidth;                                 ///< [IN]  \~chinese 图像宽                 \~english Image Width
+    unsigned short          nHeight;                                ///< [IN]  \~chinese 图像高                 \~english Image Height
+
+    unsigned char*          pImageBuffer;                           ///< [OUT] \~chinese 杈撳嚭鍥剧墖缂撳瓨           \~english Output Image Buffer
+    unsigned int            nImageLen;                              ///< [OUT] \~chinese 杈撳嚭鍥剧墖闀垮害           \~english Output Image length
+    unsigned int            nBufferSize;                            ///< [IN]  \~chinese 鎻愪緵鐨勮緭鍑虹紦鍐插尯澶у皬   \~english Output buffer size provided
+    enum MV_SAVE_IAMGE_TYPE enImageType;                            ///< [IN]  \~chinese 杈撳嚭鍥剧墖鏍煎紡           \~english Output Image Format
+    unsigned int            nJpgQuality;                            ///< [IN]  \~chinese JPG编码质量(50-99],其它格式无效   \~english Encoding quality(50-99],Other formats are invalid
+
+    unsigned int            iMethodValue;                           ///< [IN]  \~chinese 插值方法 0-快速 1-均衡(其它值默认为均衡) 2-最优 3-最优+  \~english Bayer interpolation method  0-Fast 1-Equilibrium 2-Optimal 3-Optimal+
+
+    unsigned int            nReserved[3];                           ///<       \~chinese 棰勭暀                   \~english Reserved
+
+}MV_SAVE_IMAGE_PARAM_EX;
+
+
+
+/// \~chinese 鍥剧墖淇濆瓨鍙傛暟              \~english Save Image Parameters
+typedef struct _MV_SAVE_IMG_TO_FILE_PARAM_
+{
+    enum MvGvspPixelType    enPixelType;                            ///< [IN]  \~chinese输入数据的像素格式      \~english The pixel format of the input data
+    unsigned char*          pData;                                  ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨           \~english Input Data Buffer
+    unsigned int            nDataLen;                               ///< [IN]  \~chinese 杈撳叆鏁版嵁闀垮害           \~english Input Data length
+    unsigned short          nWidth;                                 ///< [IN]  \~chinese 图像宽                 \~english Image Width
+    unsigned short          nHeight;                                ///< [IN]  \~chinese 图像高                 \~english Image Height
+    enum MV_SAVE_IAMGE_TYPE enImageType;                            ///< [IN]  \~chinese 杈撳叆鍥剧墖鏍煎紡           \~english Input Image Format
+    unsigned int            nQuality;                               ///< [IN]  \~chinese JPG编码质量(50-99],其它格式无效 \~english JPG Encoding quality(50-99],Other formats are invalid
+    char                    pImagePath[256];                        ///< [IN]  \~chinese 杈撳叆鏂囦欢璺�緞           \~english Input file path
+
+    int                     iMethodValue;                           ///< [IN]  \~chinese 插值方法 0-快速 1-均衡(其它值默认为均衡) 2-最优 3-最优+ \~english Bayer interpolation method  0-Fast 1-Equilibrium 2-Optimal 3-Optimal+
+
+    unsigned int            nReserved[8];                           ///<       \~chinese 棰勭暀                   \~english Reserved
+
+}MV_SAVE_IMG_TO_FILE_PARAM;
+
+
+// \~chinese 像素转换结构体            \~english Pixel convert structure
+typedef struct _MV_CC_PIXEL_CONVERT_PARAM_
+{
+    unsigned short          nWidth;                                 ///< [IN]  \~chinese 图像宽                 \~english Width
+    unsigned short          nHeight;                                ///< [IN]  \~chinese 图像高                 \~english Height
+
+    enum MvGvspPixelType    enSrcPixelType;                         ///< [IN]  \~chinese 源像素格式             \~english Source pixel format
+    unsigned char*          pSrcData;                               ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨           \~english Input data buffer
+    unsigned int            nSrcDataLen;                            ///< [IN]  \~chinese 杈撳叆鏁版嵁闀垮害           \~english Input data length
+
+    enum MvGvspPixelType    enDstPixelType;                         ///< [IN]  \~chinese 鐩�爣鍍忕礌鏍煎紡           \~english Destination pixel format
+    unsigned char*          pDstBuffer;                             ///< [OUT] \~chinese 杈撳嚭鏁版嵁缂撳瓨           \~english Output data buffer
+    unsigned int            nDstLen;                                ///< [OUT] \~chinese 杈撳嚭鏁版嵁闀垮害           \~english Output data length
+    unsigned int            nDstBufferSize;                         ///< [IN]  \~chinese 鎻愪緵鐨勮緭鍑虹紦鍐插尯澶у皬   \~english Provided output buffer size
+
+    unsigned int            nRes[4];                                ///<       \~chinese 棰勭暀                   \~english Reserved
+
+}MV_CC_PIXEL_CONVERT_PARAM;
+
+/// \~chinese 保存的3D数据格式          \~english The saved format for 3D data
+enum MV_SAVE_POINT_CLOUD_FILE_TYPE
+{
+    MV_PointCloudFile_Undefined         = 0,                        ///< \~chinese 鏈�畾涔夌殑鐐逛簯鏍煎紡             \~english Undefined point cloud format
+    MV_PointCloudFile_PLY               = 1,                        ///< \~chinese PLY鐐逛簯鏍煎紡                  \~english The point cloud format named PLY
+    MV_PointCloudFile_CSV               = 2,                        ///< \~chinese CSV鐐逛簯鏍煎紡                  \~english The point cloud format named CSV
+    MV_PointCloudFile_OBJ               = 3,                        ///< \~chinese OBJ鐐逛簯鏍煎紡                  \~english The point cloud format named OBJ
+
+};
+
+/// \~chinese 保存3D数据到缓存          \~english Save 3D data to buffer
+typedef struct _MV_SAVE_POINT_CLOUD_PARAM_
+{
+    unsigned int                    nLinePntNum;                    ///< [IN]  \~chinese 琛岀偣鏁帮紝鍗冲浘鍍忓�       \~english The number of points in each row,which is the width of the image
+    unsigned int                    nLineNum;                       ///< [IN]  \~chinese 行数,即图像高         \~english The number of rows,which is the height of the image
+
+    enum MvGvspPixelType            enSrcPixelType;                 ///< [IN]  \~chinese 输入数据的像素格式     \~english The pixel format of the input data
+    unsigned char*                  pSrcData;                       ///< [IN]  \~chinese 杈撳叆鏁版嵁缂撳瓨           \~english Input data buffer
+    unsigned int                    nSrcDataLen;                    ///< [IN]  \~chinese 杈撳叆鏁版嵁闀垮害           \~english Input data length
+
+    unsigned char*                  pDstBuf;                        ///< [OUT] \~chinese 杈撳嚭鍍忕礌鏁版嵁缂撳瓨       \~english Output pixel data buffer
+    unsigned int                    nDstBufSize;                    ///< [IN]  \~chinese 鎻愪緵鐨勮緭鍑虹紦鍐插尯澶у皬(nLinePntNum * nLineNum * (16*3 + 4) + 2048)   \~english Output buffer size provided(nLinePntNum * nLineNum * (16*3 + 4) + 2048) 
+    unsigned int                    nDstBufLen;                     ///< [OUT] \~chinese 杈撳嚭鍍忕礌鏁版嵁缂撳瓨闀垮害   \~english Output pixel data buffer size
+    enum MV_SAVE_POINT_CLOUD_FILE_TYPE   enPointCloudFileType;      ///< [IN]  \~chinese 提供输出的点云文件类型 \~english Output point data file type provided
+
+    unsigned int        nReserved[8];                               ///<       \~chinese 淇濈暀瀛楁�               \~english Reserved
+
+}MV_SAVE_POINT_CLOUD_PARAM;
+
+/// \~chinese 显示帧信息                \~english Display frame information
+typedef struct _MV_DISPLAY_FRAME_INFO_
+{
+	void*                   hWnd;                                   ///< [IN] \~chinese 绐楀彛鍙ユ焺                \~english HWND
+	unsigned char*          pData;                                  ///< [IN] \~chinese 显示的数据              \~english Data Buffer
+	unsigned int            nDataLen;                               ///< [IN] \~chinese 鏁版嵁闀垮害                \~english Data Size
+	unsigned short          nWidth;                                 ///< [IN] \~chinese 图像宽                  \~english Width
+	unsigned short          nHeight;                                ///< [IN] \~chinese 图像高                  \~english Height
+	enum MvGvspPixelType    enPixelType;                            ///< [IN] \~chinese 鍍忕礌鏍煎紡                \~english Pixel format
+
+	unsigned int            enRenderMode;                             ///  [IN] \~chinese 鍥惧儚娓叉煋鏂瑰紡  Windows:0-GDI(榛樿�), 1-D3D, 2-OPENGL Linux: 0-OPENGL(榛樿�)   \~english Windows:0-GDI(default), 1-D3D, 2-OPENGL Linux: 0-OPENGL(default)
+	unsigned int            nRes[3];                                ///<      \~chinese 淇濈暀                    \~english Reserved
+
+}MV_DISPLAY_FRAME_INFO;
+
+
+
+
 #endif /* _MV_OBSOLETE_CAM_PARAMS_H_ */

+ 152 - 138
Lib/mvs/Includes/PixelType.h

@@ -1,4 +1,4 @@
-
+
 #ifndef _MV_PIXEL_TYPE_H_
 #define _MV_PIXEL_TYPE_H_
 
@@ -24,158 +24,172 @@
 #define MV_GVSP_PIX_ID_MASK                             0x0000FFFF
 #define MV_GVSP_PIX_COUNT                               0x46 // next Pixel ID available
 
+/// \addtogroup 鍍忕礌鏍煎紡瀹氫箟
+///@{
+
+///< \~chinese 鍥剧墖鏍煎紡瀹氫箟
 enum MvGvspPixelType
 {
     // Undefined pixel type
-    PixelType_Gvsp_Undefined                =   0xFFFFFFFF, 
+#ifdef WIN32
+	PixelType_Gvsp_Undefined                =   0xFFFFFFFF,     ///< 鏈�畾涔夌殑鍍忕礌绫诲瀷
 
+#else
+	PixelType_Gvsp_Undefined                =   -1,             ///< 鏈�畾涔夌殑鍍忕礌绫诲瀷
+
+#endif
     // Mono buffer format defines
-    PixelType_Gvsp_Mono1p                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(1) | 0x0037),
-    PixelType_Gvsp_Mono2p                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(2) | 0x0038),
-    PixelType_Gvsp_Mono4p                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(4) | 0x0039),
-    PixelType_Gvsp_Mono8                    =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0001),
-    PixelType_Gvsp_Mono8_Signed             =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8)  | 0x0002),
-    PixelType_Gvsp_Mono10                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0003),
-    PixelType_Gvsp_Mono10_Packed            =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0004),
-    PixelType_Gvsp_Mono12                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0005),
-    PixelType_Gvsp_Mono12_Packed            =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0006),
-    PixelType_Gvsp_Mono14                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0025),
-    PixelType_Gvsp_Mono16                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0007),
+    PixelType_Gvsp_Mono1p                   = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(1) | 0x0037),                  ///< Mono1p
+    PixelType_Gvsp_Mono2p                   = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(2) | 0x0038),                  ///< Mono2p
+    PixelType_Gvsp_Mono4p                   = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(4) | 0x0039),                  ///< Mono4p
+    PixelType_Gvsp_Mono8                    = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0001),                  ///< Mono8
+    PixelType_Gvsp_Mono8_Signed             = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0002),                  ///< Mono8_Signed
+    PixelType_Gvsp_Mono10                   = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0003),                 ///< Mono10
+    PixelType_Gvsp_Mono10_Packed            = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0004),                 ///< Mono10_Packed
+    PixelType_Gvsp_Mono12                   = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0005),                 ///< Mono12
+    PixelType_Gvsp_Mono12_Packed            = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0006),                 ///< Mono12_Packed
+    PixelType_Gvsp_Mono14                   = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0025),                 ///< Mono14
+    PixelType_Gvsp_Mono16                   = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0007),                 ///< Mono16
 
     // Bayer buffer format defines 
-    PixelType_Gvsp_BayerGR8                 =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0008),
-    PixelType_Gvsp_BayerRG8                 =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0009),
-    PixelType_Gvsp_BayerGB8                 =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x000A),
-    PixelType_Gvsp_BayerBG8                 =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x000B),
-    PixelType_Gvsp_BayerRBGG8               =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0046),
-    PixelType_Gvsp_BayerGR10                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000C),
-    PixelType_Gvsp_BayerRG10                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000D),
-    PixelType_Gvsp_BayerGB10                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000E),
-    PixelType_Gvsp_BayerBG10                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000F),
-    PixelType_Gvsp_BayerGR12                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0010),
-    PixelType_Gvsp_BayerRG12                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0011),
-    PixelType_Gvsp_BayerGB12                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0012),
-    PixelType_Gvsp_BayerBG12                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0013),
-    PixelType_Gvsp_BayerGR10_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0026),
-    PixelType_Gvsp_BayerRG10_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0027),
-    PixelType_Gvsp_BayerGB10_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0028),
-    PixelType_Gvsp_BayerBG10_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0029),
-    PixelType_Gvsp_BayerGR12_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002A),
-    PixelType_Gvsp_BayerRG12_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002B),
-    PixelType_Gvsp_BayerGB12_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002C),
-    PixelType_Gvsp_BayerBG12_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002D),
-    PixelType_Gvsp_BayerGR16                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x002E),
-    PixelType_Gvsp_BayerRG16                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x002F),
-    PixelType_Gvsp_BayerGB16                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0030),
-    PixelType_Gvsp_BayerBG16                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0031),
+    PixelType_Gvsp_BayerGR8                 = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0008),                  ///< BayerGR8
+    PixelType_Gvsp_BayerRG8                 = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0009),                  ///< BayerRG8
+    PixelType_Gvsp_BayerGB8                 = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x000A),                  ///< BayerGB8
+    PixelType_Gvsp_BayerBG8                 = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x000B),                  ///< BayerBG8
+    PixelType_Gvsp_BayerRBGG8               = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0046),                  ///< BayerRBGG8
+    PixelType_Gvsp_BayerGR10                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000C),                 ///< BayerGR10
+    PixelType_Gvsp_BayerRG10                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000D),                 ///< BayerRG10
+    PixelType_Gvsp_BayerGB10                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000E),                 ///< BayerGB10
+    PixelType_Gvsp_BayerBG10                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000F),                 ///< BayerBG10
+    PixelType_Gvsp_BayerGR12                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0010),                 ///< BayerGR12
+    PixelType_Gvsp_BayerRG12                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0011),                 ///< BayerRG12
+    PixelType_Gvsp_BayerGB12                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0012),                 ///< BayerGB12
+    PixelType_Gvsp_BayerBG12                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0013),                 ///< BayerBG12
+    PixelType_Gvsp_BayerGR10_Packed         = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0026),                 ///< BayerGR10_Packed
+    PixelType_Gvsp_BayerRG10_Packed         = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0027),                 ///< BayerRG10_Packed
+    PixelType_Gvsp_BayerGB10_Packed         = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0028),                 ///< BayerGB10_Packed
+    PixelType_Gvsp_BayerBG10_Packed         = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0029),                 ///< BayerBG10_Packed
+    PixelType_Gvsp_BayerGR12_Packed         = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002A),                 ///< BayerGR12_Packed
+    PixelType_Gvsp_BayerRG12_Packed         = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002B),                 ///< BayerRG12_Packed
+    PixelType_Gvsp_BayerGB12_Packed         = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002C),                 ///< BayerGB12_Packed
+    PixelType_Gvsp_BayerBG12_Packed         = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002D),                 ///< BayerBG12_Packed
+    PixelType_Gvsp_BayerGR16                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x002E),                 ///< BayerGR16
+    PixelType_Gvsp_BayerRG16                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x002F),                 ///< BayerRG16
+    PixelType_Gvsp_BayerGB16                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0030),                 ///< BayerGB16
+    PixelType_Gvsp_BayerBG16                = (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0031),                 ///< BayerBG16
 
     // RGB Packed buffer format defines 
-    PixelType_Gvsp_RGB8_Packed              =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0014),
-    PixelType_Gvsp_BGR8_Packed              =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0015),
-    PixelType_Gvsp_RGBA8_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x0016),
-    PixelType_Gvsp_BGRA8_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x0017),
-    PixelType_Gvsp_RGB10_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0018),
-    PixelType_Gvsp_BGR10_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0019),
-    PixelType_Gvsp_RGB12_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x001A),
-    PixelType_Gvsp_BGR12_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x001B),
-    PixelType_Gvsp_RGB16_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0033),
-    PixelType_Gvsp_BGR16_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x004B),
-    PixelType_Gvsp_RGBA16_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x0064),
-    PixelType_Gvsp_BGRA16_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x0051),
-    PixelType_Gvsp_RGB10V1_Packed           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x001C),
-    PixelType_Gvsp_RGB10V2_Packed           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x001D),
-    PixelType_Gvsp_RGB12V1_Packed           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(36) | 0X0034),
-    PixelType_Gvsp_RGB565_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0035),
-    PixelType_Gvsp_BGR565_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0X0036),
+    PixelType_Gvsp_RGB8_Packed              =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0014),                  ///< RGB8_Packed
+    PixelType_Gvsp_BGR8_Packed              =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0015),                  ///< BGR8_Packed
+    PixelType_Gvsp_RGBA8_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x0016),                  ///< RGBA8_Packed
+    PixelType_Gvsp_BGRA8_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x0017),                  ///< BGRA8_Packed
+    PixelType_Gvsp_RGB10_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0018),                  ///< RGB10_Packed
+    PixelType_Gvsp_BGR10_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0019),                  ///< BGR10_Packed
+    PixelType_Gvsp_RGB12_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x001A),                  ///< RGB12_Packed
+    PixelType_Gvsp_BGR12_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x001B),                  ///< BGR12_Packed
+    PixelType_Gvsp_RGB16_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0033),                  ///< RGB16_Packed
+    PixelType_Gvsp_BGR16_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x004B),                  ///< BGR16_Packed
+    PixelType_Gvsp_RGBA16_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x0064),                  ///< RGBA16_Packed
+    PixelType_Gvsp_BGRA16_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x0051),                  ///< BGRA16_Packed
+    PixelType_Gvsp_RGB10V1_Packed           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x001C),                  ///< RGB10V1_Packed
+    PixelType_Gvsp_RGB10V2_Packed           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x001D),                  ///< RGB10V2_Packed
+    PixelType_Gvsp_RGB12V1_Packed           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(36) | 0X0034),                  ///< RGB12V1_Packed
+    PixelType_Gvsp_RGB565_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0035),                  ///< RGB565_Packed
+    PixelType_Gvsp_BGR565_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0X0036),                  ///< BGR565_Packed
 
     // YUV Packed buffer format defines 
-    PixelType_Gvsp_YUV411_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x001E),
-    PixelType_Gvsp_YUV422_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x001F),
-    PixelType_Gvsp_YUV422_YUYV_Packed       =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0032),
-    PixelType_Gvsp_YUV444_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0020),
-    PixelType_Gvsp_YCBCR8_CBYCR             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x003A),
-    PixelType_Gvsp_YCBCR422_8               =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x003B),
-    PixelType_Gvsp_YCBCR422_8_CBYCRY        =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0043),
-    PixelType_Gvsp_YCBCR411_8_CBYYCRYY      =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x003C),
-    PixelType_Gvsp_YCBCR601_8_CBYCR         =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x003D),
-    PixelType_Gvsp_YCBCR601_422_8           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x003E),
-    PixelType_Gvsp_YCBCR601_422_8_CBYCRY    =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0044),
-    PixelType_Gvsp_YCBCR601_411_8_CBYYCRYY  =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x003F),
-    PixelType_Gvsp_YCBCR709_8_CBYCR         =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0040),
-    PixelType_Gvsp_YCBCR709_422_8           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0041),
-    PixelType_Gvsp_YCBCR709_422_8_CBYCRY    =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0045),
-    PixelType_Gvsp_YCBCR709_411_8_CBYYCRYY  =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x0042),
+    PixelType_Gvsp_YUV411_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x001E),                  ///< YUV411_Packed
+    PixelType_Gvsp_YUV422_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x001F),                  ///< YUV422_Packed
+    PixelType_Gvsp_YUV422_YUYV_Packed       =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0032),                  ///< YUV422_YUYV_Packed
+    PixelType_Gvsp_YUV444_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0020),                  ///< YUV444_Packed
+    PixelType_Gvsp_YCBCR8_CBYCR             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x003A),                  ///< YCBCR8_CBYCR
+    PixelType_Gvsp_YCBCR422_8               =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x003B),                  ///< YCBCR422_8
+    PixelType_Gvsp_YCBCR422_8_CBYCRY        =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0043),                  ///< YCBCR422_8_CBYCRY
+    PixelType_Gvsp_YCBCR411_8_CBYYCRYY      =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x003C),                  ///< YCBCR411_8_CBYYCRYY
+    PixelType_Gvsp_YCBCR601_8_CBYCR         =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x003D),                  ///< YCBCR601_8_CBYCR
+    PixelType_Gvsp_YCBCR601_422_8           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x003E),                  ///< YCBCR601_422_8
+    PixelType_Gvsp_YCBCR601_422_8_CBYCRY    =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0044),                  ///< YCBCR601_422_8_CBYCRY
+    PixelType_Gvsp_YCBCR601_411_8_CBYYCRYY  =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x003F),                  ///< YCBCR601_411_8_CBYYCRYY
+    PixelType_Gvsp_YCBCR709_8_CBYCR         =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0040),                  ///< YCBCR709_8_CBYCR
+    PixelType_Gvsp_YCBCR709_422_8           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0041),                  ///< YCBCR709_422_8
+    PixelType_Gvsp_YCBCR709_422_8_CBYCRY    =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0045),                  ///< YCBCR709_422_8_CBYCRY
+    PixelType_Gvsp_YCBCR709_411_8_CBYYCRYY  =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x0042),                  ///< YCBCR709_411_8_CBYYCRYY
+
+    // YUV420
+    PixelType_Gvsp_YUV420SP_NV12            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x8001),                  ///< YUV420SP_NV12
+    PixelType_Gvsp_YUV420SP_NV21            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x8002),                  ///< YUV420SP_NV21
 
     // RGB Planar buffer format defines 
-    PixelType_Gvsp_RGB8_Planar              =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0021),
-    PixelType_Gvsp_RGB10_Planar             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0022),
-    PixelType_Gvsp_RGB12_Planar             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0023),
-    PixelType_Gvsp_RGB16_Planar             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0024),
-
-    // 自定义的图片格式
-    PixelType_Gvsp_Jpeg                     =   (MV_GVSP_PIX_CUSTOM | MV_PIXEL_BIT_COUNT(24) | 0x0001),
-
-    PixelType_Gvsp_Coord3D_ABC32f           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(96) | 0x00C0),//0x026000C0
-    PixelType_Gvsp_Coord3D_ABC32f_Planar    =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(96) | 0x00C1),//0x026000C1
-
-    // 该值被废弃,请参考PixelType_Gvsp_Coord3D_AC32f_64; the value is discarded
-    PixelType_Gvsp_Coord3D_AC32f            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(40) | 0x00C2),
-    // 该值被废弃; the value is discarded    (已放入Chunkdata)
-    PixelType_Gvsp_COORD3D_DEPTH_PLUS_MASK  =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(28) | 0x0001),
-
-    PixelType_Gvsp_Coord3D_ABC32            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(96) | 0x3001),//0x82603001
-    PixelType_Gvsp_Coord3D_AB32f            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x3002),//0x82403002
-    PixelType_Gvsp_Coord3D_AB32             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x3003),//0x82403003
-    PixelType_Gvsp_Coord3D_AC32f_64         =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x00C2),//0x024000C2
-    PixelType_Gvsp_Coord3D_AC32f_Planar     =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x00C3),//0x024000C3
-    PixelType_Gvsp_Coord3D_AC32             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x3004),//0x82403004
-    PixelType_Gvsp_Coord3D_A32f             =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(32) | 0x00BD),//0x012000BD
-    PixelType_Gvsp_Coord3D_A32              =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(32) | 0x3005),//0x81203005
-    PixelType_Gvsp_Coord3D_C32f             =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(32) | 0x00BF),//0x012000BF
-    PixelType_Gvsp_Coord3D_C32              =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(32) | 0x3006),//0x81203006
-    PixelType_Gvsp_Coord3D_ABC16            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x00B9),//0x023000B9
-    PixelType_Gvsp_Coord3D_C16              =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x00B8),//0x011000B8
-
-    //无损压缩像素格式定义
-    PixelType_Gvsp_HB_Mono8                    =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0001),
-    PixelType_Gvsp_HB_Mono10                   =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0003),
-    PixelType_Gvsp_HB_Mono10_Packed            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0004),
-    PixelType_Gvsp_HB_Mono12                   =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0005),
-    PixelType_Gvsp_HB_Mono12_Packed            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0006),
-    PixelType_Gvsp_HB_Mono16                   =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0007),
-    PixelType_Gvsp_HB_BayerGR8                 =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0008),
-    PixelType_Gvsp_HB_BayerRG8                 =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0009),
-    PixelType_Gvsp_HB_BayerGB8                 =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x000A),
-    PixelType_Gvsp_HB_BayerBG8                 =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x000B),
-    PixelType_Gvsp_HB_BayerRBGG8               =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0046),
-    PixelType_Gvsp_HB_BayerGR10                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000C),
-    PixelType_Gvsp_HB_BayerRG10                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000D),
-    PixelType_Gvsp_HB_BayerGB10                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000E),
-    PixelType_Gvsp_HB_BayerBG10                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000F),
-    PixelType_Gvsp_HB_BayerGR12                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0010),
-    PixelType_Gvsp_HB_BayerRG12                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0011),
-    PixelType_Gvsp_HB_BayerGB12                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0012),
-    PixelType_Gvsp_HB_BayerBG12                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0013),
-    PixelType_Gvsp_HB_BayerGR10_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0026),
-    PixelType_Gvsp_HB_BayerRG10_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0027),
-    PixelType_Gvsp_HB_BayerGB10_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0028),
-    PixelType_Gvsp_HB_BayerBG10_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0029),
-    PixelType_Gvsp_HB_BayerGR12_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002A),
-    PixelType_Gvsp_HB_BayerRG12_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002B),
-    PixelType_Gvsp_HB_BayerGB12_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002C),
-    PixelType_Gvsp_HB_BayerBG12_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002D),
-    PixelType_Gvsp_HB_YUV422_Packed            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x001F),
-    PixelType_Gvsp_HB_YUV422_YUYV_Packed       =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0032),
-    PixelType_Gvsp_HB_RGB8_Packed              =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0014),
-    PixelType_Gvsp_HB_BGR8_Packed              =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0015),
-    PixelType_Gvsp_HB_RGBA8_Packed             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x0016),
-    PixelType_Gvsp_HB_BGRA8_Packed             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x0017),
-    PixelType_Gvsp_HB_RGB16_Packed             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0033),
-    PixelType_Gvsp_HB_BGR16_Packed             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x004B),
-    PixelType_Gvsp_HB_RGBA16_Packed            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x0064),
-    PixelType_Gvsp_HB_BGRA16_Packed            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x0051),
+    PixelType_Gvsp_RGB8_Planar              =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0021),                  ///< RGB8_Planar
+    PixelType_Gvsp_RGB10_Planar             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0022),                  ///< RGB10_Planar
+    PixelType_Gvsp_RGB12_Planar             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0023),                  ///< RGB12_Planar
+    PixelType_Gvsp_RGB16_Planar             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0024),                  ///< RGB16_Planar
+
+    // 鑷�畾涔夌殑鍥剧墖鏍煎紡
+    PixelType_Gvsp_Jpeg                     =   (MV_GVSP_PIX_CUSTOM | MV_PIXEL_BIT_COUNT(24) | 0x0001),                  ///< Jpeg
+
+    PixelType_Gvsp_Coord3D_ABC32f           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(96) | 0x00C0),                  ///< 0x026000C0X
+    PixelType_Gvsp_Coord3D_ABC32f_Planar    =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(96) | 0x00C1),                  ///< 0x026000C1X
+
+    PixelType_Gvsp_Coord3D_AC32f            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(40) | 0x00C2),      ///< 璇ュ€艰�搴熷純锛岃�鍙傝€働ixelType_Gvsp_Coord3D_AC32f_64; the value is discarded
+    PixelType_Gvsp_COORD3D_DEPTH_PLUS_MASK  =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(28) | 0x0001),     ///< 璇ュ€艰�搴熷純; the value is discarded    (宸叉斁鍏�hunkdata)
+
+    PixelType_Gvsp_Coord3D_ABC32            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(96) | 0x3001),          ///< Coord3D_ABC32
+    PixelType_Gvsp_Coord3D_AB32f            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x3002),          ///< Coord3D_AB32f
+    PixelType_Gvsp_Coord3D_AB32             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x3003),          ///< Coord3D_AB32
+    PixelType_Gvsp_Coord3D_AC32f_64         =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x00C2),                               ///< Coord3D_AC32f_64
+    PixelType_Gvsp_Coord3D_AC32f_Planar     =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x00C3),                               ///< Coord3D_AC32f_Planar
+    PixelType_Gvsp_Coord3D_AC32             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x3004),          ///< Coord3D_AC32
+    PixelType_Gvsp_Coord3D_A32f             =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(32) | 0x00BD),                                ///< Coord3D_A32f
+    PixelType_Gvsp_Coord3D_A32              =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(32) | 0x3005),           ///< Coord3D_A32
+    PixelType_Gvsp_Coord3D_C32f             =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(32) | 0x00BF),                                ///< Coord3D_C32f
+    PixelType_Gvsp_Coord3D_C32              =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(32) | 0x3006),           ///< Coord3D_C32
+    PixelType_Gvsp_Coord3D_ABC16            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x00B9),                               ///< Coord3D_ABC16
+    PixelType_Gvsp_Coord3D_C16              =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x00B8),                                ///< Coord3D_C16
+
+    PixelType_Gvsp_Float32                  =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(32) | 0x0001),  //0x81200001
+
+    //鏃犳崯鍘嬬缉鍍忕礌鏍煎紡瀹氫箟
+    PixelType_Gvsp_HB_Mono8                    =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0001),         ///< HB_Mono8
+    PixelType_Gvsp_HB_Mono10                   =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0003),        ///< HB_Mono10
+    PixelType_Gvsp_HB_Mono10_Packed            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0004),        ///< HB_Mono10_Packed
+    PixelType_Gvsp_HB_Mono12                   =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0005),        ///< HB_Mono12
+    PixelType_Gvsp_HB_Mono12_Packed            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0006),        ///< HB_Mono12_Packed
+    PixelType_Gvsp_HB_Mono16                   =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0007),        ///< HB_Mono16
+    PixelType_Gvsp_HB_BayerGR8                 =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0008),         ///< HB_BayerGR8
+    PixelType_Gvsp_HB_BayerRG8                 =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0009),         ///< HB_BayerRG8
+    PixelType_Gvsp_HB_BayerGB8                 =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x000A),         ///< HB_BayerGB8
+    PixelType_Gvsp_HB_BayerBG8                 =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x000B),         ///< HB_BayerBG8
+    PixelType_Gvsp_HB_BayerRBGG8               =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0046),         ///< HB_BayerRBGG8
+    PixelType_Gvsp_HB_BayerGR10                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000C),        ///< HB_BayerGR10
+    PixelType_Gvsp_HB_BayerRG10                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000D),        ///< HB_BayerRG10
+    PixelType_Gvsp_HB_BayerGB10                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000E),        ///< HB_BayerGB10
+    PixelType_Gvsp_HB_BayerBG10                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000F),        ///< HB_BayerBG10
+    PixelType_Gvsp_HB_BayerGR12                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0010),        ///< HB_BayerGR12
+    PixelType_Gvsp_HB_BayerRG12                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0011),        ///< HB_BayerRG12
+    PixelType_Gvsp_HB_BayerGB12                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0012),        ///< HB_BayerGB12
+    PixelType_Gvsp_HB_BayerBG12                =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0013),        ///< HB_BayerBG12
+    PixelType_Gvsp_HB_BayerGR10_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0026),        ///< HB_BayerGR10_Packed
+    PixelType_Gvsp_HB_BayerRG10_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0027),        ///< HB_BayerRG10_Packed
+    PixelType_Gvsp_HB_BayerGB10_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0028),        ///< HB_BayerGB10_Packed
+    PixelType_Gvsp_HB_BayerBG10_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0029),        ///< HB_BayerBG10_Packed
+    PixelType_Gvsp_HB_BayerGR12_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002A),        ///< HB_BayerGR12_Packed
+    PixelType_Gvsp_HB_BayerRG12_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002B),        ///< HB_BayerRG12_Packed
+    PixelType_Gvsp_HB_BayerGB12_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002C),        ///< HB_BayerGB12_Packed
+    PixelType_Gvsp_HB_BayerBG12_Packed         =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002D),        ///< HB_BayerBG12_Packed
+    PixelType_Gvsp_HB_YUV422_Packed            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x001F),       ///< HB_YUV422_Packed
+    PixelType_Gvsp_HB_YUV422_YUYV_Packed       =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0032),       ///< HB_YUV422_YUYV_Packed
+    PixelType_Gvsp_HB_RGB8_Packed              =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0014),       ///< HB_RGB8_Packed
+    PixelType_Gvsp_HB_BGR8_Packed              =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0015),       ///< HB_BGR8_Packed
+    PixelType_Gvsp_HB_RGBA8_Packed             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x0016),       ///< HB_RGBA8_Packed
+    PixelType_Gvsp_HB_BGRA8_Packed             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x0017),       ///< HB_BGRA8_Packed
+    PixelType_Gvsp_HB_RGB16_Packed             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0033),       ///< HB_RGB16_Packed
+    PixelType_Gvsp_HB_BGR16_Packed             =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x004B),       ///< HB_BGR16_Packed
+    PixelType_Gvsp_HB_RGBA16_Packed            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x0064),       ///< HB_RGBA16_Packed
+    PixelType_Gvsp_HB_BGRA16_Packed            =   (MV_GVSP_PIX_CUSTOM | MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(64) | 0x0051),       ///< HB_BGRA16_Packed
 
 };
+///@}
 
 #ifdef WIN32
 typedef __int64 int64_t;

+ 26 - 5
q6_felgo_iot/CMakeLists.txt

@@ -30,7 +30,7 @@ set(CURL_LIB_PATHS
 
 set(MVS_LIB_PATHS
     ##第三方库的绝对路径
-    ${PROJECT_SOURCE_DIR}/../Lib/mvs/arm64-v8a
+    ${PROJECT_SOURCE_DIR}/../Lib/mvs/arm64-v8a  #//MVS-3.0.1_aarch64_20251113/lib/aarch64
 )
 
 set(LIBUVC_PATH
@@ -38,6 +38,17 @@ set(LIBUVC_PATH
     ${PROJECT_SOURCE_DIR}/../Lib/libuvc/Android-Arm-v8a
 )
 
+set(LWJSON_PATH
+    #libuvc库路径
+    ${PROJECT_SOURCE_DIR}/../Lib/lwjson-1.8.1
+)
+
+set(RGA_PATH
+    #libuvc库路径
+    ${PROJECT_SOURCE_DIR}/../Lib/librga-1.10.0/libs/AndroidNdk/arm64-v8a
+)
+
+
 find_package(Felgo REQUIRED)
 find_package(Qt6 COMPONENTS Core Quick SerialPort Sql Multimedia Mqtt TextToSpeech Positioning ShaderTools Widgets Svg NetWork REQUIRED)
 
@@ -70,12 +81,13 @@ list(REMOVE_ITEM AssetsFiles ${QmlFiles})
 
 ## 头文件
 include_directories(header)
+include_directories(${PROJECT_SOURCE_DIR}/../Lib/lwjson-1.8.1/include)
 include_directories(${PROJECT_SOURCE_DIR}/../Lib/opencv451/header)
 include_directories(${PROJECT_SOURCE_DIR}/../Lib/spdlog/header)
 include_directories(${PROJECT_SOURCE_DIR}/../Lib/curl/header)
 include_directories(${PROJECT_SOURCE_DIR}/../Lib/libuvc/Android-Arm-v8a/header)
-include_directories(${PROJECT_SOURCE_DIR}/../Lib/mvs/includes)
-
+include_directories(${PROJECT_SOURCE_DIR}/../Lib/mvs/MVS-3.0.1_aarch64_20251113/include)
+include_directories(${PROJECT_SOURCE_DIR}/../Lib/librga-1.10.0/include)
 qt_add_executable(q6_felgo_iot
     header/main.h
     #header/userfunc.h
@@ -115,6 +127,7 @@ qt_add_executable(q6_felgo_iot
     src/app_curlFunc.cpp
     src/TreeModel.cpp
     src/app_sq_save.cpp
+
     ${QmlFiles}
     ${AssetsFiles}
 )
@@ -161,7 +174,7 @@ elseif(ANDROID)
     link_directories(${OPENCV_LIB_3RDPATHS})
     link_directories(${PROJECT_SOURCE_DIR}/Lib/opencv451)
     link_directories(${PROJECT_SOURCE_DIR}/Lib/zlib)
-    link_directories(${PROJECT_SOURCE_DIR}/Lib/libuvc/Android-Arm-v8a)
+    #link_directories(${PROJECT_SOURCE_DIR}/Lib/libuvc/Android-Arm-v8a)
 endif()
 
 # NOTE: for PUBLISHING, perform the following steps:
@@ -201,7 +214,14 @@ target_link_libraries(q6_felgo_iot
   PRIVATE libz.so)
 
 target_link_libraries(q6_felgo_iot
-    PRIVATE  ${LIBUVC_PATH}/libusb1.0.so  ${LIBUVC_PATH}/libuvc.so)
+  PRIVATE ${LWJSON_PATH}/liblwjson.a)
+
+target_link_libraries(q6_felgo_iot
+  PRIVATE ${RGA_PATH}/librga.a)
+
+# target_link_libraries(q6_felgo_iot
+#     PRIVATE  ${LIBUVC_PATH}/libusb1.0.so  ${LIBUVC_PATH}/libuvc.so)
+
 
 target_link_libraries(q6_felgo_iot
   PRIVATE
@@ -218,6 +238,7 @@ target_link_libraries(q6_felgo_iot
   ${MVS_LIB_PATHS}/libNodeMapData_gcc49_v3_0.so
   ${MVS_LIB_PATHS}/libXmlParser_gcc49_v3_0.so)
 
+
 target_link_libraries(q6_felgo_iot
   PRIVATE
   ${OPENCV_LIB_3RDPATHS}/libade.a

+ 14 - 16
q6_felgo_iot/CMakeLists.txt.user

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by QtCreator 14.0.1, 2025-11-28T11:22:38. -->
+<!-- Written by QtCreator 14.0.1, 2025-12-06T09:07:35. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>
@@ -102,24 +102,24 @@
     <value type="int" key="CMake.Configure.BaseEnvironment">2</value>
     <value type="bool" key="CMake.Configure.ClearSystemEnvironment">false</value>
     <valuelist type="QVariantList" key="CMake.Configure.UserEnvironmentChanges"/>
-    <value type="QString" key="CMake.Initial.Parameters">-DANDROID_USE_LEGACY_TOOLCHAIN_FILE:BOOL=OFF
+    <value type="QString" key="CMake.Initial.Parameters">-DCMAKE_FIND_ROOT_PATH:PATH=%{Qt:QT_INSTALL_PREFIX}
 -DCMAKE_CXX_FLAGS_INIT:STRING=%{Qt:QML_DEBUG_FLAG}
--DCMAKE_FIND_ROOT_PATH:PATH=%{Qt:QT_INSTALL_PREFIX}
 -DANDROID_NATIVE_API_LEVEL:STRING=23
--DANDROID_NDK:PATH=F:/Android_Env/android-ndk-r23c
+-DQT_HOST_PATH:PATH=%{Qt:QT_HOST_PREFIX}
+-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable}
+-DANDROID_SDK_ROOT:PATH=F:/Android_Env/android_sdk
 -DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake
--DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX}
--DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx}
--DQT_NO_GLOBAL_APK_TARGET_PART_OF_ALL:BOOL=ON
 -DCMAKE_TOOLCHAIN_FILE:FILEPATH=F:/Android_Env/android-ndk-r23c/build/cmake/android.toolchain.cmake
+-DQT_NO_GLOBAL_APK_TARGET_PART_OF_ALL:BOOL=ON
+-DCMAKE_GENERATOR:STRING=Ninja
 -DANDROID_STL:STRING=c++_shared
--DANDROID_SDK_ROOT:PATH=F:/Android_Env/android_sdk
--DQT_HOST_PATH:PATH=%{Qt:QT_HOST_PREFIX}
--DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable}
+-DCMAKE_BUILD_TYPE:STRING=Release
+-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX}
 -DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C}
 -DANDROID_ABI:STRING=arm64-v8a
--DCMAKE_BUILD_TYPE:STRING=Release
--DCMAKE_GENERATOR:STRING=Ninja</value>
+-DANDROID_USE_LEGACY_TOOLCHAIN_FILE:BOOL=OFF
+-DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx}
+-DANDROID_NDK:PATH=F:/Android_Env/android-ndk-r23c</value>
     <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">F:\QT_WorkSpace\qt6_iot_all\build-q6_felgo_iot-Qt_6_4_1_android_arm64_v8a_Clang_arm64_v8a-Release</value>
     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
@@ -192,14 +192,12 @@
    <value type="qlonglong" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
    <valuemap type="QVariantMap" key="ProjectExplorer.Target.PluginSettings">
     <valuelist type="QVariantList" key="AndroidDeviceAbis">
-     <value type="QString">x86_64</value>
      <value type="QString">arm64-v8a</value>
-     <value type="QString">x86</value>
      <value type="QString">armeabi-v7a</value>
      <value type="QString">armeabi</value>
     </valuelist>
-    <value type="QString" key="AndroidDeviceSerialNumber">192.168.2.189:5555</value>
-    <value type="int" key="AndroidVersion.ApiLevel">32</value>
+    <value type="QString" key="AndroidDeviceSerialNumber">27265f4dcbced3a7</value>
+    <value type="int" key="AndroidVersion.ApiLevel">30</value>
    </valuemap>
    <valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
     <value type="bool" key="Analyzer.Perf.Settings.UseGlobalSettings">true</value>

+ 6 - 1
q6_felgo_iot/Readme.md

@@ -1,5 +1,10 @@
+## 20251206
+    #define APP_VERSION "1.3.21"
+    更新说明:
+        串口解析使用lwjson
+        取图接口调整
 ## 20251113
-    #define APP_VERSION "1.3.19"
+    #define APP_VERSION "1.3.20"
     更新说明:
         自动对焦:闪退问题解决,自动对焦过程中退出程序,再次启动APP后执行对焦拍照会触发闪退;
         原因:GPS定位成功后释放时机,延迟释放即可解决;

+ 1 - 1
q6_felgo_iot/android/build.gradle

@@ -41,7 +41,7 @@ android {
         versionCode 1
         versionName "1.0"
         ndk {
-            abiFilters 'armeabi-v7a', 'arm64-v8a'
+            abiFilters 'armeabi-v7a','arm64-v8a' //
         }
     }
 

BIN
q6_felgo_iot/android/libs/arm64-v8a/libCppUnit_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libGCBase_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libGenApi_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libLog_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libMVGigEVisionSDK.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libMathParser_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libMediaProcess.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libMvCameraControl.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libMvCameraControlWrapper.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libMvUsb3vTL.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libNodeMapData_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/arm64-v8a/libXmlParser_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libCppUnit_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libGCBase_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libGenApi_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libLog_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libMVGigEVisionSDK.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libMathParser_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libMediaProcess.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libMvCameraControl.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libMvCameraControlWrapper.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libMvUsb3vTL.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libNodeMapData_gcc49_v3_0.so


BIN
q6_felgo_iot/android/libs/armeabi-v7a/libXmlParser_gcc49_v3_0.so


+ 0 - 0
q6_felgo_iot/android/libs/放在这里的库再编译时会打包到apk里.txt


+ 57 - 46
q6_felgo_iot/header/cameramanager.h

@@ -21,17 +21,17 @@
 #include <m_loger.h>
 #include <QFuture>
 #include <ImageStitcher.h>
-#include <libuvc.h>
-#include <libusb.h>
-//#include <unrooted_android.h>
 #include <QSemaphore>
 #include <QQuickImageProvider>
 #include <QQmlImageProviderBase>
 #include <QImage>
 #include <pthread.h>
 //海康
+// #pragma pack(push, 4)
+// #include "MvCameraControl.h"
+// #pragma pack(pop)
 #include <MvCameraControl.h>
-
+#include <PixelType.h>
 
 //https://github.com/saki4510t/UVCCamera/pulls
 //https://gitee.com/dengly/UVCCamera
@@ -129,34 +129,6 @@ class Frames :public QObject//, public QQuickImageProvider //QObject  //
     Q_PROPERTY( bool camera_sw READ camera_sw WRITE setCameraSw NOTIFY cameraStaChanged )
 
 public:
-    struct UVCCaptureDescriptor {
-        uint16_t vendorID;
-        uint16_t productID;
-        uint16_t UVC_level;
-        QString serial;
-        QString manufacturer;
-        QString productName;
-        uvc_device_t* dev;
-    };
-
-    struct UVCCaptureProperties {
-        uvc_frame_format format;
-        QString formatString;
-        QRect frameRect;
-        int frameInterval;
-        unsigned int bufferSize;
-        UVCCaptureProperties():
-            format(UVC_FRAME_FORMAT_YUYV),
-            formatString("YUYV"),
-            frameRect(QRect(0,0,640,480)),
-            frameInterval(333333),
-            bufferSize(0){}
-    };
-
-    //< matrix to store the current frame
-
-
-public:
     static void registerQmlType();
     explicit Frames(QObject * parent = nullptr);
     ~Frames() override;
@@ -217,7 +189,6 @@ signals:
     void fpsStringChanged();
     void qulityStringChanged();
     void frameAvailable(const QVideoFrame &frame);
-    void uvcframeAvailable(const cv::Mat& frame);
     void frameReady(QImage image);
     void btnStatusChanged();
     void sendFocusFlag(QString flag_sta);
@@ -276,9 +247,9 @@ private slots:
     void displayCaptureError(int id, const QImageCapture::Error error, const QString &errorString);
     void displayCameraError();
 
-    void processUvchandle(const QString &qst);
     //void sendData(QByteArray m_byte);
     void displayFrame(const QVideoFrame &frame);
+    void mov_x_z_run();
 private:
     Q_DISABLE_COPY( Frames )
     //! Camera.
@@ -306,7 +277,6 @@ private:
 
     QFuture<void> m_processThread;
     QFuture<void> m_grabThread;
-    QFutureWatcher<QImage*> watcher_uvc;
 
     QJniObject *jClass;
 
@@ -328,24 +298,19 @@ private:
 
     int MAX_STEP = 30;
     QVector<double> image_qulity;
-    double max_image_qulity = 0.0;  //最大清晰度值
-    double max_image_sharp= 0.0;
+
     int image_qulity_num;
 
     int z_step = 0;
     int x_step = 0;
 
+    QMutex m_frameMutex;
+    std::unique_ptr<QVideoFrame> m_latestFrame;
     //图片归档路径
     QString picture_path_floader;
-    UVCCaptureProperties m_properties;
+
 
     QVector<cv::Mat> m_frame_buffer;
-    void uvc_error_handler(uvc_error_t res) {
-        if (res < 0) {
-            const char* error_message = uvc_strerror(res);
-            qCritical("libuvc error: %s", error_message);
-        }
-    }
 
     int testJNI();
     int checkPermission(void)
@@ -488,11 +453,57 @@ private:
 
       return cv::Mat();
     }
+
+    bool IsColor(MvGvspPixelType enType)
+    {
+        switch(enType)
+        {
+        case PixelType_Gvsp_BGR8_Packed:
+        case PixelType_Gvsp_YUV422_Packed:
+        case PixelType_Gvsp_YUV422_YUYV_Packed:
+        case PixelType_Gvsp_BayerGR8:
+        case PixelType_Gvsp_BayerRG8:
+        case PixelType_Gvsp_BayerGB8:
+        case PixelType_Gvsp_BayerBG8:
+        case PixelType_Gvsp_BayerGB10:
+        case PixelType_Gvsp_BayerGB10_Packed:
+        case PixelType_Gvsp_BayerBG10:
+        case PixelType_Gvsp_BayerBG10_Packed:
+        case PixelType_Gvsp_BayerRG10:
+        case PixelType_Gvsp_BayerRG10_Packed:
+        case PixelType_Gvsp_BayerGR10:
+        case PixelType_Gvsp_BayerGR10_Packed:
+        case PixelType_Gvsp_BayerGB12:
+        case PixelType_Gvsp_BayerGB12_Packed:
+        case PixelType_Gvsp_BayerBG12:
+        case PixelType_Gvsp_BayerBG12_Packed:
+        case PixelType_Gvsp_BayerRG12:
+        case PixelType_Gvsp_BayerRG12_Packed:
+        case PixelType_Gvsp_BayerGR12:
+        case PixelType_Gvsp_BayerGR12_Packed:
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    bool IsMono(MvGvspPixelType enType)
+    {
+        switch(enType)
+        {
+        case PixelType_Gvsp_Mono10:
+        case PixelType_Gvsp_Mono10_Packed:
+        case PixelType_Gvsp_Mono12:
+        case PixelType_Gvsp_Mono12_Packed:
+            return true;
+        default:
+            return false;
+        }
+    }
 }; // class Frames
 } /* namespace Qt6QCamera */
 
 Q_DECLARE_METATYPE(cv::Mat)
-Q_DECLARE_METATYPE(Qt6QCamera::Frames::UVCCaptureProperties)
-Q_DECLARE_METATYPE(Qt6QCamera::Frames::UVCCaptureDescriptor)
+
 
 #endif // M_FRAMES_HPP

+ 1 - 1
q6_felgo_iot/header/main.h

@@ -37,7 +37,7 @@
 #include <opencv2/features2d/features2d.hpp>
 #include <opencv2/xfeatures2d/nonfree.hpp>
 
-#define APP_VERSION "1.3.20"
+#define APP_VERSION "1.3.21"
 
 using namespace std;
 

+ 39 - 3
q6_felgo_iot/header/mserial.h

@@ -14,6 +14,10 @@
 #include <QVideoFrame>
 #include <mysql.h>
 #include <m_loger.h>
+#include "lwjson/lwjson.h"
+
+
+
 class SerialThread: public QThread
 {
     Q_OBJECT
@@ -114,7 +118,7 @@ signals:
     void netMessage(const QByteArray &data);
     void autoFocusDone();
     void autoFocusStart();
-
+    void lwjsonStreamDONE(const QByteArray &data);
     void signal_movy();
     void timeout_mov_stop();
     void gpsSuccess();
@@ -126,9 +130,39 @@ public slots:
 
 private slots:
     //void readBoardData();
-
+    void feedJsonParser(const QByteArray& data)
+    {
+        dataBuf.append(data);
+        for (uint8_t b : data) {
+            lwjsonr_t ret = lwjson_stream_parse(&lwparser, b);
+            switch (ret){
+            case lwjsonERRJSON:             // 1, 无效的字符
+            case lwjsonSTREAMWAITFIRSTCHAR: // 2, 等待首字符
+                break;
+            case lwjsonSTREAMINPROG:        // 3, 正在解析中
+                break;
+            case lwjsonSTREAMDONE:          // 4, 解析已完成
+                if(dataBuf.contains("movy")){
+                    dataBuf.clear();
+                    emit timeout_mov_stop();
+                    emit signal_movy();
+                }else{
+                    emit lwjsonStreamDONE(dataBuf);
+                }
+                 lwjson_stream_reset(&lwparser);
+                break;
+            case lwjsonERRMEM:             // 5, 嵌套的太深("LWJSON_CFG_STREAM_STACK_SIZE")
+                ERROR("lwjsonERRMEM!");
+                lwjson_stream_reset(&lwparser);
+                break;
+            default: // 流式解析时, 其它的返回值, 都不应该出现
+                ERROR("未知错误:{}",ret);
+                break;
+            }
+        }
+    }
 private:
-    void processJsonData(QByteArray &jsonData);
+    void processJsonData(const QByteArray &jsonData);
     QTimer m_dat_f;
     QTimer* timeout_mov = nullptr;
     QSerialPort m_serialPort;
@@ -146,6 +180,8 @@ private:
         int fileCount = 0;
     };
 
+    lwjson_stream_parser_t lwparser;
+
     void deleteAllFilesInDirectory(const QString &directoryPath)
     {
         QDir directory(directoryPath);

+ 192 - 272
q6_felgo_iot/src/cameramanager.cpp

@@ -42,6 +42,12 @@
 #include <m_loger.h>
 #include <QMessageBox>
 
+#include "im2d.hpp"
+#include "im2d_common.h"
+#include "RgaUtils.h"
+
+
+
 class param;
 
 namespace Qt6QCamera {
@@ -50,7 +56,9 @@ namespace Qt6QCamera {
 //< hikrobot
 void *handle = NULL;
 int nRet = MV_OK;
-bool camera_gige = false;
+MVCC_ENUMVALUE current_pixel;
+
+
 SenderCustom sender_custom;
 cv::Mat cv_frame;
 
@@ -165,20 +173,6 @@ Frames::Frames(QObject * parent)
         qRegisterMetaType<cv::Mat>("cv::Mat");
     }
 
-    id = QMetaType::fromName("UVCCaptureProperties");
-    if(id.flags() == QMetaType::UnknownType) {
-        qRegisterMetaType<UVCCaptureProperties>("UVCCaptureProperties");
-    }
-
-    id = QMetaType::fromName("QVector<UVCCaptureProperties>");
-    if(id.flags() == QMetaType::UnknownType) {
-        qRegisterMetaType<QVector<UVCCaptureProperties>>("QVector<UVCCaptureProperties>");
-    }
-
-    id = QMetaType::fromName("QVector<UVCCaptureDescriptor>");
-    if(id.flags() == QMetaType::UnknownType) {
-        qRegisterMetaType<QVector<UVCCaptureDescriptor>>("QVector<UVCCaptureDescriptor>");
-    }
 
     stitch_des = 0;
 
@@ -206,14 +200,6 @@ Frames::Frames(QObject * parent)
     connect(this,&Frames::signal_photo_saved,
             this,&Frames::upload_handle);
 
-    // connect(&sender_custom,&SenderCustom::signalToSend,
-    //         this,&Frames::parseFrame);
-
-    connect(&sender_custom,&SenderCustom::signalQStr,
-            this,&Frames::processUvchandle);
-
-
-
     initCam();
 }
 
@@ -312,19 +298,6 @@ Frames::setChange(bool stat_t)
 }
 
 void
-Frames::processUvchandle(const QString &qst){
-    if(qst.contains("UVCINIT")){
-        qDebug() << "UVC初始化成功!";
-    }else if(qst.contains("UVCOPEN")){
-        m_1s->start();
-        m_fps_timer->setRunning(true);
-        qDebug() << "UVC打开成功!";
-    }
-}
-
-
-
-void
 Frames::setCameraSw(bool stat_cam)
 {
     z_step = 0;
@@ -434,8 +407,9 @@ Frames::setCameraSw(bool stat_cam)
                      {
                          qDebug() << "Warning: Get Packet Size fail nRet:"<< nPacketSize;
                      }
-                     camera_gige = true;
+                     LOG("stDeviceList.pDeviceInfo[nIndex]->nTLayerType:{}",stDeviceList.pDeviceInfo[nIndex]->nTLayerType);
                  }
+
                  // ch:设置触发模式为off | eb:Set trigger mode as off
                  nRet = MV_CC_SetEnumValue(handle, "TriggerMode", MV_TRIGGER_MODE_OFF);
                  if (MV_OK != nRet)
@@ -471,6 +445,14 @@ Frames::setCameraSw(bool stat_cam)
                      unsigned int unsignedValue = static_cast<unsigned int>(nRet);
                      qDebug() << "[MV_CC_GetIntValueEx Height Failed]:"<< nRet;
                  }
+                 //获取像素格式
+                 nRet = MV_CC_GetPixelFormat(handle,&current_pixel);
+                 if(nRet==MV_OK){
+                     LOG("MV_CC_GetPixelFormat:{}",current_pixel.nCurValue);
+                 }else{
+                     unsigned int unsignedValue = static_cast<unsigned int>(nRet);
+                     qDebug() << "[MV_CC_GetPixelFormat Failed]:"<< nRet;
+                 }
                  // 开始取流
                  // start grab image
                  nRet = MV_CC_StartGrabbing(handle);
@@ -630,9 +612,117 @@ Frames::handle_reult_upload(bool success, const QString &error)
     }
     upload_handle();
 }
+
+void
+Frames::mov_x_z_run(){
+    /*z3x7*/
+    if(z_step==3&&x_step==7){
+        emit stopGrabbing(false);
+    }
+
+    if(z_step<=2&&x_step==7){
+        z_step++;
+        emit serial_data(m_json.MotorMove("movz",movX_b,"50"));
+    }
+
+
+    /*z3x6*/
+    if(z_step==3&&x_step==6)
+    {
+        //emit stopGrabbing(false);
+        x_step++;
+        z_step = 0;
+        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
+    }
+    if(z_step<=2&&x_step==6){
+        z_step++;
+        emit serial_data(m_json.MotorMove("movz",movZ_f,"50"));
+    }
+
+    /*z3x5*/
+    if(z_step==3&&x_step==5)
+    {
+        //emit stopGrabbing(false);
+        x_step++;
+        z_step = 0;
+        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
+    }
+    if(z_step<=2&&x_step==5){
+        z_step++;
+        emit serial_data(m_json.MotorMove("movz",movZ_b,"50"));
+    }
+
+    /*z3x4*/
+    if(z_step==3&&x_step==4)
+    {
+        x_step++;
+        z_step = 0;
+        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
+    }
+    if(z_step<=2&&x_step==4){
+        z_step++;
+        emit serial_data(m_json.MotorMove("movz",movZ_f,"50"));
+    }
+
+    /*z3x3*/
+    if(z_step==3&&x_step==3)
+    {
+        x_step++;
+        z_step = 0;
+        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
+    }
+    if(z_step<=2&&x_step==3){
+        z_step++;
+        emit serial_data(m_json.MotorMove("movz",movZ_b,"50"));
+    }
+    /**/
+
+    /*z3x2*/
+    if(z_step==3&&x_step==2)
+    {
+        x_step++;
+        z_step = 0;
+        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
+    }
+    if(z_step<=2&&x_step==2){
+        z_step++;
+        emit serial_data(m_json.MotorMove("movz",movZ_f,"50"));
+    }
+    /**/
+
+    /*z3x1*/
+    if(z_step==3&&x_step==1)
+    {
+        x_step++;
+        z_step = 0;
+        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
+    }
+
+    if(z_step<=2&&x_step==1){
+        z_step++;
+        emit serial_data(m_json.MotorMove("movz",movZ_b,"50"));
+    }
+
+    /*z3x0*/
+    if(z_step==3&&x_step==0)
+    {
+        x_step++;
+        z_step = 0;
+        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
+    }
+    if(z_step<=2&&x_step==0)
+    {
+        z_step++;
+        emit serial_data(m_json.MotorMove("movz",movZ_f,"50"));
+    }
+
+}
+
+
 void
 Frames::handleGrab(bool sta_cam){
     #if 1
+    if (m_grabThread.isRunning()) return;
     if(m_grabThread.isFinished()){
         m_grabThread = QtConcurrent::run([=]() {
             // ch:获取数据包大小 | en:Get payload size
@@ -647,211 +737,79 @@ Frames::handleGrab(bool sta_cam){
                     qDebug() << "Get PayloadSize fail! nRet:" <<  QString::number(unsignedValue, 16).toUpper();
                     return;
                 }
-            }else{
-                if(!handle) return;
             }
+            if(!handle) return;
+            const uint32_t payload = stParam.nCurValue;
+            std::unique_ptr<unsigned char[]> pData(new unsigned char[payload]);
+            unsigned char *pConvertData = NULL;
+            int nConvertDataSize;
+            //MV_FRAME_OUT_INFO_EX stImageInfo = {0};
+            QVideoFrameFormat vfmt(QSize(0,0), QVideoFrameFormat::Format_BGRA8888);
+            MV_FRAME_OUT stImageInfo = {0};
 
-            MV_FRAME_OUT_INFO_EX stImageInfo = {0};
-            memset(&stImageInfo, 0, sizeof(MV_FRAME_OUT_INFO_EX));
-            unsigned char *pData = (unsigned char *)malloc(sizeof(unsigned char) * stParam.nCurValue+2048);
-            unsigned int nDataSize = stParam.nCurValue + 2048;
-            cv::Mat tempMat;
-            MV_FRAME_OUT pFrame={0};
-            qDebug() << "MV_CC_Get nDataSize:"  << nDataSize;
             bool flag_cam = sta_cam;
-            while(true){//
-                if(flag_cam){
-                    nRet = MV_CC_GetOneFrameTimeout(handle, pData, nDataSize, &stImageInfo, 10000);
-                    if (nRet == MV_OK){
-                        //qDebug() << "MV_CC_GetOneFrameTimeout Success" <<stImageInfo.enPixelType << stImageInfo.nHeight << stImageInfo.nWidth;
-                        if ( stImageInfo.enPixelType == 0 )
-                        {
-                            //转换为Mat类型
-                            //cv::Mat tempMat = Mat(stImageInfo.nHeight , stImageInfo.nWidth, CV_8UC3,pData);  //BGR
-                            tempMat = Mat(stImageInfo.nHeight , stImageInfo.nWidth, CV_8UC1,pData);  //YUV CV_8UC2
-                            if (tempMat.empty()) {
-                                // 处理转换失败的情况
-                                qDebug() << "Failed to convert QByteArray to cv::Mat";
-                                return; // 可能需要根据实际情况进行处理,比如抛出异常或返回错误码
-                            }
-                            #if 0
-                            cv::Mat bgrImage;
-                            cv::cvtColor(tempMat, bgrImage, cv::COLOR_YUV2RGB_YVYU);//YUV422
-                            cv::cvtColor(bgrImage,m_frame,cv::COLOR_RGB2RGBA);
-                            #else
-                            if(!camera_gige){
-                                cv::cvtColor(tempMat,m_frame,cv::COLOR_BayerRG2RGBA);
-                            }else {
-                                cv::cvtColor(tempMat,m_frame,cv::COLOR_BayerGR2BGRA);
-                            }
-
-                            #endif
-                            #if 1
-                            const int size_frame = m_frame.total()*m_frame.elemSize();  //字节数
-                            //m_image = cvMatToQImage(m_frame);
-                            // 创建 QVideoFrame 对象,并设置相关参数
-                            QVideoFrameFormat frame_format(QSize(m_frame.cols, m_frame.rows),
-                                                           QVideoFrameFormat::Format_RGBA8888);
-                            QVideoFrame f(frame_format);
-                            if(f.map(QVideoFrame::WriteOnly)){
-                                // 将 cv::Mat 数据复制到 QVideoFrame
-                               memcpy(f.bits(0),m_frame.data,size_frame);
-                               f.setStartTime(0);
-                               f.unmap();
-                               // 确保在主线程更新UI
-                               QMetaObject::invokeMethod(m_videoSink, [this, f]() {
-                                   if (m_videoSink) {
-                                       m_videoSink->setVideoFrame(f);
-                                   }
-                               }, Qt::QueuedConnection);
-                               // if(m_videoSink != nullptr){
-                               //     m_videoSink->setVideoFrame(f);
-                               // }
-                            }
-                            m_fps_timer->incrementFrame();
-                            if(param::camera_tc==1||param::camera_tc==100){
-                                QDateTime currentDateTime = QDateTime::currentDateTime();
-                                QString currentDateTimeString = currentDateTime.toString("yyyyMMddhhmmss");                                
-                                if(f.isValid()) m_image = f.toImage().convertToFormat(QImage::Format_RGB32);
-                                QString pic_name = picture_path_floader + "/" + currentDateTimeString + "z" + QString::number(z_step) + "x" + QString::number(x_step) +".jpg";
-                                if(param::camera_tc==100){
-                                    m_image.save(pic_name,"jpg",80);
-                                    LOG("立即拍照图片已保存:{}",pic_name.toStdString());
-                                    param::ptlist.append(pic_name);
-                                    param::camera_tc = 0;
-                                    emit stopGrabbing(false);
-                                    return;
-                                }
-                                param::camera_tc = 0;
-                                if(m_image.save(pic_name,"jpg",80))
-                                {
-                                    LOG("图片已保存:{}",pic_name.toStdString());
-                                    //图片锐化
-                                    //m_opencvfunc.CustomSharpening(pic_name);
-                                    param::ptlist.append(pic_name);
-                                    /*z3x7*/
-                                    if(z_step==3&&x_step==7){
-                                        emit stopGrabbing(false);
-                                    }
-
-                                    if(z_step<=2&&x_step==7){
-                                        z_step++;
-                                        emit serial_data(m_json.MotorMove("movz",movX_b,"50"));
-                                    }
-
-
-                                    /*z3x6*/
-                                    if(z_step==3&&x_step==6)
-                                    {
-                                        //emit stopGrabbing(false);
-                                        x_step++;
-                                        z_step = 0;
-                                        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
-                                    }
-                                    if(z_step<=2&&x_step==6){
-                                        z_step++;
-                                        emit serial_data(m_json.MotorMove("movz",movZ_f,"50"));
-                                    }
-
-                                    /*z3x5*/
-                                    if(z_step==3&&x_step==5)
-                                    {
-                                        //emit stopGrabbing(false);
-                                        x_step++;
-                                        z_step = 0;
-                                        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
-                                    }
-                                    if(z_step<=2&&x_step==5){
-                                        z_step++;
-                                        emit serial_data(m_json.MotorMove("movz",movZ_b,"50"));
-                                    }
-
-                                    /*z3x4*/
-                                    if(z_step==3&&x_step==4)
-                                    {
-                                        x_step++;
-                                        z_step = 0;
-                                        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
-                                    }
-                                    if(z_step<=2&&x_step==4){
-                                        z_step++;
-                                        emit serial_data(m_json.MotorMove("movz",movZ_f,"50"));
-                                    }
-
-                                    /*z3x3*/
-                                    if(z_step==3&&x_step==3)
-                                    {
-                                        x_step++;
-                                        z_step = 0;
-                                        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
-                                    }
-                                    if(z_step<=2&&x_step==3){
-                                        z_step++;
-                                        emit serial_data(m_json.MotorMove("movz",movZ_b,"50"));
-                                    }
-                                    /**/
-
-                                    /*z3x2*/
-                                    if(z_step==3&&x_step==2)
-                                    {
-                                        x_step++;
-                                        z_step = 0;
-                                        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
-                                    }
-                                    if(z_step<=2&&x_step==2){
-                                        z_step++;
-                                        emit serial_data(m_json.MotorMove("movz",movZ_f,"50"));
-                                    }
-                                    /**/
-
-                                    /*z3x1*/
-                                    if(z_step==3&&x_step==1)
-                                    {
-                                        x_step++;
-                                        z_step = 0;
-                                        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
-                                    }
-
-                                    if(z_step<=2&&x_step==1){
-                                        z_step++;
-                                        emit serial_data(m_json.MotorMove("movz",movZ_b,"50"));
-                                    }
-
-                                    /*z3x0*/
-                                    if(z_step==3&&x_step==0)
-                                    {
-                                        x_step++;
-                                        z_step = 0;
-                                        emit serial_data(m_json.MotorMove("movx",movX_f,"50"));
-                                    }
-                                    if(z_step<=2&&x_step==0)
-                                    {
-                                        z_step++;
-                                        emit serial_data(m_json.MotorMove("movz",movZ_f,"50"));
-                                    }
-                                }
-                            }
-                            else if(param::camera_tc==-1)
-                            {
-                                emit stopGrabbing(false);
-                                break;
-                            }
-                            #else
-                            emit uvcframeAvailable(m_frame);
-                            #endif
-                        }else{
-                            qDebug() << "enPixelType:" << stImageInfo.enPixelType;
+            std::vector<unsigned char> rgbBuf;
+            while(flag_cam){
+
+                nRet = MV_CC_GetImageBuffer(handle, &stImageInfo, 10000);
+                if (nRet != MV_OK) {
+                    ERROR("GetOneFrameTimeout:{:x}",nRet);
+                    break;
+                }
+
+                cv::Mat raw(stImageInfo.stFrameInfo.nHeight, stImageInfo.stFrameInfo.nWidth, CV_8UC1, stImageInfo.pBufAddr);
+                m_frame = raw;
+                if(current_pixel.nCurValue == PixelType_Gvsp_BayerRG8){//PixelType_Gvsp_BayerRG8
+                    cv::cvtColor(raw, m_frame, cv::COLOR_BayerRG2BGRA);
+                }else if(current_pixel.nCurValue == PixelType_Gvsp_BayerGR8){
+                    cv::cvtColor(raw, m_frame, cv::COLOR_BayerGR2BGRA);
+                }
+
+                vfmt = QVideoFrameFormat(QSize(m_frame.cols, m_frame.rows),
+                                         QVideoFrameFormat::Format_RGBA8888);
+                QVideoFrame f(vfmt);
+                if (f.map(QVideoFrame::WriteOnly)) {
+                    memcpy(f.bits(0), m_frame.data, m_frame.total() * m_frame.elemSize());
+                    f.unmap();
+
+                    QMetaObject::invokeMethod(m_videoSink, [this,f]() {
+                        if (m_videoSink) {
+                            m_videoSink->setVideoFrame(f);
                         }
-                    }else{
-                        unsigned int unsignedValue = static_cast<unsigned int>(nRet);
-                        qDebug() << "MV_CC_GetOneFrameTimeout!" << QString::number(unsignedValue, 16).toUpper();
-                        flag_cam = false;
+                    }, Qt::QueuedConnection);
+                }
+
+                // ----- FPS -----
+                m_fps_timer->incrementFrame();
+
+                if(param::camera_tc==1||param::camera_tc==100){
+                    QString ts = QDateTime::currentDateTime().toString("yyyyMMddhhmmss");
+                    if (f.isValid()) {
+                        QImage img = f.toImage().convertToFormat(QImage::Format_RGB32);
+                        QString name = picture_path_floader + "/" + ts +
+                                       "z" + QString::number(z_step) +
+                                       "x" + QString::number(x_step) + ".jpg";
+
+                        if(img.save(name, "jpg", 80)){
+                            param::ptlist.append(name);
+                            LOG("图片已保存:{}", name.toStdString());
+                            mov_x_z_run();
+                        }
+                    }
+                    if (param::camera_tc == 100) {
+                        param::camera_tc = 0;
+                        emit stopGrabbing(false);
+                        return;
                     }
-                }else{
+                    param::camera_tc = 0;
+                }
+                if (param::camera_tc == -1) {
+                    emit stopGrabbing(false);
+                    flag_cam = false;
                     break;
                 }
+                MV_CC_FreeImageBuffer(handle, &stImageInfo);
             }
-            if(pData)   free(pData);
         });
     }
 #else
@@ -1041,9 +999,6 @@ Frames::update_qulstr(QString q_str)
 void
 Frames::saveImage()
 {
-    image_qulity_num = 0;
-    image_qulity.clear();
-
     //停止清晰度发送,关闭定时器m1s
     LOG("saveImage start!");
     #ifdef focus_board
@@ -1056,7 +1011,6 @@ Frames::saveImage()
     cv::cvtColor(m_frame,image_gray,cv::COLOR_RGBA2GRAY);
     double grayvalue = cv::mean(image_gray)[0];
     m_qulityString = m_opencvfunc.Tenengrad(m_frame);
-    image_qulity.append(m_qulityString.toDouble());
     emit serial_data(m_json.ImageFunc(m_qulityString.toDouble()));
     emit qulityStringChanged();
     LOG("image_gray:{}",grayvalue);
@@ -1070,40 +1024,6 @@ Frames::saveImage()
     #endif
 }
 
-void Frames::ImageCallBackEx(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser)
-{
-    Frames *frame_p = reinterpret_cast<Frames*>(pUser);
-    if (pFrameInfo&&frame_p)
-    {
-        qDebug() <<"Get One Frame: Width:"
-                << pFrameInfo->nWidth << " Height:"
-                <<pFrameInfo->nHeight << " nFrameNum:"
-               <<pFrameInfo->nFrameNum << "pixelType:"
-              <<pFrameInfo->enPixelType;
-        cv::Mat tempMat = cv::Mat(pFrameInfo->nHeight , pFrameInfo->nWidth, CV_8UC2,pData,cv::Mat::AUTO_STEP);
-        if (tempMat.empty()) {
-            // 处理转换失败的情况
-            qDebug() << "Failed to convert QByteArray to cv::Mat";
-            return; // 可能需要根据实际情况进行处理,比如抛出异常或返回错误码
-        }
-        cv::Mat rgbImage;
-        cv::cvtColor(tempMat, rgbImage, cv::COLOR_YUV2RGB_YVYU);//YUV422
-        emit frame_p->uvcframeAvailable(rgbImage);
-//        cv::cvtColor(rgbImage,rgbImage,cv::COLOR_RGB2RGBA);
-
-//        const int size_frame = rgbImage.total()*rgbImage.elemSize();  //字节数
-//        // 创建 QVideoFrame 对象,并设置相关参数
-//        QVideoFrameFormat frame_format(QSize(rgbImage.cols, rgbImage.rows),
-//                                       QVideoFrameFormat::Format_RGBA8888);
-//        QVideoFrame f(frame_format);
-//        if(f.map(QVideoFrame::WriteOnly)){
-//           // 将共享内存数据复制到 QVideoFrame
-//           memcpy(f.bits(0), rgbImage.data, size_frame);
-//           f.unmap();
-//           emit frame_p->frameAvailable(f);
-//        }
-    }
-}
 
 void Frames::displayFrame(const QVideoFrame &frame)
 {

+ 2 - 2
q6_felgo_iot/src/main.cpp

@@ -445,13 +445,13 @@ int main(int argc, char *argv[])
     uploader_ftp.setFtpParams("bzy_user", "YFkj@6O2O", "8.136.98.49", 21, remotepath);
 
     YMODEM m_ymodem(&serialThread);
-    #if 0   //厦门四信
+    #if 1   //厦门四信
 
     serialThread.setSerialPortSettings("ttySR3", QSerialPort::Baud115200, QSerialPort::Data8,
                                            QSerialPort::NoParity, QSerialPort::OneStop,
                                            QSerialPort::NoFlowControl);
     #else   //南京软方
-    serialThread.setSerialPortSettings("/dev/ttyS4", QSerialPort::Baud115200, QSerialPort::Data8,
+    serialThread.setSerialPortSettings("/dev/ttyS3", QSerialPort::Baud115200, QSerialPort::Data8,
                                            QSerialPort::NoParity, QSerialPort::OneStop,
                                            QSerialPort::NoFlowControl);
     #endif

+ 9 - 55
q6_felgo_iot/src/mserial.cpp

@@ -1,8 +1,9 @@
 #include "mserial.h"
-#include <QDebug>
 #include <main.h>
+#include <QDebug>
 #include <m_loger.h>
 
+
 class param;
 
 Serial_AT::Serial_AT(QObject *parent /*= 0*/ )
@@ -131,6 +132,7 @@ void Serial_AT::serialClose()
 SerialThread::SerialThread(QObject *parent)
     : QThread(parent), m_running(false)
 {
+    lwjson_stream_init(&lwparser, NULL);
     QString directoryPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
     analyzeDirectory(directoryPath);
     if(int_totalSize>=1073741824)
@@ -162,6 +164,7 @@ SerialThread::SerialThread(QObject *parent)
     });
 
     connect(this,&SerialThread::timeout_mov_stop,timeout_mov,&QTimer::stop);
+    connect(this,&SerialThread::lwjsonStreamDONE,this,&SerialThread::processJsonData);
     m_dat_f.setInterval(1000*60*param::dat_f_main);
     m_dat_f.start();
 }
@@ -185,7 +188,6 @@ void SerialThread::setSerialPortSettings(const QString &portName, QSerialPort::B
 
 void SerialThread::run()
 {
-    QJsonParseError jsonError;
     m_running = true;
     if (!m_serialPort.open(QIODevice::ReadWrite)) {
         emit dataReceived("Failed to open serial port");
@@ -194,60 +196,11 @@ void SerialThread::run()
         return;
     }
     SetLedState(false);     //异常处理:发送关闭补光灯指令
+
     while (m_running) {
         if (m_serialPort.waitForReadyRead(50)) {
-            dataBuf.append(m_serialPort.readAll());
-            qDebug() << "uart:" << dataBuf;
-
-            if(dataBuf.contains("movy")){
-                dataBuf.clear();
-                emit timeout_mov_stop();
-                emit signal_movy();
-            }
-
-            int jsonStartIndex = -1;
-            int openBrackets = 0;
-
-            for (int i = 0; i < dataBuf.size(); ++i) {
-                if (dataBuf.at(i) == '{') {
-                    if (jsonStartIndex == -1) {
-                        jsonStartIndex = i;
-                    }
-                    openBrackets++;
-                } else if (dataBuf.at(i) == '}') {
-                    openBrackets--;
-                    if (openBrackets == 0) {
-                        // 找到完整的 JSON 对象
-                        QByteArray jsonData = dataBuf.mid(jsonStartIndex, i - jsonStartIndex + 1);
-                        QJsonDocument jsonDocument = QJsonDocument::fromJson(jsonData, &jsonError);
-
-                        if (jsonError.error == QJsonParseError::NoError && jsonDocument.isObject()) {
-                            qDebug() << "接收到:" << jsonData;
-                            processJsonData(jsonData);
-                            dataBuf.remove(0, jsonStartIndex);
-                            connect_board = 0;
-                        } else {
-                            qDebug() << "JSON 解析错误:" << jsonData;
-                            if(dataBuf.contains("takephoto_done")){
-                                emit takephotodone();
-                            }else if(dataBuf.contains("auto_focus") || dataBuf.contains("focus_done")){
-                                emit autoFocusDone();
-                            }
-                        }
-
-                        // 重置索引
-                        jsonStartIndex = -1;
-                    }
-                }
-            }
-            // 移除已处理的数据
-            if (jsonStartIndex != -1) {
-                dataBuf.remove(0, jsonStartIndex);
-            } else {
-                dataBuf.clear();
-            }
-
-            if(dataBuf.contains("}{")) dataBuf.clear(); //异常处理
+            QByteArray data = m_serialPort.readAll();
+            if(!data.isEmpty()) feedJsonParser(data);
         }
     }
     m_serialPort.close();
@@ -282,7 +235,7 @@ void SerialThread::sendData(const QByteArray &data)
 
 
 void
-SerialThread::processJsonData(QByteArray &jsonData)
+SerialThread::processJsonData(const QByteArray &jsonData)
 {
     QJsonParseError error;
     QJsonDocument jsonDocument = QJsonDocument::fromJson(jsonData, &error);
@@ -364,6 +317,7 @@ SerialThread::processJsonData(QByteArray &jsonData)
     } else {
         qDebug() << "JSON parse error:" << error.errorString();
     }
+    dataBuf.clear();
 }
 
 void