关于JAVA海康ISUPSDK推送前端播放

关于JAVA海康ISUPSDK推送前端播放

码农世界 2024-06-04 前端 92 次浏览 0个评论

知识点

    • 须知
    • 安装zlmediakit流媒体服务器
    • 前端环境
    • 后端核心
    • 总结

      须知

      注意：该需求是用于公网设备（4G、户外坏境）；请先了解需求后做参考

      下载好海康的ISUPSDK的demo（ehome5.0）

      安装zlmediakit流媒体服务器

      自行查看

      前端环境

      vue2、西瓜播放器

      后端核心

      这个是核心，获取到sdk回调得到的流数据后 推送到zlm

      	private PipedOutputStream outputStream;// 管道输出流
    private PipedOutputStream picOutputStream;// 抓图管道流
    //预览回调数据
    public class FPreviewDataCallback implements PREVIEW_DATA_CB {
        @Override
        public boolean invoke(int iPreviewHandle, Pointer pPreviewCBMsg, Pointer pUserData) {
            String sClassName = NET_EHOME_PREVIEW_CB_MSG.class.getName();
            NET_EHOME_PREVIEW_CB_MSG strPreviewData=null;
            try{
                strPreviewData = (NET_EHOME_PREVIEW_CB_MSG) CommonMethod.WritePointerDataToClass(pPreviewCBMsg, sClassName);
            }catch (Exception e){
                e.printStackTrace();
            }
            if(strPreviewData.pRecvdata == null || strPreviewData.dwDataLen <= 0)
            {
                return false;
            }
            switch (strPreviewData.byDataType)
            {
                case ISUPStreamByJNA.NET_DVR_SYSHEAD: {
                    logger.info("HIK Stream Header len:" + strPreviewData.dwDataLen);
                    break;
                }
                case ISUPStreamByJNA.NET_DVR_STREAMDATA:
                {
                    try{
                        haiKangSdkAccessHashMap.get(iPreviewHandle+"_1").onMediaStream(strPreviewData.pRecvdata.getByteArray(0,strPreviewData.dwDataLen),false,true);
                    }catch (Exception e){
                        e.printStackTrace();
                        WvpDevice wvpDevice=wvpDeviceService.selectWvpDeviceByIPreviewHandle((long)iPreviewHandle);
                        if(wvpDevice!=null){
//                            Preview.StopPreview(wvpDevice.getDeviceId());
                            haiKangSdkAccessHashMap.remove(iPreviewHandle + "_1");
                        }
                    }
                }
            }
            return true;
        }

      public void onMediaStream(byte[] data, boolean isAudio, boolean isReal) throws IOException {
        if(t==null){
            String zlmRTMPUrl = rtmpUrl +deviceChannel ;
            //启动javacv解析处理器线程
            logger.info("启动javacv解析处理器线程"+zlmRTMPUrl);
            t=new JavaCVProcessThread(zlmRTMPUrl,deviceChannel,redisCache);
//            t=new JavaCVProcessThread("rtmp://127.0.0.1:1935/live/"+deviceId);
            t.start();
        }
        if(t!=null){
            //写出视频码流到javacv多线程解析处理器
            redisCache.setCacheObject(deviceChannel,deviceChannel,60, TimeUnit.SECONDS);
            t.push(data, data.length,deviceChannel, isReal);
        }
    }

      package com.wvp.camera.module.service.util;
import com.wvp.common.core.redis.RedisCache;
import com.wvp.camera.module.service.stream.EStream;
import com.wvp.camera.module.service.stream.Preview;
import lombok.extern.slf4j.Slf4j;
import org.bytedeco.ffmpeg.avcodec.AVCodecParameters;
import org.bytedeco.ffmpeg.avformat.AVFormatContext;
import org.bytedeco.ffmpeg.avformat.AVStream;
import org.bytedeco.ffmpeg.global.avcodec;
import org.bytedeco.ffmpeg.global.avutil;
import org.bytedeco.javacv.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.util.concurrent.TimeUnit;
/**
 * 海康sdk接收实时视频回调演示demo
 * @author eguid
 *
 */
public class HaiKangSdkAccess {
    RedisCache redisCache;
    //日志文件
    protected static final Logger logger = LoggerFactory.getLogger(EStream.class);
    JavaCVProcessThread t =null;
    private String deviceChannel;
    private Long luserId;
    private int lLinkHandle;
    private String rtmpUrl;
    private int model;
    public HaiKangSdkAccess(String deviceChannel, Long luserId, int lLinkHandle, String rtmpUrl,RedisCache redisCache,int model) {
        this.deviceChannel = deviceChannel;
        this.luserId = luserId;
        this.lLinkHandle = lLinkHandle;
        this.rtmpUrl = rtmpUrl;
        this.redisCache=redisCache;
        //1实时预览 2-回放
        this.model = model;
    }
    //通过海康/大华sdk回调函数每次回调传输过来的视频字节数组数据写入到管道流
    public void onMediaStream(byte[] data, boolean isAudio, boolean isReal) throws IOException {
        if(t==null){
            String zlmRTMPUrl = rtmpUrl +deviceChannel ;
            //启动javacv解析处理器线程
            logger.info("启动javacv解析处理器线程"+zlmRTMPUrl);
            t=new JavaCVProcessThread(zlmRTMPUrl,deviceChannel,redisCache);
//            t=new JavaCVProcessThread("rtmp://127.0.0.1:1935/live/"+deviceId);
            t.start();
        }
        if(t!=null){
            //写出视频码流到javacv多线程解析处理器
            redisCache.setCacheObject(deviceChannel,deviceChannel,60, TimeUnit.SECONDS);
            t.push(data, data.length,deviceChannel, isReal);
        }
    }
}
/**
 * javacv多线程解析处理器，用于读取海康/大华/宇视设备sdk回调视频码流并解析转码推流到rtmp
 * @author fs
 *
 */
class JavaCVProcessThread extends Thread{
    private static final Logger log = LoggerFactory.getLogger(JavaCVProcessThread.class);
    //日志文件
    protected static final Logger logger = LoggerFactory.getLogger(EStream.class);
    FFmpegFrameGrabber grabber=null;
    FFmpegFrameRecorder recorder = null;
    PipedInputStream inputStream;
    PipedOutputStream outputStream;
    String pushAddress;
    String deviceId;
    RedisCache redisCache;
    /**
     * 创建用于把字节数组转换为inputstream流的管道流
     * @throws IOException
     */
    public JavaCVProcessThread(String output,String deviceId,RedisCache redisCache) throws IOException {
        this.redisCache=redisCache;
        this.deviceId=deviceId;
        pushAddress = output;
        outputStream = new PipedOutputStream();
        inputStream = new PipedInputStream();
        outputStream.connect(inputStream);
        System.out.println("创建线程："+inputStream);
    }
    /**
     * 异步接收海康/大华/宇视设备sdk回调实时视频裸流数据
     * @param data
     * @param size
     */
    public void push(byte[] data,int size,String playKey, boolean isReal) throws IOException {
        try {
            outputStream.write(data, 0, size);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            if (isReal){
                Preview.StopPreview(playKey);
            }else{
                Preview.PlaybackStop(playKey);
            }
        }
    }
    @Override
    public void run() {
        try {
            Thread.sleep(500);
            // ffmepg日志级别
            avutil.av_log_set_level(avutil.AV_LOG_ERROR);
            FFmpegLogCallback.set();
            // 实例化帧抓取器对象，将文件路径传入
            // 1.直接以文件形式实例化帧抓取器，此方式可以推送h264，ps码流格式的MP4
//        FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(MP4_FILE_PATH);
            // 2.从文件中取流实例化帧抓取器,此方式只能推送ps码流的MP4
            log.info(inputStream.toString());
            FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(inputStream,0);
            long startTime = System.currentTimeMillis();
            log.info("开始初始化帧抓取器");
            // 下面两行设置可加可不加
            grabber.setOption("analyzeduration", "1000000");
//        grabber.setFormat("h264");
            // 初始化帧抓取器，例如数据结构（时间戳、编码器上下文、帧对象等），
            // 如果入参等于true，还会调用avformat_find_stream_info方法获取流的信息，放入AVFormatContext类型的成员变量oc中
            grabber.setPixelFormat(avutil.AV_PIX_FMT_YUV420P);
            grabber.setVideoCodec(avcodec.AV_CODEC_ID_H264);
            grabber.setAudioStream(Integer.MAX_VALUE);
            grabber.start();
//        grabber.startUnsafe(true); // 也可以使用此方法
            log.info("帧抓取器初始化完成，耗时[{}]毫秒", System.currentTimeMillis()-startTime);
            // grabber.start方法中，初始化的解码器信息存在放在grabber的成员变量oc中
            AVFormatContext avFormatContext = grabber.getFormatContext();
            // 文件内有几个媒体流（一般是视频流+音频流）
            int streamNum = avFormatContext.nb_streams();
            // 没有媒体流就不用继续了
            if (streamNum<1) {
                log.error("文件内不存在媒体流");
                return;
            }
            // 取得视频的帧率
            int frameRate = (int)grabber.getVideoFrameRate();
            log.info("视频帧率[{}]，视频时长[{}]秒，媒体流数量[{}]",
                    frameRate,
                    avFormatContext.duration()/1000000,
                    avFormatContext.nb_streams());
            // 遍历每一个流，检查其类型
            for (int i=0; i< streamNum; i++) {
                AVStream avStream = avFormatContext.streams(i);
                AVCodecParameters avCodecParameters = avStream.codecpar();
                log.info("流的索引[{}]，编码器类型[{}]，编码器ID[{}]", i, avCodecParameters.codec_type(), avCodecParameters.codec_id());
            }
            // 视频宽度
            int frameWidth = grabber.getImageWidth();
            // 视频高度
            int frameHeight = grabber.getImageHeight();
            // 音频通道数量
            int audioChannels = grabber.getAudioChannels();
            log.info("视频宽度[{}]，视频高度[{}]，音频通道数[{}]",
                    frameWidth,
                    frameHeight,
                    audioChannels);
            // 实例化FFmpegFrameRecorder，将SRS的推送地址传入
            FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(pushAddress,
                    frameWidth,
                    frameHeight,
                    audioChannels);
            // 设置编码格式
            recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
            // 设置封装格式
            recorder.setFormat("flv");
            // 一秒内的帧数
            recorder.setFrameRate(frameRate);
            // 两个关键帧之间的帧数
            recorder.setGopSize(frameRate);
            // 设置音频通道数，与视频源的通道数相等
            recorder.setAudioChannels(grabber.getAudioChannels());
            startTime = System.currentTimeMillis();
            log.info("开始初始化帧抓取器");
            // 初始化帧录制器，例如数据结构（音频流、视频流指针，编码器），
            // 调用av_guess_format方法，确定视频输出时的封装方式，
            // 媒体上下文对象的内存分配，
            // 编码器的各项参数设置
            recorder.start();
            log.info("帧录制初始化完成，耗时[{}]毫秒", System.currentTimeMillis()-startTime);
            Frame frame;
            startTime = System.currentTimeMillis();
            log.info("开始推流");
            long videoTS = 0;
            int videoFrameNum = 0;
            int audioFrameNum = 0;
            int dataFrameNum = 0;
            // 假设一秒钟15帧，那么两帧间隔就是(1000/15)毫秒
            int interVal = 1000/frameRate;
            // 发送完一帧后sleep的时间，不能完全等于(1000/frameRate)，不然会卡顿，
            // 要更小一些，这里取八分之一
            interVal/=8;
            // 持续从视频源取帧
            while (null!=(frame=grabber.grab())) {
                videoTS = 1000 * (System.currentTimeMillis() - startTime);
                // 时间戳
                recorder.setTimestamp(videoTS);
                // 有图像，就把视频帧加一
                if (null!=frame.image) {
                    videoFrameNum++;
                }
                // 有声音，就把音频帧加一
                if (null!=frame.samples) {
                    audioFrameNum++;
                }
                // 有数据，就把数据帧加一
                if (null!=frame.data) {
                    dataFrameNum++;
                }
                // 取出的每一帧，都推送到SRS
                recorder.record(frame);
                // 停顿一下再推送
                Thread.sleep(interVal);
            }
            String[] deviceChannel = deviceId.split("_");
            log.info("推送完成，视频帧[{}]，音频帧[{}]，数据帧[{}]，耗时[{}]秒",
                    videoFrameNum,
                    audioFrameNum,
                    dataFrameNum,
                    (System.currentTimeMillis()-startTime)/1000);
            // 关闭帧录制器
            recorder.close();
            // 关闭帧抓取器
            grabber.stop();
            grabber.close();
            inputStream.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

      总结

      海康的sdk对接起来确实有点难度，简直就是一坨*

      先去了解zlm或者其它流媒体服务器（原理都差不多），搭建好后再去写核心推流。

      业务层要基于你们的需求来（每个人都不同），关于前端如何播放的核心代码就这些

      目前我demo已经完成了实时预览、录像回放、云台控制、远程配置参数（视音频、图像OSD等）

      对接了好几个月，如有需要请联系（当然是有偿的啦回点血，不会很贵）

转载请注明来自码农世界，本文标题：《关于JAVA海康ISUPSDK推送前端播放》

百度分享代码，如果开启HTTPS请参考李洋个人博客
37815篇文章 站点 微博
每一天，每一秒，你所做的决定都会改变你的人生！

发表评论

快捷回复：

评论列表 （暂无评论，92人围观）参与讨论

还没有评论，来说两句吧...

Top