Use FFprobe to check file informations (#406)

Author: MartelliEnrico

.dockerignore

@@ -3,7 +3,6 @@
 .gradle/
 .idea/
 build/
-src/test/
 src/main/resources/images/
 .gitattributes
 .gitignore

Dockerfile

@@ -1,17 +1,19 @@
 FROM eclipse-temurin:25-alpine AS builder
 
 WORKDIR /app
+
+# bump: ffmpeg /static-ffmpeg:([\d.]+)/ docker:mwader/static-ffmpeg|~7.0
+COPY --from=mwader/static-ffmpeg:7.0.2 /ff* /usr/bin/
+
 COPY . .
-RUN --mount=type=cache,target=/root/.gradle ./gradlew installDist
+RUN --mount=type=cache,target=/root/.gradle ./gradlew check installDist --no-daemon
 
 # bump: alpine /FROM alpine:([\d.]+)/ docker:alpine|^3
 # bump: alpine link "Release notes" https://alpinelinux.org/posts/Alpine-$LATEST-released.html
-FROM alpine:3.22.1 AS bot
+FROM alpine:3.22.1
 
-# bump: ffmpeg /static-ffmpeg:([\d.]+)/ docker:mwader/static-ffmpeg|~7.0
-COPY --from=mwader/static-ffmpeg:7.0.2 /ffmpeg /usr/bin/
+COPY --from=builder /usr/bin/ff* /usr/bin/
 COPY --from=builder /app/build/install/Stickerify/ .
 
 ENV CONCURRENT_PROCESSES=5
-ENV FFMPEG_PATH=/usr/bin/ffmpeg
 CMD ["./bin/Stickerify"]

README.md

@@ -118,7 +118,7 @@ therefore counting towards the four-contribution goal.
 * The bot is deployed on [Railway](https://railway.app?referralCode=rob)
 * The official documentation of the Telegram Bot API can be found [here](https://core.telegram.org/bots)
 * The library used by the bot to work with Telegram is [Java Telegram Bot API](https://github.com/pengrad/java-telegram-bot-api)
-* Video and image conversions use [FFmpeg](https://ffmpeg.org/) and [JAVE2](https://github.com/a-schild/jave2)
+* Video and image conversions use [FFmpeg](https://ffmpeg.org/)
 * Animated sticker validation uses [Gson](https://github.com/google/gson)
 * MIME type analysis is performed using [Apache Tika](https://tika.apache.org/)
 

build.gradle

@@ -15,7 +15,6 @@ repositories {
 dependencies {
     compileOnly(libs.jspecify)
     implementation(libs.gson)
-    implementation(libs.jave)
     implementation(libs.logback.classic)
     implementation(libs.telegram.bot.api)
     implementation(libs.tika)

gradle/libs.versions.toml

@@ -1,7 +1,6 @@
 [libraries]
 gson = "com.google.code.gson:gson:2.13.2"
 hamcrest = "org.hamcrest:hamcrest:3.0"
-jave = "ws.schild:jave-core:3.5.0"
 jspecify = "org.jspecify:jspecify:1.0.0"
 junit-jupiter = "org.junit.jupiter:junit-jupiter:5.13.4"
 junit-platform = "org.junit.platform:junit-platform-launcher:1.13.4"

src/main/java/com/github/stickerifier/stickerify/bot/Stickerify.java

@@ -10,7 +10,7 @@
 import static java.util.concurrent.Executors.newThreadPerTaskExecutor;
 
 import com.github.stickerifier.stickerify.exception.BaseException;
-import com.github.stickerifier.stickerify.exception.CorruptedVideoException;
+import com.github.stickerifier.stickerify.exception.CorruptedFileException;
 import com.github.stickerifier.stickerify.exception.FileOperationException;
 import com.github.stickerifier.stickerify.exception.MediaException;
 import com.github.stickerifier.stickerify.exception.TelegramApiException;
@@ -175,7 +175,7 @@ private void processFailure(TelegramRequest request, BaseException e, String fil
 			processTelegramFailure(request.getDescription(), telegramException, false);
 		}
 
-		if (e instanceof CorruptedVideoException) {
+		if (e instanceof CorruptedFileException) {
 			LOGGER.atInfo().log("Unable to reply to the {}: the file is corrupted", request.getDescription());
 			answerText(CORRUPTED, request);
 		} else {

src/main/java/com/github/stickerifier/stickerify/exception/CorruptedFileException.java

@@ -0,0 +1,7 @@
+package com.github.stickerifier.stickerify.exception;
+
+public class CorruptedFileException extends MediaException {
+	public CorruptedFileException(String message, Throwable cause) {
+		super(message, cause);
+	}
+}

src/main/java/com/github/stickerifier/stickerify/exception/CorruptedVideoException.java

@@ -11,14 +11,14 @@ public final class MediaConstraints {
 
 	static final int MAX_SIDE_LENGTH = 512;
 	static final int MAX_VIDEO_FRAMES = 30;
-	static final int MAX_VIDEO_DURATION_MILLIS = 3000;
+	static final float MAX_VIDEO_DURATION_SECONDS = 3.0F - (1.0F / MAX_VIDEO_FRAMES);
 	static final String VP9_CODEC = "vp9";
 	static final String MATROSKA_FORMAT = "matroska";
 	static final long MAX_IMAGE_FILE_SIZE = 512_000L;
 	static final long MAX_VIDEO_FILE_SIZE = 256_000L;
 	static final long MAX_ANIMATION_FILE_SIZE = 64_000L;
 	static final int MAX_ANIMATION_FRAME_RATE = 60;
-	static final int MAX_ANIMATION_DURATION_SECONDS = 3;
+	static final float MAX_ANIMATION_DURATION_SECONDS = 3.0F;
 
 	private MediaConstraints() {
 		throw new UnsupportedOperationException();

src/main/java/com/github/stickerifier/stickerify/media/MediaConstraints.java

@@ -6,18 +6,17 @@
 import static com.github.stickerifier.stickerify.media.MediaConstraints.MAX_ANIMATION_FRAME_RATE;
 import static com.github.stickerifier.stickerify.media.MediaConstraints.MAX_IMAGE_FILE_SIZE;
 import static com.github.stickerifier.stickerify.media.MediaConstraints.MAX_SIDE_LENGTH;
-import static com.github.stickerifier.stickerify.media.MediaConstraints.MAX_VIDEO_DURATION_MILLIS;
+import static com.github.stickerifier.stickerify.media.MediaConstraints.MAX_VIDEO_DURATION_SECONDS;
 import static com.github.stickerifier.stickerify.media.MediaConstraints.MAX_VIDEO_FILE_SIZE;
 import static com.github.stickerifier.stickerify.media.MediaConstraints.MAX_VIDEO_FRAMES;
 import static com.github.stickerifier.stickerify.media.MediaConstraints.VP9_CODEC;
 import static java.nio.charset.StandardCharsets.UTF_8;
 
-import com.github.stickerifier.stickerify.exception.CorruptedVideoException;
+import com.github.stickerifier.stickerify.exception.CorruptedFileException;
 import com.github.stickerifier.stickerify.exception.FileOperationException;
 import com.github.stickerifier.stickerify.exception.MediaException;
 import com.github.stickerifier.stickerify.exception.ProcessException;
 import com.github.stickerifier.stickerify.process.OsConstants;
-import com.github.stickerifier.stickerify.process.PathLocator;
 import com.github.stickerifier.stickerify.process.ProcessHelper;
 import com.google.gson.Gson;
 import com.google.gson.JsonSyntaxException;
@@ -26,14 +25,12 @@
 import org.jspecify.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import ws.schild.jave.EncoderException;
-import ws.schild.jave.MultimediaObject;
-import ws.schild.jave.info.MultimediaInfo;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.util.List;
 import java.util.Set;
 import java.util.zip.GZIPInputStream;
 
@@ -128,37 +125,98 @@ private static boolean isSupportedVideo(String mimeType) {
 	 * @param file the file to check
 	 * @return {@code true} if the file is compliant
 	 * @throws FileOperationException if an error occurred retrieving the size of the file
+	 * @throws InterruptedException if the current thread is interrupted while retrieving file info
 	 */
-	private static boolean isVideoCompliant(File file) throws FileOperationException, CorruptedVideoException {
+	private static boolean isVideoCompliant(File file) throws FileOperationException, CorruptedFileException, InterruptedException {
 		var mediaInfo = retrieveMultimediaInfo(file);
-		var videoInfo = mediaInfo.getVideo();
-		var videoSize = videoInfo.getSize();
-
-		return isSizeCompliant(videoSize.getWidth(), videoSize.getHeight())
-				&& videoInfo.getFrameRate() <= MAX_VIDEO_FRAMES
-				&& videoInfo.getDecoder().startsWith(VP9_CODEC)
-				&& mediaInfo.getDuration() > 0L
-				&& mediaInfo.getDuration() <= MAX_VIDEO_DURATION_MILLIS
-				&& mediaInfo.getAudio() == null
-				&& MATROSKA_FORMAT.equals(mediaInfo.getFormat())
-				&& isFileSizeLowerThan(file, MAX_VIDEO_FILE_SIZE);
+
+		var formatInfo = mediaInfo.format();
+		if (formatInfo == null) {
+			return false;
+		}
+
+		if (formatInfo.duration() == null) {
+			return false;
+		}
+
+		var videoInfo = mediaInfo.video();
+		if (videoInfo == null) {
+			return false;
+		}
+
+		return isSizeCompliant(videoInfo.width(), videoInfo.height())
+				&& videoInfo.frameRate() <= MAX_VIDEO_FRAMES
+				&& VP9_CODEC.equals(videoInfo.codec())
+				&& formatInfo.duration() <= MAX_VIDEO_DURATION_SECONDS
+				&& mediaInfo.audio() == null
+				&& formatInfo.format().startsWith(MATROSKA_FORMAT)
+				&& formatInfo.size() <= MAX_VIDEO_FILE_SIZE;
 	}
 
 	/**
 	 * Convenience method to retrieve multimedia information of a file.
 	 *
 	 * @param file the video to check
 	 * @return passed-in video's multimedia information
-	 * @throws CorruptedVideoException if an error occurred retrieving video information
+	 * @throws CorruptedFileException if an error occurred retrieving file information
+	 * @throws InterruptedException if the current thread is interrupted while retrieving file info
 	 */
-	private static MultimediaInfo retrieveMultimediaInfo(File file) throws CorruptedVideoException {
+	static MultimediaInfo retrieveMultimediaInfo(File file) throws CorruptedFileException, InterruptedException {
+		var command = new String[] {
+				"ffprobe",
+				"-hide_banner",
+				"-v", "quiet",
+				"-print_format", "json",
+				"-show_format",
+				"-show_streams",
+				file.getAbsolutePath()
+		};
+
 		try {
-			return new MultimediaObject(file, PathLocator.INSTANCE).getInfo();
-		} catch (EncoderException e) {
-			throw new CorruptedVideoException("The video could not be processed successfully", e);
+			var output = ProcessHelper.executeCommand(command);
+
+			return GSON.fromJson(output, MultimediaInfo.class);
+		} catch (ProcessException | JsonSyntaxException e) {
+			throw new CorruptedFileException("The file could not be processed successfully", e);
 		}
 	}
 
+	record MultimediaInfo(List<StreamInfo> streams, @Nullable FormatInfo format) {
+		@Nullable
+		StreamInfo audio() {
+			return streams.stream()
+					.filter(s -> s.type == CodecType.AUDIO)
+					.findFirst()
+					.orElse(null);
+		}
+
+		@Nullable
+		StreamInfo video() {
+			return streams.stream()
+					.filter(s -> s.type == CodecType.VIDEO)
+					.findFirst()
+					.orElse(null);
+		}
+	}
+
+	record StreamInfo(@SerializedName("codec_name") String codec, @SerializedName("codec_type") CodecType type, int width, int height, @SerializedName("avg_frame_rate") String frameRateRatio) {
+		float frameRate() {
+			if (frameRateRatio.contains("/")) {
+				var ratio = frameRateRatio.split("/");
+				return Float.parseFloat(ratio[0]) / Float.parseFloat(ratio[1]);
+			} else {
+				return Float.parseFloat(frameRateRatio);
+			}
+		}
+	}
+
+	private enum CodecType {
+		@SerializedName("video") VIDEO,
+		@SerializedName("audio") AUDIO
+	}
+
+	record FormatInfo(@SerializedName("format_name") String format, @Nullable Float duration, long size) {}
+
 	/**
 	 * Checks if the file is a {@code gzip} archive, then it reads its content and verifies if it's a valid JSON.
 	 * Once JSON information is retrieved, they are validated against Telegram's requirements.
@@ -183,7 +241,11 @@ private static boolean isAnimatedStickerCompliant(File file, String mimeType) th
 
 				boolean isAnimationCompliant = isAnimationCompliant(sticker);
 				if (isAnimationCompliant) {
-					return isFileSizeLowerThan(file, MAX_ANIMATION_FILE_SIZE);
+					try {
+						return Files.size(file.toPath()) <= MAX_ANIMATION_FILE_SIZE;
+					} catch (IOException e) {
+						throw new FileOperationException(e);
+					}
 				}
 
 				LOGGER.atWarn().log("The {} doesn't meet Telegram's requirements", sticker);
@@ -226,38 +288,31 @@ private static boolean isAnimationCompliant(@Nullable AnimationDetails animation
 				&& animation.height() == MAX_SIDE_LENGTH;
 	}
 
-	/**
-	 * Checks that passed-in file's size does not exceed the specified threshold.
-	 *
-	 * @param file the file to check
-	 * @param threshold max allowed file size
-	 * @return {@code true} if file's size is compliant
-	 * @throws FileOperationException if an error occurred retrieving the size of the file
-	 */
-	private static boolean isFileSizeLowerThan(File file, long threshold) throws FileOperationException {
-		try {
-			return Files.size(file.toPath()) <= threshold;
-		} catch (IOException e) {
-			throw new FileOperationException(e);
-		}
-	}
-
 	/**
 	 * Checks if passed-in image is already compliant with Telegram's requisites.
 	 *
 	 * @param image the image to check
 	 * @param mimeType the MIME type of the file
 	 * @return {@code true} if the file is compliant
+	 * @throws CorruptedFileException if an error occurred retrieving image information
+	 * @throws InterruptedException if the current thread is interrupted while retrieving file info
 	 */
-	private static boolean isImageCompliant(File image, String mimeType) throws CorruptedVideoException, FileOperationException {
-		var videoSize = retrieveMultimediaInfo(image).getVideo().getSize();
-		if (videoSize == null) {
-			throw new FileOperationException("Couldn't read image dimensions");
+	private static boolean isImageCompliant(File image, String mimeType) throws CorruptedFileException, InterruptedException {
+		var mediaInfo = retrieveMultimediaInfo(image);
+
+		var formatInfo = mediaInfo.format();
+		if (formatInfo == null) {
+			return false;
+		}
+
+		var imageInfo = mediaInfo.video();
+		if (imageInfo == null) {
+			return false;
 		}
 
 		return ("image/png".equals(mimeType) || "image/webp".equals(mimeType))
-				&& isSizeCompliant(videoSize.getWidth(), videoSize.getHeight())
-				&& isFileSizeLowerThan(image, MAX_IMAGE_FILE_SIZE);
+				&& isSizeCompliant(imageInfo.width(), imageInfo.height())
+				&& formatInfo.size() <= MAX_IMAGE_FILE_SIZE;
 	}
 
 	/**
@@ -362,7 +417,7 @@ private static File convertToWebm(File file) throws MediaException, InterruptedE
 				"-c:v", "libvpx-" + VP9_CODEC,
 				"-b:v", "650K",
 				"-pix_fmt", "yuv420p",
-				"-t", String.valueOf(MAX_VIDEO_DURATION_MILLIS / 1000),
+				"-t", String.valueOf(MAX_VIDEO_DURATION_SECONDS),
 				"-an",
 				"-passlogfile", logPrefix
 		};