Implement ffmpeg-independent PNGWriter (closes #476)

Creates a dedicated folder for each video and does not depend on ffmpeg, just
like the EXRWriter (but supporting all MC versions).

Also does 32 bit depth export by chunking the 32-bit float into the 8-bit BGRA
component channels.

src/main/java/com/replaymod/render/PNGWriter.java

@@ -0,0 +1,71 @@
+package com.replaymod.render;
+
+import com.replaymod.core.versions.MCVer;
+import com.replaymod.render.blend.Util.IOConsumer;
+import com.replaymod.render.frame.BitmapFrame;
+import com.replaymod.render.rendering.Channel;
+import com.replaymod.render.rendering.FrameConsumer;
+import com.replaymod.render.utils.ByteBufferPool;
+import de.johni0702.minecraft.gui.utils.lwjgl.ReadableDimension;
+import de.johni0702.minecraft.gui.versions.Image;
+import net.minecraft.util.crash.CrashReport;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+
+public class PNGWriter implements FrameConsumer<BitmapFrame> {
+
+    private final Path outputFolder;
+
+    public PNGWriter(Path outputFolder) throws IOException {
+        this.outputFolder = outputFolder;
+
+        Files.createDirectories(outputFolder);
+    }
+
+    @Override
+    public void consume(Map<Channel, BitmapFrame> channels) {
+        BitmapFrame bgraFrame = channels.get(Channel.BRGA);
+        BitmapFrame depthFrame = channels.get(Channel.DEPTH);
+        try {
+            if (bgraFrame != null) {
+                withImage(bgraFrame, image ->
+                        image.writePNG(outputFolder.resolve(bgraFrame.getFrameId() + ".png").toFile()));
+            }
+            if (depthFrame != null) {
+                withImage(depthFrame, image ->
+                        image.writePNG(outputFolder.resolve(depthFrame.getFrameId() + ".depth.png").toFile()));
+            }
+        } catch (Throwable t) {
+            MCVer.getMinecraft().setCrashReport(CrashReport.create(t, "Exporting EXR frame"));
+        } finally {
+            channels.values().forEach(it -> ByteBufferPool.release(it.getByteBuffer()));
+        }
+    }
+
+    private void withImage(BitmapFrame frame, IOConsumer<Image> consumer) throws IOException {
+        ByteBuffer buffer = frame.getByteBuffer();
+        ReadableDimension size = frame.getSize();
+        int width = size.getWidth();
+        int height = size.getHeight();
+        try (Image image = new Image(width, height)) {
+            for (int y = 0; y < height; y++) {
+                for (int x = 0; x < width; x++) {
+                    byte b = buffer.get();
+                    byte g = buffer.get();
+                    byte r = buffer.get();
+                    byte a = buffer.get();
+                    image.setRGBA(x, y, r, g, b, a);
+                }
+            }
+            consumer.accept(image);
+        }
+    }
+
+    @Override
+    public void close() {
+    }
+}

src/main/java/com/replaymod/render/RenderSettings.java

@@ -72,7 +72,7 @@ public class RenderSettings {
 
         EXR(null, "exr"),
 
-        PNG("\"%FILENAME%-%06d.png\"", "png");
+        PNG(null, "png");
 
         private final String preset;
         private final String fileExtension;

src/main/java/com/replaymod/render/gui/GuiRenderSettings.java

@@ -406,8 +406,9 @@ public class GuiRenderSettings extends AbstractGuiPopup<GuiRenderSettings> {
 
         // Enable/Disable various options for blend export
         boolean isEXR = encodingPresetDropdown.getSelectedValue() == RenderSettings.EncodingPreset.EXR;
+        boolean isPNG = encodingPresetDropdown.getSelectedValue() == RenderSettings.EncodingPreset.PNG;
         boolean isBlend = renderMethod == RenderSettings.RenderMethod.BLEND;
-        boolean isFFmpeg = !isBlend && !isEXR;
+        boolean isFFmpeg = !isBlend && !isEXR && !isPNG;
         if (isBlend) {
             videoWidth.setDisabled();
             videoHeight.setDisabled();
@@ -417,11 +418,11 @@ public class GuiRenderSettings extends AbstractGuiPopup<GuiRenderSettings> {
         exportArguments.setEnabled(isFFmpeg);
         antiAliasingDropdown.setEnabled(isFFmpeg);
 
-        if (isEXR) {
+        if (isEXR || isPNG) {
             depthMap.setEnabled().setTooltip(null);
         } else {
             depthMap.setDisabled().setTooltip(new GuiTooltip().setColor(Colors.RED)
-                    .setI18nText("replaymod.gui.rendersettings.depthmap.onlyexr"));
+                    .setI18nText("replaymod.gui.rendersettings.depthmap.only_exr_or_png"));
         }
 
         // Enable/Disable export args reset button

src/main/java/com/replaymod/render/rendering/VideoRenderer.java

@@ -8,6 +8,7 @@ import com.replaymod.pathing.player.AbstractTimelinePlayer;
 import com.replaymod.pathing.player.ReplayTimer;
 import com.replaymod.pathing.properties.TimestampProperty;
 import com.replaymod.render.CameraPathExporter;
+import com.replaymod.render.PNGWriter;
 import com.replaymod.render.RenderSettings;
 import com.replaymod.render.ReplayModRender;
 import com.replaymod.render.FFmpegWriter;
@@ -125,15 +126,17 @@ public class VideoRenderer implements RenderInfo {
         } else {
             FrameConsumer<BitmapFrame> frameConsumer;
             if (settings.getEncodingPreset() == RenderSettings.EncodingPreset.EXR) {
-                ffmpegWriter = null;
                 //#if MC>=11400
                 frameConsumer = new EXRWriter(settings.getOutputFile().toPath());
                 //#else
                 //$$ throw new UnsupportedOperationException("EXR requires LWJGL3");
                 //#endif
+            } else if (settings.getEncodingPreset() == RenderSettings.EncodingPreset.PNG) {
+                frameConsumer = new PNGWriter(settings.getOutputFile().toPath());
             } else {
-                frameConsumer = ffmpegWriter = new FFmpegWriter(this);
+                frameConsumer = new FFmpegWriter(this);
             }
+            ffmpegWriter = frameConsumer instanceof FFmpegWriter ? (FFmpegWriter) frameConsumer : null;
             FrameConsumer<BitmapFrame> previewingFrameConsumer = new FrameConsumer<BitmapFrame>() {
                 @Override
                 public void consume(Map<Channel, BitmapFrame> channels) {