知识点

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

须知

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

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

安装zlmediakit流媒体服务器

自行查看

前端环境

vue2、西瓜播放器

后端核心

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

<code>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等）

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