Compare `b9e203b ... +2 ... 6f7a235`

import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

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

import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.io.Files;

import nl.weeaboo.common.Checks;
import nl.weeaboo.common.StringUtil;
import nl.weeaboo.vn.buildtools.file.EncodedResource;
import nl.weeaboo.vn.buildtools.file.IEncodedResource;
import nl.weeaboo.vn.buildtools.file.ITempFileProvider;
import nl.weeaboo.vn.buildtools.optimizer.video.encoder.FfmpegVideoEncoder;

/**
 * Resource encoder using ffmpeg.
 */
public abstract class FfmpegEncoder {

    private static final Logger LOG = LoggerFactory.getLogger(FfmpegVideoEncoder.class);

    private final Logger logger;
    private final ITempFileProvider tempFileProvider;

    protected FfmpegEncoder(ITempFileProvider tempFileProvider) {
    private String program = "ffmpeg";

    protected FfmpegEncoder(Logger logger, ITempFileProvider tempFileProvider) {
        this.logger = Checks.checkNotNull(logger);
        this.tempFileProvider = Checks.checkNotNull(tempFileProvider);
    }

    /**
     * @return {@code true} if a usable ffmpeg executable was found, allowing this encoder to be used.
     */
    public static boolean isAvailable() {
    public boolean isAvailable() {
        try {
            doRunProcess(Arrays.asList("ffmpeg", "-h"));
            LOG.debug("ffmpeg is available");
            doRunProcess(program, Arrays.asList("-h"));
            logger.debug("ffmpeg is available");
            return true;
        } catch (IOException e) {
            LOG.info("ffmpeg not available: {}", e.toString());
            logger.info("ffmpeg not available: {}", e.toString());
            return false;
        }
    }

@@ -57,7 +59,7 @@

            // Copy sound to temp file (input)
            Files.write(resource.readBytes(), inputFile);

            runProcess(getCommandLineArgs(inputFile, outputFile));
            runProcess(program, getCommandLineArgs(inputFile, outputFile));
            resultAudioData = EncodedResource.fromTempFile(outputFile);
        } finally {
            inputFile.delete();

@@ -66,13 +68,18 @@

        return resultAudioData;
    }

    protected void runProcess(List<String> command) throws IOException {
        doRunProcess(command);
    protected void runProcess(String program, List<String> args) throws IOException {
        doRunProcess(program, args);
    }

    private static void doRunProcess(List<String> command) throws IOException {
    private void doRunProcess(String program, List<String> args) throws IOException {
        List<String> command = new ArrayList<>();
        command.add(program);
        command.addAll(args);
        String commandString = Joiner.on(' ').join(command);

        logger.trace("Starting process: {}", command);

        Process process = new ProcessBuilder()
                .command(command)
                .redirectErrorStream(true)

@@ -85,42 +92,45 @@

            while (process.isAlive()) {
                String line = in.readLine();

                LOG.trace(line);
                logger.trace(line);

                output.append(line);
                output.append('\n');
            }

            int exitCode = process.waitFor();
            if (exitCode != 0) {
                throw new IOException("Process terminated with an error: " + exitCode
                        + "\ncommand: " + commandString
                        + "\noutput: " + output);
                throw new IOException(StringUtil.formatRoot(
                        "Process terminated with an error: %s\ncommand: %s\noutput: %s",
                        exitCode, commandString, output));
            }
        } catch (InterruptedException e) {
            throw new IOException("Process interrupted", e);
        }
    }

    private List<String> getCommandLineArgs(File inputFile, File outputFile) {
        List<String> command = Lists.newArrayList();
        command.add("ffmpeg");
        List<String> args = Lists.newArrayList();

        // Input file
        command.add("-i");
        command.add(inputFile.getAbsolutePath());
        args.add("-i");
        args.add(inputFile.getAbsolutePath());

        // File format (container)
        command.add("-f");
        command.add(getFileFormat());
        args.add("-f");
        args.add(getFileFormat());

        // Codec
        command.addAll(getCodecArgs());
        args.addAll(getCodecArgs());

        // Output file
        command.add("-y"); // Overwrite output file (is usually an empty temp file)
        command.add(outputFile.getAbsolutePath());
        return command;
        args.add("-y"); // Overwrite output file (is usually an empty temp file)
        args.add(outputFile.getAbsolutePath());
        return args;
    }

    public void setProgram(String program) {
        this.program = program;
    }

    protected abstract List<String> getCodecArgs();

@@ -54,8 +54,7 @@

    // --- State during optimization ---
    /** Definition per (optimized) sound file */
    private final Map<FilePath, SoundDefinition> optimizedDefs = Maps.newHashMap();
    private boolean ffmpegAvailable;

    private EAvailable ffmpegAvailable;

    public SoundOptimizer(IOptimizerContext context) {
        executor = context.getExecutor();

@@ -66,12 +65,14 @@

        NvlistProjectConnection project = context.getProject();
        resFileSystem = project.getResFileSystem();
        soundDefCache = new SoundDefinitionCache(resFileSystem);

        resetState();
    }

    private void resetState() {
        optimizedDefs.clear();

        ffmpegAvailable = FfmpegSoundEncoder.isAvailable();
        ffmpegAvailable = EAvailable.UNKNOWN;
    }

    /**

@@ -162,16 +163,23 @@

    }

    private ISoundEncoder createEncoder() {
        if (ffmpegAvailable) {
            return new FfmpegSoundEncoder(tempFileProvider);
        } else {
            return new NoOpSoundEncoder();
        if (ffmpegAvailable != EAvailable.NO) {
            FfmpegSoundEncoder encoder = new FfmpegSoundEncoder(tempFileProvider);
            if (ffmpegAvailable == EAvailable.YES || encoder.isAvailable()) {
                ffmpegAvailable = EAvailable.YES;
                return encoder;
            }
        }
        ffmpegAvailable = EAvailable.NO;
        return new NoOpSoundEncoder();
    }

    private FilePath getOutputPath(FilePath inputPath, String outputFilename) {
        FilePath folder = inputPath.getParent();
        return folder.resolve(outputFilename);
    }

    private enum EAvailable {
        YES, NO, UNKNOWN
    }
}

@@ -4,6 +4,11 @@

import java.util.Arrays;
import java.util.List;

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

import com.google.common.annotations.VisibleForTesting;

import nl.weeaboo.io.Filenames;
import nl.weeaboo.vn.buildtools.file.IEncodedResource;
import nl.weeaboo.vn.buildtools.file.ITempFileProvider;

@@ -15,14 +20,21 @@

 */
public final class FfmpegVideoEncoder extends FfmpegEncoder implements IVideoEncoder {

    private static final Logger LOG = LoggerFactory.getLogger(FfmpegVideoEncoder.class);

    private static final String OUTPUT_EXT = "webm";
    private static final String VIDEO_CODEC = "libvpx";
    private static final String VIDEO_QUALITY = "3";
    private static final String AUDIO_CODEC = "libvorbis";
    private static final String AUDIO_QUALITY = "3";

    public FfmpegVideoEncoder(ITempFileProvider tempFileProvider) {
        super(tempFileProvider);
        this(LOG, tempFileProvider);
    }

    @VisibleForTesting
    FfmpegVideoEncoder(Logger logger, ITempFileProvider tempFileProvider) {
        super(logger, tempFileProvider);
    }

    @Override

@@ -4,6 +4,11 @@

import java.util.Arrays;
import java.util.List;

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

import com.google.common.annotations.VisibleForTesting;

import nl.weeaboo.io.Filenames;
import nl.weeaboo.vn.buildtools.file.IEncodedResource;
import nl.weeaboo.vn.buildtools.file.ITempFileProvider;

@@ -17,12 +22,19 @@

 */
public final class FfmpegSoundEncoder extends FfmpegEncoder implements ISoundEncoder {

    private static final Logger LOG = LoggerFactory.getLogger(FfmpegSoundEncoder.class);

    private static final String OUTPUT_EXT = "ogg";
    private static final String AUDIO_CODEC = "libvorbis";
    private static final String AUDIO_QUALITY = "3";

    public FfmpegSoundEncoder(ITempFileProvider tempFileProvider) {
        super(tempFileProvider);
        this(LOG, tempFileProvider);
    }

    @VisibleForTesting
    FfmpegSoundEncoder(Logger logger, ITempFileProvider tempFileProvider) {
        super(logger, tempFileProvider);
    }

    @Override

@@ -19,7 +19,6 @@

import nl.weeaboo.vn.buildtools.optimizer.IOptimizerFileSet;
import nl.weeaboo.vn.buildtools.optimizer.IParallelExecutor;
import nl.weeaboo.vn.buildtools.optimizer.MainOptimizerConfig;
import nl.weeaboo.vn.buildtools.optimizer.sound.encoder.FfmpegSoundEncoder;
import nl.weeaboo.vn.buildtools.optimizer.video.encoder.FfmpegVideoEncoder;
import nl.weeaboo.vn.buildtools.optimizer.video.encoder.IVideoEncoder;
import nl.weeaboo.vn.buildtools.optimizer.video.encoder.NoOpVideoEncoder;

@@ -41,8 +40,7 @@

    private final IFileSystem resFileSystem;

    // --- State during optimization ---
    private boolean ffmpegAvailable;

    private EAvailable ffmpegAvailable;

    public VideoOptimizer(IOptimizerContext context) {
        executor = context.getExecutor();

@@ -52,10 +50,12 @@


        NvlistProjectConnection project = context.getProject();
        resFileSystem = project.getResFileSystem();

        resetState();
    }

    private void resetState() {
        ffmpegAvailable = FfmpegSoundEncoder.isAvailable();
        ffmpegAvailable = EAvailable.UNKNOWN;
    }

    /**

@@ -118,16 +118,23 @@

    }

    private IVideoEncoder createEncoder() {
        if (ffmpegAvailable) {
            return new FfmpegVideoEncoder(tempFileProvider);
        } else {
            return new NoOpVideoEncoder();
        if (ffmpegAvailable != EAvailable.NO) {
            FfmpegVideoEncoder encoder = new FfmpegVideoEncoder(tempFileProvider);
            if (ffmpegAvailable == EAvailable.YES || encoder.isAvailable()) {
                ffmpegAvailable = EAvailable.YES;
                return encoder;
            }
        }
        ffmpegAvailable = EAvailable.NO;
        return new NoOpVideoEncoder();
    }

    private FilePath getOutputPath(FilePath inputPath, String outputFilename) {
        FilePath folder = inputPath.getParent();
        return folder.resolve(outputFilename);
    }

    private enum EAvailable {
        YES, NO, UNKNOWN
    }
}

Learn more Showing 7 files with coverage changes found.

Changes in core/src/main/java/nl/weeaboo/vn/gdx/res/NativeMemoryTracker.java

-10

→

+10

Loading file...

Changes in core/src/main/java/nl/weeaboo/vn/impl/image/GdxTextureStore.java

-5

→

Loading file...

Changes in core/src/main/java/nl/weeaboo/vn/impl/debug/PerformanceMetrics.java

-1

→

Loading file...

Changes in buildtools/src/main/java/nl/weeaboo/vn/buildtools/optimizer/FfmpegEncoder.java

-3

→

Loading file...

Changes in buildtools/src/main/java/nl/weeaboo/vn/buildtools/file/EncodedResource.java

-2

→

Loading file...

Changes in buildtools/src/main/java/nl/weeaboo/vn/buildtools/optimizer/video/encoder/FfmpegVideoEncoder.java

-5

→

Loading file...

Changes in buildtools/src/main/java/nl/weeaboo/vn/buildtools/optimizer/sound/encoder/FfmpegSoundEncoder.java

-7

→

Loading file...

86.16% ø +0.15% 81.78% +0.10%

Add missing Headless GDX init

anonl

6f7a235

CI Passed

Hiding 2 contexual commits

+27

+41

-17

86.02% 85.71% +0.90% 81.68% +0.59%

LuaConsole show/hide was broken

anonl

b9e203b

CI Passed

Files		•	•	•	Complexity	Coverage
api/src/main/java/nl/weeaboo/vn	ø	ø	ø	ø	91.53%	96.76%
buildtools/src/main/java/nl/weeaboo/vn/buildtools	+27	+57	+3	-33	^+8.00% 66.34%	^+4.37% 74.43%
core/src/main/java/nl/weeaboo/vn	ø	-16	ø	+16	81.94%	^-0.16% 86.14%
Project Totals (369 files)	12,027	10,363	480	1,184	81.78%	86.16%

85	92		while (process.isAlive()) {
86	93		String line = in.readLine();
87	94
88		-	LOG.trace(line);
	95	+	logger.trace(line);
89	96
90	97		output.append(line);
91	98		output.append('\n');
92	99		}
93	100
94	101		int exitCode = process.waitFor();
95	102		if (exitCode != 0) {
96		-	throw new IOException("Process terminated with an error: " + exitCode
97		-	+ "\ncommand: " + commandString
98		-	+ "\noutput: " + output);
	103	+	throw new IOException(StringUtil.formatRoot(
	104	+	"Process terminated with an error: %s\ncommand: %s\noutput: %s",
	105	+	exitCode, commandString, output));
99	106		}
100	107		} catch (InterruptedException e) {
101	108		throw new IOException("Process interrupted", e);
102	109		}
103	110		}
104	111
105	112		private List<String> getCommandLineArgs(File inputFile, File outputFile) {
106		-	List<String> command = Lists.newArrayList();
107		-	command.add("ffmpeg");
	113	+	List<String> args = Lists.newArrayList();
108	114
109	115		// Input file
110		-	command.add("-i");
111		-	command.add(inputFile.getAbsolutePath());
	116	+	args.add("-i");
	117	+	args.add(inputFile.getAbsolutePath());
112	118
113	119		// File format (container)
114		-	command.add("-f");
115		-	command.add(getFileFormat());
	120	+	args.add("-f");
	121	+	args.add(getFileFormat());
116	122
117	123		// Codec
118		-	command.addAll(getCodecArgs());
	124	+	args.addAll(getCodecArgs());
119	125
120	126		// Output file
121		-	command.add("-y"); // Overwrite output file (is usually an empty temp file)
122		-	command.add(outputFile.getAbsolutePath());
123		-	return command;
	127	+	args.add("-y"); // Overwrite output file (is usually an empty temp file)
	128	+	args.add(outputFile.getAbsolutePath());
	129	+	return args;
	130	+	}
	131	+
	132	+	public void setProgram(String program) {
	133	+	this.program = program;
124	134		}
125	135
126	136		protected abstract List<String> getCodecArgs();

162	163		}
163	164
164	165		private ISoundEncoder createEncoder() {
165		-	if (ffmpegAvailable) {
166		-	return new FfmpegSoundEncoder(tempFileProvider);
167		-	} else {
168		-	return new NoOpSoundEncoder();
	166	+	if (ffmpegAvailable != EAvailable.NO) {
	167	+	FfmpegSoundEncoder encoder = new FfmpegSoundEncoder(tempFileProvider);
	168	+	if (ffmpegAvailable == EAvailable.YES \|\| encoder.isAvailable()) {
	169	+	ffmpegAvailable = EAvailable.YES;
	170	+	return encoder;
	171	+	}
169	172		}
	173	+	ffmpegAvailable = EAvailable.NO;
	174	+	return new NoOpSoundEncoder();
170	175		}
171	176
172	177		private FilePath getOutputPath(FilePath inputPath, String outputFilename) {
173	178		FilePath folder = inputPath.getParent();
174	179		return folder.resolve(outputFilename);
175	180		}
176	181
	182	+	private enum EAvailable {
	183	+	YES, NO, UNKNOWN
	184	+	}
177	185		}

118	118		}
119	119
120	120		private IVideoEncoder createEncoder() {
121		-	if (ffmpegAvailable) {
122		-	return new FfmpegVideoEncoder(tempFileProvider);
123		-	} else {
124		-	return new NoOpVideoEncoder();
	121	+	if (ffmpegAvailable != EAvailable.NO) {
	122	+	FfmpegVideoEncoder encoder = new FfmpegVideoEncoder(tempFileProvider);
	123	+	if (ffmpegAvailable == EAvailable.YES \|\| encoder.isAvailable()) {
	124	+	ffmpegAvailable = EAvailable.YES;
	125	+	return encoder;
	126	+	}
125	127		}
	128	+	ffmpegAvailable = EAvailable.NO;
	129	+	return new NoOpVideoEncoder();
126	130		}
127	131
128	132		private FilePath getOutputPath(FilePath inputPath, String outputFilename) {
129	133		FilePath folder = inputPath.getParent();
130	134		return folder.resolve(outputFilename);
131	135		}
132	136
	137	+	private enum EAvailable {
	138	+	YES, NO, UNKNOWN
	139	+	}
133	140		}

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits

Compare `b9e203b ... +2 ... 6f7a235`

No flags found

Show failed CI and contexual commits `c`

4 Commits

5	5		import java.io.IOException;
6	6		import java.io.InputStreamReader;
7	7		import java.nio.charset.StandardCharsets;
	8	+	import java.util.ArrayList;
8	9		import java.util.Arrays;
9	10		import java.util.List;
10	11
11	12		import org.slf4j.Logger;
12		-	import org.slf4j.LoggerFactory;
13	13
14	14		import com.google.common.base.Joiner;
15	15		import com.google.common.collect.Lists;
16	16		import com.google.common.io.Files;
17	17
18	18		import nl.weeaboo.common.Checks;
	19	+	import nl.weeaboo.common.StringUtil;
19	20		import nl.weeaboo.vn.buildtools.file.EncodedResource;
20	21		import nl.weeaboo.vn.buildtools.file.IEncodedResource;
21	22		import nl.weeaboo.vn.buildtools.file.ITempFileProvider;
22		-	import nl.weeaboo.vn.buildtools.optimizer.video.encoder.FfmpegVideoEncoder;
23	23
24	24		/**
25	25		* Resource encoder using ffmpeg.
26	26		*/
27	27		public abstract class FfmpegEncoder {
28	28
29		-	private static final Logger LOG = LoggerFactory.getLogger(FfmpegVideoEncoder.class);
30		-
	29	+	private final Logger logger;
31	30		private final ITempFileProvider tempFileProvider;
32	31
33		-	protected FfmpegEncoder(ITempFileProvider tempFileProvider) {
	32	+	private String program = "ffmpeg";
	33	+
	34	+	protected FfmpegEncoder(Logger logger, ITempFileProvider tempFileProvider) {
	35	+	this.logger = Checks.checkNotNull(logger);
34	36		this.tempFileProvider = Checks.checkNotNull(tempFileProvider);
35	37		}
36	38
37	39		/**
38	40		* @return {@code true} if a usable ffmpeg executable was found, allowing this encoder to be used.
39	41		*/
40		-	public static boolean isAvailable() {
	42	+	public boolean isAvailable() {
41	43		try {
42		-	doRunProcess(Arrays.asList("ffmpeg", "-h"));
43		-	LOG.debug("ffmpeg is available");
	44	+	doRunProcess(program, Arrays.asList("-h"));
	45	+	logger.debug("ffmpeg is available");
44	46		return true;
45	47		} catch (IOException e) {
46		-	LOG.info("ffmpeg not available: {}", e.toString());
	48	+	logger.info("ffmpeg not available: {}", e.toString());
47	49		return false;
48	50		}
49	51		}

57	59		// Copy sound to temp file (input)
58	60		Files.write(resource.readBytes(), inputFile);
59	61
60		-	runProcess(getCommandLineArgs(inputFile, outputFile));
	62	+	runProcess(program, getCommandLineArgs(inputFile, outputFile));
61	63		resultAudioData = EncodedResource.fromTempFile(outputFile);
62	64		} finally {
63	65		inputFile.delete();

66	68		return resultAudioData;
67	69		}
68	70
69		-	protected void runProcess(List<String> command) throws IOException {
70		-	doRunProcess(command);
	71	+	protected void runProcess(String program, List<String> args) throws IOException {
	72	+	doRunProcess(program, args);
71	73		}
72	74
73		-	private static void doRunProcess(List<String> command) throws IOException {
	75	+	private void doRunProcess(String program, List<String> args) throws IOException {
	76	+	List<String> command = new ArrayList<>();
	77	+	command.add(program);
	78	+	command.addAll(args);
74	79		String commandString = Joiner.on(' ').join(command);
75	80
	81	+	logger.trace("Starting process: {}", command);
	82	+
76	83		Process process = new ProcessBuilder()
77	84		.command(command)
78	85		.redirectErrorStream(true)

54	54		// --- State during optimization ---
55	55		/** Definition per (optimized) sound file */
56	56		private final Map<FilePath, SoundDefinition> optimizedDefs = Maps.newHashMap();
57		-	private boolean ffmpegAvailable;
58		-
	57	+	private EAvailable ffmpegAvailable;
59	58
60	59		public SoundOptimizer(IOptimizerContext context) {
61	60		executor = context.getExecutor();

66	65		NvlistProjectConnection project = context.getProject();
67	66		resFileSystem = project.getResFileSystem();
68	67		soundDefCache = new SoundDefinitionCache(resFileSystem);
	68	+
	69	+	resetState();
69	70		}
70	71
71	72		private void resetState() {
72	73		optimizedDefs.clear();
73	74
74		-	ffmpegAvailable = FfmpegSoundEncoder.isAvailable();
	75	+	ffmpegAvailable = EAvailable.UNKNOWN;
75	76		}
76	77
77	78		/**

15	20		*/
16	21		public final class FfmpegVideoEncoder extends FfmpegEncoder implements IVideoEncoder {
17	22
	23	+	private static final Logger LOG = LoggerFactory.getLogger(FfmpegVideoEncoder.class);
	24	+
18	25		private static final String OUTPUT_EXT = "webm";
19	26		private static final String VIDEO_CODEC = "libvpx";
20	27		private static final String VIDEO_QUALITY = "3";
21	28		private static final String AUDIO_CODEC = "libvorbis";
22	29		private static final String AUDIO_QUALITY = "3";
23	30
24	31		public FfmpegVideoEncoder(ITempFileProvider tempFileProvider) {
25		-	super(tempFileProvider);
	32	+	this(LOG, tempFileProvider);
	33	+	}
	34	+
	35	+	@VisibleForTesting
	36	+	FfmpegVideoEncoder(Logger logger, ITempFileProvider tempFileProvider) {
	37	+	super(logger, tempFileProvider);
26	38		}
27	39
28	40		@Override

17	22		*/
18	23		public final class FfmpegSoundEncoder extends FfmpegEncoder implements ISoundEncoder {
19	24
	25	+	private static final Logger LOG = LoggerFactory.getLogger(FfmpegSoundEncoder.class);
	26	+
20	27		private static final String OUTPUT_EXT = "ogg";
21	28		private static final String AUDIO_CODEC = "libvorbis";
22	29		private static final String AUDIO_QUALITY = "3";
23	30
24	31		public FfmpegSoundEncoder(ITempFileProvider tempFileProvider) {
25		-	super(tempFileProvider);
	32	+	this(LOG, tempFileProvider);
	33	+	}
	34	+
	35	+	@VisibleForTesting
	36	+	FfmpegSoundEncoder(Logger logger, ITempFileProvider tempFileProvider) {
	37	+	super(logger, tempFileProvider);
26	38		}
27	39
28	40		@Override

41	40		private final IFileSystem resFileSystem;
42	41
43	42		// --- State during optimization ---
44		-	private boolean ffmpegAvailable;
45		-
	43	+	private EAvailable ffmpegAvailable;
46	44
47	45		public VideoOptimizer(IOptimizerContext context) {
48	46		executor = context.getExecutor();

Compare b9e203b ... +2 ... 6f7a235

No flags found

Show failed CI and contexual commits c 4 Commits

Compare `b9e203b ... +2 ... 6f7a235`

Show failed CI and contexual commits `c`

4 Commits