Spring Boot集成海康威视NVR

最新推荐文章于 2024-07-24 20:57:33 发布
最新推荐文章于 2024-07-24 20:57:33 发布
阅读量1w 收藏 57
点赞数 7
分类专栏： Spring Boot 文章标签： spring boot 音视频 NVR
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36090013/article/details/121125003
版权

文章目录

一、海康威视NVR SDK下载

SDK下载地址
根据你的设备或者运行环境选择相应的版本（文章用的是win64版）

在这里插入图片描述

二、引入海康SDK

1.将海康提供的jar包导入到本地Maven库

【传送门】导入步骤
百度网盘Maven导入JAR
提取码：q4w3
Maven导入方式

<!-- 海康JNA jar包 -->
<dependency>
    <groupId>com.sun.jna</groupId>
    <artifactId>jna</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
<!-- 海康examples jar包 -->
<dependency>
    <groupId>com.sun.jna.examples</groupId>
    <artifactId>examples</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

在这里插入图片描述

2.将SDK放在项目中

在这里插入图片描述
将DLL文件库放到静态资源目录下，一面打JAR包时找不到文件库

3.配置文件读取

获取静态资源文件夹路径

public class CommonKit {
    /**
     * 获取DLL文件路径
     * @return
     */
    public static String getWebPath(){
        String path = CommonKit.class.getClassLoader().getResource("").getPath().substring(1);
        return path+"dll\\";
    }
}

修改SDK中DLL库读取

public interface HCNetSDK extends StdCallLibrary {
    /*加载海康DLL*/
    HCNetSDK INSTANCE = (HCNetSDK) Native.loadLibrary(CommonKit.getWebPath()+"HCNetSDK.dll", HCNetSDK.class);
}

同理PlayCtrl也一样

public interface PlayCtrl extends StdCallLibrary {
    /*加载播放DLL*/
    PlayCtrl INSTANCE = (PlayCtrl) Native.loadLibrary(CommonKit.getWebPath()+"PlayCtrl.dll", PlayCtrl.class);
}

三、写常用的接口

3.1根据时间获取文件

Controller：

package com.hikvision.nvr.controller;

import com.hikvision.nvr.common.AjaxResult;
import com.hikvision.nvr.domain.RequestVo;
import com.hikvision.nvr.service.FindVideoFileService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Map;


@RestController
@RequestMapping(value = "/nvr")
@Api(value = "调用NVR接口", description = "调用NVR接口", tags = {"调用NVR接口"})
public class NvrControcller {

    @Autowired
    private FindVideoFileService downloadVideoService;

    @RequestMapping(value = "/playback")
    @ApiOperation(value = "根据时间获取文件", httpMethod = "POST", notes = "根据时间获取文件")
    public AjaxResult playback(@RequestBody RequestVo requestVo) throws InterruptedException {
        return AjaxResult.success(downloadVideoService.playback(requestVo));
    }

    @RequestMapping(value = "/downloadByFileNmae")
    @ApiOperation(value = "根据文件名下载", httpMethod = "POST", notes = "根据文件名下载")
    public AjaxResult downloadByFileNmae(@RequestParam String fileName, @RequestBody RequestVo requestVo) {
        return AjaxResult.success(downloadVideoService.downloadByFileNmae(fileName, requestVo));
    }

    @RequestMapping(value = "/downloadByFileTime")
    @ApiOperation(value = "根据时间下载", httpMethod = "POST", notes = "根据时间下载")
    public AjaxResult downloadByFileTime(@RequestBody RequestVo requestVo) {
        return AjaxResult.success(downloadVideoService.downloadByFileTime(requestVo));
    }

    @RequestMapping(value = "/getDeviceInformation")
    @ApiOperation(value = "获取设备信息", httpMethod = "POST", notes = "获取设备信息")
    public AjaxResult getDeviceInformation(@RequestBody RequestVo requestVo)  {
        return AjaxResult.success(downloadVideoService.getDeviceInformation(requestVo));
    }

    @RequestMapping(value = "/getBackUrl")
    @ApiOperation(value = "获取回放视频流", httpMethod = "POST", notes = "获取回放视频流")
    public AjaxResult getBackUrl(@RequestBody RequestVo requestVo) {
        requestVo.getPlayBack().setUrlType(1);
        Map map = downloadVideoService.getBackUrl(requestVo);
        String value = (String) map.get("msg");
        if (value.startsWith("rtsp:")) {
            return AjaxResult.success(map);
        }
        return AjaxResult.error();
    }

    @RequestMapping(value = "/getLiveUrl")
    @ApiOperation(value = "获取实时视频流", httpMethod = "POST", notes = "获取实时视频流")
    public AjaxResult getLiveUrl(@RequestBody RequestVo requestVo){
        requestVo.getPlayBack().setUrlType(0);
        Map map = downloadVideoService.getBackUrl(requestVo);
        String value = (String) map.get("msg");
        if (value.startsWith("rtsp:")) {
            return AjaxResult.success(map);
        }
        return AjaxResult.error();
    }
}

Service：

package com.hikvision.nvr.service;

import com.hikvision.nvr.domain.RequestVo;
import com.hikvision.nvr.domain.SignIn;
import com.hikvision.nvr.domain.VideoFile;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

@Component
public interface FindVideoFileService {
    List<VideoFile> playback(RequestVo requestVo) throws InterruptedException;

    boolean downloadByFileNmae(String fileName,RequestVo requestVo);

    boolean downloadByFileTime(RequestVo requestVo);

    List<SignIn> getDeviceInformation(RequestVo requestVo);

    Map getBackUrl(RequestVo requestVo);
}

ServiceImpl：

package com.hikvision.nvr.service.impl;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.hikvision.nvr.domain.NvrTime;
import com.hikvision.nvr.domain.PlayBack;
import com.hikvision.nvr.domain.RequestVo;
import com.hikvision.nvr.domain.SignIn;
import com.hikvision.nvr.domain.VideoFile;
import com.hikvision.nvr.service.FindVideoFileService;
import com.hikvision.nvr.service.hk.HCNetSDK;
import com.hikvision.nvr.util.*;
import com.sun.jna.NativeLong;
import com.sun.jna.Pointer;
import com.sun.jna.ptr.IntByReference;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;


/**
 * @author wgq
 */
@Slf4j
@Service
public class FindVideoFileServiceImpl implements FindVideoFileService {

    /*获取IP接入配置信息*/
    public static final int NET_DVR_GET_IPPARACFG = 1048;
    /*允许加入的最多IP通道数*/
    public static final int MAX_IP_CHANNEL = 32;
    /*获得文件信息*/
    public static final int NET_DVR_FILE_SUCCESS = 1000;
    /*正在查找文件*/
    public static final int NET_DVR_ISFINDING = 1002;
    /*没有文件*/
    public static final int NET_DVR_FILE_NOFIND = 1001;
    /*开始播放*/
    public static final int NET_DVR_PLAYSTART = 1;
    /*获取文件回放的进度*/
    public static final int NET_DVR_PLAYGETPOS = 13;

    NativeLong lUserID;

    /*下载句柄*/
    NativeLong m_lDownloadHandle;


    /*设备信息*/
    NET_DVR_DEVICEINFO_V30 m_strDeviceInfo;
    HCNetSDK hCNetSDK = HCNetSDK.INSTANCE;


    @Autowired
    private ObjectMapper objectMapper;

    @Autowired
    private DataUtil dataUtil;

    /**
     * 根据时间搜索视频
     *
     * @param requestVo
     */
    @Override
    public List<VideoFile> playback(RequestVo requestVo) throws InterruptedException {
        SignIn signIn = requestVo.getSignIn();
        PlayBack playBack = requestVo.getPlayBack();
        NativeLong m_lUserID = userId(signIn);
        /*设置检索开始结束时间*/
        NvrTime startTime = dataUtil.dateToNum(playBack.getStartTime());
        NvrTime endTime = dataUtil.dateToNum(playBack.getEndTime());
        NET_DVR_TIME struStartTime;
        NET_DVR_TIME struStopTime;
        NET_DVR_FILECOND m_strFilecond = new NET_DVR_FILECOND();
        m_strFilecond.struStartTime = new NET_DVR_TIME();
        m_strFilecond.struStopTime = new NET_DVR_TIME();
        /*组装开始时间*/
        m_strFilecond.struStartTime.dwYear = startTime.getDwYear();
        m_strFilecond.struStartTime.dwMonth = startTime.getDwMonth();
        m_strFilecond.struStartTime.dwDay = startTime.getDwDay();
        m_strFilecond.struStartTime.dwHour = startTime.getDwHour();
        m_strFilecond.struStartTime.dwMinute = startTime.getDwMinute();
        m_strFilecond.struStartTime.dwSecond = startTime.getDwSecond();
        /*组装结束时间*/
        m_strFilecond.struStopTime.dwYear = endTime.getDwYear();
        m_strFilecond.struStopTime.dwMonth = endTime.getDwMonth();
        m_strFilecond.struStopTime.dwDay = endTime.getDwDay();
        m_strFilecond.struStopTime.dwHour = endTime.getDwHour();
        m_strFilecond.struStopTime.dwMinute = endTime.getDwMinute();
        m_strFilecond.struStopTime.dwSecond = endTime.getDwSecond();
        /*文件类型*/
        m_strFilecond.dwFileType = 0;
        m_strFilecond.dwIsLocked = 0xff;
        m_strFilecond.dwUseCardNo = 0;
        /*通道号*/
        m_strFilecond.lChannel = new NativeLong(playBack.getChannelNumber());
        /*获取文件*/
        NativeLong lFindFile = hCNetSDK.NET_DVR_FindFile_V30(m_lUserID, m_strFilecond);
        NET_DVR_FINDDATA_V30 strFile = new NET_DVR_FINDDATA_V30();
        long findFile = lFindFile.longValue();
        if (findFile > -1) {
            log.info("file:{}" + findFile);
        }
        NativeLong lnext;
        strFile = new NET_DVR_FINDDATA_V30();
        List<VideoFile> videoFiles = new ArrayList<>();
        while (true) {
            lnext = hCNetSDK.NET_DVR_FindNextFile_V30(lFindFile, strFile);
            if (lnext.longValue() == NET_DVR_FILE_SUCCESS) {
                log.info("搜索成功");
                /*添加文件名信息*/
                String[] s = new String[2];
                s = new String(strFile.sFileName).split("\0", 2);
                VideoFile videoFile = new VideoFile();
                /*添加文件大小信息*/
                int iTemp;
                String MyString;
                if (strFile.dwFileSize < 1024 * 1024) {
                    iTemp = (strFile.dwFileSize) / (1024);
                    MyString = iTemp + "K";
                } else {
                    iTemp = (strFile.dwFileSize) / (1024 * 1024);
                    MyString = iTemp + "M   ";
                    iTemp = ((strFile.dwFileSize) % (1024 * 1024)) / (1204);
                    MyString = MyString + iTemp + "K";
                }
                videoFile.setFileNme(new String(s[0]));
                videoFile.setFileSize(MyString);
                videoFile.setStartTime(strFile.struStartTime.toStringTime());
                videoFile.setEndTime(strFile.struStopTime.toStringTime());
                videoFiles.add(videoFile);
            } else {
                /*搜索中*/
                if (lnext.longValue() == NET_DVR_ISFINDING) {
                    log.info("搜索中");
                    continue;
                } else {
                    if (lnext.longValue() == NET_DVR_FILE_NOFIND) {
                        log.info("没有搜到文件");
                        return videoFiles;
                    } else {
                        log.info("搜索文件结束");
                        boolean flag = hCNetSDK.NET_DVR_FindClose_V30(lFindFile);
                        if (flag == false) {
                            log.info("结束搜索失败");
                        }
                        return videoFiles;
                    }
                }
            }
        }
    }

    /**
     * 按照文件下载
     *
     * @param fileName
     * @param requestVo
     * @return
     */
    @Override
    public boolean downloadByFileNmae(String fileName, RequestVo requestVo) {
        /*初始化用户*/
        NativeLong nativeLong = userId(requestVo.getSignIn());
        /*初始化下载值*/
        m_lDownloadHandle = new NativeLong(-1);
        if (m_lDownloadHandle.intValue() == -1) {
            /*根据输入的文件名查找文件*/
            m_lDownloadHandle = hCNetSDK.NET_DVR_GetFileByName(nativeLong, fileName, "D:\\fileNme.3GP");
            if (m_lDownloadHandle.intValue() >= 0) {
                /*下载文件*/
                boolean downloadFlag = hCNetSDK.NET_DVR_PlayBackControl(m_lDownloadHandle, NET_DVR_PLAYSTART, 0, null);
                int tmp = -1;
                IntByReference pos = new IntByReference();
                while (true) {
                    boolean backFlag = hCNetSDK.NET_DVR_PlayBackControl(m_lDownloadHandle, NET_DVR_PLAYGETPOS, 0, pos);
                    /*防止单个线程死循环*/
                    if (!backFlag) {
                        return downloadFlag;
                    }
                    int produce = pos.getValue();
                    /*获取下载进度*/
                    if ((produce % 10) == 0 && tmp != produce) {
                        tmp = produce;
                        log.info("视频下载进度：{}", produce + "%");
                    }
                    /*下载成功*/
                    if (produce == 100) {
                        hCNetSDK.NET_DVR_StopGetFile(m_lDownloadHandle);
                        m_lDownloadHandle.setValue(-1);
                        /*退出录像机*/
                        hCNetSDK.NET_DVR_Logout(lUserID);
                        log.info("退出状态：{}", hCNetSDK.NET_DVR_GetLastError());
                        return true;
                    }
                    /*下载失败*/
                    if (produce > 100) {
                        hCNetSDK.NET_DVR_StopGetFile(m_lDownloadHandle);
                        m_lDownloadHandle.setValue(-1);
                        log.warn("由于网络原因或NVR较忙,下载异常终止!错误原因：{}", hCNetSDK.NET_DVR_GetLastError());
                        hCNetSDK.NET_DVR_Logout(lUserID);
                        return false;
                    }
                }
            } else {
                log.info("视频下载失败！失败原因：{}", hCNetSDK.NET_DVR_GetLastError());
                return false;
            }
        }
        return true;
    }

    /**
     * 按照时间下载文件
     *
     * @param requestVo
     * @return
     */
    @Override
    public boolean downloadByFileTime(RequestVo requestVo) {
        PlayBack playBack = requestVo.getPlayBack();
        /*初始化用户*/
        NativeLong nativeLong = userId(requestVo.getSignIn());
        if (nativeLong.intValue() == -1) {
            return false;
        }
        m_lDownloadHandle = new NativeLong(-1);
        if (m_lDownloadHandle.intValue() == -1) {
            /*根据输入的文件名查找文件*/
            m_lDownloadHandle = hCNetSDK.NET_DVR_GetFileByTime(nativeLong, new NativeLong(playBack.getChannelNumber().longValue())
                    , dataUtil.getHkTime(playBack.getStartTime()), dataUtil.getHkTime(playBack.getEndTime()), "D:\\fileNme.mp4");
            if (m_lDownloadHandle.intValue() >= 0) {
                /*下载文件*/
                boolean downloadFlag = hCNetSDK.NET_DVR_PlayBackControl(m_lDownloadHandle, NET_DVR_PLAYSTART, 0, null);
                int tmp = -1;
                IntByReference pos = new IntByReference();
                while (true) {
                    boolean backFlag = hCNetSDK.NET_DVR_PlayBackControl(m_lDownloadHandle, NET_DVR_PLAYGETPOS, 0, pos);
                    /*防止单个线程死循环*/
                    if (!backFlag) {
                        return downloadFlag;
                    }
                    int produce = pos.getValue();
                    /*获取下载进度*/
                    if ((produce % 10) == 0 && tmp != produce) {
                        tmp = produce;
                        log.info("视频下载进度：{}", produce + "%");
                    }
                    /*下载成功*/
                    if (produce == 100) {
                        hCNetSDK.NET_DVR_StopGetFile(m_lDownloadHandle);
                        m_lDownloadHandle.setValue(-1);
                        /*退出录像机*/
                        hCNetSDK.NET_DVR_Logout(lUserID);
                        log.info("退出状态：{}", hCNetSDK.NET_DVR_GetLastError());
                        return true;
                    }
                    /*下载失败*/
                    if (produce > 100) {
                        hCNetSDK.NET_DVR_StopGetFile(m_lDownloadHandle);
                        m_lDownloadHandle.setValue(-1);
                        log.warn("由于网络原因或NVR较忙,下载异常终止!错误原因：{}", hCNetSDK.NET_DVR_GetLastError());
                        hCNetSDK.NET_DVR_Logout(lUserID);
                        return false;
                    }
                }
            } else {
                log.info("视频下载失败！失败原因：{}", hCNetSDK.NET_DVR_GetLastError());
                return false;
            }
        }
        return true;
    }


    /**
     * 获取用户登录信息
     *
     * @return 返回用户状态
     */
    public NativeLong userId(SignIn signIn) {
        boolean initSuc = hCNetSDK.NET_DVR_Init();
        if (initSuc != true) {
            log.info("初始化失败");
        }
        /*判断用户状态*/
        if (lUserID != null && lUserID.longValue() > -1) {
            hCNetSDK.NET_DVR_Logout_V30(lUserID);
            lUserID = new NativeLong(-1);
        }
        /*用户登录*/
        lUserID = hCNetSDK.NET_DVR_Login_V30(signIn.getIp(),
                (short) signIn.getPort(), signIn.getUserName(), signIn.getPassword(), m_strDeviceInfo);
        return lUserID;
    }

    /**
     * 用户登录 初始化设备
     *
     * @param requestVo
     * @return
     */
    @Override
    public List<SignIn> getDeviceInformation(RequestVo requestVo) {
        SignIn sign = requestVo.getSignIn();
        /*IP参数*/
        NET_DVR_IPPARACFG m_strIpparaCfg;
        /* 设备列表*/
        List<SignIn> signIns = new ArrayList<>();
        m_strDeviceInfo = new NET_DVR_DEVICEINFO_V30();
        NativeLong lUserID = userId(sign);
        long userID = lUserID.longValue();
        if (userID == -1) {
            log.info("注册失败");
            return signIns;
        } else {
            log.info("注册成功");
            /*通道树节点数目*/
            int m_iTreeNodeNum = 0;
            /*获取IP接入配置参数*/
            IntByReference ibrBytesReturned = new IntByReference(0);
            /*IP接入配置结构获取*/
            m_strIpparaCfg = new NET_DVR_IPPARACFG();
            m_strIpparaCfg.write();
            Pointer lpIpParaConfig = m_strIpparaCfg.getPointer();
            /*获取通道参数*/
            boolean bRet = hCNetSDK.NET_DVR_GetDVRConfig(lUserID, NET_DVR_GET_IPPARACFG, new NativeLong(0),
                    lpIpParaConfig, m_strIpparaCfg.size(), ibrBytesReturned);
            m_strIpparaCfg.read();
            if (!bRet) {
                /*设备不支持,则表示没有IP通道*/
                for (int iChannum = 0; iChannum < m_strDeviceInfo.byChanNum; iChannum++) {
                    SignIn s = new SignIn();
                    s.setDeviceId("Camera" + (iChannum + m_strDeviceInfo.byStartChan));
                    signIns.add(s);
                }
            } else {
                /*设备支持IP通道*/
                for (int iChannum = 0; iChannum < m_strDeviceInfo.byChanNum; iChannum++) {
                    if (m_strIpparaCfg.byAnalogChanEnable[iChannum] == 1) {
                        SignIn s = new SignIn();
                        s.setDeviceId("Camera" + (iChannum + m_strDeviceInfo.byStartChan));
                        signIns.add(s);
                        m_iTreeNodeNum++;
                    }
                }
                for (int iChannum = 0; iChannum < MAX_IP_CHANNEL; iChannum++) {
                    /*判断该通道号是否存在摄像头*/
                    if (m_strIpparaCfg.struIPChanInfo[iChannum].byChannel == 1) {
                        SignIn s = new SignIn();
                        NET_DVR_IPDEVINFO dev = m_strIpparaCfg.struIPDevInfo[iChannum];
                        s.setIp(new String(dev.struIP.sIpV4).trim());
                        s.setUserName(new String(dev.sUserName).trim());
                        s.setPort(dev.wDVRPort);
                        s.setIsLine(String.valueOf(m_strIpparaCfg.struIPChanInfo[iChannum].byEnable));
                        s.setDeviceId("IPCamera" + (iChannum + m_strDeviceInfo.byStartChan));
                        Integer channelNumber = getChannelNumber(s.getDeviceId());
                        s.setChannelNumber(channelNumber);
                        signIns.add(s);
                    }
                }
            }
            log.info("摄像头资源：{}", signIns);
        }
        return signIns;
    }

    /**
     * 回放拉流
     *
     * @param requestVo
     * @return
     */
    @Override
    public Map getBackUrl(RequestVo requestVo) {
        Map map = new HashMap();
        /*初始化用户*/
        SignIn sign = requestVo.getSignIn();
        PlayBack playBack = requestVo.getPlayBack();
        NativeLong nativeLong = userId(sign);
        if (nativeLong.intValue() == -1) {
            log.info("回放推流用户初始化失败");
            map.put("msg", "回放推流用户初始化失败");
            return map;
        }
        String url = sign.getAppId() + "/" + sign.getDeviceId();
        /*获取设备通道号*/
        List<SignIn> signIns = getDeviceInformation(requestVo);
        int channelNum = 0;
        for (SignIn signIn : signIns) {
            if (signIn.getIp().equals(sign.getDeviceIp())) {
                channelNum = signIn.getChannelNumber();
            }
        }
        if (channelNum == 0) {
            log.info("获取设备通道失败");
            map.put("msg", "获取设备通道失败！");
            return map;
        }
        String backUrl = "";
        if (playBack.getUrlType() == 1) {
            /*组装回放流地址*/
            backUrl = "rtsp://admin:" + sign.getPassword() + "@" + sign.getIp() + ":554/Streaming/tracks/" + (channelNum - 32) + "01/?" +
                    "starttime=" + dataUtil.backTimeAssemble(playBack.getStartTime()) + "&endtime=" + dataUtil.backTimeAssemble(playBack.getEndTime());
        } else {
            /*组装实时流地址*/
            backUrl = "rtsp://admin:" + sign.getPassword() + "@" + sign.getDeviceIp() + ":554/Streaming/tracks/" + (channelNum - 32) + "02/?" +
                    "transportmode=multicast";
        }
        map.put("msg", backUrl);
        return map;
    }


    /**
     * 获取选中的通道名,对通道名进行分析:
     *
     * @param sChannelName
     * @return
     */
    public int getChannelNumber(String sChannelName) {
        int iChannelNum = -1;
        /*Camara开头表示模拟通道*/
        if (sChannelName.charAt(0) == 'C') {
            /*子字符串中获取通道号*/
            iChannelNum = Integer.parseInt(sChannelName.substring(6));
        } else {
            /*IPCamara开头表示IP通道*/
            if (sChannelName.charAt(0) == 'I') {
                /*子字符创中获取通道号,IP通道号要加32,如IPCamera3 == 35*/
                iChannelNum = Integer.parseInt(sChannelName.substring(8)) + 32;
            } else {
                return -1;
            }
        }
        return iChannelNum;
    }

}

HCNetSDK：

package com.hikvision.nvr.service.hk;

import com.hikvision.nvr.util.*;
import com.sun.jna.Native;
import com.sun.jna.NativeLong;
import com.sun.jna.Pointer;
import com.sun.jna.ptr.IntByReference;
import com.sun.jna.win32.StdCallLibrary;

public interface HCNetSDK extends StdCallLibrary {

    /*加载海康DLL*/
    HCNetSDK INSTANCE = (HCNetSDK) Native.loadLibrary(CommonKit.getWebPath()+"HCNetSDK.dll", HCNetSDK.class);

    /*初始化*/
    boolean NET_DVR_Init();

    /*用户登录*/
    NativeLong NET_DVR_Login_V30(String sDVRIP, short wDVRPort, String sUserName, String sPassword, NET_DVR_DEVICEINFO_V30 lpDeviceInfo);

    /* 参数配置 begin*/
    boolean NET_DVR_GetDVRConfig(NativeLong lUserID, int dwCommand, NativeLong lChannel, Pointer lpOutBuffer, int dwOutBufferSize, IntByReference lpBytesReturned);

    /*查询视频文件*/
    NativeLong NET_DVR_FindFile_V30(NativeLong lUserID, NET_DVR_FILECOND pFindCond);

    /*查找下一个文件*/
    NativeLong NET_DVR_FindNextFile_V30(NativeLong lFindHandle, NET_DVR_FINDDATA_V30 lpFindData);

    /*结束搜索文件*/
    boolean NET_DVR_FindClose_V30(NativeLong lFindHandle);

    /*用户注销*/
    boolean NET_DVR_Logout_V30(NativeLong lUserID);

    /* 根据名称搜索文件 */
    NativeLong NET_DVR_GetFileByName(NativeLong lUserID, String sDVRFileName, String sSavedFileName);

    /*下载文件*/
    boolean NET_DVR_PlayBackControl(NativeLong lPlayHandle, int dwControlCode, int dwInValue, IntByReference LPOutValue);

    /* 停止文件下载 */
    boolean  NET_DVR_StopGetFile(NativeLong lFileHandle);

    /*退出NVR*/
    boolean  NET_DVR_Logout(NativeLong lUserID);

    /*获取退出状态*/
    int  NET_DVR_GetLastError();

    /*根据时间下载视频*/
    NativeLong  NET_DVR_GetFileByTime(NativeLong lUserID, NativeLong lChannel, NET_DVR_TIME lpStartTime, NET_DVR_TIME lpStopTime, String sSavedFileName);

}

以及HCNetSDK中其他实体类：
在这里插入图片描述

四、接口请求参数

创建一个NVR.postman_collection.json的文件，将以下文本放入导入到PostMan中即可请求

{
	"info": {
		"_postman_id": "bb70a6f1-e3a6-45cf-b914-76e3a7622628",
		"name": "NVR",
		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
	},
	"item": [
		{
			"name": "根据时间获取文件信息",
			"request": {
				"auth": {
					"type": "noauth"
				},
				"method": "POST",
				"header": [
					{
						"key": "ip",
						"value": "192.168.18.133",
						"type": "text",
						"disabled": true
					},
					{
						"key": "port",
						"value": "8000",
						"type": "text",
						"disabled": true
					},
					{
						"key": "userName",
						"value": "admin",
						"type": "text",
						"disabled": true
					},
					{
						"key": "password",
						"value": "a12345678",
						"type": "text",
						"disabled": true
					},
					{
						"key": "Content-Type",
						"value": "application/json",
						"type": "text",
						"disabled": true
					}
				],
				"body": {
					"mode": "raw",
					"raw": "{\r\n  \"playBack\": {\r\n    \"channelNumber\": 34,\r\n    \"endTime\": \"2021-11-04 18:00:00\",\r\n    \"startTime\": \"2021-11-04 15:00:00\"\r\n  },\r\n  \"signIn\": {\r\n    \"ip\": \"192.168.18.133\",\r\n    \"password\": \"a12345678\",\r\n    \"port\": 8000,\r\n    \"userName\": \"admin\"\r\n  }\r\n}",
					"options": {
						"raw": {
							"language": "json"
						}
					}
				},
				"url": {
					"raw": "http://localhost:8081/nvr/playback",
					"protocol": "http",
					"host": [
						"localhost"
					],
					"port": "8081",
					"path": [
						"nvr",
						"playback"
					]
				}
			},
			"response": []
		},
		{
			"name": "获取链接设备信息",
			"request": {
				"method": "POST",
				"header": [],
				"body": {
					"mode": "raw",
					"raw": "{\r\n  \"playBack\": {\r\n    \"channelNumber\": 34,\r\n    \"endTime\": \"2021-11-04 18:00:00\",\r\n    \"startTime\": \"2021-11-04 15:00:00\"\r\n  },\r\n  \"signIn\": {\r\n    \"ip\": \"192.168.18.133\",\r\n    \"password\": \"a12345678\",\r\n    \"port\": 8000,\r\n    \"userName\": \"admin\"\r\n  }\r\n}",
					"options": {
						"raw": {
							"language": "json"
						}
					}
				},
				"url": {
					"raw": "http://localhost:8081/nvr/getDeviceInformation",
					"protocol": "http",
					"host": [
						"localhost"
					],
					"port": "8081",
					"path": [
						"nvr",
						"getDeviceInformation"
					]
				}
			},
			"response": []
		},
		{
			"name": "根据文件名下载视频",
			"request": {
				"method": "POST",
				"header": [],
				"body": {
					"mode": "raw",
					"raw": "{\r\n  \"playBack\": {\r\n    \"channelNumber\": 34,\r\n    \"endTime\": \"2021-11-04 18:00:00\",\r\n    \"startTime\": \"2021-11-04 15:00:00\"\r\n  },\r\n  \"signIn\": {\r\n    \"ip\": \"192.168.18.133\",\r\n    \"password\": \"a12345678\",\r\n    \"port\": 8000,\r\n    \"userName\": \"admin\"\r\n  }\r\n}",
					"options": {
						"raw": {
							"language": "json"
						}
					}
				},
				"url": {
					"raw": "http://localhost:8081/nvr/downloadByFileNmae?fileName=ch0002_00010000096000000",
					"protocol": "http",
					"host": [
						"localhost"
					],
					"port": "8081",
					"path": [
						"nvr",
						"downloadByFileNmae"
					],
					"query": [
						{
							"key": "fileName",
							"value": "ch0002_00010000096000000"
						}
					]
				}
			},
			"response": []
		},
		{
			"name": "根据时间下载视频",
			"request": {
				"method": "POST",
				"header": [],
				"body": {
					"mode": "raw",
					"raw": "{\r\n  \"playBack\": {\r\n    \"channelNumber\": 33,\r\n    \"endTime\": \"2021-11-05 18:00:00\",\r\n    \"startTime\": \"2021-11-05 16:00:00\"\r\n  },\r\n  \"signIn\": {\r\n    \"ip\": \"192.168.18.133\",\r\n    \"password\": \"a12345678\",\r\n    \"port\": 8000,\r\n    \"userName\": \"admin\"\r\n  }\r\n}",
					"options": {
						"raw": {
							"language": "json"
						}
					}
				},
				"url": {
					"raw": "http://localhost:8081/nvr/downloadByFileTime",
					"protocol": "http",
					"host": [
						"localhost"
					],
					"port": "8081",
					"path": [
						"nvr",
						"downloadByFileTime"
					]
				}
			},
			"response": []
		},
		{
			"name": "获取回放流地址",
			"request": {
				"method": "POST",
				"header": [],
				"body": {
					"mode": "raw",
					"raw": "{\r\n  \"playBack\": {\r\n    \"channelNumber\": 34,\r\n    \"endTime\": \"2021-11-08 15:00:00\",\r\n    \"startTime\": \"2021-11-08 13:00:00\"\r\n  },\r\n  \"signIn\": {\r\n    \"ip\": \"192.168.18.133\",\r\n    \"password\": \"a12345678\",\r\n    \"port\": 8000,\r\n    \"userName\": \"admin\",\r\n    \"deviceIp\":\"192.168.18.183\"\r\n  }\r\n}",
					"options": {
						"raw": {
							"language": "json"
						}
					}
				},
				"url": {
					"raw": "http://localhost:8081/nvr/getBackUrl",
					"protocol": "http",
					"host": [
						"localhost"
					],
					"port": "8081",
					"path": [
						"nvr",
						"getBackUrl"
					]
				}
			},
			"response": []
		},
		{
			"name": "获取实时视频流",
			"request": {
				"method": "POST",
				"header": [],
				"body": {
					"mode": "raw",
					"raw": "{\r\n  \"playBack\": {\r\n    \"channelNumber\": 34,\r\n    \"endTime\": \"2021-11-08 15:00:00\",\r\n    \"startTime\": \"2021-11-08 13:00:00\"\r\n  },\r\n  \"signIn\": {\r\n    \"ip\": \"192.168.18.133\",\r\n    \"password\": \"a12345678\",\r\n    \"port\": 8000,\r\n    \"userName\": \"admin\",\r\n    \"deviceIp\":\"192.168.18.180\"\r\n  }\r\n}",
					"options": {
						"raw": {
							"language": "json"
						}
					}
				},
				"url": {
					"raw": "http://localhost:8081/nvr/getLiveUrl",
					"protocol": "http",
					"host": [
						"localhost"
					],
					"port": "8081",
					"path": [
						"nvr",
						"getLiveUrl"
					]
				}
			},
			"response": []
		}
	]
}

五、项目地址

避免文件使用积分问题本项目已上传至百度网盘
百度网盘Maven导入JAR
提取码：s75w
GItee: https://gitee.com/wgqtn/hikvision

六、总结

这是第一次对接硬件，还有很多不完善的地方希望大家谅解。有写的不好的地方请大家指出，日后考虑放到gitee以便大家一起维护。在此感谢！
原创不易，欢迎来喷…在这里插入图片描述

木之南月
关注
  • 7
    点赞
  • 踩
  • 57
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
java dvr_海康录像机获取回放视频流并写到磁盘中可进行播放
weixin_34887818的博客
02-23 1693
packagecom.lg.haikang.hkdevice.Controller;importcn.hutool.core.util.XmlUtil;importcom.lg.haikang.hkdevice.demo.HCNetSDK;importcom.sun.jna.NativeLong;importcom.sun.jna.Pointer;importcom.sun.jna.example...
Spring boot 集成海康sdk-java
08-09
sdk初始化； 设备注册，v30与v40； 获取通道号，v30与v40； 获取通道号名称； 文件搜索，v30与v40； 文件下载，通过文件名称下载，发送下载指令；...下载进度值，支持多文件或许进度值；...监听，布防
String boot 整合海康SDK 常用功能 实时预览,设备抓图,云台反向定位,云台旋转控制,获取云台参数
09-30
（一定要看doc文件夹中的文档）String boot 整合海康SDK 常用功能 实时预览,设备抓图,云台反向定位,云台旋转控制,获取云台参数，布防，透明通道等，不是Demo ，只直接运行使用。
【海康威视】-NVR使用及ISAPI协议透传接入
宣晨光
06-14 2616
背景说明：使用NVR网络录像机接入监控摄像头，NVR内置人脸库、人脸抓拍、比对功能、事件配置。使用的设备型号：DS-9632NX-I8R/VPro。
SpringBoot+海康威视摄像头实现在前端的预览
weixin_44738214的博客
08-09 1万+
springboot＋海康威视实现摄像头的预览
Spring boot 集成 海康威视sdk
树叶single
08-09 2214
sdk调用有如下几个接口（源码地址在文章末尾） sdk初始化 设备注册，v30与v40 获取通道号，v30与v40 获取通道号名称 文件搜索，v30与v40 文件下载，通过文件名称下载，发送下载指令 下载进度值，支持多文件或许进度值 监听，布防 监听说明： NET_DVR_StartListen_V30接口使用有个注意的参数，那就是端口值，这个端口的值不能给本地服务的端口（服务启动时的端口），否则会返回72错误码。 要给一个
JAVA Spring Boot与海康威视摄像头的故事
weixin_45456848的博客
04-05 3641
这两天因工作原因，需要对海康威视摄像头进行二次开发。说实话，刚打开开发手册的那一刻，很劝退。由于之前接触硬件开发不多，对于其中的嵌入式设备SDK、DLL动态组件库的内容不甚了解。挠破了头皮，冲！
5.海康威视-Spring boot下实现抓图并保存
qq_19331985的博客
12-11 6414
1. 配置yml文件 在yml文件中配置保存文件的地址 # 海康配置 hksetting: image: # 抓取图片上传路径 dvrPicSavePath: F://ideaworkspace/hk-project/dvr-pic 2. 抓图实现方式 创建图片结构体：HCNetSDK.NET_DVR_JPEGPARA 结构体信息： //图片质量 public static class NET_DVR_JPEGPARA extends Structure { /*注意：当图像压缩
基于 SpringBoot+Hikvision SDK 远程查看配置海康网络摄像头配置
山河已无恙
10-13 1263
工作中遇到，简单整理理解不足小伙伴帮忙指正对每个人而言，真正的职责只有一个：找到自我。然后在心中坚守其一生，全心全意，永不停息。所有其它的路都是不完整的，是人的逃避方式，是对大众理想的懦弱回归，是随波逐流，是对内心的恐惧 ——赫尔曼·黑塞《德米安》
Vue中预览HIKVSION海康威视的NVR(网络硬盘录像机)中多个通道(摄像机)的视频
BADAO_LIUMANG_QIZHI的博客
04-13 6569
场景 SpringBoot+Vue+HIKVSION实现摄像头多选并多窗口预览(插件版)： SpringBoot+Vue+HIKVSION实现摄像头多选并多窗口预览(插件版)_霸道流氓气质的博客-CSDN博客 上面实现的在Vue中直接通过单个摄像头的Ip、端口、用户名、密码来预览 摄像头的视频，这里将两个摄像头装在海康威视网络硬盘录像机，即NVR中。 怎样在Vue中进行预览。 去海康威视官网下载web开发包 具体参考上面的博客。 根据其官方文档的说明，Web控件既适应于单个摄像头的预览，也适
spring boot集成javacv + websocket实现实时视频推流回放（延时1-2秒）
热门推荐
Geminates
01-23 1万+
最近项目需要实时直播和回放，集成海康威视摄像头：（适合少量用户，或者内部系统使用） <!-- 视频处理库 --> <dependency> <groupId>org.bytedeco</groupId> <artifactId>javacv-platform</ar...
海康威视nvr ST-02升级包
12-28
升级为DS-7604版本，解决国标28181
海康威视NVR双网口配置教程.doc
11-25
海康威视NVR双网口配置教程 海康威视NVR双网口配置教程是指在海康威视NVR录像机中配置双网口，实现网络容错和多址设定的功能。该配置教程主要涉及到双网口录像机的两种网络工作模式：网络容错和多址设定。 网络...
海康威视NVR嵌入设备WEB程序
07-04
ASP源代码, 海康威视NVR嵌入设备中是带有WEB程序的，但是却不提供源代码下载，http://192.168.5.107/doc/page/login.asp 这是我从DS-8632N-ST设备中导出的ASP程序， 大家可以参考一下。
海康摄像头spring boot
05-06
在"海康摄像头支持spring bo"这个标签中，我们可以理解为这是关于海康摄像头与Spring Boot集成的讨论，可能涉及到的技术点包括摄像头API的使用、Spring Boot的安全机制、Web页面的实时性以及整个系统的可扩展性和...
如何在 Spring Boot 中开发一个操作日志系统
网罗天下方法，方便你我开发！！！
07-24 883
在开发企业级应用时，记录用户操作日志是非常重要的。这不仅能帮助开发者监控系统的行为，还能在出现问题时进行追踪。在这篇文章中，我们将介绍如何在Spring Boot中开发一个完整的日志系统，记录每一步操作，如登录、创建订单、删除、查询等。
Java面试八股之简述spring boot的目录结构
u012151345的博客
07-23 531
application.properties 或 application.yml：是 Spring Boot 的主要配置文件，可以有多个版本，例如 application-dev.yml 和 application-prod.yml，分别用于开发和生产环境。Spring Boot 项目遵循标准的 Maven 或 Gradle 项目布局，并且有一些约定的目录用于组织不同的项目组件。src/test/java 和 src/test/resources：包含测试相关的 Java 代码和资源文件。
Spring Boot自动装配原理
最新发布
qq_63688997的博客
07-24 1856
Spring Boot的自动转配原理深究以及总结。
java 海康硬盘录像机布防
09-29
要实现Java编程语言与海康硬盘录像机的布防功能，需要使用海康设备提供的开放式接口和相关的开发文档。以下是一个简单的流程示例： 1. 引入相关的海康硬盘录像机开发包或依赖项到Java项目中，确保项目可以访问所需的类和方法。 2. 创建一个与海康硬盘录像机通信的连接，通常需要提供设备的IP地址、端口号、用户名和密码等认证信息。 3. 通过连接对象调用相应的接口方法，实现布防功能。具体方法名和参数将根据硬盘录像机的型号和支持的功能而有所不同。 4. 在布防之前，可以通过查询已连接的硬盘录像机获取相关的状态信息，例如：设备是否在线、摄像头是否可用等。 5. 调用布防方法，并提供需要进行布防的摄像头编号或标识。 6. 等待布防操作完成的回调或响应，以确保布防操作被成功执行。 7. 如果需要，可以添加额外的逻辑和处理程序来处理布防过程中可能发生的异常情况，以提高系统的稳定性和异常处理能力。 需要注意的是，以上只是一个大致的实现思路，并不能完全覆盖所有细节。在实际开发中，可能还需要考虑其他因素，例如：网络稳定性、权限认证、设备兼容性等。因此，建议参考海康硬盘录像机的开发文档和示例代码，以更好地了解和掌握如何使用Java来实现硬盘录像机的布防功能。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值