rtsp协议转换m3u8

目前项目中使用海康的摄像头，但需要提供实时预览。目前通过转换协议实现预览。同时能够尽量减少服务器的压力，比如生成的ts文件个数。

思路

通过ffmpeg 将rtsp协议转换成hls协议

具体步骤

1、java调用FFmpeg 命令进行协议转换

2、解决java调用runtime时，无法自主结束子进程问题

3、解决videojs中播放m3u8时出现 (CODE:3 MEDIA_ERR_DECODE) The media playback was aborted due to a corruption problem or because the media used features your browser did not support）

 

一、java部分

package com.hxq.device.rtsp;

import com.hxq.common.config.RuoYiConfig;
import com.hxq.common.utils.StringUtils;
import com.hxq.common.utils.SystemCmdHelper;
import com.hxq.common.utils.http.HttpUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.commons.io.FileUtils;
import org.apache.http.client.utils.DateUtils;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PreDestroy;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Date;
import java.util.concurrent.ConcurrentHashMap;

/**
 * rtsp 转 hlv协议
 *
 * @author kzw
 */
@Service
@Slf4j
@EnableScheduling
public class RtspConvert {
    //转换map
    private static ConcurrentHashMap<String, CoverThread> coverMap = new ConcurrentHashMap<>();
    //每次转换3小时，3小时之后自动停止
    private static final String ffmpegCmd = "ffmpeg -timeout 3000000 -i \"%s\" -c copy -t 03:00:00 -f hls -hls_time 5.0 -hls_list_size 5 -hls_flags 2 %s";

    @PreDestroy
    public void closeProcess() {
        log.info("关闭ffmpeg转换进程，java程序不一定关闭process进程");
        for (String ip : coverMap.keySet()) {
            try {
                log.error("开始停止{}", ip);
                coverMap.get(ip).stopTask();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * ffmpeg -i "rtsp://admin:xxx@192.168.0.251:554/Streaming/Channels/101" -c copy -f hls -hls_time 5.0 -hls_list_size 5 -hls_flags 2 F:\resources\hls\2000\live.m3u8
     */
    /**
     * 检查设备ip是否能正常访问
     */
    private boolean checkDeviceOnline(String ip) {
        String res = HttpUtils.sendGet("http://" + ip);
        if (StringUtils.isNotBlank(res)) {
            return true;
        }
        return false;
    }

    /**
     * 转换rtsp并获取hls文件路径
     */
    public String rtsp2Hls(String ip, String userName, String pwd) {
        if (coverMap.containsKey(ip)) {
            CoverThread thread = coverMap.get(ip);
            if (thread == null || thread.getTaskState() != CoverThread.running) {
            } else {
                return StringUtils.replace(thread.getM3U8File(), RuoYiConfig.getProfile(), "");
            }
        }
        String rtspUrl = "rtsp://" + userName + ":" + pwd + "@" + ip + ":554/Streaming/Channels/101";
        String m3u8File = RuoYiConfig.getProfile() + File.separator + "hls"
                + File.separator + ip.replaceAll("\\.", "_") + File.separator + DateUtils.formatDate(new Date(), "yyyyMMddHHmm") + "live.m3u8";
        startTransform(ip, rtspUrl, m3u8File, userName, pwd);
        CoverThread thread = coverMap.get(ip);
        if (thread != null) {
            return StringUtils.replace(thread.getM3U8File(), RuoYiConfig.getProfile(), "");
        }
        return null;
    }

    /**
     * 开启转换
     */
    private void startTransform(String ip, String rtspUrl, String m3u8Path, String userName, String pwd) {
        log.info("转换rtsp, {},{},{}", ip, rtspUrl, m3u8Path);
        String memKey = "startLive" + ip;
        synchronized (memKey.intern()) {
            if (coverMap.containsKey(ip)) {
                stopTransform(ip);
            }
            CoverThread thread = new CoverThread(ip, rtspUrl, m3u8Path, userName, pwd);
            coverMap.put(ip, thread);
            thread.start();
        }
    }

    /**
     * 停止转换
     */
    public void stopTransform(String ip) {
        String memKey = "startLive" + ip;
        synchronized (memKey.intern()) {
            if (coverMap.containsKey(ip)) {
                CoverThread thread = coverMap.get(ip);
                if (thread != null && thread.getTaskState() != CoverThread.fail) {
                    thread.stopTask();
                }
            }
        }
    }

    /**
     * 监控所有的转换线程
     */
    @Scheduled(cron = "0 0/8 * * * ?")
    public synchronized void monitorThreads() {
        for (String ip : coverMap.keySet()) {
            CoverThread thread = coverMap.get(ip);
            if (thread != null && thread.getTaskState() != CoverThread.running) {
                //线程出现异常
                rtsp2Hls(ip, thread.getUserName(), thread.getPwd());
            }
        }
    }

    /**
     * 执行命令线程
     */
    private class CoverThread extends Thread {
        private String ip;
        private String rtspUrl;
        private String m3u8File;
        private String userName;
        private String pwd;
        private int taskState = 0; //运行状态 0未开始 1进行中 -1失败
        private static final int notStart = 0;
        private static final int running = 1;
        private static final int fail = -1;
        private Process process = null;

        CoverThread(String ip, String rtspUrl, String m3u8File, String userName, String pwd) {
            this.ip = ip;
            this.rtspUrl = rtspUrl;
            this.m3u8File = m3u8File;
            this.userName = userName;
            this.pwd = pwd;
            setName("m3u8-" + ip);
            this.taskState = notStart;
        }

        @Override
        public void run() {
            try {
                FileUtils.forceMkdir(new File(m3u8File).getParentFile());
                if (!checkDeviceOnline(ip)) {
                    log.warn("设备{},离线", ip);
                    this.taskState = fail;
                    return;
                }
                String command = String.format(ffmpegCmd, rtspUrl, m3u8File);
                this.taskState = running;

                //判断是操作系统是linux还是windows
                String[] comds;
                if (SystemCmdHelper.isWin()) {
                    comds = new String[]{"cmd", "/c", command};
//                    comds = new String[]{"cmd", "/c", "start", "/b", "cmd.exe", "/k", command};
                } else {
                    comds = new String[]{"/bin/sh", "-c", command};
                }

                // 开始执行命令
                log.info("执行命令：" + command);
                process = Runtime.getRuntime().exec(comds);

                //开启线程监听（此处解决 waitFor() 阻塞/锁死 问题）
                new SystemCmdHelper.RunThread(process.getInputStream(), "INFO").start();
                new SystemCmdHelper.RunThread(process.getErrorStream(), "ERROR").start();
                int flag = process.waitFor();
                log.info("结束{}", ip);
            } catch (Exception e) {
                log.error("出现异常" + e.getMessage(), e);
                this.taskState = fail;
            } finally {
                if (process != null) {
                    try {
                        process.exitValue();
                    } catch (Exception e) {
                    }
                    try {
                        process.destroyForcibly();
                    } catch (Exception e) {
                    }
                }
            }
        }

        /**
         * 获取任务执行状态
         */
        public int getTaskState() {
            return taskState;
        }

        /**
         * 立即停止任务
         */
        public void stopTask() {
            if (process != null) {
                try {
                    process.destroy();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        public String getM3U8File() {
            return this.m3u8File;
        }

        public String getUserName() {
            return userName;
        }

        public String getPwd() {
            return pwd;
        }
    }

    public static void main(String[] args) throws Exception {
        RtspConvert convert = new RtspConvert();
        String ip = "192.168.0.251";
        String userName = "xxx";
        String pwd = "xxx";
        String m3u8 = convert.rtsp2Hls(ip, userName, pwd);
        System.out.println("***********************************" + m3u8);
        Thread.sleep(10 * 1000);
        convert.stopTransform(ip);
        System.out.println("************************************结束**************");
    }
}

 

二、前端vue部分

<template>
  <div class="app-container">
    
    <!-- 视频播放 -->
    <el-dialog title="实时播放" :visible.sync="openPlay" width="800px" :before-close="closePlayDialog" append-to-body>
      <el-row>
          <video-player v-if="hlsUrl != null" class="video-player vjs-custom-skin" ref="videoPlayer"
            :playsinline="true" :options="playerOptions" @error="playError"></video-player>
      </el-row>
    </el-dialog>
  </div>
</template>

<script>
import { listDevice, getDevice, delDevice, addDevice, updateDevice,startTransform } from "@/api/biz/device";
import { queryAllClassRoom } from '@/api/biz/classRoom';
import { skipAiCamera, skipHikCamera } from '@/utils/ruoyi';
import 'videojs-contrib-hls'


export default {
  name: "Device",
  dicts: ['device_type', 'device_states'],
  data() {
    return {
    
      playerOptions: {
        // playbackRates: [0.5, 1.0, 1.5, 2.0], //可选择的播放速度
        autoplay: false, //如果true,浏览器准备好时开始回放。
        muted: false, // 默认情况下将会消除任何音频。
        loop: false, // 视频一结束就重新开始。
        preload: 'auto', // 建议浏览器在<video>加载元素后是否应该开始下载视频数据。auto浏览器选择最佳行为,立即开始加载视频（如果浏览器支持）
        language: 'zh-CN',
        aspectRatio: '16:9', // 将播放器置于流畅模式，并在计算播放器的动态大小时使用该值。值应该代表一个比例 - 用冒号分隔的两个数字（例如"16:9"或"4:3"）
        fluid: true, // 当true时，Video.js player将拥有流体大小。换句话说，它将按比例缩放以适应其容器。
        sources: [{
          type: "application/x-mpegURL",
          src: ''//url地址
        }],
        hls: true,
        poster: "", //你的封面地址
        // width: document.documentElement.clientWidth,
        notSupportedMessage: '此视频暂无法播放，请稍后再试', //允许覆盖Video.js无法播放媒体源时显示的默认信息。
        controlBar: {
          timeDivider: false,//当前时间和持续时间的分隔符
          durationDisplay: false,//显示持续时间
          remainingTimeDisplay: false,//是否显示剩余时间功能
          fullscreenToggle: true  //全屏按钮
        }
      },
      hlsUrl: '',
      openPlay: false,
    };
  },
  created() {

  },
  methods: {
   
    //播放监控画面
    handlePlay(row) {
      startTransform(row.id).then(res => {
        let url = process.env.VUE_APP_BASE_API + res.msg.replaceAll("\\", "/");
      //   console.log("播放url",url);
        this.openPlay = true;
        this.playerOptions.sources[0].src = url;
        // this.playerOptions.sources[0].src = "http://192.168.0.249:10000/hls/192_168_0_251/live.m3u8";
        this.hlsUrl = url;
      })
    },
    //关闭播放弹窗
    closePlayDialog(done) {
      try {
        this.$refs.videoPlayer.player.pause();
        this.$refs.videoPlayer.reset();
      } catch(e) {
      }
      done();
    },
    playError(e) {
      console.log("播放异常，自动重启播放器", e)
      if (e.error_ && e.error_.code == 4) {

      } else { //当出现m3u8文件加载错误时，自动重新播放
        this.$refs.videoPlayer.player.src(this.hlsUrl);
        this.$refs.videoPlayer.player.load(this.hlsUrl);
        this.$refs.videoPlayer.player.play();
      }
    }
  }
};
</script>

三、效果