Set max duration 1 frame less than 3 seconds

Author: MartelliEnrico

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/)
 

src/main/java/com/github/stickerifier/stickerify/media/MediaConstraints.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/MediaHelper.java

@@ -6,7 +6,7 @@
 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;
@@ -132,29 +132,25 @@ private static boolean isVideoCompliant(File file) throws FileOperationException
 
 		var formatInfo = mediaInfo.format();
 		if (formatInfo == null) {
-			return false; // not a video, maybe throw
+			return false;
 		}
 
-		var duration = formatInfo.durationAsMillis();
-		if (duration == null) {
-			return false; // not a video, maybe throw
+		if (formatInfo.duration() == null) {
+			return false;
 		}
 
 		var videoInfo = mediaInfo.video();
 		if (videoInfo == null) {
-			return false; // not a video, maybe throw
+			return false;
 		}
 
-		var size = formatInfo.sizeAsLong();
-		var frameRate = videoInfo.frameRateAsFloat();
-
 		return isSizeCompliant(videoInfo.width(), videoInfo.height())
-				&& frameRate <= MAX_VIDEO_FRAMES
+				&& videoInfo.frameRate() <= MAX_VIDEO_FRAMES
 				&& VP9_CODEC.equals(videoInfo.codec())
-				&& duration <= MAX_VIDEO_DURATION_MILLIS
+				&& Float.parseFloat(formatInfo.duration()) <= MAX_VIDEO_DURATION_SECONDS
 				&& mediaInfo.audio() == null
 				&& formatInfo.format().startsWith(MATROSKA_FORMAT)
-				&& size <= MAX_VIDEO_FILE_SIZE;
+				&& Long.parseLong(formatInfo.size()) <= MAX_VIDEO_FILE_SIZE;
 	}
 
 	/**
@@ -189,43 +185,33 @@ static MultimediaInfo retrieveMultimediaInfo(File file) throws CorruptedFileExce
 	record MultimediaInfo(List<StreamInfo> streams, @Nullable FormatInfo format) {
 		@Nullable StreamInfo audio() {
 			return streams.stream()
-					.filter(s -> StreamInfo.TYPE_AUDIO.equals(s.type))
+					.filter(s -> s.type == CodecType.AUDIO)
 					.findFirst()
 					.orElse(null);
 		}
 
 		@Nullable StreamInfo video() {
 			return streams.stream()
-					.filter(s -> StreamInfo.TYPE_VIDEO.equals(s.type))
+					.filter(s -> s.type == CodecType.VIDEO)
 					.findFirst()
 					.orElse(null);
 		}
 	}
-	record StreamInfo(@SerializedName("codec_name") String codec, @SerializedName("codec_type") String type, int width, int height, @SerializedName("avg_frame_rate") String frameRateFraction) {
-		private static final String TYPE_AUDIO = "audio";
-		private static final String TYPE_VIDEO = "video";
-
-		float frameRateAsFloat() {
-			if (frameRateFraction.contains("/")) {
-				var ratio = frameRateFraction.split("/");
+	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(frameRateFraction);
+				return Float.parseFloat(frameRateRatio);
 			}
 		}
 	}
-	record FormatInfo(@SerializedName("format_name") String format, @SerializedName("duration") @Nullable String duration, String size) {
-		@Nullable Long durationAsMillis() {
-			if (duration == null) {
-				return null;
-			}
-			return (long) (Float.parseFloat(duration) * 1000);
-		}
-
-		long sizeAsLong() {
-			return Long.parseLong(size);
-		}
+	private enum CodecType {
+		@SerializedName("video") VIDEO,
+		@SerializedName("audio") AUDIO
 	}
+	record FormatInfo(@SerializedName("format_name") String format, @Nullable String duration, String size) {}
 
 	/**
 	 * Checks if the file is a {@code gzip} archive, then it reads its content and verifies if it's a valid JSON.
@@ -312,19 +298,17 @@ private static boolean isImageCompliant(File image, String mimeType) throws Corr
 
 		var formatInfo = mediaInfo.format();
 		if (formatInfo == null) {
-			return false; // not an image, maybe throw
+			return false;
 		}
 
 		var videoInfo = mediaInfo.video();
 		if (videoInfo == null) {
-			return false; // not an image, maybe throw
+			return false;
 		}
 
-		var size = formatInfo.sizeAsLong();
-
 		return ("image/png".equals(mimeType) || "image/webp".equals(mimeType))
 				&& isSizeCompliant(videoInfo.width(), videoInfo.height())
-				&& size <= MAX_IMAGE_FILE_SIZE;
+				&& Long.parseLong(formatInfo.size()) <= MAX_IMAGE_FILE_SIZE;
 	}
 
 	/**
@@ -429,7 +413,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
 		};

src/main/java/com/github/stickerifier/stickerify/runner/Main.java

@@ -5,7 +5,7 @@
 public class Main {
 	static final Object LOCK = new Object();
 
-	public static void main(String[] args) {
+	static void main() {
 		try (var _ = new Stickerify()) {
 			Runtime.getRuntime().addShutdownHook(new Thread(() -> {
 				synchronized (LOCK) {

src/test/java/com/github/stickerifier/stickerify/media/MediaHelperTest.java

@@ -46,16 +46,16 @@ void resizeRectangularImage() throws Exception {
 		assertImageConsistency(result, 512, 341);
 	}
 
-	private static void assertImageConsistency(File result, int expectedWidth, int expectedHeight) throws Exception {
-		var videoInfo = MediaHelper.retrieveMultimediaInfo(result).video();
-		assertNotNull(videoInfo);
-		var actualExtension = getExtension(result);
+	private static void assertImageConsistency(File image, int expectedWidth, int expectedHeight) throws Exception {
+		var imageInfo = MediaHelper.retrieveMultimediaInfo(image).video();
+		assertNotNull(imageInfo);
+		var actualExtension = getExtension(image);
 
 		assertAll("Image validation failed",
 				() -> assertThat("image's extension must be webp", actualExtension, is(equalTo(".webp"))),
-				() -> assertThat("image's width is not correct", videoInfo.width(), is(equalTo(expectedWidth))),
-				() -> assertThat("image's height is not correct", videoInfo.height(), is(equalTo(expectedHeight))),
-				() -> assertThat("image size should not exceed 512 KB", Files.size(result.toPath()), is(lessThanOrEqualTo(MAX_IMAGE_FILE_SIZE)))
+				() -> assertThat("image's width is not correct", imageInfo.width(), is(equalTo(expectedWidth))),
+				() -> assertThat("image's height is not correct", imageInfo.height(), is(equalTo(expectedHeight))),
+				() -> assertThat("image size should not exceed 512 KB", Files.size(image.toPath()), is(lessThanOrEqualTo(MAX_IMAGE_FILE_SIZE)))
 		);
 	}
 
@@ -149,28 +149,29 @@ void convertLongMovVideo() throws Exception {
 		var movVideo = loadResource("long.mov");
 		var result = MediaHelper.convert(movVideo);
 
-		assertVideoConsistency(result, 512, 288, 29.97003F, 3_003L);
+		assertVideoConsistency(result, 512, 288, 29.97003F, 2.969F);
 	}
 
-	private static void assertVideoConsistency(File result, int expectedWidth, int expectedHeight, float expectedFrameRate, long expectedDuration) throws Exception {
-		var mediaInfo = MediaHelper.retrieveMultimediaInfo(result);
+	private static void assertVideoConsistency(File video, int expectedWidth, int expectedHeight, float expectedFrameRate, float expectedDuration) throws Exception {
+		var mediaInfo = MediaHelper.retrieveMultimediaInfo(video);
 		var videoInfo = mediaInfo.video();
 		assertNotNull(videoInfo);
 		var formatInfo = mediaInfo.format();
 		assertNotNull(formatInfo);
+		assertNotNull(formatInfo.duration());
 
-		var actualExtension = getExtension(result);
+		var actualExtension = getExtension(video);
 
 		assertAll("Video validation failed",
 				() -> assertThat("video's extension must be webm", actualExtension, is(equalTo(".webm"))),
 				() -> assertThat("video's width is not correct", videoInfo.width(), is(equalTo(expectedWidth))),
 				() -> assertThat("video's height is not correct", videoInfo.height(), is(equalTo(expectedHeight))),
-				() -> assertThat("video's frame rate is not correct", videoInfo.frameRateAsFloat(), is(equalTo(expectedFrameRate))),
+				() -> assertThat("video's frame rate is not correct", videoInfo.frameRate(), is(equalTo(expectedFrameRate))),
 				() -> assertThat("video must be encoded with the VP9 codec", videoInfo.codec(), is(equalTo(VP9_CODEC))),
-				() -> assertThat("video's duration is not correct", formatInfo.durationAsMillis(), is(equalTo(expectedDuration))),
+				() -> assertThat("video's duration is not correct", Float.parseFloat(formatInfo.duration()), is(equalTo(expectedDuration))),
 				() -> assertThat("video's format must be matroska", formatInfo.format(), startsWith(MATROSKA_FORMAT)),
 				() -> assertThat("video must have no audio stream", mediaInfo.audio(), is(nullValue())),
-				() -> assertThat("video size should not exceed 256 KB", Files.size(result.toPath()), is(lessThanOrEqualTo(MAX_VIDEO_FILE_SIZE)))
+				() -> assertThat("video size should not exceed 256 KB", Files.size(video.toPath()), is(lessThanOrEqualTo(MAX_VIDEO_FILE_SIZE)))
 		);
 	}
 
@@ -180,7 +181,7 @@ void convertMp4WithAudio() throws Exception {
 		var mp4Video = loadResource("video_with_audio.mp4");
 		var result = MediaHelper.convert(mp4Video);
 
-		assertVideoConsistency(result, 512, 288, 29.97003F, 3_003L);
+		assertVideoConsistency(result, 512, 288, 29.97003F, 2.969F);
 	}
 
 	@Test
@@ -189,7 +190,7 @@ void convertM4vWithAudio() throws Exception {
 		var m4vVideo = loadResource("video_with_audio.m4v");
 		var result = MediaHelper.convert(m4vVideo);
 
-		assertVideoConsistency(result, 512, 214, 23.976025F, 3_003L);
+		assertVideoConsistency(result, 512, 214, 23.976025F, 2.962F);
 	}
 
 	@Test
@@ -198,7 +199,7 @@ void convertShortAndLowFpsVideo() throws Exception {
 		var webmVideo = loadResource("short_low_fps.webm");
 		var result = MediaHelper.convert(webmVideo);
 
-		assertVideoConsistency(result, 512, 288, 10F, 1_000L);
+		assertVideoConsistency(result, 512, 288, 10F, 1.0F);
 	}
 
 	@Test
@@ -207,7 +208,7 @@ void resizeSmallWebmVideo() throws Exception {
 		var webmVideo = loadResource("small_video_sticker.webm");
 		var result = MediaHelper.convert(webmVideo);
 
-		assertVideoConsistency(result, 512, 212, 30F, 2_600L);
+		assertVideoConsistency(result, 512, 212, 30F, 2.6F);
 	}
 
 	@Test
@@ -216,7 +217,7 @@ void convertVerticalWebmVideo() throws Exception {
 		var webmVideo = loadResource("vertical_video_sticker.webm");
 		var result = MediaHelper.convert(webmVideo);
 
-		assertVideoConsistency(result, 288, 512, 30F, 2_000L);
+		assertVideoConsistency(result, 288, 512, 30F, 2.0F);
 	}
 
 	@Test
@@ -225,7 +226,7 @@ void convertGifVideo() throws Exception {
 		var gifVideo = loadResource("valid.gif");
 		var result = MediaHelper.convert(gifVideo);
 
-		assertVideoConsistency(result, 512, 274, 10F, 1_000L);
+		assertVideoConsistency(result, 512, 274, 10F, 1.0F);
 	}
 
 	@Test
@@ -234,7 +235,7 @@ void convertAviVideo() throws Exception {
 		var aviVideo = loadResource("valid.avi");
 		var result = MediaHelper.convert(aviVideo);
 
-		assertVideoConsistency(result, 512, 512, 30F, 3_000L);
+		assertVideoConsistency(result, 512, 512, 30F, 2.966F);
 	}
 
 	@Test