基于javacv的视频截图、转码、提取音频

已于 2023-02-08 18:03:25 修改
阅读量2.4k 收藏 15
点赞数 3
分类专栏： java 文章标签： ffmpeg javacv 转码 截图 音频编码解码
于 2021-01-31 20:55:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daodfs111/article/details/113484567
版权

目录

目标

将所有格式的视频转码为H5能播放的mp4格式，也可以截取任意一帧图片

全量依赖

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

最小依赖

直接引入javacv-platform依赖，打包后大约有800MB，以下是支持linux-x86_64和windows-x86_64平台的转码和截图功能的最小依赖配置

<properties>
	<javacv.version>1.5.3</javacv.version>
	<javacv.linux-x86_64>linux-x86_64</javacv.linux-x86_64>
	<javacv.windows-x86_64>windows-x86_64</javacv.windows-x86_64>
</properties>

<dependencies>
	<dependency>
	    <groupId>org.bytedeco</groupId>
	    <artifactId>javacv</artifactId>
	    <version>${javacv.version}</version>
	    <exclusions>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>flycapture</artifactId>
	    	</exclusion>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>libdc1394</artifactId>
	    	</exclusion>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>libfreenect</artifactId>
	    	</exclusion>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>libfreenect2</artifactId>
	    	</exclusion>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>librealsense</artifactId>
	    	</exclusion>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>librealsense2</artifactId>
	    	</exclusion>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>videoinput</artifactId>
	    	</exclusion>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>artoolkitplus</artifactId>
	    	</exclusion>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>flandmark</artifactId>
	    	</exclusion>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>leptonica</artifactId>
	    	</exclusion>
	    	<exclusion>
	    		<groupId>org.bytedeco</groupId>
	    		<artifactId>tesseract</artifactId>
	    	</exclusion>
	    </exclusions>
	</dependency>
	<dependency>
	    <groupId>org.bytedeco</groupId>
	    <artifactId>ffmpeg</artifactId>
	    <version>4.2.2-${javacv.version}</version>
	    <classifier>${javacv.linux-x86_64}</classifier>
	</dependency>
	<dependency>
	    <groupId>org.bytedeco</groupId>
	    <artifactId>ffmpeg</artifactId>
	    <version>4.2.2-${javacv.version}</version>
	    <classifier>${javacv.windows-x86_64}</classifier>
	</dependency>
	<dependency>
	    <groupId>org.bytedeco</groupId>
	    <artifactId>javacpp</artifactId>
	    <version>${javacv.version}</version>
	    <classifier>${javacv.linux-x86_64}</classifier>
	</dependency>
	<dependency>
	    <groupId>org.bytedeco</groupId>
	    <artifactId>javacpp</artifactId>
	    <version>${javacv.version}</version>
	    <classifier>${javacv.windows-x86_64}</classifier>
	</dependency>
	<dependency>
	    <groupId>org.bytedeco</groupId>
	    <artifactId>openblas</artifactId>
	    <version>0.3.9-${javacv.version}</version>
	    <classifier>${javacv.linux-x86_64}</classifier>
	</dependency>
	<dependency>
	    <groupId>org.bytedeco</groupId>
	    <artifactId>openblas</artifactId>
	    <version>0.3.9-${javacv.version}</version>
	    <classifier>${javacv.windows-x86_64}</classifier>
	</dependency>
	<dependency>
	    <groupId>org.bytedeco</groupId>
	    <artifactId>opencv</artifactId>
	    <version>4.3.0-${javacv.version}</version>
	    <classifier>${javacv.linux-x86_64}</classifier>
	</dependency>
	<dependency>
	    <groupId>org.bytedeco</groupId>
	    <artifactId>opencv</artifactId>
	    <version>4.3.0-${javacv.version}</version>
	    <classifier>${javacv.windows-x86_64}</classifier>
	</dependency>
</dependencies>

截图配置类

TargetShot.java

package com.videotest.video;

public class TargetShot {

	private String targetParentPath;//截图保存目录，如果不设置，则与源文件目录相同
	
	private String prefix = "";//截图文件名前缀
	
	private String suffix = "_shot";//截图文件简单名后缀
	
	private String extName = "jpg";//截图文件扩展名
	
	private int frameNum = 1;//截取视频第几帧

	public String getTargetParentPath() {
		return targetParentPath;
	}

	public TargetShot setTargetParentPath(String targetParentPath) {
		this.targetParentPath = targetParentPath;
		return this;
	}

	public String getPrefix() {
		return prefix;
	}

	public TargetShot setPrefix(String prefix) {
		this.prefix = prefix;
		return this;
	}

	public String getSuffix() {
		return suffix;
	}

	public TargetShot setSuffix(String suffix) {
		this.suffix = suffix;
		return this;
	}

	public String getExtName() {
		return extName;
	}

	public TargetShot setExtName(String extName) {
		this.extName = extName;
		return this;
	}

	public int getFrameNum() {
		return frameNum;
	}

	public TargetShot setFrameNum(int frameNum) {
		if (frameNum < 1) {
			frameNum = 1;
		}
		this.frameNum = frameNum;
		return this;
	}

	@Override
	public String toString() {
		return "TargetShot [targetParentPath=" + targetParentPath + ", prefix=" + prefix + ", suffix=" + suffix
				+ ", extName=" + extName + ", frameNum=" + frameNum + "]";
	}
	
}

转码配置类

TargetVideo.class

package com.videotest.video;

public class TargetVideo {

	private String targetParentPath;//转码后的文件保存目录，如果不设置，则与源文件目录相同
	
	private String prefix = "";//转码后的文件名前缀
	
	private String suffix = "_recode";//转码后的文件简单名后缀
	
	private boolean closeSound;//转码后的文件是否删除音轨，默认不删除

	public String getTargetParentPath() {
		return targetParentPath;
	}

	public TargetVideo setTargetParentPath(String targetParentPath) {
		this.targetParentPath = targetParentPath;
		return this;
	}

	public String getPrefix() {
		return prefix;
	}

	public TargetVideo setPrefix(String prefix) {
		this.prefix = prefix;
		return this;
	}

	public String getSuffix() {
		return suffix;
	}

	public TargetVideo setSuffix(String suffix) {
		this.suffix = suffix;
		return this;
	}

	public boolean isCloseSound() {
		return closeSound;
	}

	public TargetVideo setCloseSound(boolean closeSound) {
		this.closeSound = closeSound;
		return this;
	}

	@Override
	public String toString() {
		return "TargetVideo [targetParentPath=" + targetParentPath + ", prefix=" + prefix + ", suffix=" + suffix
				+ ", closeSound=" + closeSound + "]";
	}
	
}

提取音频配置类

TargetSound.class

package com.videotest.video;

public class TargetSound {

	private String targetParentPath;//截图保存目录，如果不设置，则与源文件目录相同
	
	private String prefix = "";//截图文件名前缀
	
	private String suffix = "_sound";//截图文件简单名后缀
	
	private String extName = "mp3";//截图文件扩展名

	public String getTargetParentPath() {
		return targetParentPath;
	}

	public TargetSound setTargetParentPath(String targetParentPath) {
		this.targetParentPath = targetParentPath;
		return this;
	}

	public String getPrefix() {
		return prefix;
	}

	public TargetSound setPrefix(String prefix) {
		this.prefix = prefix;
		return this;
	}

	public String getSuffix() {
		return suffix;
	}

	public TargetSound setSuffix(String suffix) {
		this.suffix = suffix;
		return this;
	}

	public String getExtName() {
		return extName;
	}

	public TargetSound setExtName(String extName) {
		this.extName = extName;
		return this;
	}

	@Override
	public String toString() {
		return "TargetSound [targetParentPath=" + targetParentPath + ", prefix=" + prefix + ", suffix=" + suffix
				+ ", extName=" + extName + "]";
	}
	
}

源视频处理结果类

VideoInfo.class

package com.videotest.video;

public class VideoInfo<T> {
	
	private T id;//数据唯一标识

	private boolean sourceExists;//源文件是否存在
	
	private boolean sourceIsFile;//源文件是否文件
	
	private String sourceAbsolutePath;//sourceParentPath + "/" + sourceName
	
	private String sourceParentPath = "";//源文件目录
	
	private String sourceName = ""; //sourceSimpleName + ["." + extName]
	
	private String sourceSimpleName = "";
	
	private String sourceExtName = "";//扩展名

	/**
	 * @See {org.bytedeco.ffmpeg.global.avcodec}
	 */
	private int sourceVideoCodec;//视频编码格式
	
	/**
	 * @See {org.bytedeco.ffmpeg.global.avcodec}
	 */
	private int sourceAudioCodec;//音频编码格式
	
	private String sourceFormat = "";//封装格式
	
	private boolean shotExists;//处理结果是否存在截图
	
	private String targetShotPath;//截图绝对路径
	
	private String targetShotName;//截图文件名
	
	private boolean videoExists;//处理结果是否存在转码后的视频
	
	private String targetVideoPath;//转码后的视频绝对路径
	
	private String targetVideoName;//转码后的视频文件名
	
	private boolean soundExists;//处理结果是否存在音频
	
	private String targetSoundPath;//提取的音频绝对路径
	
	private String targetSoundName;//提取的音频文件名
	
	public VideoInfo(T id) {
		this.id = id;
	}

	public T getId() {
		return id;
	}

	void setId(T id) {
		this.id = id;
	}

	public boolean isSourceExists() {
		return sourceExists;
	}

	void setSourceExists(boolean sourceExists) {
		this.sourceExists = sourceExists;
	}

	public boolean isSourceIsFile() {
		return sourceIsFile;
	}

	void setSourceIsFile(boolean sourceIsFile) {
		this.sourceIsFile = sourceIsFile;
	}

	public String getSourceAbsolutePath() {
		return sourceAbsolutePath;
	}

	void setSourceAbsolutePath(String sourceAbsolutePath) {
		this.sourceAbsolutePath = sourceAbsolutePath;
	}

	public String getSourceParentPath() {
		return sourceParentPath;
	}

	void setSourceParentPath(String sourceParentPath) {
		this.sourceParentPath = sourceParentPath;
	}

	public String getSourceName() {
		return sourceName;
	}

	void setSourceName(String sourceName) {
		this.sourceName = sourceName;
	}

	public String getSourceSimpleName() {
		return sourceSimpleName;
	}

	void setSourceSimpleName(String sourceSimpleName) {
		this.sourceSimpleName = sourceSimpleName;
	}

	public String getSourceExtName() {
		return sourceExtName;
	}

	void setSourceExtName(String sourceExtName) {
		this.sourceExtName = sourceExtName;
	}

	public int getSourceVideoCodec() {
		return sourceVideoCodec;
	}

	void setSourceVideoCodec(int sourceVideoCodec) {
		this.sourceVideoCodec = sourceVideoCodec;
	}

	public int getSourceAudioCodec() {
		return sourceAudioCodec;
	}

	void setSourceAudioCodec(int sourceAudioCodec) {
		this.sourceAudioCodec = sourceAudioCodec;
	}

	public String getSourceFormat() {
		return sourceFormat;
	}

	void setSourceFormat(String sourceFormat) {
		this.sourceFormat = sourceFormat;
	}

	public boolean getShotExists() {
		return shotExists;
	}

	void setShotExists(boolean shotExists) {
		this.shotExists = shotExists;
	}

	public String getTargetShotPath() {
		return targetShotPath;
	}

	void setTargetShotPath(String targetShotPath) {
		this.targetShotPath = targetShotPath;
	}

	public String getTargetShotName() {
		return targetShotName;
	}

	void setTargetShotName(String targetShotName) {
		this.targetShotName = targetShotName;
	}

	public boolean getVideoExists() {
		return videoExists;
	}

	void setVideoExists(boolean videoExists) {
		this.videoExists = videoExists;
	}

	public String getTargetVideoPath() {
		return targetVideoPath;
	}

	void setTargetVideoPath(String targetVideoPath) {
		this.targetVideoPath = targetVideoPath;
	}

	public String getTargetVideoName() {
		return targetVideoName;
	}

	void setTargetVideoName(String targetVideoName) {
		this.targetVideoName = targetVideoName;
	}

	public boolean isSoundExists() {
		return soundExists;
	}

	void setSoundExists(boolean soundExists) {
		this.soundExists = soundExists;
	}

	public String getTargetSoundPath() {
		return targetSoundPath;
	}

	void setTargetSoundPath(String targetSoundPath) {
		this.targetSoundPath = targetSoundPath;
	}

	public String getTargetSoundName() {
		return targetSoundName;
	}

	void setTargetSoundName(String targetSoundName) {
		this.targetSoundName = targetSoundName;
	}

	@Override
	public String toString() {
		return "VideoInfo [id=" + id + ", sourceExists=" + sourceExists + ", sourceIsFile=" + sourceIsFile
				+ ", sourceAbsolutePath=" + sourceAbsolutePath + ", sourceParentPath=" + sourceParentPath
				+ ", sourceName=" + sourceName + ", sourceSimpleName=" + sourceSimpleName + ", sourceExtName="
				+ sourceExtName + ", sourceVideoCodec=" + sourceVideoCodec + ", sourceAudioCodec=" + sourceAudioCodec
				+ ", sourceFormat=" + sourceFormat + ", shotExists=" + shotExists + ", targetShotPath=" + targetShotPath
				+ ", targetShotName=" + targetShotName + ", videoExists=" + videoExists + ", targetVideoPath="
				+ targetVideoPath + ", targetVideoName=" + targetVideoName + ", soundExists=" + soundExists
				+ ", targetSoundPath=" + targetSoundPath + ", targetSoundName=" + targetSoundName + "]";
	}

}

核心类

Video.class

package com.videotest.video;

import java.awt.image.BufferedImage;
import java.io.File;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;

import javax.imageio.ImageIO;

import org.bytedeco.ffmpeg.global.avcodec;
import org.bytedeco.ffmpeg.global.avutil;
import org.bytedeco.javacv.FFmpegFrameGrabber;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import org.bytedeco.javacv.FFmpegLogCallback;
import org.bytedeco.javacv.Frame;
import org.bytedeco.javacv.Java2DFrameConverter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public final class Video<T> {
	private static final Logger logger = LoggerFactory.getLogger(Video.class);
	
	private static final String DEFAULT_VIDEO_EXTNAME = "mp4";
	
	private static final String DEFAULT_FORMAT = "mov,mp4,m4a,3gp,3g2,mj2";
	
	private VideoInfo<T> videoInfo;
	
	private File sourceFile;
	
	private TargetShot targetShot;
	
	private TargetVideo targetVideo;
	
	private TargetSound targetSound;

	private Video (T id) {
		this.videoInfo = new VideoInfo<T>(id);
	}
	
	public static <T> Video<T> getInstance(T id) {
		return new Video<T>(id);
	}
	
	public Video<T> sourceFile (String sourceAbsolutePath) {
		return this.sourceFile(new File(sourceAbsolutePath));
	}
	
	public Video<T> sourceFile (String sourceParentPath, String sourceName) {
		return this.sourceFile(new File(sourceParentPath, sourceName));
	}
	
	public Video<T> sourceFile (File sourceFile) {
		this.sourceFile = sourceFile;
		return this;
	}
	
	/**
	 * 开启截图功能
	 * @return
	 */
	public Video<T> enableShot () {
		this.targetShot = new TargetShot();
		return this;
	}
	
	public Video<T> enableShot (TargetShot targetShot) {
		this.targetShot = targetShot;
		return this;
	}
	
	/**
	 * 开启转码功能
	 * @return
	 */
	public Video<T> enableVideo () {
		this.targetVideo = new TargetVideo();
		return this;
	}
	
	public Video<T> enableVideo (TargetVideo targetVideo) {
		this.targetVideo = targetVideo;
		return this;
	}
	
	/**
	 * 开启提取音频功能
	 * @return
	 */
	public Video<T> enableSound () {
		this.targetSound = new TargetSound();
		return this;
	}
	
	public Video<T> enableSound (TargetSound targetSound) {
		this.targetSound = targetSound;
		return this;
	}
	
	/**
	 * 开始转码截图
	 * @return
	 */
	public VideoInfo<T> start () {
		avutil.av_log_set_level(avutil.AV_LOG_INFO);
		FFmpegLogCallback.set();
		VideoInfo<T> videoInfo = this.videoInfo;
		File sourceFile = this.sourceFile;
		TargetVideo targetVideo = this.targetVideo;
		TargetShot targetShot = this.targetShot;
		TargetSound targetSound = this.targetSound;
		FFmpegFrameGrabber frameGrabber = null;
		try {
			videoInfo.setSourceExists(sourceFile.exists());
			videoInfo.setSourceIsFile(sourceFile.isFile());
			videoInfo.setSourceAbsolutePath(sourceFile.getAbsolutePath().replace("\\", "/"));
			videoInfo.setSourceParentPath(sourceFile.getParent().replace("\\", "/"));
			if (targetVideo != null && targetVideo.getTargetParentPath() == null) {
				targetVideo.setTargetParentPath(videoInfo.getSourceParentPath());
			}
			if (targetShot != null && targetShot.getTargetParentPath() == null) {
				targetShot.setTargetParentPath(videoInfo.getSourceParentPath());
			}
			if (targetSound != null && targetSound.getTargetParentPath() == null) {
				targetSound.setTargetParentPath(videoInfo.getSourceParentPath());
			}
			videoInfo.setSourceName(sourceFile.getName());
			if (!sourceFile.isFile()) {
				return videoInfo;
			}
			int dotLastIndex = videoInfo.getSourceName().lastIndexOf(".");
			if (dotLastIndex > 0 && dotLastIndex < videoInfo.getSourceName().length() - 1) {
				videoInfo.setSourceSimpleName(videoInfo.getSourceName().substring(0, dotLastIndex));
				videoInfo.setSourceExtName(videoInfo.getSourceName().substring(dotLastIndex + 1));
			} else {
				videoInfo.setSourceSimpleName(videoInfo.getSourceName());
			}
			frameGrabber = FFmpegFrameGrabber.createDefault(sourceFile);
			frameGrabber.start();
			videoInfo.setSourceVideoCodec(frameGrabber.getVideoCodec());
			videoInfo.setSourceAudioCodec(frameGrabber.getAudioCodec());
			videoInfo.setSourceFormat(frameGrabber.getFormat());
			if (!this.isVideo()) {
				throw new org.bytedeco.javacv.FrameGrabber.Exception("[" + videoInfo.getSourceAbsolutePath() + "] 不是视频文件");
			}
			if (targetShot != null) {
				this.shot(frameGrabber);
			}
		} catch (Exception e) {
			logger.warn(sourceFile.getAbsolutePath() + " -> error", e);
		} finally {
			if (frameGrabber != null) {
				try {
					frameGrabber.close();
				} catch (org.bytedeco.javacv.FrameGrabber.Exception e) {
					logger.warn("frameGrabber.close异常", e);
				}
				frameGrabber = null;
			}
		}
		if (targetVideo != null) {
			this.convert2Mp4();
		}
		if (targetSound != null && this.hasAudio()) {
			this.extractSound();
		}
		return videoInfo;
	}

	private void shot (FFmpegFrameGrabber frameGrabber) throws Exception {
		TargetShot targetShot = this.targetShot;
		VideoInfo<T> videoInfo = this.videoInfo;
		Frame frame = null;
		int i = 0;
        int fps = (int) frameGrabber.getFrameRate();
        int lengthInFrames = frameGrabber.getLengthInFrames();
        int frameNum = targetShot.getFrameNum();
        BufferedImage buffer = null;
        while (i < lengthInFrames) {
            frame = frameGrabber.grabImage();
            if (frameNum <= 1
            		|| i >= fps && i % (fps * frameNum) == 0
            		|| i == (lengthInFrames - 1) / fps * fps) {
                Java2DFrameConverter converter = new Java2DFrameConverter();
                buffer = converter.getBufferedImage(frame);
                File file = new File(targetShot.getTargetParentPath(), targetShot.getPrefix() + videoInfo.getSourceSimpleName() + targetShot.getSuffix() + "." + targetShot.getExtName());
                Files.deleteIfExists(file.toPath());
                ImageIO.write(buffer, targetShot.getExtName(), file);
                videoInfo.setShotExists(true);
                videoInfo.setTargetShotPath(file.getAbsolutePath().replace("\\", "/"));
                videoInfo.setTargetShotName(file.getName());
                logger.info(videoInfo.getTargetShotPath() + " -> 截图完成");
                break;
            }
            i++;
        }
        frameGrabber.stop();
	}
	
	private void convert2Mp4 () {
		VideoInfo<T> videoInfo = this.videoInfo;
		TargetVideo targetVideo = this.targetVideo;
		File sourceFile = this.sourceFile;
		FFmpegFrameGrabber frameGrabber = null;
		FFmpegFrameRecorder recorder = null;
		try {
			File videoOutFile = new File(targetVideo.getTargetParentPath());
			if (videoOutFile.isFile()) {
				throw new FileAlreadyExistsException("[" + targetVideo.getTargetParentPath() + "] 是文件并且已存在");
			}
			if (!videoOutFile.exists()) {
				videoOutFile.mkdirs();
			}
			File file = new File(targetVideo.getTargetParentPath(), targetVideo.getPrefix() + videoInfo.getSourceSimpleName() + targetVideo.getSuffix() + "." + DEFAULT_VIDEO_EXTNAME);
			String videoOutFilePath = file.getAbsolutePath().replace("\\", "/");
			if (this.canPlayInH5IgnoreExtName() && (!targetVideo.isCloseSound() || !this.hasAudio())) {
				Files.copy(new File(videoInfo.getSourceParentPath(), videoInfo.getSourceName()).toPath(), new File(videoOutFilePath).toPath(), StandardCopyOption.REPLACE_EXISTING);
			} else {
				frameGrabber = FFmpegFrameGrabber.createDefault(sourceFile);
				frameGrabber.start();
				Frame captured_frame = null;
				recorder = new FFmpegFrameRecorder(videoOutFilePath, frameGrabber.getImageWidth(), frameGrabber.getImageHeight(), frameGrabber.getAudioChannels());
				recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
				recorder.setFormat(DEFAULT_VIDEO_EXTNAME);
				recorder.setFrameRate(frameGrabber.getFrameRate());
				int bitrate = Long.valueOf(frameGrabber.getFormatContext().bit_rate()).intValue();
				if (bitrate > 0) {
					int videoBitrate = frameGrabber.getVideoBitrate();
					int audioBitrate = frameGrabber.getAudioBitrate();
					if (audioBitrate < 1) {
						recorder.setVideoBitrate(bitrate);
					} else if (videoBitrate < 1) {
						recorder.setAudioBitrate(bitrate);
					} else {
						double rate = (videoBitrate + audioBitrate) * 1.0 / bitrate;
						if (rate > 0.95 && rate < 1.05) {
							recorder.setVideoBitrate(videoBitrate);
							recorder.setAudioBitrate(audioBitrate);
						} else {
							recorder.setVideoBitrate(Math.round(bitrate * 1.0f * videoBitrate / (videoBitrate + audioBitrate)));
							recorder.setAudioBitrate(Math.round(bitrate * 1.0f * audioBitrate / (videoBitrate + audioBitrate)));
						}
					}
				}
				recorder.setSampleRate(frameGrabber.getSampleRate());
				recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
				recorder.start();
				if (targetVideo.isCloseSound()) {
					while (true) {
						captured_frame = frameGrabber.grabImage();
						if (captured_frame == null) {
							logger.info(videoOutFilePath + " 转码完成");
							break;
						}
						if (frameGrabber.getTimestamp() > -1) {
							recorder.setTimestamp(frameGrabber.getTimestamp());
						}
						recorder.record(captured_frame);
					}
				} else {
					while (true) {
						captured_frame = frameGrabber.grabFrame();
						if (captured_frame == null) {
							logger.info(videoOutFilePath + " 转码完成");
							break;
						}
						if (frameGrabber.getTimestamp() > -1) {
							recorder.setTimestamp(frameGrabber.getTimestamp());
						}
						recorder.record(captured_frame);
					}
				}
			}
			videoInfo.setVideoExists(true);
			videoInfo.setTargetVideoPath(videoOutFilePath);
			videoInfo.setTargetVideoName(file.getName());
		} catch (Exception e) {
			logger.warn(sourceFile.getAbsolutePath() + " -> 转码 error", e);
		} finally {
			if (recorder != null) {
				try {
					recorder.close();
				} catch (Exception e) {
					logger.warn("recorder.close异常", e);
				}
			}
			if (frameGrabber != null) {
				try {
					frameGrabber.close();
				} catch (org.bytedeco.javacv.FrameGrabber.Exception e) {
					logger.warn("frameGrabber.close异常", e);
				}
			}
		}
	}
	
	private void extractSound() {
		VideoInfo<T> videoInfo = this.videoInfo;
		TargetSound targetSound = this.targetSound;
		File sourceFile = this.sourceFile;
		FFmpegFrameGrabber frameGrabber = null;
		FFmpegFrameRecorder recorder = null;
		try {
			File soundOutFile = new File(targetSound.getTargetParentPath());
			if (soundOutFile.isFile()) {
				throw new FileAlreadyExistsException("[" + targetSound.getTargetParentPath() + "] 是文件并且已存在");
			}
			if (!soundOutFile.exists()) {
				soundOutFile.mkdirs();
			}
			File file = new File(targetSound.getTargetParentPath(), targetSound.getPrefix() + videoInfo.getSourceSimpleName() + targetSound.getSuffix() + "." + targetSound.getExtName());
			String soundOutFilePath = file.getAbsolutePath().replace("\\", "/");
			
			frameGrabber = FFmpegFrameGrabber.createDefault(sourceFile);
			frameGrabber.start();
			Frame captured_frame = null;
			recorder = new FFmpegFrameRecorder(soundOutFilePath, frameGrabber.getAudioChannels());
			recorder.setFormat(targetSound.getExtName());
			recorder.setSampleRate(frameGrabber.getSampleRate());
			int bitrate = Long.valueOf(frameGrabber.getFormatContext().bit_rate()).intValue();
			if (bitrate > 0) {
				int videoBitrate = frameGrabber.getVideoBitrate();
				int audioBitrate = frameGrabber.getAudioBitrate();
				if (audioBitrate > 0) {
					if (videoBitrate < 1) {
						recorder.setAudioBitrate(bitrate);
					} else {
						double rate = (videoBitrate + audioBitrate) * 1.0 / bitrate;
						if (rate > 0.95 && rate < 1.05) {
							recorder.setAudioBitrate(audioBitrate);
						} else {
							recorder.setAudioBitrate(Math.round(bitrate * 1.0f * audioBitrate / (videoBitrate + audioBitrate)));
						}
					}
				}
			}
			recorder.start();
			while (true) {
				captured_frame = frameGrabber.grabSamples();
				if (captured_frame == null) {
					logger.info(soundOutFilePath + " 音频提取完成");
					break;
				}
				if (frameGrabber.getTimestamp() > -1) {
					recorder.setTimestamp(frameGrabber.getTimestamp());
				}
				recorder.recordSamples(captured_frame.samples);
			}
			videoInfo.setTargetSoundPath(soundOutFilePath);
			videoInfo.setTargetSoundName(file.getName());
			videoInfo.setSoundExists(true);
		} catch (Exception e) {
			logger.warn(sourceFile.getAbsolutePath() + " -> 音频提取 error", e);
		} finally {
			if (recorder != null) {
				try {
					recorder.close();
				} catch (Exception e) {
					logger.warn("recorder.close异常", e);
				}
			}
			if (frameGrabber != null) {
				try {
					frameGrabber.close();
				} catch (org.bytedeco.javacv.FrameGrabber.Exception e) {
					logger.warn("frameGrabber.close异常", e);
				}
			}
		}
	}
	
	private boolean isVideo () {
		return this.videoInfo.getSourceVideoCodec() != avcodec.AV_CODEC_ID_NONE;
	}
	
	private boolean hasAudio () {
		return this.videoInfo.getSourceAudioCodec() != avcodec.AV_CODEC_ID_NONE;
	}
	
	private boolean canPlayInH5IgnoreExtName () {
		if (!this.isVideo()) {
			return false;
		}
		VideoInfo<T> videoInfo = this.videoInfo;
		if (this.hasAudio() && videoInfo.getSourceAudioCodec() != avcodec.AV_CODEC_ID_AAC) {
			return false;
		}
		if (videoInfo.getSourceVideoCodec() != avcodec.AV_CODEC_ID_H264) {
			return false;
		}
		if (!DEFAULT_FORMAT.equals(videoInfo.getSourceFormat())) {
			return false;
		}
		return true;
	}
	
}

怎么使用

package com.videotest;

import java.io.File;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.videotest.video.TargetShot;
import com.videotest.video.TargetSound;
import com.videotest.video.TargetVideo;
import com.videotest.video.Video;
import com.videotest.video.VideoInfo;


public class Test {
	private static final Logger logger = LoggerFactory.getLogger(Test.class);

	public static void main(String[] args) throws JsonProcessingException {
		
		File file = new File("D:/data");
		File[] listFiles = file.listFiles();
		for (File file2 : listFiles) {
			VideoInfo<Long> videoInfo = Video
				.getInstance(4622L)
//				.getInstance("234567765")
//				.sourceFile("D:/案例视频/测试android", "同业36-安卓.mp4")
//				.sourceFile("D:/1607589556364qq.mp4")
				.sourceFile(file2)
				.enableShot(null)
//				.enableShot(new TargetShot())
//				.enableShot(new TargetShot().setExtName("png").setPrefix("tmp_").setTargetParentPath("D:/data"))
				.enableVideo(null)
//				.enableVideo(new TargetVideo())
//				.enableVideo(new TargetVideo().setCloseSound(true)) //关闭音频
				.enableSound()
//				.enableSound(new TargetSound().setExtName("mp3").setPrefix("tmp_").setSuffix("").setTargetParentPath("D:/data"))
				.start();
			String writeValueAsString = new ObjectMapper().writeValueAsString(videoInfo);
			logger.info(writeValueAsString);
		}
	}
}
daodfs1
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java从视频中提取音频
05-25
Java从视频中提取音频 下载依赖包是会比较慢，请在网络好的环境下载 依赖包下载好后，直接编译即可运行 懒得下载或网络不好的，可以去下方地址下载 https://download.csdn.net/download/qq_34096425/87804913
java使用FFmpeg合成视频和音频并获取视频中的音频等操作(实例代码详解)
08-24
主要介绍了java使用FFmpeg合成视频和音频并获取视频中的音频等操作，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
JAVACV+ffmpeg+OpenCV实现视频叠加合成（AR效果视频生成）
最新发布
weixin_54191781的博客
05-08 1268
【代码】JAVACV+ffmpeg+OpenCV实现视频叠加合成（AR效果视频生成）
javaCV开发详解之7：让音频转换更加简单，实现通用音频编码格式转换、重采样等音频参数的转换功能（以pcm16le编码的wav转mp3为例）
小白成神路
04-22 1441
转自：http://blog.csdn.net/eguid_1/article/details/52982108 前言： 之前几章把javaCV-FFmpeg中的能够实现的基本功能大致梳理了一遍，本章在之前几章基础上实现一个通用的音频编码和参数转换器 实现功能： ①音频编码转换②音频格式转换③音频重采样④等等。。。跟多功能自行探索
Java提取视频中的音频（JavaCV）
qq_35719898的博客
05-06 4018
1、pom.xml导入包 <dependency> <groupId>org.bytedeco</groupId> <artifactId>javacv-platform</artifactId> <version>1.5</version> </dependency> 2、创建类MP4ToAudio.java import org.bytedeco.javacv.F
javacv音视频截图,音频抽取汇总
VISION_SONG的博客
01-18 1486
java 使用 javacv 视频截帧, 跳到指定帧截图, 从视频中抽取音频, 音频分割为多段。
快速降低javacv依赖包的大小
LYQ
08-07 1537
由于在项目中需要对视频进行缩略图的截图处理，引入了javacv-platform的包，但是打包后发现打出来的jar包非常的大后面得知是因为javacv-platform会将所有平台的包集中起来处理，导致包特别的大。
javacv 视频转音频（提取视频中音频）
笨笨CEO的博客
04-20 2355
1、工程项目中添加依赖 <dependency> <groupId>org.bytedeco</groupId> <artifactId>javacv-platform</artifactId> <version>1.5</version> </dependency> 2、准备需要提取音频的视频文件
java判断文件类型，并提取视频文件中的音频
我是死宅萝莉控的博客
06-05 2367
业务场景 只需要音频，但是有一些用户将视频格式的文件修改后缀名后提交了上来，现在需要去读取文件头判断文件的真实类型，并将视频格式的文件中的音频提取出来 解决方案 首先读取文件文件头判断文件真实类型 private static HashMap<String,String> fileHeadMap = new HashMap<>(); static { //音频 fileHeadMap.put("494433030000","mp3")
Javacv处理视频,提取成帧图片,生成gif
07-18
提取本地视频的帧图片，根据本地视频生成gif,jar版本是1.4.1,maven项目
Javacv使用ffmpeg实现音视频同步播放
08-28
Javacv使用ffmpeg实现音视频同步播放是通过FFmpegFrameGrabber帧捕捉器来捕捉音频和视频帧，然后使用生产者消费者模式来播放音频和视频帧。下面是相关的知识点： 1. FFmpegFrameGrabber帧捕捉器：...
javacv1.1-linux-x86_64
03-29
javacv1.1 linux-x86_64平台。包含opencv、javacpp、ffmpeg、leptonica、tesseract、artoolkitplus等较为全面的图像视频处理依赖包
java实现音视频转码
11-07
中档中包含linux安装yasm环境，ffmpeg工具，lame解码器，以及环境报错解决方案，如何使用jave包maven导入pom配置，java代码帮你实现转换拷入有效，以及所有工具的下载地址,让你不走弯路5分钟解决音视频转码问题，微信录音转mp3问题
javacv截取视频图像并旋转为正向
10-09
javacv 与 opencv对视频进行处理，截取视频中的三张图片（截取图片可自由截取每一帧图片），并旋转转正图片为正向window linux 通用
视频 音频转换 音频转文字 字幕，字幕处理规则。录音啦
07-27
视频 音频转换 音频转文字 字幕，字幕处理规则。录音啦
JavaCV实现将视频以帧方式抽取
08-25
JavaCV是一款基于Java的计算机视觉库，它提供了多种视频处理功能，包括视频抓取、视频压缩、图像处理等。下面将详细介绍JavaCV实现将视频以帧方式抽取的知识点。 知识点1：JavaCV简介 JavaCV是一个开源的Java库，...
javacv视频抽帧的实现过程详解（附代码）
08-25
JavaCV是一个流行的Java媒体处理库，它提供了多种媒体处理功能，包括视频抽帧、图像处理、音频处理等。视频抽帧是指从视频中提取指定时间段的帧的过程，在 JavaCV 中，我们可以使用 FFmpegFrameGrabber 类来实现视频...
Linux下JavaCv使用GPU加速(Nvidia显卡)
qq_30374237的博客
03-31 9910
1.环境配置，安装显卡驱动、cudnn ​​​​​​linux上安装NVIDIA显卡驱动以及深度学习需要的cudn、cudnn、pytorch_宜城有少年的博客-CSDN博客_linux安装nvidia显卡驱动 2.安装FFmpeg视频转码所需要的包 （1）安装依赖 yum install autoconf automake bzip2 cmake freetype-devel gcc gcc-c++ git libtool make mercurial pkgconfig zlib-d..
java 视频转码 视频压缩
gao_yuwushengchu的博客
04-01 3496
javacv、opencv、ppmpeg 视频处理
JAVACV 视频转码
08-23
您好！要使用JAVACV进行视频转码，您可以按照以下步骤操作： 1. 首先，确保已经在项目中添加了JAVACV库的依赖。 2. 创建一个FFmpegFrameGrabber对象，用于读取要转码的视频文件。例如： ```java FFmpegFrameGrabber grabber = new FFmpegFrameGrabber("input.mp4"); grabber.start(); ``` 3. 创建一个FFmpegFrameRecorder对象，用于进行视频编码和转码。您需要设置目标输出文件的格式、分辨率、帧率等参数。例如： ```java FFmpegFrameRecorder recorder = new FFmpegFrameRecorder("output.mp4", grabber.getImageWidth(), grabber.getImageHeight()); recorder.setFrameRate(grabber.getFrameRate()); recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264); recorder.setFormat("mp4"); recorder.start(); ``` 4. 逐帧读取视频，并将每一帧写入目标文件。例如： ```java Frame frame; while ((frame = grabber.grab()) != null) { recorder.record(frame); } ``` 5. 最后，记得关闭grabber和recorder对象以释放资源。 ```java grabber.stop(); grabber.release(); recorder.stop(); recorder.release(); ``` 这样就完成了视频的转码过程。您可以根据需要进行更多的设置和处理。希望对您有所帮助！如有任何问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值