Java-视频按秒截取帧

秒速五厘米 2023-10-01 22:29 96阅读 0赞

Java视频按秒截取帧

1. Java视频按秒截取帧工具类

  1. 具体方法都在工具类中，可以文件地址，可以按照参数传递，
  2. 基本逻辑就是获取文件下载地址，将文件类型进行转换，然后传入javacv进行读取流操作。
  3. 具体场景需要根据工具类具体改造一下，但是基本原理是不变的。
  5. <!--视频流-->
  6.         <!-- https://mvnrepository.com/artifact/com.github.vip-zpf/jave -->
  7.         <dependency>
  8.             <groupId>com.github.vip-zpf</groupId>
  9.             <artifactId>jave</artifactId>
  10.             <version>1.1.1</version>
  11.         </dependency>
  13.         <dependency>
  14.             <groupId>com.github.vip-zpf</groupId>
  15.             <artifactId>jave</artifactId>
  16.             <version>1.0.8</version>
  17.         </dependency>
  18.         <dependency>
  19.             <groupId>org.bytedeco</groupId>
  20.             <artifactId>javacv</artifactId>
  21.             <version>1.5.6</version>
  22.         </dependency>
  24.         <dependency>
  25.             <groupId>org.bytedeco</groupId>
  26.             <artifactId>ffmpeg-platform</artifactId>
  27.             <version>4.4-1.5.6</version>
  28.         </dependency>
  30. package com.wondertek.util;
  32. import com.wondertek.util.img.ConvertToMultipartFile;
  33. import com.wondertek.web.fastdfs.DRFdfsUpAndDowService;
  34. import it.sauronsoftware.jave.Encoder;
  35. import it.sauronsoftware.jave.EncoderException;
  36. import it.sauronsoftware.jave.MultimediaInfo;
  37. import lombok.extern.slf4j.Slf4j;
  38. import org.bytedeco.javacv.FFmpegFrameGrabber;
  39. import org.bytedeco.javacv.Frame;
  40. import org.bytedeco.javacv.Java2DFrameConverter;
  41. import org.springframework.beans.factory.annotation.Autowired;
  42. import org.springframework.stereotype.Component;
  43. import org.springframework.web.multipart.MultipartFile;
  45. import javax.annotation.PostConstruct;
  46. import javax.imageio.ImageIO;
  47. import java.awt.*;
  48. import java.awt.image.BufferedImage;
  49. import java.io.*;
  50. import java.net.URLDecoder;
  51. import java.util.ArrayList;
  52. import java.util.HashMap;
  53. import java.util.List;
  54. import java.util.Map;
  56. /**
  57.  * @author xxx
  58.  */
  59. @Component
  60. @Slf4j
  61. public class VideoUtil {
  63.     private static DRFdfsUpAndDowService drFdfsUpAndDowService;
  64.     @Autowired
  65.     private DRFdfsUpAndDowService remoteDrFdfsUpAndDowService;
  67.     /**
  68.      * 获取视频帧数
  69.      *
  70.      * @param file
  71.      * @return
  72.      */
  73.     public static Double getVideoFrameRate(MultipartFile file) {
  74.         try {
  75.             FFmpegFrameGrabber frameGrabber = new FFmpegFrameGrabber(file.getInputStream()); // 获取视频文件
  76.             frameGrabber.start();
  77.             double frameRate = frameGrabber.getFrameRate();
  78. //            System.out.println("视频帧数："+frameGrabber.getFrameRate()); // 视频帧数
  79. //            System.out.println("时长为："+frameGrabber.getLengthInTime() / (1000 * 1000)); // 时长
  80.             frameGrabber.close();
  81.             return frameRate;
  82.         } catch (Exception e) {
  83.             e.printStackTrace();
  84.         }
  85.         return null;
  86.     }
  88.     /**
  89.      * 根据读取到的视频文件，获取视频中的每一帧图片
  90.      *
  91.      * @param video         视频文件
  92.      *                      http://192.168.0.107:9087/datago/detectsysfiles/204/createFile/frameFile/001/frameFile001.mp4
  93.      * @param frameFilePath 图片的保存路径
  94.      *                      E:/detectsysfiles/204/createFile/frameFile/001/
  95.      * @param picPath       图像访问路径
  96.      *                      http://192.168.0.107:9087/datago/detectsysfiles/204/createFile/frameFile/001/
  97.      */
  98.     public static Map<String, Object> getVideoPic(String frameFilePath, File video, String picPath) {
  99.         //1.根据一个视频文件，创建一个按照视频中每一帧进行抓取图片的抓取对象
  100.         FFmpegFrameGrabber ff = new FFmpegFrameGrabber(video);
  101.         Map<String, Object> strMap = new HashMap<>();
  102.         List<String> strList = new ArrayList<>();
  103.         try {
  104.             ff.start();
  105.             //抓每一帧图片
  106.             //2.先知道这个视频一共有多少帧
  107.             int length = ff.getLengthInFrames();
  108.             //3.读取视频中每一帧图片
  109.             Frame frame = null;
  110.             for (int i = 1; i < length; i++) {
  111.                 frame = ff.grabFrame();
  112.                 if (frame.image == null) {
  113.                     continue;
  114.                 }
  115.                 //将获取的帧，存储为图片
  116.                 Java2DFrameConverter converter = new Java2DFrameConverter();//创建一个帧-->图片的转换器
  117.                 BufferedImage image = converter.getBufferedImage(frame);//转换
  118.                 String img = picPath + i + ".png";
  119.                 File picFile = new File(img);
  120.                 //将图片保存到目标文件中
  121.                 ImageIO.write(image, "png", picFile);
  122.                 strList.add(frameFilePath + "/" + i + ".png");
  123.             }
  124.             strMap.put("height", ff.getImageHeight());//视频高度
  125.             strMap.put("width", ff.getImageWidth());//视频宽度
  126.             strMap.put("frame", ff.getFrameRate());//帧率
  127.             strMap.put("imgPath", strList);//每一帧图像数据
  128.             ff.stop();
  129.         } catch (Exception e) {
  130.             e.printStackTrace();
  131.         }
  132.         return strMap;
  133.     }
  135.     /**
  136.      * 获取视频时长
  137.      *
  138.      * @param multipartFile
  139.      * @return
  140.      * @throws EncoderException
  141.      */
  142.     public static int queryVideoDuration(MultipartFile multipartFile) throws EncoderException {
  143.         //机算视频时长
  144.         File dfile = null;
  145.         try {
  146.             dfile = File.createTempFile("prefix", "_" + multipartFile.getOriginalFilename());
  147.             multipartFile.transferTo(dfile);
  148.         } catch (IOException e) {
  149.             e.printStackTrace();
  150.         }
  151.         // 获取视频时长
  152.         Encoder encoder = new Encoder();
  153.         MultimediaInfo m = encoder.getInfo(dfile);
  154.         long ls = m.getDuration() / 1000;
  155.         int hour = (int) (ls / 3600);
  156.         int minute = (int) (ls % 3600) / 60;
  157.         int second = (int) (ls - hour * 3600 - minute * 60);
  158.         //删除临时文件
  159.         dfile.delete();
  160.         return second;
  161.     }
  163.     public static void approvalFile(MultipartFile filecontent, String path) {
  164.         OutputStream os = null;
  165.         InputStream inputStream = null;
  166.         String fileName = null;
  167.         try {
  168.             inputStream = filecontent.getInputStream();
  169.             fileName = filecontent.getOriginalFilename();
  170.         } catch (IOException e) {
  171.             e.printStackTrace();
  172.         }
  173.         try {
  174.             // 1K的数据缓冲
  175.             byte[] bs = new byte[1024];
  176.             // 读取到的数据长度
  177.             int len;
  178.             // 输出的文件流保存到本地文件
  179.             File tempFile = new File(path);
  180.             if (!tempFile.exists()) {
  181.                 tempFile.mkdirs();
  182.             }
  183.             os = new FileOutputStream(tempFile.getPath() + File.separator + fileName);
  184.             // 开始读取
  185.             while ((len = inputStream.read(bs)) != -1) {
  186.                 os.write(bs, 0, len);
  187.             }
  188.         } catch (IOException e) {
  189.             e.printStackTrace();
  190.         } catch (Exception e) {
  191.             e.printStackTrace();
  192.         } finally {
  193.             // 完毕，关闭所有链接
  194.             try {
  195.                 os.close();
  196.                 inputStream.close();
  197.             } catch (IOException e) {
  198.                 e.printStackTrace();
  199.             }
  200.         }
  201.     }
  203.     private static BufferedImage rotate(BufferedImage src, int angel) {
  204.         int src_width = src.getWidth(null);
  205.         int src_height = src.getHeight(null);
  206.         int type = src.getColorModel().getTransparency();
  207.         Rectangle rect_des = calcRotatedSize(new Rectangle(new Dimension(src_width, src_height)), angel);
  208.         BufferedImage bi = new BufferedImage(rect_des.width, rect_des.height, type);
  209.         Graphics2D g2 = bi.createGraphics();
  210.         g2.translate((rect_des.width - src_width) / 2, (rect_des.height - src_height) / 2);
  211.         g2.rotate(Math.toRadians(angel), src_width / 2, src_height / 2);
  212.         g2.drawImage(src, 0, 0, null);
  213.         g2.dispose();
  214.         return bi;
  215.     }
  217.     private static Rectangle calcRotatedSize(Rectangle src, int angel) {
  218.         if (angel >= 90) {
  219.             if (angel / 90 % 2 == 1) {
  220.                 int temp = src.height;
  221.                 src.height = src.width;
  222.                 src.width = temp;
  223.             }
  224.             angel = angel % 90;
  225.         }
  226.         double r = Math.sqrt(src.height * src.height + src.width * src.width) / 2;
  227.         double len = 2 * Math.sin(Math.toRadians(angel) / 2) * r;
  228.         double angel_alpha = (Math.PI - Math.toRadians(angel)) / 2;
  229.         double angel_dalta_width = Math.atan((double) src.height / src.width);
  230.         double angel_dalta_height = Math.atan((double) src.width / src.height);
  231.         int len_dalta_width = (int) (len * Math.cos(Math.PI - angel_alpha - angel_dalta_width));
  232.         int len_dalta_height = (int) (len * Math.cos(Math.PI - angel_alpha - angel_dalta_height));
  233.         int des_width = src.width + len_dalta_width * 2;
  234.         int des_height = src.height + len_dalta_height * 2;
  235.         return new Rectangle(new Dimension(des_width, des_height));
  236.     }
  238.     /**
  239.      * fileUrl  根据视频在线地址获取文件url按秒截取帧
  240.      */
  241.     public static List<MultipartFile> getVideoImageByUrl(String onlineFileUrl) {
  242.         //导出本地地址
  243. //        String filePath="C:\\Users\\wonder\\Desktop\\ai测试图片\\检测\\ai_ability_gateway\\视频截取后\\";
  244. //        File folder = new File(filePath);
  245. //        if (!folder.exists())
  246. //        {
  247. //            folder.mkdirs();//如果文件夹不存在则创建
  248. //        }
  249.         List<MultipartFile> list = new ArrayList<>();
  250.         try {
  251.             //url编码处理，中文名称会变成百分号编码
  252.             String fileUrl = URLDecoder.decode(onlineFileUrl, "utf-8");
  253.             MultipartFile multipartFile = drFdfsUpAndDowService.downloadMultipartByUrl(fileUrl);
  255.             FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(multipartFile.getInputStream());
  256.             //FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(file);
  257.             grabber.start();
  258.             long ftp = grabber.getLengthInFrames();
  259.             Frame frame = null;
  260.             int sum = 1;
  262.             int count = (int) Math.round(grabber.getFrameRate());
  263.             for (int i = 1; i <= ftp; i++) {
  264.                 frame = grabber.grabImage();
  265.                 if (i % count == 0) {
  266.                     String rotate = grabber.getVideoMetadata("rotate");
  267.                     //创建BufferedImage对象
  268.                     Java2DFrameConverter converter = new Java2DFrameConverter();
  269.                     BufferedImage bufferedImage = converter.getBufferedImage(frame);
  270.                     if (rotate != null) {
  271.                         //旋转图片
  272.                         bufferedImage = rotate(bufferedImage, Integer.parseInt(rotate));
  273.                     }
  274.                     String newFileName = sum + ".jpeg";
  275.                     //写入本地
  276.                     //ImageIO.write(bufferedImage, "jpeg", new File(filePath+newFileName));
  277.                     //BufferedImage 转化为 ByteArrayOutputStream
  278.                     ByteArrayOutputStream out = new ByteArrayOutputStream();
  279.                     ImageIO.write(bufferedImage, "jpeg", out);
  280.                     //ByteArrayOutputStream 转化为 byte[]
  281.                     byte[] imageByte = out.toByteArray();
  282.                     //将 byte[] 转为 MultipartFile
  283.                     MultipartFile convertMultipartFile = new ConvertToMultipartFile(imageByte, null, newFileName, "jpeg", imageByte.length);
  284.                     list.add(convertMultipartFile);
  285.                     sum++;
  286.                 }
  288.             }
  289.             grabber.close();
  290.             grabber.stop();
  291.         } catch (Exception e) {
  292.             System.out.printf("获取视频图片失败！", e);
  293.         }
  294.         return list;
  295.     }
  297.     /**
  298.      * fileUrl  根据视频在线地址获取文件url按秒截取帧
  299.      */
  300.     public static List<MultipartFile> getVideoImageByUrlTest() {
  301.         //导出本地地址
  302.         String filePath = "C:\\Users\\wonder\\Desktop\\ai测试图片\\检测\\ai_ability_gateway\\视频截取后\\";
  303.         File folder = new File(filePath);
  304.         if (!folder.exists()) {
  305.             folder.mkdirs();//如果文件夹不存在则创建
  306.         }
  307.         List<MultipartFile> list = new ArrayList<>();
  308.         try {
  310.             //File file = new File("C:\\Users\\wonder\\Desktop\\ai测试图片\\检测\\ai_ability_gateway\\test.mp4");
  311.             File file = new File("C:\\Users\\wonder\\Desktop\\ai测试图片\\检测\\ai_ability_gateway\\测试视频.mp4");
  312.             MultipartFile multipartFile = FileUtil.fileToMultipartFile(file);
  313.             //MultipartFile multipartFile = drFdfsUpAndDowService.downloadMultipartByUrl(fileUrl);
  315.             FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(multipartFile.getInputStream());
  316.             //FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(file);
  317.             grabber.start();
  318.             long ftp = grabber.getLengthInFrames();
  319.             Frame frame = null;
  320.             int sum = 1;
  321.             int flag = 0;
  322.             int count = (int) Math.round(grabber.getFrameRate());
  323.             for (int i = 1; i <= ftp; i++) {
  324.                 frame = grabber.grabImage();
  325.                 if (i % count == 0) {
  326.                     String rotate = grabber.getVideoMetadata("rotate");
  327.                     //创建BufferedImage对象
  328.                     Java2DFrameConverter converter = new Java2DFrameConverter();
  329.                     BufferedImage bufferedImage = converter.getBufferedImage(frame);
  330.                     if (rotate != null) {
  331.                         //旋转图片
  332.                         bufferedImage = rotate(bufferedImage, Integer.parseInt(rotate));
  333.                     }
  334.                     String newFileName = sum + ".jpeg";
  335.                     //写入本地
  336.                     ImageIO.write(bufferedImage, "jpeg", new File(filePath + newFileName));
  337.                     //BufferedImage 转化为 ByteArrayOutputStream
  338.                     ByteArrayOutputStream out = new ByteArrayOutputStream();
  339.                     ImageIO.write(bufferedImage, "jpeg", out);
  340.                     //ByteArrayOutputStream 转化为 byte[]
  341.                     byte[] imageByte = out.toByteArray();
  342.                     //将 byte[] 转为 MultipartFile
  343.                     MultipartFile convertMultipartFile = new ConvertToMultipartFile(imageByte, null, newFileName, "jpeg", imageByte.length);
  344.                     list.add(convertMultipartFile);
  345.                     sum++;
  346.                 }
  348.             }
  349.             grabber.close();
  350.             grabber.stop();
  351.         } catch (Exception e) {
  352.             System.out.printf("获取视频图片失败！", e);
  353.         }
  354.         return list;
  355.     }
  357.     public static void main(String[] args) {
  358.         List<MultipartFile> videoImageByUrl = getVideoImageByUrlTest();
  360.     }
  362.     @PostConstruct
  363.     public void init() {
  364.         drFdfsUpAndDowService = remoteDrFdfsUpAndDowService;
  365.     }
  367. }

2.获取视频时长

  1. /**
  2.      * 获取视频时长
  3.      * @param multipartFile
  4.      * @return
  5.      * @throws EncoderException
  6.      */
  7.     public static int queryVideoDuration(MultipartFile multipartFile) throws EncoderException {
  8.         //机算视频时长
  9.         File dfile = null;
  10.         try {
  11.             dfile = File.createTempFile("prefix", "_" + multipartFile.getOriginalFilename());
  12.             multipartFile.transferTo(dfile);
  13.         } catch (IOException e) {
  14.             e.printStackTrace();
  15.         }
  16.         // 获取视频时长
  17.         Encoder encoder = new Encoder();
  18.         MultimediaInfo m = encoder.getInfo(dfile);
  19.         long ls = m.getDuration()/1000;
  20.         int hour = (int) (ls/3600);
  21.         int minute = (int) (ls%3600)/60;
  22.         int second = (int) (ls-hour*3600-minute*60);
  23.         //删除临时文件
  24.         dfile.delete();
  25.         return second;
  26.     }

3.ConvertToMultipartFile 工具类

  1. package com.wondertek.util.img;
  3. import org.springframework.web.multipart.MultipartFile;
  5. import java.io.*;
  7. public class ConvertToMultipartFile implements MultipartFile {
  8.     private byte[] fileBytes;
  9.     String name;
  10.     String originalFilename;
  11.     String contentType;
  12.     boolean isEmpty;
  13.     long size;
  15.     public ConvertToMultipartFile(byte[] fileBytes, String name, String originalFilename, String contentType,
  16.                                   long size) {
  17.         this.fileBytes = fileBytes;
  18.         this.name = name;
  19.         this.originalFilename = originalFilename;
  20.         this.contentType = contentType;
  21.         this.size = size;
  22.         this.isEmpty = false;
  23.     }
  25.     @Override
  26.     public String getName() {
  27.         return name;
  28.     }
  30.     @Override
  31.     public String getOriginalFilename() {
  32.         return originalFilename;
  33.     }
  35.     @Override
  36.     public String getContentType() {
  37.         return contentType;
  38.     }
  40.     @Override
  41.     public boolean isEmpty() {
  42.         return isEmpty;
  43.     }
  45.     @Override
  46.     public long getSize() {
  47.         return size;
  48.     }
  50.     @Override
  51.     public byte[] getBytes() throws IOException {
  52.         return fileBytes;
  53.     }
  55.     @Override
  56.     public InputStream getInputStream() throws IOException {
  57.         return new ByteArrayInputStream(fileBytes);
  58.     }
  60.     @Override
  61.     public void transferTo(File dest) throws IOException, IllegalStateException {
  62.         new FileOutputStream(dest).write(fileBytes);
  63.     }
  64. }

发表评论

表情：
评论列表 （有 0 条评论，96人围观）

还没有评论，来说两句吧...

相关阅读