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

作者 : admin 本文共8182个字,预计阅读时间需要21分钟 发布时间: 2024-06-11 共1人阅读

知识点

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

须知

注意:该需求是用于公网设备(4G、户外坏境);请先了解需求后做参考
下载好海康的ISUPSDK的demo(ehome5.0)
关于JAVA海康ISUPSDK推送前端播放插图

安装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等)
对接了好几个月,如有需要请联系(当然是有偿的啦回点血,不会很贵)

本站无任何商业行为
个人在线分享-虚灵IT资料分享 » 关于JAVA海康ISUPSDK推送前端播放
E-->