package org.sxkj.common.utils.ffmpeg;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.io.*;
|
import java.nio.file.Files;
|
import java.nio.file.Path;
|
import java.util.Arrays;
|
import java.util.UUID;
|
import java.util.concurrent.ExecutorService;
|
import java.util.concurrent.Executors;
|
import java.util.concurrent.TimeUnit;
|
|
/**
|
* @Description 音频视频转码工具类(使用FFmpeg)
|
* @Author AIX
|
* @Date 2025/5/22 14:11
|
* @Version 1.0
|
*/
|
public class FfmpegConverterUtils {
|
|
private static final Logger logger = LoggerFactory.getLogger(FfmpegConverterUtils.class);
|
private static final int PROCESS_TIMEOUT_SECONDS = 600;
|
|
|
|
/**
|
* 音频转码为Opus格式
|
* @param inputFile 待转换音频文件
|
* @param name 输出文件名(不含扩展名)
|
* @return 转换后的Opus文件对象
|
* @throws ConversionException 转换失败时抛出
|
*/
|
public static File convertToOpus(File inputFile, String name) throws ConversionException {
|
validateInputFile(inputFile);
|
if (name == null || name.trim().isEmpty()) {
|
throw new ConversionException("输出文件名不能为空");
|
}
|
|
File outputFile = createTempFile(name, "opus");
|
|
try {
|
ProcessBuilder pb = new ProcessBuilder(
|
"ffmpeg",
|
"-i", inputFile.getAbsolutePath(),
|
"-ar", "16000",
|
"-ac", "1",
|
"-b:a", "16k",
|
"-compression_level", "8",
|
"-y",
|
outputFile.getAbsolutePath()
|
);
|
|
executeConversion(pb, outputFile);
|
return outputFile;
|
} catch (Exception e) {
|
cleanupTempFile(outputFile);
|
throw new ConversionException("音频转Opus失败: " + e.getMessage(), e);
|
}
|
}
|
|
/**
|
* 将音频转换为PCM格式
|
*/
|
public static File convertToPcm(File inputFile, String name) throws ConversionException {
|
String fileType = getFileExtension(inputFile.getName());
|
|
if ("wav".equalsIgnoreCase(fileType)) {
|
return convertTo16kPcmWav(inputFile);
|
} else {
|
return convertTo16kRawPcm(inputFile);
|
}
|
}
|
|
/**
|
* 压缩视频文件
|
*/
|
public static File compressVideo(File inputFile, int targetSizeMB, String outputFileName) throws ConversionException {
|
validateInputFile(inputFile);
|
if (targetSizeMB <= 0) {
|
throw new ConversionException("目标大小必须大于0");
|
}
|
validateOutputFileName(outputFileName);
|
|
File outputFile = createTempFile(outputFileName, "mp4");
|
|
try {
|
int durationSeconds = getVideoDuration(inputFile);
|
if (durationSeconds <= 0) {
|
throw new ConversionException("无法获取视频时长或时长为0");
|
}
|
|
int targetBitrate = (int) ((targetSizeMB * 1024 * 8) / durationSeconds);
|
|
ProcessBuilder pb = new ProcessBuilder(
|
"ffmpeg",
|
"-i", inputFile.getAbsolutePath(),
|
"-threads", "1",
|
"-c:v", "libx264",
|
"-b:v", targetBitrate + "k",
|
"-c:a", "aac",
|
"-b:a", "128k",
|
"-movflags", "+faststart",
|
"-y",
|
outputFile.getAbsolutePath()
|
);
|
|
executeConversion(pb, outputFile);
|
return outputFile;
|
} catch (Exception e) {
|
cleanupTempFile(outputFile);
|
throw new ConversionException("视频压缩失败: " + e.getMessage(), e);
|
}
|
}
|
|
/**
|
* 从视频中抽取一帧作为图片
|
*/
|
public static File extractVideoFrame(File inputFile, String timePosition, String outputFileName, String imageFormat)
|
throws ConversionException {
|
validateInputFile(inputFile);
|
if (timePosition == null || timePosition.trim().isEmpty()) {
|
throw new ConversionException("时间位置不能为空");
|
}
|
validateOutputFileName(outputFileName);
|
|
String format = imageFormat.toLowerCase();
|
if (!Arrays.asList("jpg", "png").contains(format)) {
|
throw new ConversionException("不支持的图片格式: " + imageFormat);
|
}
|
|
File outputFile = createTempFile(outputFileName, format);
|
|
try {
|
ProcessBuilder pb = new ProcessBuilder(
|
"ffmpeg",
|
"-ss", timePosition,
|
"-noaccurate_seek",
|
"-i", inputFile.getAbsolutePath(),
|
"-map", "0:v:0",
|
"-an", "-sn", "-dn",
|
"-frames:v", "1",
|
"-q:v", "30",
|
"-y",
|
outputFile.getAbsolutePath()
|
);
|
|
executeConversion(pb, outputFile);
|
return outputFile;
|
} catch (Exception e) {
|
cleanupTempFile(outputFile);
|
throw new ConversionException("视频帧抽取失败: " + e.getMessage(), e);
|
}
|
}
|
|
/**
|
* 获取视频时长(秒)
|
*/
|
public static int getVideoDuration(File videoFile) throws ConversionException {
|
Process process = null;
|
try {
|
ProcessBuilder pb = new ProcessBuilder(
|
"ffprobe",
|
"-v", "error",
|
"-show_entries", "format=duration",
|
"-of", "default=noprint_wrappers=1:nokey=1",
|
videoFile.getAbsolutePath()
|
);
|
|
process = pb.start();
|
String output;
|
try (InputStream is = process.getInputStream()) {
|
output = new String(is.readAllBytes()).trim();
|
}
|
|
int exitCode = process.waitFor();
|
if (exitCode != 0) {
|
throw new ConversionException("获取视频时长失败，退出码: " + exitCode);
|
}
|
|
return (int) Math.round(Double.parseDouble(output));
|
} catch (Exception e) {
|
throw new ConversionException("获取视频时长失败: " + e.getMessage(), e);
|
} finally {
|
if (process != null) {
|
process.destroy();
|
}
|
}
|
}
|
|
/**
|
* 将音频转换为16kHz PCM WAV格式
|
*/
|
private static File convertTo16kPcmWav(File inputFile) throws ConversionException {
|
validateInputFile(inputFile);
|
File outputFile = createTempFile(UUID.randomUUID().toString(), "wav");
|
|
try {
|
ProcessBuilder pb = new ProcessBuilder(
|
"ffmpeg",
|
"-i", inputFile.getAbsolutePath(),
|
"-ar", "16000",
|
"-ac", "1",
|
"-acodec", "pcm_s16le",
|
"-f", "wav",
|
"-y",
|
outputFile.getAbsolutePath()
|
);
|
|
executeConversion(pb, outputFile);
|
return outputFile;
|
} catch (Exception e) {
|
cleanupTempFile(outputFile);
|
throw new ConversionException("转16k PCM WAV失败: " + e.getMessage(), e);
|
}
|
}
|
|
/**
|
* 将音频转换为原始16kHz PCM格式
|
*/
|
private static File convertTo16kRawPcm(File inputFile) throws ConversionException {
|
validateInputFile(inputFile);
|
File outputFile = createTempFile(UUID.randomUUID().toString(), "pcm");
|
|
try {
|
ProcessBuilder pb = new ProcessBuilder(
|
"ffmpeg",
|
"-i", inputFile.getAbsolutePath(),
|
"-ar", "16000",
|
"-ac", "1",
|
"-acodec", "pcm_s16le",
|
"-f", "s16le",
|
"-y",
|
outputFile.getAbsolutePath()
|
);
|
|
executeConversion(pb, outputFile);
|
return outputFile;
|
} catch (Exception e) {
|
cleanupTempFile(outputFile);
|
throw new ConversionException("转16k原始PCM失败: " + e.getMessage(), e);
|
}
|
}
|
|
// ============== 辅助方法 ==============
|
|
private static String getFileExtension(String fileName) {
|
int lastIndex = fileName.lastIndexOf('.');
|
return (lastIndex != -1) ? fileName.substring(lastIndex + 1).toLowerCase() : "";
|
}
|
|
private static void validateInputFile(File inputFile) throws ConversionException {
|
if (inputFile == null || !inputFile.exists()) {
|
throw new ConversionException("输入文件不能为空且必须存在");
|
}
|
if (!inputFile.canRead()) {
|
throw new ConversionException("无法读取输入文件: " + inputFile.getAbsolutePath());
|
}
|
}
|
|
private static void validateOutputFileName(String fileName) throws ConversionException {
|
if (fileName == null || fileName.trim().isEmpty()) {
|
throw new ConversionException("输出文件名不能为空");
|
}
|
}
|
|
private static File createTempFile(String name, String extension) throws ConversionException {
|
try {
|
Path tempDir = Files.createTempDirectory("ffmpeg_conv_");
|
registerTempDirForCleanup(tempDir);
|
return tempDir.resolve(name + "." + extension).toFile();
|
} catch (IOException e) {
|
throw new ConversionException("无法创建临时文件", e);
|
}
|
}
|
|
// 在 FfmpegConverterUtils 类中添加如下字段：
|
private static final ExecutorService streamConsumerPool = Executors.newCachedThreadPool();
|
|
/**
|
* 消费流数据
|
*/
|
private static void executeConversion(ProcessBuilder pb, File outputFile)
|
throws IOException, InterruptedException, ConversionException {
|
pb.redirectErrorStream(true);
|
Process process = pb.start();
|
|
try (InputStream stdout = process.getInputStream();
|
InputStream stderr = process.getErrorStream()) {
|
|
// 使用线程池提交任务消费输出流
|
streamConsumerPool.submit(() -> consumeStream(stdout));
|
streamConsumerPool.submit(() -> consumeStream(stderr));
|
|
process.waitFor();
|
|
// boolean finished = process.waitFor(PROCESS_TIMEOUT_SECONDS, TimeUnit.SECONDS);
|
// if (!finished) {
|
// process.destroyForcibly();
|
// throw new ConversionException("转换超时");
|
// }
|
|
}
|
|
if (process.exitValue() != 0) {
|
String errorOutput = new String(process.getInputStream().readAllBytes());
|
logger.error("FFmpeg命令执行失败，错误输出:\n{}", errorOutput);
|
throw new ConversionException("FFmpeg失败，退出码: " + process.exitValue());
|
}
|
|
if (!outputFile.exists() || outputFile.length() == 0) {
|
throw new ConversionException("输出文件无效");
|
}
|
}
|
|
private static void consumeStream(InputStream is) {
|
try (BufferedReader reader = new BufferedReader(new InputStreamReader(is))) {
|
String line;
|
while ((line = reader.readLine()) != null) {
|
System.out.println(line);
|
}
|
} catch (IOException e) {
|
logger.warn("流消费异常", e);
|
}
|
}
|
|
private static void registerTempDirForCleanup(Path dirPath) {
|
dirPath.toFile().deleteOnExit();
|
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
|
try {
|
Files.walk(dirPath)
|
.sorted((a, b) -> b.compareTo(a)) // 先删除文件再删除目录
|
.forEach(path -> {
|
try {
|
Files.deleteIfExists(path);
|
} catch (IOException e) {
|
logger.warn("临时文件清理失败: {}", path, e);
|
}
|
});
|
} catch (IOException e) {
|
logger.warn("临时目录清理失败: {}", dirPath, e);
|
}
|
}));
|
}
|
|
private static void cleanupTempFile(File file) {
|
if (file != null && file.exists()) {
|
try {
|
Path path = file.toPath();
|
Path parent = path.getParent();
|
|
Files.deleteIfExists(path);
|
|
if (parent != null && Files.isDirectory(parent)) {
|
try (var stream = Files.list(parent)) {
|
if (stream.count() == 0) {
|
Files.deleteIfExists(parent);
|
}
|
}
|
}
|
} catch (IOException e) {
|
logger.warn("清理临时文件失败: {}", file.getAbsolutePath(), e);
|
}
|
}
|
}
|
|
/**
|
* 自定义转换异常
|
*/
|
public static class ConversionException extends Exception {
|
public ConversionException(String message) {
|
super(message);
|
}
|
public ConversionException(String message, Throwable cause) {
|
super(message, cause);
|
}
|
}
|
|
|
}
|
