KnarCraft/FFmpegConvert
KnarCraft/FFmpegConvert
1
0
Fork 0
Code Issues 4 Pull Requests Releases Wiki Activity

Improves FFMpeg command generation

Browse Source 
Adds an object for storing FFmpeg variables. This allows any argument type to be added at any time, removing the limitation of having to add to the command in a specific order.
Makes stream objects store the index of the input file they belong to.
Saves the result of probes to a record that's easy to pass around.
Always passes all probed files to the input files of ffmpeg.
Makes it easier to enable h26x encoding/decoding when necessary.
Removes the hard-coded behavior for external subtitles, and allows any stream to be an external stream.
This commit is contained in:
Kristian Knarvik 2024-04-08 20:00:09 +02:00
parent be88845731
commit 376d5655f2
20 changed files with 537 additions and 450 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
src/main/java/net/knarcraft/ffmpegconverter/container/FFMpegCommand.java Normal file
View File

@ -0,0 +1,139 @@
package net.knarcraft.ffmpegconverter.container;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.List;
/**
* A class for generating and storing a ffmpeg command
*/
public class FFMpegCommand {
private final @NotNull String executable;
private final @NotNull List<String> globalOptions;
private final @NotNull List<String> inputFileOptions;
private final @NotNull List<String> inputFiles;
private final @NotNull List<String> outputFileOptions;
private @NotNull String outputFile;
/**
* Instantiates a new FFMPEG command
*
* @param executable <p>The FFMPEG/FFPROBE executable to run</p>
*/
public FFMpegCommand(@NotNull String executable) {
this.executable = executable;
this.globalOptions = new ArrayList<>();
this.inputFileOptions = new ArrayList<>();
this.inputFiles = new ArrayList<>();
this.outputFileOptions = new ArrayList<>();
this.outputFile = "";
}
/**
* Instantiates a new FFMPEG command
*
* @param executable <p>The FFMPEG/FFPROBE executable to run</p>
* @param globalOptions <p>Options for FFMPEG itself</p>
* @param inputFileOptions <p>Options for processing of the input files</p>
* @param inputFiles <p>The input files to execute on</p>
* @param outputFileOptions <p>Options for the output files</p>
* @param outputFile <p>The output file to write to</p>
*/
public FFMpegCommand(@NotNull String executable, @NotNull List<String> globalOptions,
@NotNull List<String> inputFileOptions, @NotNull List<String> inputFiles,
@NotNull List<String> outputFileOptions, @NotNull String outputFile) {
this.executable = executable;
this.globalOptions = globalOptions;
this.inputFileOptions = inputFileOptions;
this.inputFiles = inputFiles;
this.outputFileOptions = outputFileOptions;
this.outputFile = outputFile;
}
/**
* Adds a global ffmpeg option to this command
*
* @param argument <p>The option(s) to add</p>
*/
public void addGlobalOption(@NotNull String... argument) {
this.globalOptions.addAll(List.of(argument));
}
/**
* Adds an input file option to this command
*
* @param argument <p>The input file option(s) to add</p>
*/
public void addInputFileOption(@NotNull String... argument) {
this.inputFileOptions.addAll(List.of(argument));
}
/**
* Adds an input file to this command
*
* <p>Note that this adds the "-i", so don't add that yourself!</p>
*
* @param argument <p>The input file(s) to add</p>
*/
public void addInputFile(@NotNull String... argument) {
for (String fileName : argument) {
if (fileName.isEmpty()) {
continue;
}
this.inputFiles.add(fileName);
}
}
/**
* Gets the input files currently added to this command
*
* @return <p>The input files</p>
*/
@NotNull
public List<String> getInputFiles() {
return new ArrayList<>(this.inputFiles);
}
/**
* Adds an output file option to this command
*
* @param argument <p>The output file option(s) to add</p>
*/
public void addOutputFileOption(@NotNull String... argument) {
this.outputFileOptions.addAll(List.of(argument));
}
/**
* Sets the output file for this command
*
* @param argument <p>The path to the output file</p>
*/
public void setOutputFile(@NotNull String argument) {
this.outputFile = argument;
}
/**
* Gets the result of combining all the given input
*
* @return <p>The generated FFMPEG command</p>
*/
@NotNull
public String[] getResult() {
List<String> result = new ArrayList<>();
result.add(executable);
result.addAll(globalOptions);
result.addAll(inputFileOptions);
for (String inputFile : inputFiles) {
result.add("-i");
result.add(inputFile);
}
result.addAll(outputFileOptions);
if (!outputFile.isEmpty()) {
result.add(outputFile);
}
return result.toArray(new String[0]);
}
}

16
src/main/java/net/knarcraft/ffmpegconverter/container/StreamProbeResult.java Normal file
View File

@ -0,0 +1,16 @@
package net.knarcraft.ffmpegconverter.container;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.List;
/**
* A record for storing the result of probing for streams
*
* @param parsedFiles <p>The files that were parsed to get the attached streams</p>
* @param parsedStreams <p>The streams that were parsed from the files</p>
*/
public record StreamProbeResult(@NotNull List<File> parsedFiles, @NotNull List<StreamObject> parsedStreams) {
}

10
src/main/java/net/knarcraft/ffmpegconverter/converter/AbstractConverter.java
View File

@ -1,5 +1,6 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.AudioStream;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.streams.SubtitleStream;
@ -122,19 +123,20 @@ public abstract class AbstractConverter implements Converter {
* @param file <p>The file to process.</p>
* @throws IOException <p>If the BufferedReader fails.</p>
*/
private void processFile(File folder, File file) throws IOException {
List<StreamObject> streams = FFMpegHelper.probeFile(ffprobePath, file);
if (streams.isEmpty()) {
private void processFile(@NotNull File folder, @NotNull File file) throws IOException {
StreamProbeResult probeResult = FFMpegHelper.probeFile(ffprobePath, file);
if (probeResult.parsedStreams().isEmpty()) {
throw new IllegalArgumentException("The file has no valid streams. Please make sure the file exists and" +
" is not corrupt.");
}
String outExtension = newExtension != null ? newExtension : FileUtil.getExtension(file.getName());
String newPath = FileUtil.getNonCollidingPath(folder, file, outExtension);
OutputUtil.println();
OutputUtil.println("Preparing to start process...");
OutputUtil.println("Converting " + file);
String[] command = generateConversionCommand(ffmpegPath, file, streams, newPath);
String[] command = generateConversionCommand(ffmpegPath, probeResult, newPath);
// If no commands were given, no conversion is necessary
if (command.length == 0) {
return;

19
src/main/java/net/knarcraft/ffmpegconverter/converter/AnimeConverter.java
View File

@ -1,12 +1,14 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.container.FFMpegCommand;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.AudioStream;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.streams.SubtitleStream;
import net.knarcraft.ffmpegconverter.streams.VideoStream;
import net.knarcraft.ffmpegconverter.utility.FFMpegHelper;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
@ -51,8 +53,10 @@ public class AnimeConverter extends AbstractConverter {
}
@Override
public String[] generateConversionCommand(String executable, File file, List<StreamObject> streams, String outFile) {
List<String> command = FFMpegHelper.getFFMpegWebVideoCommand(executable, file.getName());
public String[] generateConversionCommand(@NotNull String executable, @NotNull StreamProbeResult probeResult,
@NotNull String outFile) {
FFMpegCommand command = FFMpegHelper.getFFMpegWebVideoCommand(executable, probeResult.parsedFiles());
List<StreamObject> streams = probeResult.parsedStreams();
if (this.debug) {
FFMpegHelper.addDebugArguments(command, 50, 120);
}
@ -71,13 +75,16 @@ public class AnimeConverter extends AbstractConverter {
//Get the first video stream
VideoStream videoStream = getNthVideoStream(streams, 0);
if (videoStream == null) {
throw new IllegalArgumentException("The selected video stream does not exist");
}
//Add streams to output file
FFMpegHelper.addAudioStream(command, audioStream, this.toStereo);
FFMpegHelper.addSubtitleAndVideoStream(command, subtitleStream, videoStream, file);
FFMpegHelper.addSubtitleAndVideoStream(command, subtitleStream, videoStream);
command.add(outFile);
return command.toArray(new String[0]);
command.setOutputFile(outFile);
return command.getResult();
}
@Override

14
src/main/java/net/knarcraft/ffmpegconverter/converter/AudioConverter.java
View File

@ -1,10 +1,12 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.container.FFMpegCommand;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.AudioStream;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.utility.FFMpegHelper;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.List;
/**
@ -26,8 +28,10 @@ public class AudioConverter extends AbstractConverter {
}
@Override
public String[] generateConversionCommand(String executable, File file, List<StreamObject> streams, String outFile) {
List<String> command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, file.getName());
public String[] generateConversionCommand(@NotNull String executable, @NotNull StreamProbeResult probeResult,
@NotNull String outFile) {
FFMpegCommand command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, probeResult.parsedFiles());
List<StreamObject> streams = probeResult.parsedStreams();
if (this.debug) {
FFMpegHelper.addDebugArguments(command, 50, 120);
}
@ -35,9 +39,9 @@ public class AudioConverter extends AbstractConverter {
//Gets the first audio stream from the file and adds it to the output file
AudioStream audioStream = getNthAudioSteam(streams, 0);
FFMpegHelper.addAudioStream(command, audioStream, false);
command.add(outFile);
command.setOutputFile(outFile);
return command.toArray(new String[0]);
return command.getResult();
}
@Override

18
src/main/java/net/knarcraft/ffmpegconverter/converter/Converter.java
View File

@ -1,10 +1,10 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.io.IOException;
import java.util.List;
/**
* This interface describes a file converter
@ -16,6 +16,7 @@ public interface Converter {
*
* @return <p>A list of valid input formats</p>
*/
@NotNull
String[] getValidFormats();
/**
@ -24,17 +25,18 @@ public interface Converter {
* @param file <p>The file to convert.</p>
* @throws IOException <p>If the file cannot be converted.</p>
*/
void convert(File file) throws IOException;
void convert(@NotNull File file) throws IOException;
/**
* Generates a command for a ProcessBuilder.
*
* @param executable <p>The executable file for ffmpeg.</p>
* @param file <p>The input file.</p>
* @param streams <p>A list of ffprobe streams.</p>
* @param outFile <p>The output file.</p>
* @param executable <p>The executable file for ffmpeg</p>
* @param probeResult <p>The result of probing the input file</p>
* @param outFile <p>The output file</p>
* @return <p>A list of commands</p>
*/
String[] generateConversionCommand(String executable, File file, List<StreamObject> streams, String outFile);
@NotNull
String[] generateConversionCommand(@NotNull String executable, @NotNull StreamProbeResult probeResult,
@NotNull String outFile);
}

33
src/main/java/net/knarcraft/ffmpegconverter/converter/DownScaleConverter.java
View File

@ -1,10 +1,12 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.container.FFMpegCommand;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.streams.VideoStream;
import net.knarcraft.ffmpegconverter.utility.FFMpegHelper;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.List;
/**
@ -32,33 +34,28 @@ public class DownScaleConverter extends AbstractConverter {
}
@Override
public String[] generateConversionCommand(String executable, File file, List<StreamObject> streams, String outFile) {
public String[] generateConversionCommand(@NotNull String executable, @NotNull StreamProbeResult probeResult,
@NotNull String outFile) {
List<StreamObject> streams = probeResult.parsedStreams();
VideoStream videoStream = getNthVideoStream(streams, 0);
if (videoStream == null || (videoStream.getWidth() <= newWidth && videoStream.getHeight() <= newHeight)) {
return new String[0];
}
List<String> command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, file.getName());
FFMpegCommand command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, probeResult.parsedFiles());
if (this.debug) {
FFMpegHelper.addDebugArguments(command, 50, 120);
}
//Add all streams without re-encoding
command.add("-map");
command.add("0");
command.add("-c:a");
command.add("copy");
command.add("-c:s");
command.add("copy");
command.add("-vf");
command.add("scale=" + newWidth + ":" + newHeight);
command.add("-crf");
command.add("20");
command.add("-preset");
command.add("slow");
command.add(outFile);
return command.toArray(new String[0]);
FFMpegHelper.mapAllStreams(command, streams);
command.addOutputFileOption("-c:a", "copy");
command.addOutputFileOption("-c:s", "copy");
command.addOutputFileOption("-vf", "scale=" + newWidth + ":" + newHeight);
command.addOutputFileOption("-crf", "20");
command.addOutputFileOption("-preset", "slow");
command.setOutputFile(outFile);
return command.getResult();
}
@Override

26
src/main/java/net/knarcraft/ffmpegconverter/converter/MKVToMP4Transcoder.java
View File

@ -1,12 +1,14 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.container.FFMpegCommand;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.AudioStream;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.streams.SubtitleStream;
import net.knarcraft.ffmpegconverter.streams.VideoStream;
import net.knarcraft.ffmpegconverter.utility.FFMpegHelper;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
@ -44,8 +46,10 @@ public class MKVToMP4Transcoder extends AbstractConverter {
}
@Override
public String[] generateConversionCommand(String executable, File file, List<StreamObject> streams, String outFile) {
List<String> command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, file.getName());
public String[] generateConversionCommand(@NotNull String executable, @NotNull StreamProbeResult probeResult,
@NotNull String outFile) {
FFMpegCommand command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, probeResult.parsedFiles());
List<StreamObject> streams = probeResult.parsedStreams();
if (this.debug) {
FFMpegHelper.addDebugArguments(command, 50, 120);
}
@ -61,21 +65,19 @@ public class MKVToMP4Transcoder extends AbstractConverter {
//Get the nth video stream
VideoStream videoStream = getNthVideoStream(streams, Math.max(this.videoStreamIndex, 0));
if (videoStream == null) {
throw new IllegalArgumentException("The selected video stream was not found");
}
// Copy stream info
command.add("-map_metadata");
command.add("0");
command.add("-movflags");
command.add("use_metadata_tags");
command.add("-c");
command.add("copy");
command.addOutputFileOption("-c", "copy");
//Add streams to output file
FFMpegHelper.addAudioStream(command, audioStream, false);
FFMpegHelper.addSubtitleAndVideoStream(command, subtitleStream, videoStream, file);
FFMpegHelper.addSubtitleAndVideoStream(command, subtitleStream, videoStream);
command.add(outFile);
return command.toArray(new String[0]);
command.setOutputFile(outFile);
return command.getResult();
}
}

88
src/main/java/net/knarcraft/ffmpegconverter/converter/MkvH264Converter.java
View File

@ -1,13 +1,14 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.container.FFMpegCommand;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.AudioStream;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.streams.SubtitleStream;
import net.knarcraft.ffmpegconverter.streams.VideoStream;
import net.knarcraft.ffmpegconverter.utility.FFMpegHelper;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/**
@ -33,73 +34,50 @@ public class MkvH264Converter extends AbstractConverter {
}
@Override
public String[] generateConversionCommand(String executable, File file, List<StreamObject> streams,
String outFile) {
List<String> command = new ArrayList<>();
command.add(executable);
command.add("-hwaccel");
command.add("cuda");
command.add("-hwaccel_output_format");
command.add("cuda");
command.add("-i");
command.add(file.getName());
public String[] generateConversionCommand(@NotNull String executable, @NotNull StreamProbeResult probeResult,
@NotNull String outFile) {
FFMpegCommand command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, probeResult.parsedFiles());
List<StreamObject> streams = probeResult.parsedStreams();
if (this.debug) {
FFMpegHelper.addDebugArguments(command, 50, 120);
}
// Map video if present
if (!filterStreamsByType(streams, VideoStream.class).isEmpty()) {
command.add("-map");
command.add("0:v");
command.add("-crf");
command.add("28");
command.add("-codec:v");
command.add("h264_nvenc");
command.add("-preset");
command.add("slow");
command.add("-movflags");
command.add("+faststart");
List<StreamObject> videoStreams = filterStreamsByType(streams, VideoStream.class);
if (!videoStreams.isEmpty()) {
for (StreamObject streamObject : videoStreams) {
if (!streamObject.getCodecName().equals("h264") && !streamObject.getCodecName().equals("h266")) {
continue;
}
FFMpegHelper.addH26xHardwareDecoding(command);
break;
}
FFMpegHelper.mapAllStreams(command, videoStreams);
FFMpegHelper.addH264HardwareEncoding(command, 17);
command.addOutputFileOption("-movflags", "+faststart");
}
// Map audio if present
if (!filterStreamsByType(streams, AudioStream.class).isEmpty()) {
command.add("-map");
command.add("0:a");
command.add("-c:a");
command.add("copy");
List<StreamObject> audioStreams = filterStreamsByType(streams, AudioStream.class);
if (!audioStreams.isEmpty()) {
FFMpegHelper.mapAllStreams(command, audioStreams);
command.addOutputFileOption("-c:a", "copy");
}
// Map subtitles if present
if (hasInternalStreams(streams)) {
command.add("-map");
command.add("0:s");
command.add("-c:s");
command.add("copy");
List<StreamObject> subtitleStreams = filterStreamsByType(streams, SubtitleStream.class);
if (!subtitleStreams.isEmpty()) {
FFMpegHelper.mapAllStreams(command, subtitleStreams);
command.addOutputFileOption("-c:s", "copy");
}
command.add("-map_metadata");
command.add("0");
command.add("-movflags");
command.add("use_metadata_tags");
command.addOutputFileOption("-f", "matroska");
command.add(outFile);
return command.toArray(new String[0]);
}
/**
* Checks whether the processed file has any internal subtitle streams
*
* @param streams <p>All parsed streams for the video file</p>
* @return <p>True if the file has at least one internal subtitle stream</p>
*/
private boolean hasInternalStreams(List<StreamObject> streams) {
for (StreamObject subtitleStream : filterStreamsByType(streams, SubtitleStream.class)) {
if (((SubtitleStream) subtitleStream).isInternalSubtitle()) {
return true;
}
}
return false;
command.setOutputFile(outFile);
return command.getResult();
}
}

88
src/main/java/net/knarcraft/ffmpegconverter/converter/MkvH265ReducedConverter.java
View File

@ -1,13 +1,14 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.container.FFMpegCommand;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.AudioStream;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.streams.SubtitleStream;
import net.knarcraft.ffmpegconverter.streams.VideoStream;
import net.knarcraft.ffmpegconverter.utility.FFMpegHelper;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/**
@ -33,76 +34,49 @@ public class MkvH265ReducedConverter extends AbstractConverter {
}
@Override
public String[] generateConversionCommand(String executable, File file, List<StreamObject> streams,
String outFile) {
List<String> command = new ArrayList<>();
command.add(executable);
command.add("-hwaccel");
command.add("cuda");
command.add("-hwaccel_output_format");
command.add("cuda");
command.add("-i");
command.add(file.getName());
public String[] generateConversionCommand(@NotNull String executable, @NotNull StreamProbeResult probeResult,
@NotNull String outFile) {
FFMpegCommand command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, probeResult.parsedFiles());
List<StreamObject> streams = probeResult.parsedStreams();
if (this.debug) {
FFMpegHelper.addDebugArguments(command, 50, 120);
}
// Map video if present
if (!filterStreamsByType(streams, VideoStream.class).isEmpty()) {
command.add("-map");
command.add("0:v");
command.add("-codec:v");
command.add("hevc_nvenc");
command.add("-crf");
command.add("28");
command.add("-preset");
command.add("slow");
command.add("-tag:v");
command.add("hvc1");
command.add("-movflags");
command.add("+faststart");
List<StreamObject> videoStreams = filterStreamsByType(streams, VideoStream.class);
if (!videoStreams.isEmpty()) {
for (StreamObject streamObject : videoStreams) {
if (!streamObject.getCodecName().equals("h264") && !streamObject.getCodecName().equals("h266")) {
continue;
}
FFMpegHelper.addH26xHardwareDecoding(command);
break;
}
FFMpegHelper.mapAllStreams(command, videoStreams);
FFMpegHelper.addH265HardwareEncoding(command, 17);
command.addOutputFileOption("-movflags", "+faststart");
}
// Map audio if present
if (!filterStreamsByType(streams, AudioStream.class).isEmpty()) {
command.add("-map");
command.add("0:a");
List<StreamObject> audioStreams = filterStreamsByType(streams, AudioStream.class);
if (!audioStreams.isEmpty()) {
FFMpegHelper.mapAllStreams(command, audioStreams);
}
// Map subtitles if present
if (hasInternalStreams(streams)) {
command.add("-map");
command.add("0:s");
command.add("-c:s");
command.add("copy");
List<StreamObject> subtitleStreams = filterStreamsByType(streams, SubtitleStream.class);
if (!subtitleStreams.isEmpty()) {
FFMpegHelper.mapAllStreams(command, subtitleStreams);
command.addOutputFileOption("-c:s", "copy");
}
command.add("-map_metadata");
command.add("0");
command.add("-movflags");
command.add("use_metadata_tags");
command.add("-f");
command.add("matroska");
command.addOutputFileOption("-f", "matroska");
command.add(outFile);
return command.toArray(new String[0]);
}
/**
* Checks whether the processed file has any internal subtitle streams
*
* @param streams <p>All parsed streams for the video file</p>
* @return <p>True if the file has at least one internal subtitle stream</p>
*/
private boolean hasInternalStreams(List<StreamObject> streams) {
for (StreamObject subtitleStream : filterStreamsByType(streams, SubtitleStream.class)) {
if (((SubtitleStream) subtitleStream).isInternalSubtitle()) {
return true;
}
}
return false;
command.setOutputFile(outFile);
return command.getResult();
}
}

48
src/main/java/net/knarcraft/ffmpegconverter/converter/SubtitleEmbed.java
View File

@ -1,11 +1,11 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.container.FFMpegCommand;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.streams.SubtitleStream;
import net.knarcraft.ffmpegconverter.utility.FFMpegHelper;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/**
@ -31,44 +31,22 @@ public class SubtitleEmbed extends AbstractConverter {
}
@Override
public String[] generateConversionCommand(String executable, File file, List<StreamObject> streams, String outFile) {
List<String> command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, file.getName());
public String[] generateConversionCommand(@NotNull String executable, @NotNull StreamProbeResult probeResult,
@NotNull String outFile) {
FFMpegCommand command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, probeResult.parsedFiles());
List<StreamObject> streams = probeResult.parsedStreams();
List<SubtitleStream> subtitleStreams = filterStreamsByType(streams, SubtitleStream.class);
List<SubtitleStream> externalSubtitles = new ArrayList<>();
for (SubtitleStream subtitleStream : subtitleStreams) {
if (!subtitleStream.isInternalSubtitle()) {
externalSubtitles.add(subtitleStream);
}
}
if (externalSubtitles.isEmpty()) {
System.err.println("No external subtitles found for " + file.getName());
}
for (SubtitleStream subtitleStream : externalSubtitles) {
command.add("-i");
command.add(subtitleStream.getFile());
}
command.add("-c");
command.add("copy");
command.add("-c:s");
command.add("mov_text");
int i = 0;
for (SubtitleStream subtitleStream : subtitleStreams) {
command.add("-metadata:s:s:" + i);
command.add("language=" + subtitleStream.getLanguage());
i++;
}
FFMpegHelper.mapAllStreams(command, streams);
command.addOutputFileOption("-c:a", "copy");
command.addOutputFileOption("-c:v", "copy");
command.addOutputFileOption("-c:s", "mov_text");
if (this.debug) {
FFMpegHelper.addDebugArguments(command, 50, 120);
}
command.add(outFile);
return command.toArray(new String[0]);
command.setOutputFile(outFile);
return command.getResult();
}
}

20
src/main/java/net/knarcraft/ffmpegconverter/converter/VideoConverter.java
View File

@ -1,9 +1,11 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.container.FFMpegCommand;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.utility.FFMpegHelper;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.List;
/**
@ -25,20 +27,20 @@ public class VideoConverter extends AbstractConverter {
}
@Override
public String[] generateConversionCommand(String executable, File file, List<StreamObject> streams, String outFile) {
List<String> command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, file.getName());
public String[] generateConversionCommand(@NotNull String executable, @NotNull StreamProbeResult probeResult,
@NotNull String outFile) {
FFMpegCommand command = FFMpegHelper.getFFMpegGeneralFileCommand(executable, probeResult.parsedFiles());
List<StreamObject> streams = probeResult.parsedStreams();
if (this.debug) {
FFMpegHelper.addDebugArguments(command, 50, 120);
}
//Add all streams without re-encoding
command.add("-map");
command.add("0");
command.add("-c");
command.add("copy");
FFMpegHelper.mapAllStreams(command, streams);
command.addOutputFileOption("-c", "copy");
command.add(outFile);
return command.toArray(new String[0]);
command.setOutputFile(outFile);
return command.getResult();
}
@Override

20
src/main/java/net/knarcraft/ffmpegconverter/converter/WebVideoConverter.java
View File

@ -1,12 +1,14 @@
package net.knarcraft.ffmpegconverter.converter;
import net.knarcraft.ffmpegconverter.container.FFMpegCommand;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.AudioStream;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.streams.SubtitleStream;
import net.knarcraft.ffmpegconverter.streams.VideoStream;
import net.knarcraft.ffmpegconverter.utility.FFMpegHelper;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.util.List;
/**
@ -33,8 +35,10 @@ public class WebVideoConverter extends AbstractConverter {
}
@Override
public String[] generateConversionCommand(String executable, File file, List<StreamObject> streams, String outFile) {
List<String> command = FFMpegHelper.getFFMpegWebVideoCommand(executable, file.getName());
public String[] generateConversionCommand(@NotNull String executable, @NotNull StreamProbeResult probeResult,
@NotNull String outFile) {
FFMpegCommand command = FFMpegHelper.getFFMpegWebVideoCommand(executable, probeResult.parsedFiles());
List<StreamObject> streams = probeResult.parsedStreams();
if (this.debug) {
FFMpegHelper.addDebugArguments(command, 50, 120);
}
@ -44,13 +48,17 @@ public class WebVideoConverter extends AbstractConverter {
VideoStream videoStream = getNthVideoStream(streams, 0);
AudioStream audioStream = getNthAudioSteam(streams, 0);
if (videoStream == null) {
throw new IllegalArgumentException("The selected video stream does not exist.");
}
//Add streams to output
FFMpegHelper.addSubtitleAndVideoStream(command, subtitleStream, videoStream, file);
FFMpegHelper.addSubtitleAndVideoStream(command, subtitleStream, videoStream);
if (audioStream != null) {
FFMpegHelper.addAudioStream(command, audioStream, true);
}
command.add(outFile);
return command.toArray(new String[0]);
command.setOutputFile(outFile);
return command.getResult();
}
}

13
src/main/java/net/knarcraft/ffmpegconverter/streams/AbstractStream.java
View File

@ -10,10 +10,11 @@ import java.util.Map;
*/
public abstract class AbstractStream implements StreamObject {
protected final int inputIndex;
protected final int absoluteIndex;
protected final int relativeIndex;
protected final String codecName;
protected String language;
protected final String language;
protected final boolean isDefault;
protected final String title;
@ -21,14 +22,16 @@ public abstract class AbstractStream implements StreamObject {
* Instantiates a new abstract stream
*
* @param streamInfo <p>All info about the stream</p>
* @param inputIndex <p>The index of the input file this stream belongs to</p>
* @param relativeIndex <p>The relative index of this stream, only considering streams of the same type</p>
*/
protected AbstractStream(@NotNull Map<StreamTag, String> streamInfo, int relativeIndex) {
protected AbstractStream(@NotNull Map<StreamTag, String> streamInfo, int inputIndex, int relativeIndex) {
this.codecName = ValueParsingHelper.parseString(streamInfo.get(StreamTag.CODEC_NAME), "");
this.absoluteIndex = ValueParsingHelper.parseInt(streamInfo.get(StreamTag.INDEX), -1);
this.language = ValueParsingHelper.parseString(streamInfo.get(StreamTag.TAG_LANGUAGE), "und");
this.isDefault = ValueParsingHelper.parseBoolean(streamInfo.get(StreamTag.DISPOSITION_DEFAULT), false);
this.title = ValueParsingHelper.parseString(streamInfo.get(StreamTag.TAG_TITLE), "");
this.inputIndex = inputIndex;
this.relativeIndex = relativeIndex;
}
@ -58,8 +61,14 @@ public abstract class AbstractStream implements StreamObject {
}
@Override
@NotNull
public String getTitle() {
return this.title;
}
@Override
public int getInputIndex() {
return this.inputIndex;
}
}

5
src/main/java/net/knarcraft/ffmpegconverter/streams/AudioStream.java
View File

@ -16,10 +16,11 @@ public class AudioStream extends AbstractStream implements StreamObject {
* Instantiates a new audio stream
*
* @param streamInfo <p>All info about the stream</p>
* @param inputIndex <p>The index of the input file containing this stream</p>
* @param relativeIndex <p>The index of the audio stream relative to other audio streams.</p>
*/
public AudioStream(@NotNull Map<StreamTag, String> streamInfo, int relativeIndex) {
super(streamInfo, relativeIndex);
public AudioStream(@NotNull Map<StreamTag, String> streamInfo, int inputIndex, int relativeIndex) {
super(streamInfo, inputIndex, relativeIndex);
this.channels = ValueParsingHelper.parseInt(streamInfo.get(StreamTag.CHANNELS), 0);
}

10
src/main/java/net/knarcraft/ffmpegconverter/streams/StreamObject.java
View File

@ -22,6 +22,15 @@ public interface StreamObject {
*/
int getAbsoluteIndex();
/**
* Gets the index of the input file this stream belongs to
*
* <p>This is the first number given to a map argument in order to map this stream to the output file.</p>
*
* @return <p>The input index of this stream</p>
*/
int getInputIndex();
/**
* Gets the relative index of a stream object (kth element of codec type)
*
@ -57,6 +66,7 @@ public interface StreamObject {
*
* @return <p>The title of the subtitle stream.</p>
*/
@NotNull
String getTitle();
}

56
src/main/java/net/knarcraft/ffmpegconverter/streams/SubtitleStream.java
View File

@ -1,6 +1,5 @@
package net.knarcraft.ffmpegconverter.streams;
import net.knarcraft.ffmpegconverter.utility.FileUtil;
import org.jetbrains.annotations.NotNull;
import java.util.Map;
@ -10,51 +9,21 @@ import java.util.Map;
*/
public class SubtitleStream extends AbstractStream implements StreamObject {
final private String file;
final private boolean isFullSubtitle;
final private boolean isImageSubtitle;
final private boolean isInternalStream;
/**
* Instantiates a new subtitle stream
*
* @param streamInfo <p>All info about the stream</p>
* @param inputIndex <p>The index of the input file containing this stream</p>
* @param relativeIndex <p>The index of the subtitle stream relative to other subtitle streams.</p>
* @param file <p>The file containing the subtitle.</p>
* @param isInternalStream <p>Whether this subtitle stream is in the video file itself</p>
*/
public SubtitleStream(@NotNull Map<StreamTag, String> streamInfo, int relativeIndex,
@NotNull String file, boolean isInternalStream) {
super(streamInfo, relativeIndex);
public SubtitleStream(@NotNull Map<StreamTag, String> streamInfo, int inputIndex, int relativeIndex) {
super(streamInfo, inputIndex, relativeIndex);
this.isFullSubtitle = isFullSubtitle();
this.isImageSubtitle = isImageSubtitle();
this.isInternalStream = isInternalStream;
this.file = file;
if (this.language == null || this.language.isEmpty()) {
String possibleLanguage = FileUtil.getLanguage(file);
if (possibleLanguage != null) {
this.language = possibleLanguage;
}
}
}
/**
* Gets the file name of the file containing this subtitle
*
* @return <p>The file name containing the subtitle stream.</p>
*/
public String getFile() {
return this.file;
}
/**
* Gets whether this subtitle stream is an internal stream, not an external one
*
* @return <p>True if this stream is an internal stream</p>
*/
public boolean isInternalSubtitle() {
return this.isInternalStream;
this.isImageSubtitle = codecName != null &&
(getCodecName().equals("hdmv_pgs_subtitle") || getCodecName().equals("dvd_subtitle"));
}
/**
@ -75,25 +44,12 @@ public class SubtitleStream extends AbstractStream implements StreamObject {
return this.isFullSubtitle;
}
/**
* Checks whether a subtitle is image based (as opposed to text based)
*
* @return <p>True if the subtitle is image based.</p>
*/
private boolean isImageSubtitle() {
return codecName != null && (getCodecName().equals("hdmv_pgs_subtitle")
|| getCodecName().equals("dvd_subtitle"));
}
/**
* Checks whether the subtitle translates everything (as opposed to just songs and signs)
*
* @return <p>True if the subtitle translates everything.</p>
*/
private boolean isFullSubtitle() {
if (getTitle() == null) {
return false;
}
String titleLowercase = getTitle().toLowerCase();
return !titleLowercase.matches(".*si(ng|gn)s?[ &/a-z]+songs?.*") &&
!titleLowercase.matches(".*songs?[ &/a-z]+si(gn|ng)s?.*") &&
@ -101,7 +57,7 @@ public class SubtitleStream extends AbstractStream implements StreamObject {
!titleLowercase.matches(".*s&s.*") &&
!titleLowercase.matches("signs?") &&
!titleLowercase.matches("songs?") &&
!titleLowercase.contains("signs only");
!titleLowercase.matches(".*signs only.*");
}
@Override

5
src/main/java/net/knarcraft/ffmpegconverter/streams/VideoStream.java
View File

@ -17,10 +17,11 @@ public class VideoStream extends AbstractStream implements StreamObject {
* Instantiates a new video stream
*
* @param streamInfo <p>All info about the stream</p>
* @param inputIndex <p>The index of the input file containing this stream</p>
* @param relativeIndex <p>The index of the video stream relative to other video streams.</p>
*/
public VideoStream(@NotNull Map<StreamTag, String> streamInfo, int relativeIndex) {
super(streamInfo, relativeIndex);
public VideoStream(@NotNull Map<StreamTag, String> streamInfo, int inputIndex, int relativeIndex) {
super(streamInfo, inputIndex, relativeIndex);
this.width = ValueParsingHelper.parseInt(streamInfo.get(StreamTag.WIDTH), -1);
this.height = ValueParsingHelper.parseInt(streamInfo.get(StreamTag.HEIGHT), -1);
}

300
src/main/java/net/knarcraft/ffmpegconverter/utility/FFMpegHelper.java
View File

@ -1,5 +1,7 @@
package net.knarcraft.ffmpegconverter.utility;
import net.knarcraft.ffmpegconverter.container.FFMpegCommand;
import net.knarcraft.ffmpegconverter.container.StreamProbeResult;
import net.knarcraft.ffmpegconverter.streams.AudioStream;
import net.knarcraft.ffmpegconverter.streams.StreamObject;
import net.knarcraft.ffmpegconverter.streams.StreamTag;
@ -48,6 +50,13 @@ public final class FFMpegHelper {
Plan: Sort all streams by set criteria. Map all selected streams by looping using their relative index for
selection.
Streams should probably have an input index, so it's easier to treat extra subtitles more seamlessly. So, by
including any external subtitle files as input, there would be no need to fiddle more with storing input files.
Instead of storing the ffmpeg command as a list of strings, it should be stored as an object with different list
for input arguments and output arguments. That way, it would be much easier to add input-related arguments later
in the process.
*/
/**
@ -58,71 +67,73 @@ public final class FFMpegHelper {
* @return <p>A list of StreamObjects.</p>
* @throws IOException <p>If the process can't be readProcess.</p>
*/
public static List<StreamObject> probeFile(String ffprobePath, File file) throws IOException {
@NotNull
public static StreamProbeResult probeFile(@NotNull String ffprobePath, @NotNull File file) throws IOException {
return parseStreams(ffprobePath, probeForStreams(ffprobePath, file), file);
}
/**
* Creates a list containing all required arguments for converting a video to a web playable video
*
* @param executable <p>The executable to use (ffmpeg/ffprobe).</p>
* @param fileName <p>The name of the file to execute on.</p>
* @return <p>A base list of ffmpeg commands for converting a video for web</p>
* @param executable <p>The executable to use (ffmpeg/ffprobe)</p>
* @param files <p>The files to execute on</p>
* @return <p>A FFMPEG command for web-playable video</p>
*/
public static List<String> getFFMpegWebVideoCommand(String executable, String fileName) {
List<String> command = getFFMpegGeneralFileCommand(executable, fileName);
command.add("-vcodec");
command.add("h264");
command.add("-pix_fmt");
command.add("yuv420p");
command.add("-ar");
command.add("48000");
command.add("-movflags");
command.add("+faststart");
@NotNull
public static FFMpegCommand getFFMpegWebVideoCommand(@NotNull String executable, @NotNull List<File> files) {
FFMpegCommand command = getFFMpegGeneralFileCommand(executable, files);
command.addOutputFileOption("-vcodec", "h264");
command.addOutputFileOption("-pix_fmt", "yuv420p");
command.addOutputFileOption("-ar", "48000");
command.addOutputFileOption("-movflags", "+faststart");
command.addOutputFileOption("-map_metadata", "0");
command.addOutputFileOption("-movflags", "+use_metadata_tags");
return command;
}
/**
* Creates a list containing command line arguments for a general file
*
* @param executable <p>The executable to use (ffmpeg/ffprobe).</p>
* @param fileName <p>The name of the file to execute on.</p>
* @return <p>A base list of ffmpeg commands for converting a file.</p>
* @param executable <p>The executable to use (ffmpeg/ffprobe)</p>
* @param files <p>The files to execute on</p>
* @return <p>A basic FFMPEG command</p>
*/
public static List<String> getFFMpegGeneralFileCommand(String executable, String fileName) {
List<String> command = new ArrayList<>();
command.add(executable);
command.add("-nostdin");
command.add("-i");
command.add(fileName);
@NotNull
public static FFMpegCommand getFFMpegGeneralFileCommand(@NotNull String executable, @NotNull List<File> files) {
FFMpegCommand command = new FFMpegCommand(executable);
command.addGlobalOption("-nostdin");
for (File file : files) {
command.addInputFile(file.getName());
}
command.addOutputFileOption("-map_metadata", "0");
command.addOutputFileOption("-movflags", "+use_metadata_tags");
return command;
}
/**
* Adds debugging parameters for only converting parts of a file
*
* @param command <p>The list containing the command to run.</p>
* @param start <p>The offset before converting.</p>
* @param length <p>The offset for stopping the conversion.</p>
* @param command <p>The command to add to</p>
* @param start <p>The time to start at</p>
* @param duration <p>The duration of video to output</p>
*/
public static void addDebugArguments(List<String> command, int start, int length) {
command.add("-ss");
command.add("" + start);
command.add("-t");
command.add("" + length);
public static void addDebugArguments(@NotNull FFMpegCommand command, int start, int duration) {
command.addInputFileOption("-ss", String.valueOf(start));
command.addOutputFileOption("-t", String.valueOf(duration));
}
/**
* Starts and prints output of a process
*
* @param processBuilder <p>The process to run.</p>
* @param folder <p>The folder the process should run in.</p>
* @param spacer <p>The character(s) to use between each new line read.</p>
* @param write <p>Whether to write the output directly instead of storing it.</p>
* @throws IOException <p>If the process can't be readProcess.</p>
* @param processBuilder <p>The process to run</p>
* @param folder <p>The folder the process should run in</p>
* @param spacer <p>The character(s) to use between each new line read</p>
* @param write <p>Whether to write the output directly instead of storing it</p>
* @throws IOException <p>If the process can't be readProcess</p>
*/
public static String runProcess(ProcessBuilder processBuilder, File folder, String spacer, boolean write)
throws IOException {
@NotNull
public static String runProcess(@NotNull ProcessBuilder processBuilder, @NotNull File folder,
@NotNull String spacer, boolean write) throws IOException {
//Give the user information about what's about to happen
OutputUtil.print("Command to be run: ");
OutputUtil.println(processBuilder.command().toString());
@ -136,7 +147,10 @@ public final class FFMpegHelper {
StringBuilder output = new StringBuilder();
while (process.isAlive()) {
String read = readProcess(processReader, spacer);
if (!read.isEmpty()) {
if (read.isEmpty()) {
continue;
}
if (write) {
OutputUtil.println(read);
} else {
@ -144,27 +158,21 @@ public final class FFMpegHelper {
output.append(read);
}
}
}
OutputUtil.println("Process finished.");
return output.toString();
}
/**
* Adds audio to a command
* Maps an audio track to a ffmpeg command's output
*
* @param command <p>The command to add audio to.</p>
* @param audioStream <p>The audio stream to be added.</p>
* @param toStereo <p>Whether to convert the audio stream to stereo.</p>
* @param command <p>The command to add the audio track to</p>
* @param audioStream <p>The audio stream to be mapped</p>
* @param toStereo <p>Whether to convert the audio stream to stereo</p>
*/
public static void addAudioStream(List<String> command, AudioStream audioStream, boolean toStereo) {
if (audioStream != null) {
command.add("-map");
command.add("0:" + audioStream.getAbsoluteIndex());
public static void addAudioStream(@NotNull FFMpegCommand command, @NotNull AudioStream audioStream, boolean toStereo) {
mapStream(command, audioStream);
if (toStereo && audioStream.getChannels() > 2) {
command.add("-af");
command.add("pan=stereo|FL=FC+0.30*FL+0.30*BL|FR=FC+0.30*FR+0.30*BR");
//command.add("pan=stereo|FL < 1.0*FL + 0.707*FC + 0.707*BL|FR < 1.0*FR + 0.707*FC + 0.707*BR");
}
command.addOutputFileOption("-af", "pan=stereo|FL=FC+0.30*FL+0.30*BL|FR=FC+0.30*FR+0.30*BR");
}
}
@ -174,37 +182,23 @@ public final class FFMpegHelper {
* @param command <p>The list containing the rest of the command.</p>
* @param subtitleStream <p>The subtitle stream to be used.</p>
* @param videoStream <p>The video stream to be used.</p>
* @param file <p>The file to convert.</p>
*/
public static void addSubtitleAndVideoStream(List<String> command, SubtitleStream subtitleStream,
VideoStream videoStream, File file) {
public static void addSubtitleAndVideoStream(@NotNull FFMpegCommand command, @Nullable SubtitleStream subtitleStream,
@NotNull VideoStream videoStream) {
//No appropriate subtitle was found. Just add the video stream.
if (subtitleStream == null) {
addVideoStream(command, videoStream);
mapStream(command, videoStream);
return;
}
//Add the correct command arguments depending on the subtitle type
if (!subtitleStream.getIsImageSubtitle()) {
addSubtitle(command, subtitleStream, videoStream);
} else if (file.getName().equals(subtitleStream.getFile())) {
addInternalImageSubtitle(command, subtitleStream, videoStream);
addBurnedInSubtitle(command, subtitleStream, videoStream);
} else {
addExternalImageSubtitle(command, subtitleStream, videoStream);
addBurnedInImageSubtitle(command, subtitleStream, videoStream);
}
}
/**
* Adds video mapping to a command
*
* @param command <p>The list containing the rest of the command.</p>
* @param videoStream <p>The video stream to be used.</p>
*/
private static void addVideoStream(List<String> command, VideoStream videoStream) {
command.add("-map");
command.add(String.format("0:%d", videoStream.getAbsoluteIndex()));
}
/**
* Adds subtitle commands to a command list
*
@ -212,14 +206,75 @@ public final class FFMpegHelper {
* @param subtitleStream <p>The subtitle stream to add.</p>
* @param videoStream <p>The video stream to burn the subtitle into.</p>
*/
private static void addSubtitle(List<String> command, SubtitleStream subtitleStream, VideoStream videoStream) {
command.add("-map");
command.add(String.format("0:%d", videoStream.getAbsoluteIndex()));
command.add("-vf");
String safeFileName = escapeSpecialCharactersInFileName(subtitleStream.getFile());
private static void addBurnedInSubtitle(@NotNull FFMpegCommand command, @NotNull SubtitleStream subtitleStream,
@NotNull VideoStream videoStream) {
mapStream(command, videoStream);
String safeFileName = escapeSpecialCharactersInFileName(
command.getInputFiles().get(subtitleStream.getInputIndex()));
String subtitleCommand = String.format("subtitles='%s':si=%d", safeFileName,
subtitleStream.getRelativeIndex());
command.add(subtitleCommand);
command.addOutputFileOption("-vf", subtitleCommand);
}
/**
* Adds arguments for converting a file to h264 using hardware acceleration
*
* @param command <p>The command to add the arguments to</p>
* @param quality <p>The quality to encode. 0 = best, 51 = worst.</p>
*/
public static void addH264HardwareEncoding(@NotNull FFMpegCommand command, int quality) {
command.addOutputFileOption("-codec:v", "h264_nvenc");
command.addOutputFileOption("-profile", "high");
command.addOutputFileOption("-preset", "p7");
command.addOutputFileOption("-crf", String.valueOf(quality));
}
/**
* Adds arguments for converting a file to h265 using hardware acceleration
*
* @param command <p>The command to add the arguments to</p>
* @param quality <p>The quality to encode. 0 = best, 51 = worst.</p>
*/
public static void addH265HardwareEncoding(@NotNull FFMpegCommand command, int quality) {
command.addOutputFileOption("-codec:v", "hevc_nvenc");
command.addOutputFileOption("-profile", "main10");
command.addOutputFileOption("-preset", "p7");
command.addOutputFileOption("-tag:v", "hvc1");
command.addOutputFileOption("-crf", String.valueOf(quality));
}
/**
* Adds arguments for using hardware acceleration during h264 decoding
*
* @param command <p>The command to add the arguments to</p>
*/
public static void addH26xHardwareDecoding(@NotNull FFMpegCommand command) {
command.addInputFileOption("-hwaccel", "cuda");
command.addInputFileOption("-hwaccel_output_format", "cuda");
}
/**
* Maps all streams in the given list to the output in the given command
*
* @param command <p>The command to add the mappings to</p>
* @param streams <p>The streams to map</p>
*/
public static void mapAllStreams(@NotNull FFMpegCommand command, @NotNull List<StreamObject> streams) {
for (StreamObject stream : streams) {
mapStream(command, stream);
}
}
/**
* Maps the given stream to the given FFMPEG command's output
*
* @param command <p>The command to map the stream to</p>
* @param stream <p>The stream to map</p>
*/
public static void mapStream(@NotNull FFMpegCommand command, @NotNull StreamObject stream) {
command.addOutputFileOption("-map", String.format("%d:%d",
stream.getInputIndex(), stream.getAbsoluteIndex()));
}
/**
@ -237,38 +292,22 @@ public final class FFMpegHelper {
.replace("[", "\\[");
}
/**
* Adds image subtitle commands to a command list
*
* @param command <p>The list containing the FFmpeg commands.</p>
* @param subtitleStream <p>The subtitle stream to add.</p>
* @param videoStream <p>The video stream to burn the subtitle into.</p>
*/
private static void addInternalImageSubtitle(List<String> command, SubtitleStream subtitleStream,
VideoStream videoStream) {
command.add("-filter_complex");
String filter = String.format("[0:v:%d][0:%d]overlay", videoStream.getRelativeIndex(),
subtitleStream.getAbsoluteIndex());
command.add(filter);
}
/**
* Adds external image subtitle commands to a command list
*
* @param command <p>The list containing the FFmpeg commands.</p>
* @param externalImageSubtitle <p>The external image subtitle stream to add.</p>
* @param videoStream <p>The video stream to burn the subtitle into.</p>
* @param command <p>The FFMPEG command to modify</p>
* @param subtitleStream <p>The external image subtitle stream to burn in</p>
* @param videoStream <p>The video stream to burn the subtitle into</p>
*/
private static void addExternalImageSubtitle(List<String> command, SubtitleStream externalImageSubtitle,
VideoStream videoStream) {
command.add("-i");
command.add(externalImageSubtitle.getFile());
command.add("-filter_complex");
command.add(String.format("[1:s]scale=width=%d:height=%d,crop=w=%d:h=%d:x=0:y=out_h[sub];[%d:v]" +
"[sub]overlay", videoStream.getWidth(), videoStream.getHeight(), videoStream.getWidth(),
videoStream.getHeight(), videoStream.getAbsoluteIndex()));
command.add("-profile:v");
command.add("baseline");
private static void addBurnedInImageSubtitle(@NotNull FFMpegCommand command,
@NotNull SubtitleStream subtitleStream,
@NotNull VideoStream videoStream) {
command.addOutputFileOption("-filter_complex",
String.format("[%d:%d]scale=width=%d:height=%d,crop=w=%d:h=%d:x=0:y=out_h[sub];[%d:%d][sub]overlay",
subtitleStream.getInputIndex(), subtitleStream.getAbsoluteIndex(), videoStream.getWidth(),
videoStream.getHeight(), videoStream.getWidth(), videoStream.getHeight(),
videoStream.getInputIndex(), videoStream.getAbsoluteIndex()));
command.addOutputFileOption("-profile:v", "baseline");
}
/**
@ -280,13 +319,11 @@ public final class FFMpegHelper {
* @throws IOException <p>If something goes wrong while probing.</p>
*/
private static String[] probeForStreams(String ffprobePath, File file) throws IOException {
ProcessBuilder processBuilder = new ProcessBuilder(
ffprobePath,
"-v",
"error",
"-show_streams",
file.toString()
);
FFMpegCommand probeCommand = new FFMpegCommand(ffprobePath);
probeCommand.addGlobalOption("-v", "error", "-show_streams");
probeCommand.addInputFile(file.toString());
ProcessBuilder processBuilder = new ProcessBuilder(probeCommand.getResult());
String result = runProcess(processBuilder, file.getParentFile(), PROBE_SPLIT_CHARACTER, false);
return StringUtil.stringBetween(result, "[STREAM]", "[/STREAM]");
}
@ -298,7 +335,9 @@ public final class FFMpegHelper {
* @param file <p>The file currently being converted.</p>
* @return <p>A list of StreamObjects.</p>
*/
private static List<StreamObject> parseStreams(String ffprobePath, String[] streams, File file) throws IOException {
@NotNull
private static StreamProbeResult parseStreams(@NotNull String ffprobePath, @NotNull String[] streams,
@NotNull File file) throws IOException {
List<StreamObject> parsedStreams = new ArrayList<>();
int relativeAudioIndex = 0;
int relativeVideoIndex = 0;
@ -311,19 +350,19 @@ public final class FFMpegHelper {
String codecType = ValueParsingHelper.parseString(streamInfo.get(StreamTag.CODEC_TYPE), "");
switch (codecType) {
case "video":
parsedStreams.add(new VideoStream(streamInfo, relativeVideoIndex++));
parsedStreams.add(new VideoStream(streamInfo, 0, relativeVideoIndex++));
break;
case "audio":
parsedStreams.add(new AudioStream(streamInfo, relativeAudioIndex++));
parsedStreams.add(new AudioStream(streamInfo, 0, relativeAudioIndex++));
break;
case "subtitle":
parsedStreams.add(new SubtitleStream(streamInfo, relativeSubtitleIndex++, file.getName(), true));
parsedStreams.add(new SubtitleStream(streamInfo, 0, relativeSubtitleIndex++));
break;
}
}
List<StreamObject> externalSubtitles = getExternalSubtitles(ffprobePath, file.getParentFile(), file.getName());
parsedStreams.addAll(externalSubtitles);
return parsedStreams;
StreamProbeResult probeResult = new StreamProbeResult(List.of(file), parsedStreams);
getExternalSubtitles(probeResult, ffprobePath, file.getParentFile(), file.getName());
return probeResult;
}
/**
@ -349,26 +388,25 @@ public final class FFMpegHelper {
}
/**
* Checks whether there exists an external image subtitle with the same filename as the file
* Tries to find any external subtitles adjacent to the first input file, and appends it to the given probe result
*
* @param ffprobePath <p>The path/command to ffprobe.</p>
* @param directory <p>The directory containing the file.</p>
* @param convertingFile <p>The file to be converted.</p>
* @return <p>The extension of the subtitle or empty if no subtitle was found.</p>
* @param ffprobePath <p>The path/command to ffprobe</p>
* @param directory <p>The directory containing the file</p>
* @param convertingFile <p>The first/main file to be converted</p>
*/
@NotNull
private static List<StreamObject> getExternalSubtitles(@NotNull String ffprobePath, @NotNull File directory,
private static void getExternalSubtitles(@NotNull StreamProbeResult streamProbeResult,
@NotNull String ffprobePath, @NotNull File directory,
@NotNull String convertingFile) throws IOException {
List<StreamObject> parsedStreams = new ArrayList<>();
//Find all files in the same directory with external subtitle formats
if (subtitleFormats == null) {
subtitleFormats = FileUtil.readFileLines("subtitle_formats.txt");
}
File[] subtitleFiles = FileUtil.listFilesRecursive(directory, subtitleFormats, 1);
// TODO: Generalize this for external audio tracks
//Return early if no files were found
if (subtitleFiles == null) {
return parsedStreams;
return;
}
String fileTitle = FileUtil.stripExtension(convertingFile);
@ -379,15 +417,17 @@ public final class FFMpegHelper {
(subtitleFile) -> subtitleFile.getName().contains(fileTitle));
for (File subtitleFile : subtitleFilesList) {
int inputIndex = streamProbeResult.parsedFiles().size();
streamProbeResult.parsedFiles().add(subtitleFile);
//Probe the files and add them to the result list
String[] streams = probeForStreams(ffprobePath, subtitleFile);
int relativeIndex = 0;
for (String stream : streams) {
String[] streamParts = stream.split(PROBE_SPLIT_CHARACTER);
Map<StreamTag, String> streamInfo = getStreamInfo(streamParts);
parsedStreams.add(new SubtitleStream(streamInfo, 0, subtitleFile.getName(), false));
streamProbeResult.parsedStreams().add(new SubtitleStream(streamInfo, inputIndex, relativeIndex++));
}
}
return parsedStreams;
}
/**

39
src/main/java/net/knarcraft/ffmpegconverter/utility/FileUtil.java
View File

@ -142,43 +142,4 @@ public final class FileUtil {
return file.substring(0, file.lastIndexOf('.'));
}
/**
* Gets the locale specifying the language of the given file name
*
* @param fileName <p>The file name to check</p>
* @return <p>The locale, or null if no locale could be parsed</p>
*/
public static @Nullable String getLanguage(@NotNull String fileName) {
fileName = stripExtension(fileName);
String possibleLanguage = getExtension(fileName);
// NRK Nett-TV has a tendency to use nb-ttv for Norwegian for some reason
possibleLanguage = possibleLanguage.replace("nb-ttv", "nb-nor");
// TODO: Some languages are specified by using "-en" or "-English" or ".en" or ".English" at the end of file names
if (possibleLanguage.length() <= 1 || (possibleLanguage.length() >= 4 &&
(!possibleLanguage.contains("-") || possibleLanguage.length() >= 8))) {
return null;
}
// Hope the text is an actual valid language
if (!possibleLanguage.contains("-")) {
return possibleLanguage;
}
// Make sure the "-" has at least two characters on each side
String[] parts = possibleLanguage.split("-");
if (parts[0].length() < 2 || parts[1].length() < 2) {
return null;
}
if (parts[1].length() == 3) {
// Return three-letter country code
return parts[1].toLowerCase();
} else {
// Return en-US country code
return parts[0].substring(0, 2).toLowerCase() + "-" + parts[1].substring(0, 2).toUpperCase();
}
}
}