java多线程按照时间段切割视频流片段

最新推荐文章于 2025-03-30 16:40:51 发布
最新推荐文章于 2025-03-30 16:40:51 发布
阅读量1.3k 收藏 5
点赞数 2
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiaogg3678/article/details/119826678
版权
此篇博客介绍了如何使用Spring Boot创建一个控制器，实现实时视频流的推送和停止操作，并通过SaveRecord线程管理器进行磁盘录像。提到的服务包括SaveRecord线程管理、推流异步任务、WoYunOSS文件上传和视频记录管理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

package com.chinaunicom.zwboy.controller;

import cn.hutool.core.io.FileUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.chinaunicom.common.base.convert.BaseConvert;
import com.chinaunicom.common.base.feign.RemoteUserGbCodeService;
import com.chinaunicom.common.base.feign.model.DeviceCommandPtzReqBaseDto;
import com.chinaunicom.common.core.constant.SecurityConstants;
import com.chinaunicom.video.entity.Lives;
import com.chinaunicom.video.entity.SvAircraftVideoRecord;
import com.chinaunicom.video.service.LivesService;
import com.chinaunicom.video.util.RedisUtil;
import com.chinaunicom.video.util.WoYunOssUtils;
import com.chinaunicom.zwboy.model.PushData;
import com.chinaunicom.zwboy.model.PushTask;
import com.chinaunicom.zwboy.service.*;
import com.chinaunicom.zwboy.service.impl.SaveRecordThreadManagerImpl;
import com.chinaunicom.zwboy.util.FileOperUtils;
import com.lh.service.SaveRecord;
import com.lh.service.SliceType;
import com.lh.service.impl.SaveRecordImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.*;

@Slf4j
@RestController
//@RequestMapping("/pushAsync")
public class PushLhController {

    @Autowired
    private SaveRecordThreadManagerImpl saveRecordThreadManagerImpl;

    @Autowired
    private PushAsyncService pushAsyncService;
    @Autowired
    private PushLhService pushLhService;

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private WoYunOssUtils woYunOssUtils;

    @Autowired
    private LivesService livesService;
    @Autowired
    private MyTaskService myTaskService;


    @Value("${linux.path}")
    private String linuxPath;

    @Value("${redisTime.expiredTime}")
    private Integer expiredTime;



    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;


    capableBeanFactory.autowireBean(forwardTask);


    // 创建一个定长线程池，支持定时及周期性任务执行,建立一个延时任务，1000毫秒之后执行
    ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);

    @PostMapping(value = "/pushers")
    @ResponseBody
    public String pusherAndStop(HttpServletRequest request, HttpServletResponse response, @RequestBody String param) {
        log.info("PushLhController PusherAndStop() param="+Thread.currentThread().getName()+" "+param);
        log.info("PushLhController PusherAndStop() linuxPath="+linuxPath);
        log.info("PushLhController PusherAndStop() expiredTime="+expiredTime);
        JSONObject jsonObject = JSONObject.parseObject(param);
        String stream = jsonObject.getString("stream");
        QueryWrapper<Lives> queryWrapperByid = BaseConvert.buildDelQueryWrapper();
        queryWrapperByid.eq("c_id", stream);
        Lives lives = livesService.getOne(queryWrapperByid);
        log.info("PushLhController PusherAndStop() lives="+ JSON.toJSONString(lives));
        if(lives==null){//无视
            return "0";
        }
        try {
            //校验推送流还是关闭流
            if (jsonObject.getString("action").equals("on_publish")) {
                PushData pushTask = new PushData();
                String uuid = UUID.randomUUID().toString().replace("-", "");
                pushTask.setId(uuid);
                pushTask.setPushSrcUrl(lives.getRtmpUrl());//推流源地址/改成播放地址
                pushTask.setPushDescUrl(linuxPath);
                pushTask.setStream(stream);
                String pushTaskJson = JSONUtil.toJsonStr(pushTask);
                log.info("PushLhController PusherAndStop() on_publish pushTaskJson="+pushTaskJson);
                //生成磁盘录像文件 //上传沃云成功并保存本地表记录
                //pushLhService.asyncStart(pushTask);
                String pushSrcUrl = pushTask.getPushSrcUrl();
                String pushDescUrl = pushTask.getPushDescUrl();
                String streamId = pushTask.getStream();
                // 参数"1234", "rtmp://172.16.10.196:1935/live/5e7367809f32448682177561af153f9d", "D:/tmp/", true, SliceType.DURATION, 10
                saveRecordThreadManagerImpl.start(streamId,pushSrcUrl,pushDescUrl,true, SliceType.DURATION, expiredTime);
                long initialDelay =  3L; //定时任务延时启动30秒
                long period = expiredTime+3L; //定时任务时间间隔5分钟,
                log.info("PushLhController PusherAndStop() period="+period);
                executor.scheduleAtFixedRate(myTaskService,initialDelay ,period, TimeUnit.SECONDS);
                //SaveRecord saveRecord = new SaveRecordImpl();
                //saveRecord.start("1234", "rtmp://172.16.10.196:1935/live/5e7367809f32448682177561af153f9d","D:/tmp/", true, SliceType.DURATION, 30);
                return "0";
            } else if (jsonObject.getString("action").equals("on_unpublish")) {
                //停止推流
                if(StringUtils.isNotBlank(stream)) {
                    pushLhService.asyncStop(stream);
                }
                return "0";
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return "0";
    }

}



package com.chinaunicom.zwboy.service.impl;

import com.chinaunicom.zwboy.service.SaveRecordService;
import com.chinaunicom.zwboy.util.ApplicationContextUtil;
import com.lh.service.SliceType;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;
@Slf4j
@Service
public class SaveRecordThreadManagerImpl  {

    Map<String, SaveRecordService> saveRecordMap = new HashMap<>();


    /**
     *
     * @param id 线程id
     * @param inputFile 网络输入流 rtmp
     * @param outputFile 输出mp4文件
     * @param needAudio 是否录音
     * @param sliceType
     * @param arg 多久生成一个mp4 单位秒
     */


    @Async
    public void start(String id, String inputFile, String outputFile, Boolean needAudio, SliceType sliceType, int arg) {
        SaveRecordService saveRecord;
        synchronized (saveRecordMap) {
            saveRecord = saveRecordMap.get(id);
            if (saveRecord == null) {
                saveRecord = new SaveRecordServiceImpl();
                //saveRecord =  ApplicationContextUtil.getBean("saveRecordServiceImpl");
                saveRecordMap.put(id, saveRecord);
            }
        }
        saveRecord.start(id, inputFile, outputFile, needAudio, sliceType, arg);
    }


    public void stop(String id) {
        SaveRecordService saveRecord;
        synchronized (saveRecordMap) {
            saveRecord = saveRecordMap.get(id);
            saveRecordMap.remove(id);
        }
        if (saveRecord != null)
            saveRecord.stop(id);
    }



}




package com.chinaunicom.zwboy.service.impl;

import com.chinaunicom.zwboy.service.NewRecordService;
import com.chinaunicom.zwboy.service.SaveRecordService;
import com.lh.service.SliceType;
import lombok.extern.slf4j.Slf4j;
import org.bytedeco.javacv.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.io.File;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

@Slf4j
@Service("saveRecordServiceImpl")
public class SaveRecordServiceImpl implements SaveRecordService {
    private FFmpegFrameGrabber grabber;
    private FFmpegFrameRecorder recorder;


    private NewRecordService newRecordService;

    private String id;
    private Boolean isStart = false;
    private int seconds;

    @Value("5000000")
    private String stimeout;        // 连接输入视频流超时, us

    @Value("3000000")
    private String timeout;         // tcp/udp超时, us

    private String inputFile;       // 输入视频流地址
    private String outPath;         // 输出路径
    private String outputFile;      // 输出文件
    private Boolean needAudio;      // 是否需要音频
    private Date startTime;
    SliceType sliceType;            // 切片类型
    int sliceArg;                   // 切片参数
    Frame lastKeyFrame;
    Integer index = 0;


    @Override
    public void start(String id, String inputFile, String outPath, Boolean needAudio, SliceType sliceType, int arg) {
        synchronized (isStart) {
            if (isStart)
                return;
            this.id = id;
            this.inputFile = inputFile;
            if (outPath.charAt(outPath.length() - 1) != '/')
                this.outPath = outPath + "/";
            else
                this.outPath = outPath;
            this.needAudio = needAudio;
            this.sliceType = sliceType;
            this.sliceArg = arg;
            this.isStart = true;
        }
        save_record();
    }

    @Override
    public void stop(String id) {
        synchronized (isStart) {
            if (!isStart)
                return;
            isStart = false;
        }
    }

    @Async
    public void save_record() {
        while (isStart) {
            try {
                // 打开视频流
                if (grabber == null) {
                    try {
                        log.info("打开流地址={}", inputFile);
                        grabber = new FFmpegFrameGrabber(inputFile);
                        grabber.setOption("stimeout", stimeout);
                        grabber.setOption("timeout", timeout);
                        grabber.start();
                    } catch (FrameGrabber.Exception e) {
                        log.error("grabber打开失败, {}", e.toString());
                        grabber = null;
                        continue;
                    }
                }
                getFilename();
                recorder = new FFmpegFrameRecorder(outputFile, grabber.getImageWidth(), grabber.getImageHeight(),
                        needAudio ? 1 : 0);
                recorder.start();
                startTime = new Date();
                Frame frame = null;
                try {
                    while (isStart) {
                        if (lastKeyFrame == null)
                            frame = grabber.grabFrame();
                        else {
                            frame = lastKeyFrame;
                            lastKeyFrame = null;
                        }
                        if (needSlice(frame)) {
                            lastKeyFrame = frame;
                            saveRecord();
                            break;
                        }
                        if (frame != null) {
                            recorder.record(frame);
                        }
                    }
                } catch (FrameRecorder.Exception e) {
                    log.error("save_record 1= 写录像出错, {}", e.toString());
                }
                saveRecord();
            } catch (FrameGrabber.Exception | FrameRecorder.Exception e) {
                log.error("save_record 2= 初始化失败", e.toString());
                e.printStackTrace();
            } finally {
                saveRecord();
            }
        }
    }

    // 判断是否需要切片
    boolean needSlice(Frame frame) {
        switch (sliceType) {
            case DURATION:
                return sliceArg <= getDuration() && frame.keyFrame;
            case SIZE:
                break;
            default:
                assert false;
        }
        return false;
    }

    // 保存当前的录像
    void saveRecord() {
        try {
            if (recorder != null) {
                recorder.stop();
                Date cur = new Date();
                log.info("saveRecourdFile=新录像生成={}, startTime={}, duration={}", outputFile, startTime, getDuration());
                //log.info("deleteRecourdFile=新录像删除={}, startTime={}, duration={}", outputFile, startTime, getDuration());
                //newRecordService.newRocord(id, outputFile, startTime, getDuration());
                newRecordService=new NewRecordServiceImpl();
                newRecordService.delNewRocord(id, outputFile, startTime, getDuration());
                recorder = null;
            }
        } catch (FrameRecorder.Exception e) {
            log.info("saveRecord FrameRecorder:"+e.getMessage());
            e.printStackTrace();
        }
    }

    long getDuration() {
        Date cur = new Date();
        return (cur.getTime() - startTime.getTime()) / 1000;
    }

    void getFilename() {
        DateFormat df = new SimpleDateFormat("yyMMddHHmmssSSS"); // add S if you need millisecon// ds
        String filename = df.format(new Date());
        outputFile = outPath + filename + "_" + id + ".mp4";
        index += 1;
    }


}





package com.chinaunicom.zwboy.service.impl;

import com.chinaunicom.video.service.LivesService;
import com.chinaunicom.video.util.WoYunOssUtils;
import com.chinaunicom.zwboy.service.NewRecordService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.io.File;
import java.util.Date;


@Slf4j
@Service
public class NewRecordServiceImpl implements NewRecordService {

    @Value("${linux.path}")
    private String linuxPath;

    @Value("${redisTime.expiredTime}")
    private Long expiredTime;

    @Autowired
    private WoYunOssUtils woYunOssUtils;

    @Autowired
    private LivesService livesService;
    int count=0;

    @Override
    public void newRocord(String id, String fileName, Date startTime, long duration) {
        // 定时任务业务逻辑
        count++;
        log.info("NewRecordServiceImpl newRocord fileName:" + fileName+"id:"+id+" count:"+count++);
        /*File child = new File(fileName);
        if (child.length() <= 258) {
            return;
        }
        String stream = id;
        log.info("NewRecordServiceImpl toUpload2 fileName=" + fileName);
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream(child);
            DateFormat df = new SimpleDateFormat(FileOperUtils.dateFormatStr); // add S if you need millisecon// ds
            String filename = df.format(new Date());
            String fileName2 = filename + "-" + stream + ".mp4";
            String url = woYunOssUtils.uploadFileToMp4(inputStream, fileName2, child.length());
            PushData pushData = new PushData();
            String uuid = UUID.randomUUID().toString().replace("-", "");
            pushData.setId(uuid);
            pushData.setPushDescUrl(fileName2);
            pushData.setStream(stream);
            pushData.setRecordCreateTime(new Date());
            pushData.setRecordName(fileName2);
            pushData.setRecordStorePath(url);
            log.info("NewRecordServiceImpl toUpload2 pushData=" + JSON.toJSONString(pushData));
            QueryWrapper<Lives> queryWrapperByid = BaseConvert.buildDelQueryWrapper();
            queryWrapperByid.eq("c_id", pushData.getStream());
            Lives lives = livesService.getOne(queryWrapperByid);
            log.info("NewRecordServiceImpl toUpload() lives:" + JSON.toJSONString(lives));
            SvAircraftVideoRecord svAircraftVideoRecord = new SvAircraftVideoRecord();
            svAircraftVideoRecord.setSvLiveId(lives.getCId());
            svAircraftVideoRecord.setFileSize(child.length());
            svAircraftVideoRecord.setRecordName(pushData.getRecordName());
            svAircraftVideoRecord.setRecordStorePath(pushData.getRecordStorePath());
            svAircraftVideoRecord.setRecordCreateTime(pushData.getRecordCreateTime());
            log.info("NewRecordServiceImpl toUpload2 svAircraftVideoRecord=" + JSON.toJSONString(svAircraftVideoRecord));
            //livesService.saveSvAircraftVideoRecord(svAircraftVideoRecord);
            //上传完沃云删除服务器本地文件
            //child.delete();
        } catch (Exception e) {
            e.printStackTrace();
        }*/
    }

    @Override
    public void delNewRocord(String id, String filename, Date startTime, long duration) {
        //log.info("NewRecordServiceImpl delNewRocord :" + filename);
        File root = new File(filename);
        if (root.isFile()) {
            if(root.length()<=258) {
                root.delete();
            }
        }
    }
}




package com.chinaunicom.zwboy.service;

import cn.hutool.core.io.FileUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.chinaunicom.common.base.convert.BaseConvert;
import com.chinaunicom.video.entity.Lives;
import com.chinaunicom.video.entity.SvAircraftVideoRecord;
import com.chinaunicom.video.service.LivesService;
import com.chinaunicom.video.util.WoYunOssUtils;
import com.chinaunicom.zwboy.model.PushData;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Date;
import java.util.UUID;

@Slf4j
@Service
public class MyTaskService implements Runnable{

    @Value("${linux.path}")
    private String linuxPath;

    @Value("${redisTime.expiredTime}")
    private Long expiredTime;

    @Autowired
    private WoYunOssUtils woYunOssUtils;

    @Autowired
    private LivesService livesService;

    @Override
    public void run() {
        // 定时任务业务逻辑
        log.info("MyTaskService runLinuxPath :"+linuxPath);
        File root = new File(linuxPath);
        if (root != null && root.exists()) {
            if (root.isDirectory()) {
                File[] children = root.listFiles();
                if (children != null) {
                    for (File child : children) {
                        String fileName = child.getName();
                        if (child.isFile() && fileName.endsWith("mp4")) {
                            long fileSize = child.length();
                            if(fileSize<=258){
                                child.delete();
                            }else {
                                String[] fileNames = fileName.split("_");
                                String streamId = fileNames[1];
                                Integer nameIndex2 = streamId.lastIndexOf(".");
                                String stream = streamId.substring(0, nameIndex2);
                                log.info("MyTaskService child.length() :" + fileSize + "fileName:" + fileName);
                                InputStream inputStream = null;
                                try {
                                    if(fileSize<=258){
                                        child.delete();
                                        continue;
                                    }
                                    inputStream = new FileInputStream(child);
                                    String url = woYunOssUtils.uploadFileToMp4(inputStream, fileName, fileSize);
                                    PushData pushData = new PushData();
                                    String uuid = UUID.randomUUID().toString().replace("-", "");
                                    pushData.setId(uuid);
                                    pushData.setPushDescUrl(fileName);
                                    pushData.setStream(stream);
                                    pushData.setRecordCreateTime(new Date());
                                    pushData.setRecordName(fileName);
                                    pushData.setRecordStorePath(url);
                                    log.info("MyTaskService toUpload2 pushData=" + JSON.toJSONString(pushData));
                                    QueryWrapper<Lives> queryWrapperByid = BaseConvert.buildDelQueryWrapper();
                                    queryWrapperByid.eq("c_id", pushData.getStream());
                                    Lives lives = livesService.getOne(queryWrapperByid);
                                    log.info("MyTaskService toUpload2() lives:" + JSON.toJSONString(lives));
                                    if(lives!=null) {
                                        SvAircraftVideoRecord svAircraftVideoRecord = new SvAircraftVideoRecord();
                                        svAircraftVideoRecord.setSvLiveId(lives.getCId());
                                        svAircraftVideoRecord.setSvLiveName(lives.getName());
                                        svAircraftVideoRecord.setFileSize(fileSize);
                                        svAircraftVideoRecord.setRecordName(pushData.getRecordName());
                                        svAircraftVideoRecord.setRecordStorePath(pushData.getRecordStorePath());
                                        svAircraftVideoRecord.setRecordCreateTime(pushData.getRecordCreateTime());
                                        log.info("MyTaskService toUpload2 svAircraftVideoRecord=" + JSON.toJSONString(svAircraftVideoRecord));
                                        livesService.saveSvAircraftVideoRecord(svAircraftVideoRecord);
                                        //上传完沃云删除服务器本地文件
                                        child.delete();
                                    }
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

使用JavaCV将视频切割为多个分片文件（以MP4格式为例）
CyberXZ的博客
09-03 1012
在本文中，我们将使用JavaCV库来实现将视频文件切割为多个分片文件的功能，我们以MP4格式的视频为例进行说明。JavaCV是一个基于Java平台的计算机视觉和机器学习库，它提供了许多用于处理视频和图像的功能。现在，我们将实现将视频切割为多个分片文件的功能。然后，我们使用循环逐帧读取视频，并根据设定的分片持续时间创建新的分片文件。现在，我们可以调用上面编写的视频切割方法来将视频切割为多个分片文件。在上面的代码中，我们指定了输入视频文件的路径、输出分片文件的路径以及每个分片的持续时间。实例来保存下一个分片。
使用JavaCV进行视频切割，并生成多个MP4分片文件
DevRevolt的博客
08-14 732
在本篇文章中，我们将讨论如何使用JavaCV库来切割视频，并生成多个MP4格式的分片文件。JavaCV是一个在Java中使用OpenCV和FFmpeg的强大工具库，它为我们提供了许多处理图像和视频的功能。确保在运行代码之前，导入所需的视频文件，并根据需要修改输入文件路径和输出文件名前缀。首先，我们需要在项目中引入JavaCV库。接下来，我们将编写代码来实现视频切割的功能。方法中，我们设置输入文件路径、输出文件名前缀和要生成的分片数量，并调用。获取视频的总帧数，并计算每个分片应有的帧数。
Java 实现视频时间维度剪切 | Java工具类
阿良的博客
12-27 2723
本文提供将视频按照时间维度进行剪切的Java工具类，一如既往的实用主义。
如何用Java实现视频文件夹的分片上传下载？
最新发布
2501_90699800的博客
03-30 686
要求：开源，免费，技术支持技术：分片,分块,断点续传,加密传输,加密存储需求：大文件上传，批量上传，断点续传，文件夹上传，大文件下载，批量下载，断点下载，文件夹下载文件夹：上传下载需要支持层级结构，采用非压缩方式文件大小：100G前端：vue2,vue3,vue-cli,jquery,html,webuploader后端：java,JSP,springboot,struts服务器：linux,信创国产化数据库：mysql,oracle,达梦，国产化数据库。
视频分片播放java
weixin_42135073的博客
08-12 419
视频分片播放的实现：Java开发新手指南 在视频处理领域，视频分片播放是一种常见的技术，它能够分段加载视频，节省带宽并提高播放效率。在这篇文章中，我将带你一步一步地实现一个简单的视频分片播放功能。我们将使用Java来完成这个任务。 整体流程 在开始之前，首先我们需要了解一下视频分片播放的整体流程。下表展示了这个过程的主要步...
java视频剪辑,截取视频指定时间段内容
12-08
功能说明：java视频剪辑，可按时间将视频截取为子视频。 使用说明：解压导入eclipse后执行main方法即可。
手机视频裁剪与合并工具介绍
- 视频流同步：合并视频时，各个视频片段的视频流和音频流都需要同步，可能需要对时间戳进行校正。 - 编码兼容性：合并的视频片段在编码格式上需要相互兼容，否则需要进行转码处理。 - 解决黑屏或音画不同步问题：在...
Java后端常见场景业务问题
weixin_43739821的博客
04-09 1795
单点登录如何实现 权限认证如何实现 上传数据的安全性如何保证 项目日志如何采集 已经上线的bug如何排查 如何快速定位系统瓶颈
Java知识点概览
qq_48403611的博客
08-03 3774
java后端开发常见面试题总结
【Java项目整理】-＞ 多文件自平衡云传输 -＞ 从零搭建一个分布式中间件
欢迎来到新世界
02-23 1185
多文件自平衡云传输Ⅰ 前言Ⅱ 框架的搭建壹 · 基本构想A. 信息头——文件块该如何发送与接收 Ⅰ 前言 此篇文章将详细分析一个中间件 多文件自平衡云传输（FilesCloudTransmission） 是如何搭建起来的。 先来介绍一下这个框架。 一般我们要下载比如一个电影的话，最简单就是两种方式，一个是HTTP协议，通过浏览器下载，但是这个在文件稍微一大的时候，会把你卡崩溃。 还有一种就是FTP（文件传输协议） FTP采用两个 TCP 连接来传输一个文件。 但是无论是HTTP还是FTP，都难以解决单一服务
Java使用ffmpeg进行视频切片
Marclew_的博客
01-12 2112
Java使用ffmpeg进行视频切片
java 大文件（视频）分片上传+压缩
09-04
java实现视频上传，前端用webuploader分片，后台合文件并用ffmpeg进行压缩处理。
java 视频截取 播放
02-26
一个功能完善的java视频截取播放源代码
Java CV 将视频按每帧进行拆分
taojin12的博客
04-22 1195
导入依赖包 <dependency> <groupId>org.bytedeco</groupId> <artifactId>javacv</artifactId> <version>1.5.3</version> </dependency> <dependency>
java上传下载插件_java大文件(百M以上)的上传下载插件
weixin_36398572的博客
02-13 499
我们平时经常做的是上传文件，上传文件夹与上传文件类似，但也有一些不同之处，这次做了上传文件夹就记录下以备后用。首先我们需要了解的是上传文件三要素：1.表单提交方式:post (get方式提交有大小限制,post没有)2.表单的enctype属性:必须设置为multipart/form-data.3.表单必须有文件上传项:file，且文件项需要给定name值上传文件夹需要增加一个属性webkitdi...
Java如何剪切视频
weixin_44270183的博客
03-01 1426
FFmpeg 是一个强大的开源多媒体处理工具，被广泛应用于音视频的录制、转码、编辑等方面。它支持几乎所有主流的音视频格式，能够在各种操作系统平台上运行，包括 Windows、macOS 和 Linux。FFmpeg 提供了丰富的命令行工具，可以完成诸如剪辑、合并、分割、转换格式、添加水印等各种多媒体处理任务。通过构建FFmpeg命令字符串数组，指定输入视频文件、输出文件格式、分段时长等参数，并利用Java的ProcessBuilder类创建子进程来执行FFmpeg命令。背景：如何使用Java批量切割视频。
java 视频切片,使用ffmpeg对视频进行TS切片
weixin_35879114的博客
03-14 1116
1.ffmpeg切片命令，以H264和AAC的形式对视频进行输出ffmpeg -i input.mp4 -c:v libx264 -c:a aac -strict -2 -f hls output.m3u82.ffmpeg转化成HLS时附带的指令-hls_time n: 设置每片的长度，默认值为2。单位为秒-hls_list_size n:设置播放列表保存的最多条目，设置为0会保存有所片信息，默认...
java视频切片_使用ffmpeg视频切片并加密和视频AES-128加密后播放
weixin_42501329的博客
02-26 1115
创建加密文件：将一个mp4视频文件切割为多个ts片段，并在切割过程中对每一个片段使用AES-128 加密，最后生成一个m3u8的视频索引文件；1.加密用的key(文件则保存当前目录)指令：openssl rand -base64 20 >enc.key#提示打开文件本次生成的 n4DHLx7kMPeewvW3dGlm5i/EE8I=2.另一个是iv(生成一段字符串，记下来)：指令：open...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值