package com.ard.work.sdk.hb.service;
|
|
import com.ard.common.core.constant.CacheConstants;
|
import com.ard.common.core.exception.ServiceException;
|
import com.ard.common.redis.service.RedisService;
|
import com.ard.work.api.domian.*;
|
import com.ard.work.device.camera.domain.PtzParamDTO;
|
import com.ard.work.event.LoginEvent;
|
import com.ard.work.sdk.common.osSelect;
|
import com.ard.work.sdk.hb.cache.CameraRealHandleCache;
|
import com.ard.work.sdk.hb.cache.HbDeviceInfoCache;
|
import com.ard.work.sdk.hb.cache.HbRealCallbackCache;
|
import com.ard.work.sdk.hb.cache.HbStreamStatsCache;
|
import com.ard.work.sdk.hb.lib.HBNetSDK;
|
import com.ard.work.sdk.hb.lib.HbSdkErrorCodeEnum;
|
import com.ard.work.sdk.model.DeviceCFG;
|
import com.ard.work.sdk.model.PtzScope;
|
import com.ard.work.sdk.service.CameraSDK;
|
import com.ard.work.utils.ArdTool;
|
import com.sun.jna.Native;
|
import jakarta.annotation.Resource;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.context.ApplicationEventPublisher;
|
import org.springframework.stereotype.Service;
|
import java.io.File;
|
import java.io.IOException;
|
import java.io.OutputStream;
|
import java.nio.charset.Charset;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* 类描述：汉邦SDK
|
*
|
* @author lsy
|
* @since 2026/3/11 7:55
|
*/
|
@Service("hbSDK")
|
@Slf4j
|
public class HbSDK implements CameraSDK {
|
private static HBNetSDK hbNetSDK = null;
|
@Resource
|
private RedisService redisService;
|
@Resource
|
private ApplicationEventPublisher eventPublisher;
|
|
static {
|
// initSdk();
|
}
|
|
public static void initSdk() {
|
if (hbNetSDK == null) {
|
if (!CreateSDKInstance()) {
|
System.out.println("Load SDK fail");
|
return;
|
}
|
}
|
// 初始化
|
if (!hbNetSDK.HB_NET_Init()) {
|
log.warn("汉邦SDK初始化失败，错误码:{} 原因:{}", hbNetSDK.HB_NET_GetLastError(),
|
HbSdkErrorCodeEnum.getDescByCode(hbNetSDK.HB_NET_GetLastError()));
|
return;
|
}
|
hbNetSDK.HB_NET_SetLogLevel(-1);
|
log.info("初始化汉邦SDK完成");
|
}
|
|
@Override
|
public void login(ArdCamera camera) {
|
try {
|
String ip = camera.getIp();
|
String username = camera.getUsername();
|
String password = camera.getPassword();
|
short port = camera.getPort().shortValue();
|
log.info("登录设备 IP: {}, Port: {}, User: {}, Password: {}", ip, port, username, password);
|
HBNetSDK.HB_NET_DEVICEINFO deviceInfo = new HBNetSDK.HB_NET_DEVICEINFO();
|
long userId = hbNetSDK.HB_NET_Login(ip, port, username, password, deviceInfo);
|
if (userId == 0) {
|
handleLoginFail(camera, userId);
|
} else {
|
handleLoginSuccess(camera, userId, deviceInfo);
|
}
|
// 发布登录事件
|
eventPublisher.publishEvent(new LoginEvent(camera));
|
} catch (Exception e) {
|
camera.setLoginId(-1L);
|
log.error("登录失败: {}", e.getMessage());
|
}
|
}
|
|
/**
|
* 登录失败处理
|
*/
|
private void handleLoginFail(ArdCamera camera, Long loginId) {
|
camera.setChanNum(0);
|
camera.setLoginId(loginId);
|
camera.setState("0");
|
int error = hbNetSDK.HB_NET_GetLastError();
|
log.warn("设备[{}:{}]登录失败，错误码:{} 原因:{}", camera.getIp(), camera.getPort(), error,
|
HbSdkErrorCodeEnum.getDescByCode(error));
|
}
|
|
/**
|
* 登录成功处理
|
*/
|
private void handleLoginSuccess(ArdCamera camera, Long loginId, HBNetSDK.HB_NET_DEVICEINFO deviceInfo) {
|
deviceInfo.read();
|
// 更新设备信息
|
camera.setLoginId(loginId);
|
camera.setState("1");
|
int chanNum = Byte.toUnsignedInt(deviceInfo.byChanNum);
|
camera.setChanNum(chanNum);
|
//log.info("设备名称: {}", ArdTool.parseBytesToString(deviceInfo.sDvrName, Charset.forName("GBK")));
|
HbDeviceInfoCache.put(camera.getId(), deviceInfo);
|
// 获取最新通道
|
List<ArdChannel> channels = getChannels(camera);
|
if (!channels.isEmpty()) {
|
camera.setChannelList(channels);
|
}
|
startRealPlay(camera);
|
// 登录成功
|
log.info("设备登录成功 [{}:{}]", camera.getIp(), camera.getPort());
|
}
|
|
private long startRealPlay(ArdCamera camera) {
|
String cameraId = camera.getId();
|
int chanNo = 1;
|
Long lUserID = camera.getLoginId(); // 已保证登录成功
|
log.warn("开始预览，登录句柄：{}", lUserID);
|
// 1. 初始化队列和运行状态
|
CameraStreamQueueManager.destroyCameraQueue(cameraId);
|
HbStreamStatsCache.initRunningStatus(cameraId); // 初始化运行状态为true
|
CameraStreamQueueManager.createCameraQueue(cameraId);
|
// 启动推流线程
|
String RTSP_URL = "rtsp://192.168.1.2:8554/" + cameraId + "_" + chanNo;
|
startPushThread(cameraId, RTSP_URL);
|
// ===================== 核心：使用回调缓存 =====================
|
// 2.1 从缓存获取回调实例（无则创建）
|
StreamCallBack streamCallback = HbRealCallbackCache.get(cameraId);
|
if (streamCallback == null) {
|
// 缓存中无实例，创建新的并存入缓存
|
streamCallback = new StreamCallBack(cameraId);
|
HbRealCallbackCache.put(cameraId, streamCallback);
|
log.info("相机[{}]创建新的流回调实例并缓存", cameraId);
|
} else {
|
log.info("相机[{}]复用已缓存的流回调实例", cameraId);
|
}
|
// 客户端信息
|
HBNetSDK.HB_NET_CLIENTINFO clientInfo = new HBNetSDK.HB_NET_CLIENTINFO();
|
clientInfo.dwSize = clientInfo.size();
|
clientInfo.lChannel = 0;
|
clientInfo.lStreamType = 0;
|
clientInfo.lLinkMode = 0;
|
clientInfo.pfnCallback = streamCallback;
|
clientInfo.dwRes = new int[2];
|
clientInfo.write();
|
|
// 启动预览
|
long handle = hbNetSDK.HB_NET_RealPlay(lUserID, clientInfo);
|
if (handle < 0) {
|
log.error("预览启动失败, 错误码: {}", hbNetSDK.HB_NET_GetLastError());
|
return -1;
|
}
|
|
hbNetSDK.HB_NET_MakeKeyFrame(lUserID, 0, 0);
|
|
log.info("预览启动成功，句柄: {}", handle);
|
return handle;
|
}
|
|
private void startPushThread(String cameraId, String RTSP_URL) {
|
Thread pushThread = new Thread(() -> {
|
|
log.info("推流线程启动，目标地址: {}", RTSP_URL);
|
|
boolean hasKeyFrame = false;
|
|
Process ffmpegProcess = null;
|
OutputStream ffmpegInput = null;
|
|
boolean isRunning = HbStreamStatsCache.getRunningStatus(cameraId);
|
while (isRunning) {
|
try {
|
ProcessBuilder pb = new ProcessBuilder(
|
"ffmpeg",
|
"-loglevel", "error", // 错误日志级别
|
"-re", // 实时推流
|
"-i", "pipe:0", // 从标准输入读取
|
"-c:v", "copy", // 视频编码拷贝
|
"-an", // 无音频
|
"-f", "rtsp", // 输出格式RTSP
|
"-rtsp_transport", "tcp", // TCP传输
|
"-timeout", "5000000", // 5秒超时
|
"-buffer_size", "1024000", // 缓冲区大小
|
"-max_delay", "500000", // 最大延迟
|
RTSP_URL
|
);
|
|
pb.redirectErrorStream(true);
|
ffmpegProcess = pb.start();
|
ffmpegInput = ffmpegProcess.getOutputStream();
|
log.info("FFmpeg进程启动成功");
|
|
while (HbStreamStatsCache.getRunningStatus(cameraId)) {
|
if (!isProcessAlive(ffmpegProcess)) {
|
log.error("FFmpeg进程已退出，准备重启");
|
break;
|
}
|
|
byte[] data = CameraStreamQueueManager.pollDataFromQueue(cameraId);
|
if (data == null) {
|
continue;
|
}
|
|
// 等待关键帧
|
if (!hasKeyFrame && data.length >= 5) {
|
int nalType = data[4] & 0x1F;
|
if (nalType == 5) {
|
hasKeyFrame = true;
|
}
|
}
|
if (!hasKeyFrame) {
|
continue;
|
}
|
|
// 原样推流，不控制、不丢帧、不花屏
|
try {
|
ffmpegInput.write(data);
|
ffmpegInput.flush();
|
} catch (IOException e) {
|
log.error("写入FFmpeg失败: {}", e.getMessage());
|
break;
|
}
|
}
|
|
} catch (Exception e) {
|
log.error("推流异常", e);
|
} finally {
|
try {
|
if (ffmpegInput != null) ffmpegInput.close();
|
} catch (Exception ignored) {
|
}
|
try {
|
if (ffmpegProcess != null) ffmpegProcess.destroy();
|
} catch (Exception ignored) {
|
}
|
|
isRunning = HbStreamStatsCache.getRunningStatus(cameraId);
|
if (isRunning) {
|
log.warn("相机[{}]推流中断，5秒后重启...", cameraId);
|
try {
|
Thread.sleep(5000);
|
} catch (InterruptedException ignored) {
|
}
|
}
|
}
|
}
|
log.info("推流线程结束");
|
}, "PushThread");
|
|
pushThread.setDaemon(true);
|
pushThread.start();
|
}
|
|
/**
|
* 检查进程是否存活
|
*/
|
private boolean isProcessAlive(Process process) {
|
if (process == null) return false;
|
try {
|
process.exitValue();
|
return false;
|
} catch (IllegalThreadStateException e) {
|
return true;
|
}
|
}
|
|
@Override
|
public void logout(String cameraId) {
|
try {
|
// 1. 停止推流线程（让while循环退出）
|
HbStreamStatsCache.stopRunning(cameraId);
|
|
// 2. 移除状态缓存
|
HbStreamStatsCache.removeRunningStatus(cameraId);
|
|
// 3. 停止SDK预览
|
Long lRealHandle = CameraRealHandleCache.get(cameraId);
|
if (lRealHandle != null) {
|
hbNetSDK.HB_NET_StopRealPlay(lRealHandle);
|
CameraRealHandleCache.remove(cameraId);
|
log.info("【{}】停止预览成功", cameraId);
|
}
|
|
// 4. 登出设备
|
Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cameraId);
|
if (loginId != null) {
|
hbNetSDK.HB_NET_Logout(loginId);
|
redisService.deleteCacheMapValue(CacheConstants.CAMERA_ONLINE, cameraId);
|
log.info("【{}】设备登出成功", cameraId);
|
}
|
|
// 5. 销毁队列
|
CameraStreamQueueManager.destroyCameraQueue(cameraId);
|
|
log.info("【{}】注销完成 → 推流已停止", cameraId);
|
} catch (Exception e) {
|
log.error("【{}】注销异常", cameraId, e);
|
}
|
}
|
|
@Override
|
public Boolean isOnLine(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean pTZControl(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean setFocusPos(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Integer getFocusPos(CameraCmd cmd) {
|
return 0;
|
}
|
|
@Override
|
public Boolean setPreset(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean gotoPreset(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public VideoCompressionCfg getVideoCompressionCfg(CameraCmd cmd) {
|
return null;
|
}
|
|
@Override
|
public Boolean controlDefog(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean isEnableDefog(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean controlInfrared(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean isEnableInfrared(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean controlFocusMode(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean getFocusMode(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean controlPTHeater(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean controlCameraDeicing(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean getPTZLockInfo(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean setPTZLockInfo(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public byte[] localCapture(CameraCmd cmd) {
|
return new byte[0];
|
}
|
|
@Override
|
public String picCutCate(CameraCmd cmd) {
|
return "";
|
}
|
|
@Override
|
public String picCutCate(CameraCmd cmd, String bucketName, String objectName) {
|
return "";
|
}
|
|
@Override
|
public PtzDto getPtz(CameraCmd cmd) {
|
return null;
|
}
|
|
|
@Override
|
public PtzScope getPtzScope(CameraCmd cmd) {
|
return null;
|
}
|
|
@Override
|
public Boolean setPtz(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean setZeroPtz(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public String record(CameraCmd cmd) {
|
return "";
|
}
|
|
@Override
|
public Boolean guideTargetPosition(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public Boolean recordStart(CameraCmd cmd) {
|
return true;
|
}
|
|
@Override
|
public String recordStop(CameraCmd cmd) {
|
return "";
|
}
|
|
@Override
|
public PtzParamDTO getGisInfo(CameraCmd cmd) {
|
return null;
|
}
|
|
@Override
|
public Double correctPitch(CameraCmd cmd) {
|
return 0.0;
|
}
|
|
@Override
|
public List<ArdChannel> getChannels(ArdCamera camera) {
|
//获取通道
|
List<ArdChannel> channelList = new ArrayList<>();
|
try {
|
HBNetSDK.HB_NET_DEVICEINFO deviceInfo = HbDeviceInfoCache.get(camera.getId());
|
if (deviceInfo == null) {
|
log.warn("汉邦设备信息为空，无法获取通道");
|
return channelList;
|
}
|
int chanNum = Byte.toUnsignedInt(deviceInfo.byChanNum); // 实际通道数
|
log.info("通道数量: {}", chanNum);
|
String allChanNames = ArdTool.parseBytesToString(deviceInfo.sChanName, Charset.forName("GBK"));
|
String[] chanNames = new String[chanNum];
|
// 按每个通道名称长度拆分（HB_NAME_LEN）
|
for (int i = 0; i < chanNum; i++) {
|
int start = i * 32;
|
int end = Math.min(start + 32, allChanNames.length());
|
chanNames[i] = allChanNames.substring(start, end).trim();
|
log.info("通道号: {}", i);
|
log.info("通道名称: {}", chanNames[i]);
|
ArdChannel ardChannel = new ArdChannel();
|
ardChannel.setName(chanNames[i]);
|
ardChannel.setChanNo(i + 1);
|
ardChannel.setDeviceId(camera.getId());
|
channelList.add(ardChannel);
|
}
|
} catch (Exception ex) {
|
log.error("获取IP通道异常:{}", ex.getMessage(), ex);
|
}
|
return channelList;
|
}
|
|
@Override
|
public Boolean set3DPosition(CameraCmd cmd) {
|
return null;
|
}
|
|
@Override
|
public DeviceCFG getSystemInfo(CameraCmd cmd) {
|
return null;
|
}
|
|
/**
|
* 动态库加载
|
*/
|
private static boolean CreateSDKInstance() {
|
if (hbNetSDK == null) {
|
synchronized (HBNetSDK.class) {
|
String strDllPath = "";
|
try {
|
String userDir = System.getProperty("user.dir");
|
if (osSelect.isWindows()) {
|
strDllPath = userDir + "\\lib\\hb\\win64\\libnetsdk.dll";
|
} else if (osSelect.isLinux()) {
|
if (osSelect.isArm64()) {
|
strDllPath = userDir + "/lib/hb/linux-arm64/libnetsdk.so";
|
} else if (osSelect.isX64()) {
|
strDllPath = userDir + "/lib/hb/linux64/libnetsdk.so";
|
} else {
|
throw new UnsupportedOperationException("❌ 不支持的 Linux 架构: " + osSelect.getArch());
|
}
|
} else {
|
throw new UnsupportedOperationException("❌ 不支持的操作系统: " + osSelect.getOsName());
|
}
|
|
// 校验文件是否存在
|
File sdkFile = new File(strDllPath);
|
if (!sdkFile.exists()) {
|
System.err.println("❌ SDK 动态库不存在: " + strDllPath);
|
return false;
|
}
|
|
System.out.println("✅ 尝试加载动态库: " + strDllPath);
|
hbNetSDK = Native.loadLibrary(strDllPath, HBNetSDK.class);
|
System.out.println("✅ SDK 加载成功！");
|
} catch (Exception ex) {
|
System.err.println("❌ SDK 加载失败: " + strDllPath + "\n异常信息: " + ex.getMessage());
|
ex.printStackTrace();
|
return false;
|
}
|
}
|
}
|
return true;
|
}
|
@Override
|
public List<Map<String, Object>> getCameraVideoLable(Long userId, CameraCmd cmd)throws ServiceException {
|
return null;
|
}
|
}
|
