Calling ffmpeg from command line does not wait until file was fully written do hard drive

I am currently working on a service to allower conversion of audio files. I am using ffmpeg under the hood and use the Runtime in order to make the call.

After the call I read the converted file and upload it to a cloud storage.

The problem:

The problem is, that reading the file back from the drive gives me only a few bytes. After investigating, it actually has like 5 MB on the drive but readFileToByArray() reads only a few kb. I assume this is because the file was not completely persisted at the point where I want to read it back.

Is there any way I can make sure that ffmpeg is done writing to the hard drive? It seems that the main process that ffmpeg was running in finishes before a parallel process that is responsible for writing. Maybe?

Below is the relevant code that converts an arbitrary file to AAC-format:

File tempFile = File.createTempFile("input-", ".tmp", new File("/tmp"));
OutputStream outStream = new FileOutputStream(tempFile);
outStream.write(bytes);

String convertedFilePath = String.format("/tmp/output-%s.aac", UUID.randomUUID().toString());

String command = String.format(
        "ffmpeg -i %s -c:a aac -b:a 256k %s",
        tempFile.getAbsolutePath(),
        convertedFilePath
);

LOGGER.debug(String.format("Converting file to AAC; Running %s", command));

Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec(command);
try {
    process.waitFor(200, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
    throw new RuntimeException("Time out");
}

File convertedFile = new File(convertedFilePath);
byte[] result = FileUtils.readFileToByteArray(convertedFile);

// Upload "result" to cloud storage ..

I think the problem here is that you don't wait enough for ffmpeg process to finish and after only 200 milliseconds you go on trying to read the converted file without checking whether ffmpeg process exited correctly.

from waitFor​(long timeout, TimeUnit unit) docs (emphasis mine):

> Causes the current thread to wait, if necessary, until the process represented by this Process object has terminated, or the specified waiting time elapses.
>
> ...
>
> Returns:
>
> true if the process has exited and false if the waiting time elapsed before the process has exited.

here a rewrite of your code that takes advantage of waitFor() return value to decide if it needs to keep waiting or not:

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.lang.Runtime;
import java.lang.RuntimeException;
import java.nio.file.Files;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
public class FFmpeg
{
public static void main(String[] args) throws Exception
{
/* just for testing purpose */
File fooFile = new File("foo.mp3");
byte[] bytes = Files.readAllBytes(fooFile.toPath());
File tempFile = File.createTempFile("input-", ".tmp", new File("/tmp"));
OutputStream outStream = new FileOutputStream(tempFile);
outStream.write(bytes);
outStream.close();
String convertedFilePath = String.format("output-%s.aac", UUID.randomUUID().toString());
String command = String.format(
"ffmpeg -nostdin -i %s -c:a aac -b:a 256k %s",
tempFile.getAbsolutePath(),
convertedFilePath
);
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec(command);
System.out.print("converting");
while ( ! process.waitFor(500, TimeUnit.MILLISECONDS)) {
/* here you have the opportunity to kill the process if
* it is taking too long, print something etc.. */
System.out.print(".");
}
System.out.print("\n");
if (process.exitValue() != 0) {
System.err.printf("ffmpeg failed with value %d\n", process.exitValue());
return;
}
File convertedFile = new File(convertedFilePath);
byte[] result = Files.readAllBytes(convertedFile.toPath());
System.out.println(result.length);
}
}

and a little demo:

$ ls -l
total 5368
-rw-r--r-- 1 marco marco    1557 Oct 10 17:46 FFmpeg.java
-rw-r--r-- 1 marco marco 5486341 Oct 10 17:09 foo.mp3
$ javac FFmpeg.java
$ java FFmpeg
converting.........
7329962
$ ls -l
total 12528
-rw-r--r-- 1 marco marco    1793 Oct 10 17:49 FFmpeg.class
-rw-r--r-- 1 marco marco    1557 Oct 10 17:46 FFmpeg.java
-rw-r--r-- 1 marco marco 5486341 Oct 10 17:09 foo.mp3
-rw-r--r-- 1 marco marco 7329962 Oct 10 17:50 output-176a2e73-82d6-483b-8a40-aec0819c749f.aac
$

(length of converted file is printed at the end, notice how it matches the one in ls output).

another important thing I added is the -nostdin flag to ffmpeg command. ffmpeg is often run as an interactive program taking user input from stdin e.g. when it asks if you want to overwrite target file. here of course we don't have the chance to answer "yes" or "no" and -nostdin will make the process to fail and exit when a user interaction is required. without that flag, it will wait for user input indefinitely (you maybe interested in -y and -n flags also).