723 lines
23 KiB
C++
723 lines
23 KiB
C++
#include "HikDevice.h"
|
||
#include "VrLog.h"
|
||
#include "VrError.h"
|
||
#include <cstring>
|
||
#include <cstdint>
|
||
#include <algorithm>
|
||
#include <thread>
|
||
#include <chrono>
|
||
|
||
// 海康相机默认账户密码
|
||
#define HIK_DEFAULT_USERNAME "admin"
|
||
#define HIK_DEFAULT_PASSWORD "wood0908"
|
||
|
||
// 静态成员变量定义
|
||
std::map<long, CHikDevice*> CHikDevice::s_portDeviceMap;
|
||
std::mutex CHikDevice::s_mapMutex;
|
||
|
||
// ============ 静态工厂方法 ============
|
||
|
||
int IHikDevice::CreateObject(IHikDevice** ppDevice)
|
||
{
|
||
if (!ppDevice) {
|
||
return ERR_CODE(DEV_ARG_INVAILD);
|
||
}
|
||
|
||
*ppDevice = new CHikDevice();
|
||
return (*ppDevice != nullptr) ? SUCCESS : ERR_CODE(DATA_ERR_MEM);
|
||
}
|
||
|
||
// ============ 构造函数和析构函数 ============
|
||
|
||
CHikDevice::CHikDevice()
|
||
{
|
||
LOG_INFO("CHikDevice created\n");
|
||
}
|
||
|
||
CHikDevice::~CHikDevice()
|
||
{
|
||
// 停止预览
|
||
StopPreview();
|
||
|
||
// 登出
|
||
Logout();
|
||
|
||
// 清理SDK
|
||
CleanupSDK();
|
||
|
||
LOG_INFO("CHikDevice destroyed\n");
|
||
}
|
||
|
||
// ============ SDK 初始化 ============
|
||
|
||
int CHikDevice::InitSDK()
|
||
{
|
||
if (m_bSDKInitialized) {
|
||
LOG_INFO("CHikDevice::InitSDK - SDK already initialized\n");
|
||
return SUCCESS;
|
||
}
|
||
|
||
LOG_INFO("CHikDevice::InitSDK - Initializing HCNetSDK\n");
|
||
|
||
// 初始化海康SDK
|
||
if (!NET_DVR_Init()) {
|
||
m_lastError = NET_DVR_GetLastError();
|
||
LOG_ERR("NET_DVR_Init failed, error code: %d\n", m_lastError);
|
||
return ERR_CODE(DEV_OPEN_ERR);
|
||
}
|
||
|
||
// 设置连接超时和重连
|
||
NET_DVR_SetConnectTime(2000, 1); // 连接超时2秒
|
||
NET_DVR_SetReconnect(10000, TRUE); // 重连间隔10秒
|
||
|
||
// 设置异常回调
|
||
NET_DVR_SetExceptionCallBack_V30(0, NULL, HikSDKExceptionCallback, this);
|
||
|
||
m_bSDKInitialized = true;
|
||
LOG_INFO("CHikDevice::InitSDK - HCNetSDK initialized successfully\n");
|
||
return SUCCESS;
|
||
}
|
||
|
||
void CHikDevice::CleanupSDK()
|
||
{
|
||
if (!m_bSDKInitialized) {
|
||
return;
|
||
}
|
||
|
||
NET_DVR_Cleanup();
|
||
m_bSDKInitialized = false;
|
||
LOG_INFO("CHikDevice::CleanupSDK - HCNetSDK cleaned up\n");
|
||
}
|
||
|
||
// ============ 登录/登出 ============
|
||
|
||
int CHikDevice::Login(const HikDeviceConfig& config)
|
||
{
|
||
LOG_INFO("CHikDevice::Login - IP: %s, Port: %d\n", config.ip.c_str(), config.port);
|
||
|
||
if (!m_bSDKInitialized) {
|
||
LOG_ERR("CHikDevice::Login - SDK not initialized\n");
|
||
return ERR_CODE(DEV_NO_OPEN);
|
||
}
|
||
|
||
if (m_lUserID >= 0) {
|
||
LOG_WARN("CHikDevice::Login - Already logged in, logout first\n");
|
||
Logout();
|
||
}
|
||
|
||
// 保存配置
|
||
m_config = config;
|
||
|
||
// 如果用户名或密码为空，使用默认值
|
||
std::string username = config.username.empty() ? HIK_DEFAULT_USERNAME : config.username;
|
||
std::string password = config.password.empty() ? HIK_DEFAULT_PASSWORD : config.password;
|
||
|
||
if (config.username.empty() || config.password.empty()) {
|
||
LOG_INFO("CHikDevice::Login - Using default credentials (username: %s)\n", username.c_str());
|
||
}
|
||
|
||
// 登录参数
|
||
NET_DVR_USER_LOGIN_INFO loginInfo = {0};
|
||
NET_DVR_DEVICEINFO_V40 deviceInfo = {0};
|
||
|
||
loginInfo.bUseAsynLogin = FALSE; // 同步登录
|
||
strncpy(loginInfo.sDeviceAddress, config.ip.c_str(), NET_DVR_DEV_ADDRESS_MAX_LEN - 1);
|
||
loginInfo.wPort = static_cast<WORD>(config.port);
|
||
strncpy(loginInfo.sUserName, username.c_str(), NAME_LEN - 1);
|
||
strncpy(loginInfo.sPassword, password.c_str(), NAME_LEN - 1);
|
||
|
||
// 执行登录
|
||
m_lUserID = NET_DVR_Login_V40(&loginInfo, &deviceInfo);
|
||
if (m_lUserID < 0) {
|
||
m_lastError = NET_DVR_GetLastError();
|
||
LOG_ERR("NET_DVR_Login_V40 failed, error code: %d\n", m_lastError);
|
||
UpdateStatus(EHikDeviceStatus::Disconnected);
|
||
if (m_lastError == NET_DVR_ERROR_DEVICE_NOT_ACTIVATED) {
|
||
LOG_INFO("Device already activated\n");
|
||
return ERR_CODE(DEV_UNACTIVATE);
|
||
}
|
||
return ERR_CODE(NET_ERR_CONNECT);
|
||
}
|
||
|
||
UpdateStatus(EHikDeviceStatus::Connected);
|
||
LOG_INFO("CHikDevice::Login - Login successful, UserID: %ld, Channels: %d\n", m_lUserID, deviceInfo.struDeviceV30.byChanNum);
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
void CHikDevice::Logout()
|
||
{
|
||
if (m_lUserID >= 0) {
|
||
// 先停止预览
|
||
StopPreview();
|
||
|
||
NET_DVR_Logout(m_lUserID);
|
||
LOG_INFO("CHikDevice::Logout - Logged out, UserID: %ld\n", m_lUserID);
|
||
m_lUserID = -1;
|
||
}
|
||
|
||
UpdateStatus(EHikDeviceStatus::Disconnected);
|
||
}
|
||
|
||
bool CHikDevice::IsLoggedIn() const
|
||
{
|
||
return m_lUserID >= 0;
|
||
}
|
||
|
||
// ============ 预览控制 ============
|
||
|
||
int CHikDevice::StartPreview()
|
||
{
|
||
LOG_INFO("CHikDevice::StartPreview\n");
|
||
|
||
if (m_lUserID < 0) {
|
||
LOG_ERR("CHikDevice::StartPreview - Not logged in\n");
|
||
return ERR_CODE(DEV_NO_OPEN);
|
||
}
|
||
|
||
if (m_lRealPlayHandle >= 0) {
|
||
LOG_WARN("CHikDevice::StartPreview - Preview already started\n");
|
||
return SUCCESS;
|
||
}
|
||
|
||
// 设置预览参数
|
||
NET_DVR_PREVIEWINFO previewInfo = {0};
|
||
previewInfo.hPlayWnd = NULL; // 不使用窗口显示，通过回调获取数据
|
||
previewInfo.lChannel = m_config.channelNo;
|
||
previewInfo.dwStreamType = m_config.streamType;
|
||
previewInfo.dwLinkMode = 0; // TCP方式
|
||
previewInfo.bBlocked = TRUE;
|
||
|
||
// 开始预览
|
||
m_lRealPlayHandle = NET_DVR_RealPlay_V40(m_lUserID, &previewInfo, HikRealDataCallback, this);
|
||
|
||
if (m_lRealPlayHandle < 0) {
|
||
m_lastError = NET_DVR_GetLastError();
|
||
LOG_ERR("NET_DVR_RealPlay_V40 failed, error code: %d\n", m_lastError);
|
||
return ERR_CODE(DEV_CTRL_ERR);
|
||
}
|
||
|
||
m_bPreviewing = true;
|
||
UpdateStatus(EHikDeviceStatus::Previewing);
|
||
LOG_INFO("CHikDevice::StartPreview - Preview started, Handle: %ld\n", m_lRealPlayHandle);
|
||
return SUCCESS;
|
||
}
|
||
|
||
int CHikDevice::StartPreviewEx(void* hWnd)
|
||
{
|
||
LOG_INFO("CHikDevice::StartPreviewEx - hWnd: %p\n", hWnd);
|
||
|
||
if (m_lUserID < 0) {
|
||
LOG_ERR("CHikDevice::StartPreviewEx - Not logged in\n");
|
||
return ERR_CODE(DEV_NO_OPEN);
|
||
}
|
||
|
||
if (m_lRealPlayHandle >= 0) {
|
||
LOG_WARN("CHikDevice::StartPreviewEx - Preview already started\n");
|
||
return SUCCESS;
|
||
}
|
||
|
||
// 设置预览参数
|
||
NET_DVR_PREVIEWINFO previewInfo = {0};
|
||
#ifdef _WIN32
|
||
previewInfo.hPlayWnd = (HWND)hWnd; // Windows: HWND 是指针类型
|
||
#else
|
||
// Linux: HWND 是 unsigned int (X11 窗口 ID)，需要通过 uintptr_t 转换
|
||
previewInfo.hPlayWnd = static_cast<HWND>(reinterpret_cast<uintptr_t>(hWnd));
|
||
#endif
|
||
previewInfo.lChannel = m_config.channelNo;
|
||
previewInfo.dwStreamType = m_config.streamType;
|
||
previewInfo.dwLinkMode = 0; // TCP方式
|
||
previewInfo.bBlocked = TRUE;
|
||
previewInfo.dwDisplayBufNum = 1; // 最小显示缓冲，降低延迟
|
||
|
||
// 开始预览（不需要回调，SDK直接渲染）
|
||
m_lRealPlayHandle = NET_DVR_RealPlay_V40(m_lUserID, &previewInfo, NULL, NULL);
|
||
|
||
if (m_lRealPlayHandle < 0) {
|
||
m_lastError = NET_DVR_GetLastError();
|
||
LOG_ERR("NET_DVR_RealPlay_V40 failed, error code: %d\n", m_lastError);
|
||
return ERR_CODE(DEV_CTRL_ERR);
|
||
}
|
||
|
||
// 设置预览延迟模式为实时（最低延迟）
|
||
NET_DVR_SetPlayerBufNumber(m_lRealPlayHandle, 1);
|
||
|
||
m_bPreviewing = true;
|
||
UpdateStatus(EHikDeviceStatus::Previewing);
|
||
LOG_INFO("CHikDevice::StartPreviewEx - Preview started with hardware rendering, Handle: %ld\n", m_lRealPlayHandle);
|
||
return SUCCESS;
|
||
}
|
||
|
||
void CHikDevice::StopPreview()
|
||
{
|
||
// 先停止预览
|
||
if (m_lRealPlayHandle >= 0) {
|
||
NET_DVR_StopRealPlay(m_lRealPlayHandle);
|
||
LOG_INFO("CHikDevice::StopPreview - Preview stopped, Handle: %ld\n", m_lRealPlayHandle);
|
||
m_lRealPlayHandle = -1;
|
||
}
|
||
|
||
// 停止 PlayM4 解码
|
||
if (m_lPlayM4Port >= 0) {
|
||
// 先移除端口映射
|
||
{
|
||
std::lock_guard<std::mutex> lock(s_mapMutex);
|
||
s_portDeviceMap.erase(m_lPlayM4Port);
|
||
}
|
||
|
||
if (m_bPlayM4Playing) {
|
||
PlayM4_Stop(m_lPlayM4Port);
|
||
m_bPlayM4Playing = false;
|
||
}
|
||
PlayM4_CloseStream(m_lPlayM4Port);
|
||
PlayM4_FreePort(m_lPlayM4Port);
|
||
m_lPlayM4Port = -1;
|
||
LOG_INFO("CHikDevice::StopPreview - PlayM4 decoder stopped and port freed\n");
|
||
}
|
||
|
||
m_bPreviewing = false;
|
||
|
||
if (m_lUserID >= 0) {
|
||
UpdateStatus(EHikDeviceStatus::Connected);
|
||
} else {
|
||
UpdateStatus(EHikDeviceStatus::Disconnected);
|
||
}
|
||
}
|
||
|
||
bool CHikDevice::IsPreviewing() const
|
||
{
|
||
return m_bPreviewing;
|
||
}
|
||
|
||
// ============ 状态管理 ============
|
||
|
||
EHikDeviceStatus CHikDevice::GetStatus() const
|
||
{
|
||
return m_status;
|
||
}
|
||
|
||
void CHikDevice::UpdateStatus(EHikDeviceStatus status)
|
||
{
|
||
if (m_status != status) {
|
||
m_status = status;
|
||
LOG_INFO("CHikDevice status changed to: %d\n", static_cast<int>(status));
|
||
|
||
if (m_statusCallback) {
|
||
m_statusCallback(status, m_pStatusCallbackUser);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ============ 回调设置 ============
|
||
|
||
void CHikDevice::SetDecodedFrameCallback(HikDecodedFrameCallback callback, void* pUser)
|
||
{
|
||
m_frameCallback = callback;
|
||
m_pFrameCallbackUser = pUser;
|
||
}
|
||
|
||
void CHikDevice::SetStatusCallback(HikDeviceStatusCallback callback, void* pUser)
|
||
{
|
||
m_statusCallback = callback;
|
||
m_pStatusCallbackUser = pUser;
|
||
}
|
||
|
||
void CHikDevice::SetExceptionCallback(HikExceptionCallback callback, void* pUser)
|
||
{
|
||
m_exceptionCallback = callback;
|
||
m_pExceptionCallbackUser = pUser;
|
||
}
|
||
|
||
// ============ 帧数据获取 ============
|
||
|
||
int CHikDevice::GetCurrentFrame(unsigned char* pBuffer, int bufferSize, HikFrameInfo& frameInfo)
|
||
{
|
||
std::lock_guard<std::mutex> lock(m_frameMutex);
|
||
|
||
if (m_currentFrameData.empty()) {
|
||
return ERR_CODE(DEV_RESULT_EMPTY);
|
||
}
|
||
|
||
int dataSize = static_cast<int>(m_currentFrameData.size());
|
||
if (bufferSize < dataSize) {
|
||
return ERR_CODE(DATA_ERR_LEN);
|
||
}
|
||
|
||
memcpy(pBuffer, m_currentFrameData.data(), dataSize);
|
||
frameInfo = m_currentFrameInfo;
|
||
|
||
return dataSize;
|
||
}
|
||
|
||
const HikDeviceConfig& CHikDevice::GetConfig() const
|
||
{
|
||
return m_config;
|
||
}
|
||
|
||
// ============ 抓图 ============
|
||
|
||
int CHikDevice::CaptureToFile(const std::string& filePath, bool isJpeg)
|
||
{
|
||
if (m_lUserID < 0) {
|
||
LOG_ERR("CHikDevice::CaptureToFile - Not logged in\n");
|
||
return ERR_CODE(DEV_NO_OPEN);
|
||
}
|
||
|
||
if (isJpeg) {
|
||
// JPEG抓图
|
||
NET_DVR_JPEGPARA jpegPara = {0};
|
||
jpegPara.wPicSize = 0xFF; // 使用当前分辨率
|
||
jpegPara.wPicQuality = 0; // 最高质量
|
||
|
||
if (!NET_DVR_CaptureJPEGPicture(m_lUserID, m_config.channelNo, &jpegPara, (char*)filePath.c_str())) {
|
||
m_lastError = NET_DVR_GetLastError();
|
||
LOG_ERR("NET_DVR_CaptureJPEGPicture failed, error code: %d\n", m_lastError);
|
||
return ERR_CODE(DEV_CTRL_ERR);
|
||
}
|
||
} else {
|
||
// BMP抓图 (需要预览句柄)
|
||
if (m_lRealPlayHandle < 0) {
|
||
LOG_ERR("CHikDevice::CaptureToFile - Preview not started for BMP capture\n");
|
||
return ERR_CODE(DEV_NO_OPEN);
|
||
}
|
||
|
||
if (!NET_DVR_CapturePicture(m_lRealPlayHandle, (char*)filePath.c_str())) {
|
||
m_lastError = NET_DVR_GetLastError();
|
||
LOG_ERR("NET_DVR_CapturePicture failed, error code: %d\n", m_lastError);
|
||
return ERR_CODE(DEV_CTRL_ERR);
|
||
}
|
||
}
|
||
|
||
LOG_INFO("CHikDevice::CaptureToFile - Captured to: %s\n", filePath.c_str());
|
||
return SUCCESS;
|
||
}
|
||
|
||
// ============ 云台控制 ============
|
||
|
||
int CHikDevice::PTZControl(int command, bool stop, int speed)
|
||
{
|
||
if (m_lRealPlayHandle < 0) {
|
||
LOG_ERR("CHikDevice::PTZControl - Preview not started\n");
|
||
return ERR_CODE(DEV_NO_OPEN);
|
||
}
|
||
|
||
DWORD dwStop = stop ? 1 : 0;
|
||
|
||
if (!NET_DVR_PTZControlWithSpeed(m_lRealPlayHandle, command, dwStop, speed)) {
|
||
m_lastError = NET_DVR_GetLastError();
|
||
LOG_ERR("NET_DVR_PTZControlWithSpeed failed, error code: %d\n", m_lastError);
|
||
return ERR_CODE(DEV_CTRL_ERR);
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
// ============ OSD配置 ============
|
||
|
||
int CHikDevice::ConfigureOSD(bool showChanName, bool showOsd)
|
||
{
|
||
LOG_INFO("CHikDevice::ConfigureOSD - showChanName: %d, showOsd: %d\n", showChanName, showOsd);
|
||
|
||
if (m_lUserID < 0) {
|
||
LOG_ERR("CHikDevice::ConfigureOSD - Not logged in\n");
|
||
return ERR_CODE(DEV_NO_OPEN);
|
||
}
|
||
|
||
// 获取当前图像参数
|
||
DWORD uiReturnLen = 0;
|
||
NET_DVR_PICCFG_V30 struPicCfg = {0};
|
||
struPicCfg.dwSize = sizeof(NET_DVR_PICCFG_V30);
|
||
|
||
if (!NET_DVR_GetDVRConfig(m_lUserID, NET_DVR_GET_PICCFG_V30, m_config.channelNo,
|
||
&struPicCfg, sizeof(NET_DVR_PICCFG_V30), &uiReturnLen)) {
|
||
m_lastError = NET_DVR_GetLastError();
|
||
LOG_ERR("NET_DVR_GetDVRConfig(PICCFG_V30) failed, error: %d\n", m_lastError);
|
||
return ERR_CODE(DEV_CTRL_ERR);
|
||
}
|
||
|
||
// 修改OSD设置
|
||
struPicCfg.dwShowChanName = showChanName ? 1 : 0; // 通道名称
|
||
struPicCfg.dwShowOsd = showOsd ? 1 : 0; // OSD时间
|
||
|
||
// 设置图像参数
|
||
if (!NET_DVR_SetDVRConfig(m_lUserID, NET_DVR_SET_PICCFG_V30, m_config.channelNo,
|
||
&struPicCfg, sizeof(NET_DVR_PICCFG_V30))) {
|
||
m_lastError = NET_DVR_GetLastError();
|
||
LOG_ERR("NET_DVR_SetDVRConfig(PICCFG_V30) failed, error: %d\n", m_lastError);
|
||
return ERR_CODE(DEV_CTRL_ERR);
|
||
}
|
||
|
||
LOG_INFO("CHikDevice::ConfigureOSD - OSD configured successfully\n");
|
||
return SUCCESS;
|
||
}
|
||
|
||
// ============ 静态回调函数实现 ============
|
||
|
||
void CALLBACK CHikDevice::HikRealDataCallback(LONG lRealHandle, DWORD dwDataType,
|
||
BYTE* pBuffer, DWORD dwBufSize, void* pUser)
|
||
{
|
||
CHikDevice* pDevice = static_cast<CHikDevice*>(pUser);
|
||
if (!pDevice) return;
|
||
|
||
switch (dwDataType) {
|
||
case NET_DVR_SYSHEAD:
|
||
{
|
||
// 系统头数据 - 初始化 PlayM4 解码器
|
||
LOG_DEBUG("CHikDevice received system header, size: %lu\n", dwBufSize);
|
||
|
||
// 获取 PlayM4 端口
|
||
if (pDevice->m_lPlayM4Port < 0) {
|
||
if (!PlayM4_GetPort(&pDevice->m_lPlayM4Port)) {
|
||
LOG_ERR("PlayM4_GetPort failed, error: %lu\n", PlayM4_GetLastError(pDevice->m_lPlayM4Port));
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 设置流播放模式
|
||
if (!PlayM4_SetStreamOpenMode(pDevice->m_lPlayM4Port, STREAME_REALTIME)) {
|
||
LOG_ERR("PlayM4_SetStreamOpenMode failed, error: %lu\n", PlayM4_GetLastError(pDevice->m_lPlayM4Port));
|
||
return;
|
||
}
|
||
|
||
// 打开流（减小缓冲区到350KB以降低延迟）
|
||
if (!PlayM4_OpenStream(pDevice->m_lPlayM4Port, pBuffer, dwBufSize, 350 * 1024)) {
|
||
LOG_ERR("PlayM4_OpenStream failed, error: %lu\n", PlayM4_GetLastError(pDevice->m_lPlayM4Port));
|
||
return;
|
||
}
|
||
|
||
// 设置解码输出为 RGB32 格式（避免手动YUV转换）
|
||
if (!PlayM4_SetDecCBStream(pDevice->m_lPlayM4Port, T_RGB32)) {
|
||
LOG_WARN("PlayM4_SetDecCBStream(T_RGB32) failed, will use YV12 conversion\n");
|
||
}
|
||
|
||
// 注册端口到实例的映射（解决64位系统指针截断问题）
|
||
{
|
||
std::lock_guard<std::mutex> lock(s_mapMutex);
|
||
s_portDeviceMap[pDevice->m_lPlayM4Port] = pDevice;
|
||
}
|
||
|
||
// 设置解码回调（通过端口号映射查找实例，nUser 参数不使用）
|
||
#ifdef _WIN32
|
||
if (!PlayM4_SetDecCallBackMend(pDevice->m_lPlayM4Port, PlayM4DecodeCallback,
|
||
pDevice->m_lPlayM4Port)) {
|
||
#else
|
||
if (!PlayM4_SetDecCallBackMend(pDevice->m_lPlayM4Port, PlayM4DecodeCallback,
|
||
nullptr)) {
|
||
#endif
|
||
LOG_ERR("PlayM4_SetDecCallBackMend failed, error: %lu\n", PlayM4_GetLastError(pDevice->m_lPlayM4Port));
|
||
// 移除映射
|
||
{
|
||
std::lock_guard<std::mutex> lock(s_mapMutex);
|
||
s_portDeviceMap.erase(pDevice->m_lPlayM4Port);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 开始播放（不需要窗口句柄，仅解码）
|
||
if (!PlayM4_Play(pDevice->m_lPlayM4Port, NULL)) {
|
||
LOG_ERR("PlayM4_Play failed, error: %lu\n", PlayM4_GetLastError(pDevice->m_lPlayM4Port));
|
||
// 移除映射
|
||
{
|
||
std::lock_guard<std::mutex> lock(s_mapMutex);
|
||
s_portDeviceMap.erase(pDevice->m_lPlayM4Port);
|
||
}
|
||
return;
|
||
}
|
||
|
||
pDevice->m_bPlayM4Playing = true;
|
||
LOG_INFO("CHikDevice PlayM4 decoder initialized and started, port: %ld\n", pDevice->m_lPlayM4Port);
|
||
break;
|
||
}
|
||
|
||
case NET_DVR_STREAMDATA:
|
||
{
|
||
// 流数据 - 输入到 PlayM4 解码器
|
||
if (pDevice->m_lPlayM4Port >= 0 && pDevice->m_bPlayM4Playing) {
|
||
if (!PlayM4_InputData(pDevice->m_lPlayM4Port, pBuffer, dwBufSize)) {
|
||
// 缓冲区满时可能会失败，这是正常的
|
||
DWORD dwError = PlayM4_GetLastError(pDevice->m_lPlayM4Port);
|
||
if (dwError != PLAYM4_BUF_OVER) {
|
||
LOG_WARN("PlayM4_InputData failed, error: %lu\n", dwError);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
#ifdef _WIN32
|
||
void CALLBACK CHikDevice::PlayM4DecodeCallback(long nPort, char* pBuf, long nSize,
|
||
FRAME_INFO* pFrameInfo, long nUser, long nReserved2)
|
||
#else
|
||
void CALLBACK CHikDevice::PlayM4DecodeCallback(int nPort, char* pBuf, int nSize,
|
||
FRAME_INFO* pFrameInfo, void* nUser, int nReserved2)
|
||
#endif
|
||
{
|
||
(void)nUser; // 未使用，通过端口号查找实例
|
||
(void)nReserved2; // 未使用
|
||
|
||
if (!pBuf || !pFrameInfo) {
|
||
return;
|
||
}
|
||
|
||
// 通过端口号查找实例
|
||
CHikDevice* pDevice = nullptr;
|
||
{
|
||
std::lock_guard<std::mutex> lock(s_mapMutex);
|
||
auto it = s_portDeviceMap.find(nPort);
|
||
if (it != s_portDeviceMap.end()) {
|
||
pDevice = it->second;
|
||
}
|
||
}
|
||
|
||
if (!pDevice) {
|
||
return;
|
||
}
|
||
|
||
// 只处理视频帧（YV12 或 RGB32 格式）
|
||
if (pFrameInfo->nType == T_YV12 || pFrameInfo->nType == T_RGB32) {
|
||
pDevice->ProcessDecodedFrame(pBuf, nSize, pFrameInfo);
|
||
}
|
||
}
|
||
|
||
void CALLBACK CHikDevice::HikSDKExceptionCallback(DWORD dwType, LONG lUserID, LONG lHandle, void* pUser)
|
||
{
|
||
CHikDevice* pDevice = static_cast<CHikDevice*>(pUser);
|
||
if (!pDevice) {
|
||
return;
|
||
}
|
||
|
||
pDevice->HandleException(dwType);
|
||
}
|
||
|
||
// ============ 内部方法实现 ============
|
||
|
||
void CHikDevice::ProcessDecodedFrame(char* pBuf, long nSize, FRAME_INFO* pFrameInfo)
|
||
{
|
||
if (!pBuf || !pFrameInfo) {
|
||
return;
|
||
}
|
||
|
||
int width = pFrameInfo->nWidth;
|
||
int height = pFrameInfo->nHeight;
|
||
int rgbSize = width * height * 4; // RGB32
|
||
|
||
// 更新当前帧数据
|
||
{
|
||
std::lock_guard<std::mutex> lock(m_frameMutex);
|
||
|
||
// 确保缓冲区大小足够
|
||
if (m_currentFrameData.size() != static_cast<size_t>(rgbSize)) {
|
||
m_currentFrameData.resize(rgbSize);
|
||
}
|
||
|
||
// 根据帧类型处理
|
||
if (pFrameInfo->nType == T_RGB32) {
|
||
// 直接使用 RGB32 数据（PlayM4 已转换）
|
||
memcpy(m_currentFrameData.data(), pBuf, rgbSize);
|
||
} else if (pFrameInfo->nType == T_YV12) {
|
||
// YV12 格式需要手动转换
|
||
unsigned char* yPlane = reinterpret_cast<unsigned char*>(pBuf);
|
||
unsigned char* vPlane = yPlane + width * height;
|
||
unsigned char* uPlane = vPlane + (width / 2) * (height / 2);
|
||
ConvertYV12ToRGB32(yPlane, uPlane, vPlane, m_currentFrameData.data(), width, height);
|
||
} else {
|
||
LOG_WARN("Unsupported frame type: %d\n", pFrameInfo->nType);
|
||
return;
|
||
}
|
||
|
||
// 更新帧信息
|
||
m_currentFrameInfo.width = width;
|
||
m_currentFrameInfo.height = height;
|
||
m_currentFrameInfo.frameType = pFrameInfo->nType;
|
||
m_currentFrameInfo.timestamp = pFrameInfo->nStamp;
|
||
}
|
||
|
||
// 调用帧回调
|
||
if (m_frameCallback) {
|
||
m_frameCallback(m_currentFrameData.data(), rgbSize, m_currentFrameInfo, m_pFrameCallbackUser);
|
||
}
|
||
}
|
||
|
||
void CHikDevice::HandleException(DWORD dwType)
|
||
{
|
||
EHikExceptionType exType = EHikExceptionType::None;
|
||
|
||
switch (dwType) {
|
||
case EXCEPTION_RECONNECT:
|
||
LOG_INFO("CHikDevice reconnecting (preview)...\n");
|
||
exType = EHikExceptionType::Reconnect;
|
||
UpdateStatus(EHikDeviceStatus::Reconnecting);
|
||
break;
|
||
|
||
case EXCEPTION_PREVIEW:
|
||
LOG_WARN("CHikDevice preview exception\n");
|
||
exType = EHikExceptionType::PreviewException;
|
||
m_bPreviewing = false;
|
||
UpdateStatus(EHikDeviceStatus::Error);
|
||
break;
|
||
|
||
case EXCEPTION_SERIAL:
|
||
LOG_WARN("CHikDevice serial exception\n");
|
||
exType = EHikExceptionType::SerialException;
|
||
break;
|
||
|
||
case EXCEPTION_ALARMRECONNECT:
|
||
LOG_INFO("CHikDevice alarm reconnecting...\n");
|
||
exType = EHikExceptionType::AlarmReconnect;
|
||
break;
|
||
|
||
case EXCEPTION_EXCHANGE:
|
||
LOG_WARN("CHikDevice exchange exception\n");
|
||
exType = EHikExceptionType::ExchangeException;
|
||
break;
|
||
|
||
default:
|
||
LOG_DEBUG("CHikDevice unknown exception: %lu\n", dwType);
|
||
break;
|
||
}
|
||
|
||
// 调用异常回调
|
||
if (m_exceptionCallback && exType != EHikExceptionType::None) {
|
||
m_exceptionCallback(exType, m_pExceptionCallbackUser);
|
||
}
|
||
}
|
||
|
||
void CHikDevice::ConvertYV12ToRGB32(const unsigned char* yPlane, const unsigned char* uPlane,
|
||
const unsigned char* vPlane, unsigned char* rgbData,
|
||
int width, int height)
|
||
{
|
||
for (int y = 0; y < height; y++) {
|
||
for (int x = 0; x < width; x++) {
|
||
int yIndex = y * width + x;
|
||
int uvIndex = (y / 2) * (width / 2) + (x / 2);
|
||
|
||
int Y = yPlane[yIndex];
|
||
int U = uPlane[uvIndex] - 128;
|
||
int V = vPlane[uvIndex] - 128;
|
||
|
||
// YUV to RGB 转换公式
|
||
int R = static_cast<int>(Y + 1.402 * V);
|
||
int G = static_cast<int>(Y - 0.344 * U - 0.714 * V);
|
||
int B = static_cast<int>(Y + 1.772 * U);
|
||
|
||
// 限制范围
|
||
R = (std::max)(0, (std::min)(255, R));
|
||
G = (std::max)(0, (std::min)(255, G));
|
||
B = (std::max)(0, (std::min)(255, B));
|
||
|
||
// RGB32 格式: B G R A
|
||
int rgbIndex = yIndex * 4;
|
||
rgbData[rgbIndex + 0] = static_cast<unsigned char>(B);
|
||
rgbData[rgbIndex + 1] = static_cast<unsigned char>(G);
|
||
rgbData[rgbIndex + 2] = static_cast<unsigned char>(R);
|
||
rgbData[rgbIndex + 3] = 255; // Alpha
|
||
}
|
||
}
|
||
}
|