AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

javacv实现流媒体服务

2022-02-11 6597
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 通过javacv将rtsp、rtmp流转换为flv

一、引入pom

构建springboot项目

            <groupId>org.bytedeco</groupId>
            <artifactId>javacv-platform</artifactId>
            <version>1.5.1</version>
        </dependency>

二、创建全局异常处理器、返回类

j
import com.xgc.rtspconverterflvspringbootstarter.result.JsonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.properties.bind.validation.BindValidationException;
import org.springframework.http.converter.HttpMessageConversionException;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.validation.BindException;
import org.springframework.web.HttpMediaTypeException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * 全局异常处理器
 * 
 */
@Slf4j
@RestControllerAdvice
public class GlobleExceptionHandler {

    /**
     * 404 异常捕捉处理
     * 
     * @param ex
     * @return
     */
    @ExceptionHandler(value = org.springframework.web.servlet.NoHandlerFoundException.class)
    public JsonResult errorHandler(org.springframework.web.servlet.NoHandlerFoundException ex) {
        log.error(ex.getMessage(), ex);
        return JsonResult.result(404, "服务接口不存在。");
    }

    /**
     * 参数校验出错
     * 
     * @param ex
     * @return
     */
    @ExceptionHandler(value = BindException.class)
    public JsonResult errorHandler(BindException ex) {
        log.error(ex.getMessage(), ex);
        return JsonResult.error().put("message", "参数不正确," + ex.getMessage());
    }

    /**
     * 参数校验出错
     * 
     * @param ex
     * @return
     */
    @ExceptionHandler(value = BindValidationException.class)
    public JsonResult errorHandler(BindValidationException ex) {
        log.error(ex.getMessage(), ex);
        return JsonResult.error().put("message", "参数不正确," + ex.getMessage());
    }

    /**
     * 请求的方式不支持
     * 
     * @param ex
     * @return
     */
    @ExceptionHandler(value = HttpRequestMethodNotSupportedException.class)
    public JsonResult errorHandler(HttpRequestMethodNotSupportedException ex) {
        log.error(ex.getMessage(), ex);
        return JsonResult.error().put("message", "Http 方式不正确," + ex.getMessage());
    }

    /**
     * 非法的参数异常
     * 
     * @param ex
     * @return
     */
    @ExceptionHandler(value = IllegalArgumentException.class)
    public JsonResult errorHandler(IllegalArgumentException ex) {
        log.error(ex.getMessage(), ex);
        return JsonResult.error(500, "非法的参数，" + ex.getMessage());
    }

    /**
     * 类型异常
     * 
     * @param ex
     * @return
     */
    @ExceptionHandler(value = HttpMediaTypeException.class)
    public JsonResult errorHandler(HttpMediaTypeException ex) {
        log.error(ex.getMessage(), ex);
        return JsonResult.error().put("message", "服务异常,请检查参数及调用方式。详情内容为： " + ex.getMessage());
    }

    /**
     * 拦截捕捉 CMSException.class
     * 
     * @param ex
     * @return
     */
    @ExceptionHandler(value = HttpMessageConversionException.class)
    public JsonResult errorHandler(HttpMessageConversionException ex) {
        log.error(ex.getMessage(), ex);
        return JsonResult.error().put("message", "参数不正确。详情内容为：" + ex.getMessage());
    }

    /**
     * 全局异常捕捉处理
     * 
     * @param ex
     * @return
     */
    @ExceptionHandler(value = Exception.class)
    public JsonResult errorHandler(Exception ex) {
        log.error(ex.getMessage(), ex);
        return JsonResult.error().put("message", "服务异常,暂时不可用。" + ex.getMessage());
    }

    /**
     * 参数不能解析
     * 
     * @param ex
     * @return
     */
    @ExceptionHandler(value = HttpMessageNotReadableException.class)
    public JsonResult errorHandler(HttpMessageNotReadableException ex) {
        log.error(ex.getMessage(), ex);
        return JsonResult.error().put("message", "参数解析异常，请检查参数格式。" + ex.getMessage());
    }
}```

import com.alibaba.fastjson.JSONObject;

import java.io.Serializable;
import java.util.HashMap;

/**

  • 封装返回结果

*/
public class JsonResult extends HashMap<String, Object> implements Serializable {

private static final long serialVersionUID = 1L;
public static final int SUCCESS = 200;

public JsonResult() {
}

/**
 * 返回成功
 */
public static JsonResult ok() {
    return ok("操作成功");
}

/**
 * 返回成功
 */
public static JsonResult okFallBack() {
    return okFallBack("操作成功");
}

/**
 * 返回成功
 */
public JsonResult put(Object obj) {
    return this.put("data", obj);
}

/**
 * 返回成功
 */
public static JsonResult ok(String message) {
    return result(200, message);
}

/**
 * 降级函数 - 返回成功
 */
public static JsonResult okFallBack(String message) {
    return result(205, message);
}

/**
 * 返回成功
 */
public static JsonResult result(int code, String message) {
    JsonResult jsonResult = new JsonResult();
    jsonResult.put("timestamp", System.currentTimeMillis());
    jsonResult.put("status", code);
    jsonResult.put("message", message);
    return jsonResult;
}

/**
 * 返回失败
 */
public static JsonResult error() {
    return error("操作失败");
}

/**
 * 返回失败
 */
public static JsonResult error(String message) {
    return error(500, message);
}

/**
 * 返回失败
 */
public static JsonResult error(int code, String message) {
    JsonResult jsonResult = new JsonResult();
    jsonResult.put("timestamp", System.currentTimeMillis());
    jsonResult.put("status", code);
    jsonResult.put("message", message);
    return jsonResult;
}

/**
 * 设置code
 */
public JsonResult setCode(int code) {
    super.put("status", code);
    return this;
}

/**
 * 设置message
 */
public JsonResult setMessage(String message) {
    super.put("message", message);
    return this;
}

/**
 * 放入object
 */
@Override
public JsonResult put(String key, Object object) {
    super.put(key, object);
    return this;
}

/**
 * 权限禁止
 */
public static JsonResult forbidden(String message) {
    JsonResult jsonResult = new JsonResult();
    jsonResult.put("timestamp", System.currentTimeMillis());
    jsonResult.put("status", 401);
    jsonResult.put("message", message);
    return jsonResult;
}

@Override
public String toString() {
    return JSONObject.toJSONString(this);
}

public JSONObject toJSONObject() {
    return JSONObject.parseObject(toString());
}

}`

三、创建转换器接口

public interface Converter {

    /**
     * 获取该转换的key
     */
    public String getKey();

    /**
     * 获取该转换的url
     * 
     * @return
     */
    public String getUrl();

    /**
     * 添加一个流输出
     * 
     * @param entity
     */
    public void addOutputStreamEntity(String key, AsyncContext entity) throws IOException;

    /**
     * 退出转换
     */
    public void exit();

    /**
     * 启动
     */
    public void start();

}

四、javacv转包装处理类


import com.alibaba.fastjson.util.IOUtils;
import lombok.extern.slf4j.Slf4j;
import org.bytedeco.ffmpeg.avcodec.AVPacket;
import org.bytedeco.ffmpeg.global.avcodec;
import org.bytedeco.javacv.FFmpegFrameGrabber;
import org.bytedeco.javacv.FFmpegFrameRecorder;

import javax.servlet.AsyncContext;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * javacv转包装<br/>
 * 无须转码，更低的资源消耗，更低的延迟<br/>
 * 确保流来源视频H264格式,音频AAC格式
 * 
 * @author gc.x
 */
@Slf4j
public class ConverterFactories extends Thread implements Converter {
    public volatile boolean runing = true;
    /**
     * 读流器
     */
    private FFmpegFrameGrabber grabber;
    /**
     * 转码器
     */
    private FFmpegFrameRecorder recorder;
    /**
     * 转FLV格式的头信息<br/>
     * 如果有第二个客户端播放首先要返回头信息
     */
    private byte[] headers;
    /**
     * 保存转换好的流
     */
    private ByteArrayOutputStream stream;
    /**
     * 流地址，h264,aac
     */
    private String url;
    /**
     * 流输出
     */
    private List<AsyncContext> outEntitys;

    /**
     * key用于表示这个转换器
     */
    private String key;

    /**
     * 转换队列
     */
    private Map<String, Converter> factories;

    public ConverterFactories(String url, String key, Map<String, Converter> factories, List<AsyncContext> outEntitys) {
        this.url = url;
        this.key = key;
        this.factories = factories;
        this.outEntitys = outEntitys;
    }

    @Override
    public void run() {
        boolean isCloseGrabberAndResponse = true;
        try {
            grabber = new FFmpegFrameGrabber(url);
            if ("rtsp".equals(url.substring(0, 4))) {
                grabber.setOption("rtsp_transport", "tcp");
                grabber.setOption("stimeout", "5000000");
            }
            grabber.start();
            if (avcodec.AV_CODEC_ID_H264 == grabber.getVideoCodec()
                    && (grabber.getAudioChannels() == 0 || avcodec.AV_CODEC_ID_AAC == grabber.getAudioCodec())) {
                log.info("this url:{} converterFactories start", url);
                // 来源视频H264格式,音频AAC格式
                // 无须转码，更低的资源消耗，更低的延迟
                stream = new ByteArrayOutputStream();
                recorder = new FFmpegFrameRecorder(stream, grabber.getImageWidth(), grabber.getImageHeight(),
                        grabber.getAudioChannels());
                recorder.setInterleaved(true);
                recorder.setVideoOption("preset", "ultrafast");
                recorder.setVideoOption("tune", "zerolatency");
                recorder.setVideoOption("crf", "25");
                recorder.setFrameRate(grabber.getFrameRate());
                recorder.setSampleRate(grabber.getSampleRate());
                if (grabber.getAudioChannels() > 0) {
                    recorder.setAudioChannels(grabber.getAudioChannels());
                    recorder.setAudioBitrate(grabber.getAudioBitrate());
                    recorder.setAudioCodec(grabber.getAudioCodec());
                }
                recorder.setFormat("flv");
                recorder.setVideoBitrate(grabber.getVideoBitrate());
                recorder.setVideoCodec(grabber.getVideoCodec());
                recorder.start(grabber.getFormatContext());
                if (headers == null) {
                    headers = stream.toByteArray();
                    stream.reset();
                    writeResponse(headers);
                }
                int nullNumber = 0;
                while (runing) {
                    AVPacket k = grabber.grabPacket();
                    if (k != null) {
                        try {
                            recorder.recordPacket(k);
                        } catch (Exception e) {
                        }
                        if (stream.size() > 0) {
                            byte[] b = stream.toByteArray();
                            stream.reset();
                            writeResponse(b);
                            if (outEntitys.isEmpty()) {
                                log.info("没有输出退出");
                                break;
                            }
                        }
                        avcodec.av_packet_unref(k);
                    } else {
                        nullNumber++;
                        if (nullNumber > 200) {
                            break;
                        }
                    }
                    Thread.sleep(5);
                }
            } else {
                isCloseGrabberAndResponse = false;
                // 需要转码为视频H264格式,音频AAC格式
                ConverterTranFactories c = new ConverterTranFactories(url, key, factories, outEntitys, grabber);
                factories.put(key, c);
                c.start();
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        } finally {
            closeConverter(isCloseGrabberAndResponse);
            completeResponse(isCloseGrabberAndResponse);
            log.info("this url:{} converterFactories exit", url);

        }
    }

    /**
     * 输出FLV视频流
     * 
     * @param b
     */
    public void writeResponse(byte[] b) {
        Iterator<AsyncContext> it = outEntitys.iterator();
        while (it.hasNext()) {
            AsyncContext o = it.next();
            try {
                o.getResponse().getOutputStream().write(b);
            } catch (Exception e) {
                log.info("移除一个输出");
                it.remove();
            }
        }
    }

    /**
     * 退出转换
     */
    public void closeConverter(boolean isCloseGrabberAndResponse) {
        if (isCloseGrabberAndResponse) {
            IOUtils.close(grabber);
            factories.remove(this.key);
        }
        IOUtils.close(recorder);
        IOUtils.close(stream);
    }

    /**
     * 关闭异步响应
     * 
     * @param isCloseGrabberAndResponse
     */
    public void completeResponse(boolean isCloseGrabberAndResponse) {
        if (isCloseGrabberAndResponse) {
            Iterator<AsyncContext> it = outEntitys.iterator();
            while (it.hasNext()) {
                AsyncContext o = it.next();
                o.complete();
            }
        }
    }

    @Override
    public String getKey() {
        return this.key;
    }

    @Override
    public String getUrl() {
        return this.url;
    }

    @Override
    public void addOutputStreamEntity(String key, AsyncContext entity) throws IOException {
        if (headers == null) {
            outEntitys.add(entity);
        } else {
            entity.getResponse().getOutputStream().write(headers);
            entity.getResponse().getOutputStream().flush();
            outEntitys.add(entity);
        }
    }

    @Override
    public void exit() {
        this.runing = false;
        try {
            this.join();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }

}


import com.alibaba.fastjson.util.IOUtils;
import lombok.extern.slf4j.Slf4j;
import org.bytedeco.ffmpeg.global.avcodec;
import org.bytedeco.javacv.FFmpegFrameGrabber;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import org.bytedeco.javacv.Frame;

import javax.servlet.AsyncContext;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * javacv转码<br/>
 * 流来源不是视频H264格式,音频AAC格式 转码为视频H264格式,音频AAC格式
 * 
 * @author gc.x
 */
@Slf4j
public class ConverterTranFactories extends Thread implements Converter {
    public volatile boolean runing = true;
    /**
     * 读流器
     */
    private FFmpegFrameGrabber grabber;
    /**
     * 转码器
     */
    private FFmpegFrameRecorder recorder;
    /**
     * 转FLV格式的头信息<br/>
     * 如果有第二个客户端播放首先要返回头信息
     */
    private byte[] headers;
    /**
     * 保存转换好的流
     */
    private ByteArrayOutputStream stream;
    /**
     * 流地址，h264,aac
     */
    private String url;
    /**
     * 流输出
     */
    private List<AsyncContext> outEntitys;

    /**
     * key用于表示这个转换器
     */
    private String key;

    /**
     * 转换队列
     */
    private Map<String, Converter> factories;

    public ConverterTranFactories(String url, String key, Map<String, Converter> factories,
            List<AsyncContext> outEntitys, FFmpegFrameGrabber grabber) {
        this.url = url;
        this.key = key;
        this.factories = factories;
        this.outEntitys = outEntitys;
        this.grabber = grabber;
    }

    @Override
    public void run() {
        try {
            log.info("this url:{} converterTranFactories start", url);
            grabber.setFrameRate(25);
            if (grabber.getImageWidth() > 1920) {
                grabber.setImageWidth(1920);
            }
            if (grabber.getImageHeight() > 1080) {
                grabber.setImageHeight(1080);
            }
            stream = new ByteArrayOutputStream();
            recorder = new FFmpegFrameRecorder(stream, grabber.getImageWidth(), grabber.getImageHeight(),
                    grabber.getAudioChannels());
            recorder.setInterleaved(true);
            recorder.setVideoOption("preset", "ultrafast");
            recorder.setVideoOption("tune", "zerolatency");
            recorder.setVideoOption("crf", "25");
            recorder.setGopSize(50);
            recorder.setFrameRate(25);
            recorder.setSampleRate(grabber.getSampleRate());
            if (grabber.getAudioChannels() > 0) {
                recorder.setAudioChannels(grabber.getAudioChannels());
                recorder.setAudioBitrate(grabber.getAudioBitrate());
                recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
            }
            recorder.setFormat("flv");
            recorder.setVideoBitrate(grabber.getVideoBitrate());
            recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
            recorder.start();
            if (headers == null) {
                headers = stream.toByteArray();
                stream.reset();
                writeResponse(headers);
            }
            int nullNumber = 0;
            while (runing) {
                // 抓取一帧
                Frame f = grabber.grab();
                if (f != null) {
                    try {
                        // 转码
                        recorder.record(f);
                    } catch (Exception e) {
                    }
                    if (stream.size() > 0) {
                        byte[] b = stream.toByteArray();
                        stream.reset();
                        writeResponse(b);
                        if (outEntitys.isEmpty()) {
                            log.info("没有输出退出");
                            break;
                        }
                    }
                } else {
                    nullNumber++;
                    if (nullNumber > 200) {
                        break;
                    }
                }
                Thread.sleep(5);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        } finally {
            closeConverter();
            completeResponse();
            log.info("this url:{} converterTranFactories exit", url);
            factories.remove(this.key);
        }
    }

    /**
     * 输出FLV视频流
     * 
     * @param b
     */
    public void writeResponse(byte[] b) {
        Iterator<AsyncContext> it = outEntitys.iterator();
        while (it.hasNext()) {
            AsyncContext o = it.next();
            try {
                o.getResponse().getOutputStream().write(b);
            } catch (Exception e) {
                log.info("移除一个输出");
                it.remove();
            }
        }
    }

    /**
     * 退出转换
     */
    public void closeConverter() {
        IOUtils.close(grabber);
        IOUtils.close(recorder);
        IOUtils.close(stream);
    }

    /**
     * 关闭异步响应
     */
    public void completeResponse() {
        Iterator<AsyncContext> it = outEntitys.iterator();
        while (it.hasNext()) {
            AsyncContext o = it.next();
            o.complete();
        }
    }

    @Override
    public String getKey() {
        return this.key;
    }

    @Override
    public String getUrl() {
        return this.url;
    }

    @Override
    public void addOutputStreamEntity(String key, AsyncContext entity) throws IOException {
        if (headers == null) {
            outEntitys.add(entity);
        } else {
            entity.getResponse().getOutputStream().write(headers);
            entity.getResponse().getOutputStream().flush();
            outEntitys.add(entity);
        }
    }

    @Override
    public void exit() {
        this.runing = false;
        try {
            this.join();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }

}

五、使用

image.png



/**
 * FLV流转换
 * 
 * @author gc.x
 */
@Api(tags = "flv")
@RestController
public class FLVController {

    @Autowired
    private IFLVService service;
    @Autowired
    private IOpenFLVService openFLVService;

    @GetMapping(value = "/flv/hls/stream_{channel}.flv")
    public void open4(@PathVariable(value = "channel") Integer channel,HttpServletResponse response,
                      HttpServletRequest request) {
        String url = openFLVService.getUrl(channel);
        if(!StringUtils.isEmpty(url)){
            service.open(url, response, request);
        }
    }
}

image.png



import com.google.common.collect.Lists;
import com.xgc.rtspconverterflvspringbootstarter.factories.Converter;
import com.xgc.rtspconverterflvspringbootstarter.factories.ConverterFactories;
import com.xgc.rtspconverterflvspringbootstarter.service.IFLVService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.servlet.AsyncContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * FLV流转换
 * 
 * @author gc.x
 */
@Slf4j
@Service
public class FLVService implements IFLVService {

    private ConcurrentHashMap<String, Converter> converters = new ConcurrentHashMap<>();

    @Override
    public void open(String url, HttpServletResponse response, HttpServletRequest request) {
        String key = md5(url);
        AsyncContext async = request.startAsync();
        async.setTimeout(0);
        if (converters.containsKey(key)) {
            Converter c = converters.get(key);
            try {
                c.addOutputStreamEntity(key, async);
            } catch (IOException e) {
                log.error(e.getMessage(), e);
                throw new IllegalArgumentException(e.getMessage());
            }
        } else {
            List<AsyncContext> outs = Lists.newArrayList();
            outs.add(async);
            ConverterFactories c = new ConverterFactories(url, key, converters, outs);
            c.start();
            converters.put(key, c);
        }
        response.setContentType("video/x-flv");
        response.setHeader("Connection", "keep-alive");
        response.setStatus(HttpServletResponse.SC_OK);
        try {
            response.flushBuffer();
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        }
    }

    public String md5(String plainText) {
        StringBuilder buf = null;
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(plainText.getBytes());
            byte b[] = md.digest();
            int i;
            buf = new StringBuilder("");
            for (int offset = 0; offset < b.length; offset++) {
                i = b[offset];
                if (i < 0)
                    i += 256;
                if (i < 16)
                    buf.append("0");
                buf.append(Integer.toHexString(i));
            }
        } catch (NoSuchAlgorithmException e) {
            log.error(e.getMessage(), e);
        }
        return buf.toString();
    }

}

image.png

六、gitee地址

https://gitee.com/giteeClass/rtsp-converter-flv-spring-boot-starter

文章标签：
Java
javpower
目录
相关文章
热烈的马
|
分布式计算 大数据 Apache
【大数据技术】流数据、流计算、Spark Streaming、DStream的讲解（图文解释 超详细）
【大数据技术】流数据、流计算、Spark Streaming、DStream的讲解（图文解释 超详细）
热烈的马
563 0
zzy的aly
|
11月前
|
应用服务中间件 Linux nginx
FFmpeg学习笔记(一):实现rtsp推流rtmp以及ffplay完成拉流操作
这篇博客介绍了如何使用FFmpeg实现RTSP推流到RTMP服务器，并使用ffplay进行拉流操作，包括在Windows和Linux系统下的命令示例，以及如何通过HTML页面显示视频流。
zzy的aly
2347 0
Naylor
|
JavaScript IDE 测试技术
Rtsp转Flv在浏览器中播放
【2月更文挑战第5天】本文简单介绍如何间接实现在浏览器中播放rtsp的流，涉及技术点和工具较多，本文仅做功能实现思路的梳理和简单的代码实践，后续整理更深入的实现原理。
Naylor
1040 1
码农阿豪
|
存储 Java
java用modbus4j的RTU去操作那些寄存器（线圈，保持，输入，离散输入寄存器）
java用modbus4j的RTU去操作那些寄存器（线圈，保持，输入，离散输入寄存器）
码农阿豪
753 0
东方睿赢
|
10月前
|
编解码 监控 网络协议
如何使用FFmpeg实现RTSP推送H.264和H.265（HEVC）编码视频
本文详细介绍了如何使用FFmpeg实现RTSP推送H.264和H.265（HEVC）编码视频。内容涵盖环境搭建、编码配置、服务器端与客户端实现等方面，适合视频监控系统和直播平台等应用场景。通过具体命令和示例代码，帮助读者快速上手并实现目标。
东方睿赢
2457 6
jianz123
|
Web App开发 编解码 前端开发
怎么把rtsp视频流转成webrtc接口
【8月更文挑战第8天】将RTSP视频流转换为WebRTC接口涉及多个步骤：首先使用工具如webrtc-streamer、ffmpeg等从RTSP源获取视频流；接着对流进行解码与编码至WebRTC兼容格式（如VP8、H.264）；然后利用WebSocket建立客户端与服务器间的双向信令通道；再通过JavaScript创建WebRTC PeerConnection并交换SDP信息；最后添加Track传输视频数据，并在接收端解析显示。使用webrtc-streamer可简化这一过程，其API支持多种操作如添加ICE候选、创建Offer等。
jianz123
1969 2
一只会写程序的猫
|
监控 Oracle Java
Java视频流提取与播放技术详解
Java视频流提取与播放技术详解
一只会写程序的猫
1725 1
笨笨小乌龟
|
存储 编解码 容器
FFmpeg avformat_open_input() 函数返回错误protocol not found解决方法(实测有效！附简单FFMPEG的编解码流程)
我个人出现这个错误的时候是在打开文件时报的错误，开始以为我需要加上资源文件，那样QT确实能检测到文件的存在，但是在Debug中他是检测不到这个文件的。
笨笨小乌龟
1163 1
热爱技术的小郑
|
Java Linux Windows
java系列之 复制原始目录文件到新的 目录文件【Windows 和 Linux 均可使用】
这篇文章提供了Java中复制或移动目录及其文件（包括权限）的示例代码，包括删除目标目录内容、复制或移动整个目录的过程，并强调了在操作过程中需要注意的一些关键点。
热爱技术的小郑
305 0
code2roc
|
编解码 前端开发 Java
SpringBoot集成ffmpeg实现视频转码播放
之前构建过文件预览服务，对于视频部分前端播放组件限制只能为mp4格式，为了支持更多视频格式决定对方案进行升级，由于视频格式较多，针对每一种格式定制选择播放器不太现实，决定对视频源统一转码，转码后的格式为mp4，兼容性稳定且前后端改造工作较小
code2roc
813 0