A LOT of changes!

Firstly a desktop icon system, secondly in the cameras ui you can now see time, thirdly you can now set the recording quality, lastly you have a desktop icon specifically for exporting!
recording was fucked up. FIX!
2026-01-31 21:40:34 +01:00 · 2026-01-29 17:02:04 +01:00 · 2026-01-29 16:40:36 +01:00 · 2026-01-25 19:39:03 +01:00
24 changed files with 1226 additions and 407 deletions
--- a/pom.xml
+++ b/pom.xml
@@ -7,7 +7,7 @@
    <groupId>io.swtc</groupId>
    <artifactId>swtc</artifactId>
    <version>1.0-SNAPSHOT</version>
-
+<!--
    <build>
        <plugins>
            <plugin>
@@ -42,6 +42,43 @@
            </plugin>
        </plugins>
    </build>
+-->
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.6.1</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <transformers>
+                                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>io.swtc.Main</mainClass>
+                                </transformer>
+                            </transformers>
+                            <filters>
+                                <filter>
+                                    <artifact>*:*</artifact>
+                                    <excludes>
+                                        <exclude>META-INF/*.SF</exclude>
+                                        <exclude>META-INF/*.DSA</exclude>
+                                        <exclude>META-INF/*.RSA</exclude>
+                                    </excludes>
+                                </filter>
+                            </filters>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
@@ -63,30 +100,30 @@
            <version>0.3.12</version>
        </dependency>

-        <!-- for gl we use lwjgl -->
-        <dependency>
-            <groupId>org.lwjgl</groupId>
-            <artifactId>lwjgl</artifactId>
-            <version>3.3.3</version>
-        </dependency>
-        <dependency>
-            <groupId>org.lwjgl</groupId>
-            <artifactId>lwjgl-opengl</artifactId>
-            <version>3.3.3</version>
-        </dependency>
+<!--        &lt;!&ndash; for gl we use lwjgl &ndash;&gt;-->
+<!--        <dependency>-->
+<!--            <groupId>org.lwjgl</groupId>-->
+<!--            <artifactId>lwjgl</artifactId>-->
+<!--            <version>3.3.3</version>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>org.lwjgl</groupId>-->
+<!--            <artifactId>lwjgl-opengl</artifactId>-->
+<!--            <version>3.3.3</version>-->
+<!--        </dependency>-->

-        <dependency>
-            <groupId>org.lwjgl</groupId>
-            <artifactId>lwjgl</artifactId>
-            <version>3.3.3</version>
-            <classifier>natives-windows</classifier>
-        </dependency>
-        <dependency>
-            <groupId>org.lwjgl</groupId>
-            <artifactId>lwjgl-opengl</artifactId>
-            <version>3.3.3</version>
-            <classifier>natives-windows</classifier>
-        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.lwjgl</groupId>-->
+<!--            <artifactId>lwjgl</artifactId>-->
+<!--            <version>3.3.3</version>-->
+<!--            <classifier>natives-windows</classifier>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>org.lwjgl</groupId>-->
+<!--            <artifactId>lwjgl-opengl</artifactId>-->
+<!--            <version>3.3.3</version>-->
+<!--            <classifier>natives-windows</classifier>-->
+<!--        </dependency>-->

        <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
@@ -106,22 +143,35 @@
            <version>2.20.1</version>
        </dependency>

-        <!-- https://mvnrepository.com/artifact/org.jcodec/jcodec -->
-        <!--
-            Saving into Files
-        -->
-        <dependency>
-            <groupId>org.jcodec</groupId>
-            <artifactId>jcodec</artifactId>
-            <version>0.2.5</version>
-        </dependency>
+<!--        &lt;!&ndash; https://mvnrepository.com/artifact/org.jcodec/jcodec &ndash;&gt;-->
+<!--        &lt;!&ndash;-->
+<!--            Saving into Files-->
+<!--        &ndash;&gt;-->
+<!--        <dependency>-->
+<!--            <groupId>org.jcodec</groupId>-->
+<!--            <artifactId>jcodec</artifactId>-->
+<!--            <version>0.2.5</version>-->
+<!--        </dependency>-->

-        <!-- https://mvnrepository.com/artifact/org.jcodec/jcodec-javase -->
-        <dependency>
-            <groupId>org.jcodec</groupId>
-            <artifactId>jcodec-javase</artifactId>
-            <version>0.2.5</version>
-        </dependency>
+<!--        &lt;!&ndash; https://mvnrepository.com/artifact/org.jcodec/jcodec-javase &ndash;&gt;-->
+<!--        <dependency>-->
+<!--            <groupId>org.jcodec</groupId>-->
+<!--            <artifactId>jcodec-javase</artifactId>-->
+<!--            <version>0.2.5</version>-->
+<!--        </dependency>-->
+
+            <dependency>
+                <groupId>org.bytedeco</groupId>
+                <artifactId>javacv</artifactId>
+                <version>1.5.10</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.bytedeco</groupId>
+                <artifactId>ffmpeg</artifactId>
+                <version>6.1.1-1.5.10</version>
+                <classifier>windows-x86_64</classifier>
+            </dependency>

    </dependencies>
 </project>
--- a/src/main/java/io/swtc/Main.java
+++ b/src/main/java/io/swtc/Main.java
@@ -8,15 +8,13 @@ import io.swtc.proccessing.ui.ShowError;
 public class Main {

    public static void main(String[] args) {
-        for (int i = 0; i < args.length; i++) {
-            System.out.println("Arg " + i + ": " + args[i]);
-        }
+//        for (int i = 0; i < args.length; i++) {
+//            System.out.println("Arg " + i + ": " + args[i]);
+//        }

        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
-        } catch (Exception e) {
-            ShowError.warning(null,"LaF Warn","LaF");
-        }
+        } catch (Exception e) { /* Do nothing */ }

        SwingCCTVManager.main(null);
    }
--- a/src/main/java/io/swtc/SwingIFrame.java
+++ b/src/main/java/io/swtc/SwingIFrame.java
@@ -2,7 +2,9 @@ package io.swtc;

 import com.github.sarxos.webcam.Webcam;
 import io.swtc.proccessing.ui.IconSetter;
-import io.swtc.proccessing.ui.iframe.*; // Your custom frames
+import io.swtc.proccessing.ui.desktop.DIM;
+import io.swtc.proccessing.ui.desktop.evidence.EvidenceExportFrame;
+import io.swtc.proccessing.ui.iframe.*;
 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.ActionEvent;
@@ -10,10 +12,12 @@ import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;

 public class SwingIFrame {
    private final JFrame mainFrame;
    private final DesktopPane desktopPane;
+    private final DIM desktopIconManager;
    private final Map<JInternalFrame, EffectsPanelFrame> cameraToEffects = new HashMap<>();

    private boolean fullscreen = false;
@@ -24,6 +28,7 @@ public class SwingIFrame {

    private final JPopupMenu popupMenu = new JPopupMenu();

+
    public SwingIFrame() {
        mainFrame = new JFrame("Viewer");
        mainFrame.setSize(1280, 720);
@@ -35,6 +40,10 @@ public class SwingIFrame {
        desktopPane.setBackground(defDesktopBg);
        mainFrame.add(desktopPane, BorderLayout.CENTER);

+        desktopIconManager = new DIM(desktopPane);
+
+        setupDesktopExportFrame();
+
        setupFullscreenToggle();
        setupBlackBg();
        initPopupMenu();
@@ -42,6 +51,14 @@ public class SwingIFrame {
        desktopPane.addMouseListener(popupListener());
    }

+    private void setupDesktopExportFrame() {
+        desktopIconManager.addIcon(
+                "Export Evidence",
+                IconSetter.getSaveIconAsImageIcon(),
+                EvidenceExportFrame::showExport
+        );
+    }
+
    public void addCameraInternalFrame(Webcam webcam) {
        CameraInternalFrame cameraFrame = new CameraInternalFrame(webcam, this::handleEffectsRequest);

@@ -109,7 +126,14 @@ public class SwingIFrame {
        popupMenu.removeAll(); // clean slate

        JCheckBoxMenuItem fullscreenItem = new JCheckBoxMenuItem("Fullscreen");
+        JCheckBoxMenuItem mmfullscreenItem = new JCheckBoxMenuItem("Multi Monitor Fullscreen");
+        JCheckBoxMenuItem backgroundcolor = new JCheckBoxMenuItem("Calmer Background");
+        JMenuItem colorpicker = new JMenuItem("Set background color");
+
        fullscreenItem.addActionListener(e -> toggleFullscreen());
+        mmfullscreenItem.addActionListener(e -> toggleMMFullscreen());
+        backgroundcolor.addActionListener(e -> toggleBackground());
+        colorpicker.addActionListener(e -> chooseBgColor());

        popupMenu.addPopupMenuListener(new javax.swing.event.PopupMenuListener() {
            @Override
@@ -121,6 +145,22 @@ public class SwingIFrame {
        });

        popupMenu.add(fullscreenItem);
+        popupMenu.add(mmfullscreenItem);
+        popupMenu.add(backgroundcolor);
+        popupMenu.add(colorpicker);
+    }
+
+    private void chooseBgColor() {
+        Color selected = JColorChooser.showDialog(
+                mainFrame,
+                "Select Background Color",
+                desktopPane.getBackground()
+        );
+
+        if (!Objects.isNull(selected)) {
+            desktopPane.setBackground(selected);
+            desktopPane.repaint();
+        }
    }

    private void setupBlackBg() {
@@ -137,6 +177,7 @@ public class SwingIFrame {

    private void setupFullscreenToggle() {
        JRootPane root = mainFrame.getRootPane();
+        // One Monitor FS
        root.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
                .put(KeyStroke.getKeyStroke("F11"), "toggleFullscreen");
        root.getActionMap().put("toggleFullscreen", new AbstractAction() {
@@ -145,6 +186,16 @@ public class SwingIFrame {
                toggleFullscreen();
            }
        });
+
+        // Multi Monitor FS
+        root.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
+                .put(KeyStroke.getKeyStroke("F12"), "toggleMMFullscreen");
+        root.getActionMap().put("toggleMMFullscreen", new AbstractAction() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                toggleMMFullscreen();
+            }
+        });
    }

    private void toggleBackground() {
@@ -153,6 +204,33 @@ public class SwingIFrame {
        desktopPane.repaint();
    }

+    private void toggleMMFullscreen() {
+        if (!fullscreen) {
+            windowedBounds = mainFrame.getBounds();
+
+            Rectangle virtualBounds = new Rectangle();
+            GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+            GraphicsDevice[] gs = ge.getScreenDevices();
+
+            for (GraphicsDevice gd : gs) {
+                GraphicsConfiguration[] gc = gd.getConfigurations();
+                for (GraphicsConfiguration configuration : gc) {
+                    virtualBounds = virtualBounds.union(configuration.getBounds());
+                }
+            }
+
+            mainFrame.dispose();
+            mainFrame.setUndecorated(true);
+
+            mainFrame.setBounds(virtualBounds);
+            mainFrame.setVisible(true);
+
+            fullscreen = true;
+        } else {
+            toggleFullscreen();
+        }
+    }
+
    /** Toggle fullscreen mode */
    private void toggleFullscreen() {
        if (!fullscreen) {
--- a/src/main/java/io/swtc/proccessing/CameraPanel.java
+++ b/src/main/java/io/swtc/proccessing/CameraPanel.java
@@ -1,12 +1,19 @@
 package io.swtc.proccessing;

+import io.swtc.proccessing.ui.IconSetter;
 import io.swtc.proccessing.ui.ShowError;
+import io.swtc.recording.cv.AVRecorder;

 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.*;
-import java.awt.geom.AffineTransform;
+import java.awt.font.GlyphVector;
 import java.awt.image.BufferedImage;
+import java.io.InputStream;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
@@ -16,6 +23,23 @@ public class CameraPanel extends JPanel {
    private volatile BufferedImage sourceImage;
    private volatile BufferedImage processedImage;
    private Function<BufferedImage, BufferedImage> imageProcessor;
+
+    private Font overlayFont;
+    private final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
+    private final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");
+
+    // Cached glyph vectors for performance
+    private GlyphVector dateGlyphs;
+    private GlyphVector timeGlyphs;
+    private String lastDate = "";
+    private String lastTime = "";
+
+    // Pre-calculated positions to avoid repeated calculations
+    private static final int OVERLAY_X = 8;
+    private static final int OVERLAY_Y = 20;
+    private static final int TIME_Y_OFFSET = 19;
+
+    private volatile AVRecorder recorder;       // this is now javacv, jcodec is stoopid
    private final AtomicBoolean repaintScheduled = new AtomicBoolean(false);

    private double zoomLevel = 1.0;
@@ -24,22 +48,39 @@ public class CameraPanel extends JPanel {
    private Point dragStartPoint;

    private static final double MIN_ZOOM = 1.0;
-    private static final double MAX_ZOOM = 10.0; // ten is enough if ur using 640x480
+    private static final double MAX_ZOOM = 10.0;
    private static final double ZOOM_MULTIPLIER = 1.1;

+    private final GraphicsConfiguration graphicsConfig;
+
    public CameraPanel() {
        setBackground(Color.BLACK);
        setPreferredSize(new Dimension(640, 480));

+        loadFont();
+
+        graphicsConfig = GraphicsEnvironment.getLocalGraphicsEnvironment()
+                .getDefaultScreenDevice().getDefaultConfiguration();
+
        initInteractionListeners();
    }

+    private void loadFont() {
+        try (InputStream is = getClass().getResourceAsStream("/font/OverlayFont.ttf")) {
+            if (is != null) {
+                overlayFont = Font.createFont(Font.TRUETYPE_FONT, is).deriveFont(15f);
+            } else {
+                overlayFont = new Font(Font.MONOSPACED, Font.PLAIN, 15);
+            }
+        } catch (Exception e) {
+            overlayFont = new Font(Font.MONOSPACED, Font.PLAIN, 15);
+        }
+    }
+
    private void initInteractionListeners() {
        MouseAdapter mouseHandler = new MouseAdapter() {
            @Override
-            public void mouseWheelMoved(MouseWheelEvent e) {
-                handleZoom(e);
-            }
+            public void mouseWheelMoved(MouseWheelEvent e) { handleZoom(e); }

            @Override
            public void mousePressed(MouseEvent e) {
@@ -49,17 +90,14 @@ public class CameraPanel extends JPanel {

            @Override
            public void mouseClicked(MouseEvent e) {
-                if (e.getClickCount() == 2)
-                    resetView();
+                if (e.getClickCount() == 2) resetView();
            }

            @Override
            public void mouseReleased(MouseEvent e) { setCursor(Cursor.getDefaultCursor()); }

            @Override
-            public void mouseDragged(MouseEvent e) {
-                handlePan(e);
-            }
+            public void mouseDragged(MouseEvent e) { handlePan(e); }

            @Override
            public void mouseExited(MouseEvent e) { setCursor(Cursor.getDefaultCursor()); }
@@ -70,10 +108,20 @@ public class CameraPanel extends JPanel {
        addMouseMotionListener(mouseHandler);
    }

+    public void setExternalRecorder(AVRecorder recorder) {
+        this.recorder = recorder;
+    }
+
    public void setImage(BufferedImage img) {
-        sourceImage = img;
+        this.sourceImage = img;
        updateProcessedImage();

+        // Feed the AVRecorder using its 'accept' method if active
+        AVRecorder currentRecorder = this.recorder;
+        if (currentRecorder != null && currentRecorder.isRecording() && processedImage != null) {
+            currentRecorder.accept(processedImage);
+        }
+
        scheduleRepaint();
    }

@@ -85,19 +133,78 @@ public class CameraPanel extends JPanel {
        }
    }

+    public BufferedImage getCurrentProcessedImage() {
+        return processedImage;
+    }
+
+    public void resetView() {
+        zoomLevel = 1.0;
+        xOffset = 0;
+        yOffset = 0;
+        repaint();
+    }
+
    private void updateProcessedImage() {
        if (sourceImage == null) return;

+        BufferedImage temp;
        if (imageProcessor != null) {
            try {
-                processedImage = imageProcessor.apply(sourceImage);
+                temp = imageProcessor.apply(sourceImage);
            } catch (Exception e) {
-                ShowError.error(null,"Fucked up in rendering \n" + Arrays.toString(e.getStackTrace()),"Problem");
-                processedImage = sourceImage; // Fallback
+                ShowError.error(null, "Error in image processing: \n" + Arrays.toString(e.getStackTrace()), "Processing Error");
+                temp = sourceImage;
            }
        } else {
-            processedImage = sourceImage;
+            temp = sourceImage;
        }
+
+        if (processedImage == null ||
+                processedImage.getWidth() != temp.getWidth() ||
+                processedImage.getHeight() != temp.getHeight()) {
+
+            processedImage = graphicsConfig.createCompatibleImage(
+                    temp.getWidth(),
+                    temp.getHeight(),
+                    temp.getTransparency()
+            );
+        }
+
+        Graphics2D g2d = processedImage.createGraphics();
+        try {
+            g2d.drawImage(temp, 0, 0, null);    // this is fucking expensive
+            drawTimeOverlay(g2d);
+        } finally {
+            g2d.dispose();
+        }
+    }
+
+
+    private void drawTimeOverlay(Graphics2D g) {
+        g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+        g.setFont(overlayFont);
+
+        LocalDateTime now = LocalDateTime.now();
+        String dateStr = now.format(dateFormatter);
+        String timeStr = now.format(timeFormatter);
+
+        if (!dateStr.equals(lastDate)) {
+            dateGlyphs = overlayFont.createGlyphVector(g.getFontRenderContext(), dateStr);
+            lastDate = dateStr;
+        }
+
+        if (!timeStr.equals(lastTime)) {
+            timeGlyphs = overlayFont.createGlyphVector(g.getFontRenderContext(), timeStr);
+            lastTime = timeStr;
+        }
+
+        g.setColor(Color.BLACK);
+        g.drawGlyphVector(dateGlyphs, OVERLAY_X + 2, OVERLAY_Y + 2);
+        g.drawGlyphVector(timeGlyphs, OVERLAY_X + 2, OVERLAY_Y + TIME_Y_OFFSET + 2);
+
+        g.setColor(Color.WHITE);
+        g.drawGlyphVector(dateGlyphs, OVERLAY_X, OVERLAY_Y);
+        g.drawGlyphVector(timeGlyphs, OVERLAY_X, OVERLAY_Y + TIME_Y_OFFSET);
    }

    private void scheduleRepaint() {
@@ -109,24 +216,46 @@ public class CameraPanel extends JPanel {
        }
    }

+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        if (processedImage == null) return;
+
+        Graphics2D g2d = (Graphics2D) g.create();
+        try {
+            g2d.setRenderingHint(
+                    RenderingHints.KEY_INTERPOLATION,
+                    RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR
+            );
+
+            g2d.translate((int)xOffset, (int)yOffset);
+
+            double scaleX = (double) getWidth() / processedImage.getWidth();
+            double scaleY = (double) getHeight() / processedImage.getHeight();
+
+            g2d.scale(scaleX * zoomLevel, scaleY * zoomLevel);
+            g2d.drawImage(processedImage, 0, 0, null);
+
+        } finally {
+            g2d.dispose();
+        }
+    }
+
    private void handleZoom(MouseWheelEvent e) {
        if (processedImage == null) return;

        double oldZoom = zoomLevel;
-
        if (e.getWheelRotation() < 0) {
-            zoomLevel *= ZOOM_MULTIPLIER; // Zoom In
+            zoomLevel *= ZOOM_MULTIPLIER;
        } else {
-            zoomLevel /= ZOOM_MULTIPLIER; // Zoom Out
+            zoomLevel /= ZOOM_MULTIPLIER;
        }

-        // clamp shit
        zoomLevel = Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, zoomLevel));

        if (oldZoom != zoomLevel) {
            double xRel = e.getX() - xOffset;
            double yRel = e.getY() - yOffset;
-
            double zoomFactor = zoomLevel / oldZoom;

            xOffset = e.getX() - (xRel * zoomFactor);
@@ -140,15 +269,10 @@ public class CameraPanel extends JPanel {
    private void handlePan(MouseEvent e) {
        if (processedImage == null || dragStartPoint == null) return;

-        // Calculate delta
-        int dx = e.getX() - dragStartPoint.x;
-        int dy = e.getY() - dragStartPoint.y;
-
-        xOffset += dx;
-        yOffset += dy;
+        xOffset += e.getX() - dragStartPoint.x;
+        yOffset += e.getY() - dragStartPoint.y;

        dragStartPoint = e.getPoint();
-
        checkBounds();
        repaint();
    }
@@ -167,42 +291,4 @@ public class CameraPanel extends JPanel {
            yOffset = getHeight() - viewedHeight;
        }
    }
-
-    @Override
-    protected void paintComponent(Graphics g) {
-        super.paintComponent(g);
-
-        if (processedImage == null) return;
-
-        Graphics2D g2d = (Graphics2D) g;
-
-        AffineTransform originalTransform = g2d.getTransform();
-
-        g2d.setRenderingHint(
-                RenderingHints.KEY_INTERPOLATION,
-                RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR
-        );
-
-        g2d.translate(xOffset, yOffset);
-
-        double scaleX = (double) getWidth() / processedImage.getWidth();
-        double scaleY = (double) getHeight() / processedImage.getHeight();
-
-        g2d.scale(scaleX * zoomLevel, scaleY * zoomLevel);
-
-        g2d.drawImage(processedImage, 0, 0, null);
-
-        g2d.setTransform(originalTransform);
-    }
-
-    public BufferedImage getCurrentProcessedImage() {
-        return processedImage;
-    }
-
-    public void resetView() {
-        zoomLevel = 1.0;
-        xOffset = 0;
-        yOffset = 0;
-        repaint();
-    }
 }
--- a/src/main/java/io/swtc/proccessing/ui/IconSetter.java
+++ b/src/main/java/io/swtc/proccessing/ui/IconSetter.java
@@ -2,6 +2,7 @@ package io.swtc.proccessing.ui;

 import javax.swing.*;
 import java.awt.*;
+import java.io.InputStream;
 import java.net.URL;
 import java.util.Objects;

@@ -37,4 +38,13 @@ public class IconSetter {
        }
        return ICON_ICON;
    }
+
+    public static ImageIcon getSaveIconAsImageIcon() {
+        if (Objects.isNull(ICON_ICON)) {
+            URL url = IconSetter.class.getResource("/icons/save.png");
+            if (Objects.isNull(url)) throw new RuntimeException("Icon not found: /icons/save.ico");
+            ICON_ICON = new ImageIcon(url);
+        }
+        return ICON_ICON;
+    }
 }
--- a/src/main/java/io/swtc/proccessing/ui/desktop/DIM.java
+++ b/src/main/java/io/swtc/proccessing/ui/desktop/DIM.java
@@ -0,0 +1,50 @@
+package io.swtc.proccessing.ui.desktop;
+
+import javax.swing.*;
+import java.awt.*;
+
+/* DesktopIconManager */
+public class DIM {
+
+    private final JDesktopPane desktop;
+
+    private int cX;
+    private int cY;
+
+    private static final int PAD = 6;
+
+    public DIM(JDesktopPane desktop) {
+        this.desktop = desktop;
+
+        Insets insets = desktop.getInsets();
+        this.cX = insets.left + PAD;
+        this.cY = insets.top + PAD;
+    }
+
+    public void addIcon(String label, Icon icon, Runnable runaction) {
+        DesktopIcon desktopIcon = new DesktopIcon(label, icon, runaction);
+
+        Dimension pref = desktopIcon.getPreferredSize();
+        int w = pref.width;
+        int h = pref.height;
+
+        Insets insets = desktop.getInsets();
+        int usableHeight = desktop.getHeight() - insets.top - insets.bottom;
+
+        if (usableHeight <= 0) {
+            usableHeight = Integer.MAX_VALUE;
+        }
+
+        if (cY + h > usableHeight) {
+            cY = insets.top + PAD;
+            cX += w + PAD;
+        }
+
+        desktopIcon.setBounds(cX, cY, w, h);
+
+        desktop.add(desktopIcon, JLayeredPane.DEFAULT_LAYER);
+
+        cY += h + PAD;
+        desktop.repaint();
+    }
+}
--- a/src/main/java/io/swtc/proccessing/ui/desktop/DesktopIcon.java
+++ b/src/main/java/io/swtc/proccessing/ui/desktop/DesktopIcon.java
@@ -0,0 +1,107 @@
+package io.swtc.proccessing.ui.desktop;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+public class DesktopIcon extends JPanel {
+
+    private boolean hovered = false;
+
+    private final JLabel iconLabel;
+    private final JLabel textLabel;
+
+    public DesktopIcon(String label, Icon icon, Runnable action) {
+
+        setLayout(new BorderLayout(4, 4));
+        setOpaque(false);
+
+        if (icon instanceof ImageIcon) {
+            Image img = ((ImageIcon) icon).getImage();
+            Image scaled = img.getScaledInstance(64, 64, Image.SCALE_SMOOTH);
+            icon = new ImageIcon(scaled);
+        }
+
+        iconLabel = new JLabel(icon, SwingConstants.CENTER);
+        textLabel = new ShadowLabel(label);
+        textLabel.setHorizontalAlignment(SwingConstants.CENTER);
+
+        add(iconLabel, BorderLayout.CENTER);
+        add(textLabel, BorderLayout.SOUTH);
+
+        addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                if (SwingUtilities.isLeftMouseButton(e) && e.getClickCount() == 2) {
+                    if (action != null) action.run();
+                }
+            }
+
+            @Override
+            public void mouseEntered(MouseEvent e) {
+                hovered = true;
+                repaint();
+            }
+
+            @Override
+            public void mouseExited(MouseEvent e) {
+                hovered = false;
+                repaint();
+            }
+        });
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        Dimension icon = iconLabel.getPreferredSize();
+        Dimension text = textLabel.getPreferredSize();
+
+        int w = Math.max(icon.width, text.width) + 12;
+        int h = icon.height + text.height + 12;
+
+        return new Dimension(w, h);
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (hovered) {
+            Graphics2D g2 = (Graphics2D) g.create();
+            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                    RenderingHints.VALUE_ANTIALIAS_ON);
+
+            boolean lightBg = isBackgroundLight();
+
+            Color fill = lightBg
+                    ? new Color(0, 0, 0, 30)
+                    : new Color(255, 255, 255, 40);
+
+            Color border = lightBg
+                    ? new Color(0, 0, 0, 80)
+                    : new Color(255, 255, 255, 100);
+
+            g2.setColor(fill);
+            g2.fillRoundRect(2, 2, getWidth() - 4, getHeight() - 4, 10, 10);
+
+            g2.setColor(border);
+            g2.drawRoundRect(2, 2, getWidth() - 5, getHeight() - 5, 10, 10);
+
+            g2.dispose();
+        }
+
+        super.paintComponent(g);
+    }
+
+    private boolean isBackgroundLight() {
+        Container p = getParent();
+        if (p == null) return true;
+
+        Color bg = p.getBackground();
+        int luminance = (int) (
+                bg.getRed() * 0.299 +
+                        bg.getGreen() * 0.587 +
+                        bg.getBlue() * 0.114
+        );
+        return luminance > 180;
+    }
+}
--- a/src/main/java/io/swtc/proccessing/ui/desktop/ShadowLabel.java
+++ b/src/main/java/io/swtc/proccessing/ui/desktop/ShadowLabel.java
@@ -0,0 +1,32 @@
+package io.swtc.proccessing.ui.desktop;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class ShadowLabel extends JLabel {
+    public ShadowLabel(String text) {
+        super(text, SwingConstants.CENTER);
+        setForeground(Color.WHITE);
+        setPreferredSize(new Dimension(15, 20));
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        Graphics2D g2d = (Graphics2D) g.create();
+        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+
+        FontMetrics fm = g2d.getFontMetrics();
+        String text = getText();
+
+        int x = (getWidth() - fm.stringWidth(text)) / 2;
+        int y = ((getHeight() - fm.getHeight()) / 2) + fm.getAscent();
+
+        g2d.setColor(new Color(0, 0, 0, 200));
+        g2d.drawString(text, x + 1, y + 1);
+
+        g2d.setColor(getForeground());
+        g2d.drawString(text, x, y);
+
+        g2d.dispose();
+    }
+}
--- a/src/main/java/io/swtc/proccessing/ui/desktop/evidence/EvidenceExportFrame.java
+++ b/src/main/java/io/swtc/proccessing/ui/desktop/evidence/EvidenceExportFrame.java
@@ -0,0 +1,110 @@
+package io.swtc.proccessing.ui.desktop.evidence;
+
+import io.swtc.proccessing.ui.ShowError;
+import io.swtc.recording.evidence.USBExportManager;
+
+import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+import java.awt.*;
+import java.nio.file.Path;
+import java.io.File;
+
+public class EvidenceExportFrame extends JFrame {
+
+    private final JProgressBar progressBar;
+    private final JLabel statusLabel;
+    private final JLabel detailLabel;
+    private final JButton actionBtn;
+
+    private EvidenceExportFrame(Path sourceDir, Path usbTargetDir) {
+        setTitle("Export");
+        setSize(400, 220);
+        setLocationRelativeTo(null);
+        setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+
+        JPanel contentPane = new JPanel();
+        contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));
+        contentPane.setBorder(new EmptyBorder(25, 25, 25, 25));
+
+        statusLabel = new JLabel("Starting export");
+        statusLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+        statusLabel.setFont(new Font(statusLabel.getFont().getName(), Font.BOLD, 14));
+        detailLabel = new JLabel("Initializing");
+        detailLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+        detailLabel.setForeground(Color.GRAY);
+
+        progressBar = new JProgressBar(0, 100);
+        progressBar.setAlignmentX(Component.LEFT_ALIGNMENT);
+        progressBar.setMaximumSize(new Dimension(Integer.MAX_VALUE, 20));
+
+        actionBtn = new JButton("Cancel");
+        actionBtn.setAlignmentX(Component.LEFT_ALIGNMENT);
+        contentPane.add(statusLabel);
+        contentPane.add(Box.createRigidArea(new Dimension(0, 10)));
+        contentPane.add(detailLabel);
+        contentPane.add(Box.createRigidArea(new Dimension(0, 20)));
+        contentPane.add(progressBar);
+        contentPane.add(Box.createVerticalGlue());
+        contentPane.add(actionBtn);
+
+        add(contentPane);
+
+        actionBtn.addActionListener(e -> handleAction());
+
+        setVisible(true);
+        startExport(sourceDir, usbTargetDir);
+    }
+
+    private void handleAction() {
+        if (actionBtn.getText().equals("Close")) {
+            dispose();
+            return;
+        }
+
+        int confirm = JOptionPane.showConfirmDialog(this,
+                "Stop export?", "Confirm", JOptionPane.YES_NO_OPTION);
+        if (confirm == JOptionPane.YES_OPTION) dispose();
+    }
+
+    private void startExport(Path sourceDir, Path usbTargetDir) {
+        USBExportManager.exportAsync(
+                sourceDir,
+                usbTargetDir,
+                stats -> SwingUtilities.invokeLater(() -> {
+                    progressBar.setValue(stats.percent());
+                    statusLabel.setText("Exporting  " + stats.percent() + "%");
+                    detailLabel.setText(String.format("%s | %s remaining",
+                            stats.getSpeedMBps(), stats.timeLeft()));
+                }),
+                () -> SwingUtilities.invokeLater(() -> {
+                    progressBar.setValue(100);
+                    statusLabel.setText("Export Complete");
+                    detailLabel.setText("Files saved");
+                    actionBtn.setText("Close");
+                    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+                }),
+                ex -> SwingUtilities.invokeLater(() -> {
+                    statusLabel.setText("Export Failed");
+                    detailLabel.setText(ex.getMessage());
+                    ShowError.error(this, ex.getMessage(), "Error");
+                })
+        );
+    }
+
+    public static void showExport() {
+        SwingUtilities.invokeLater(() -> {
+            File videoDir = new File(System.getProperty("user.home"), "Videos/swtcctv-rec");
+            if (!videoDir.exists()) {
+                ShowError.warning(null, "No recordings found.", "Not Found");
+                return;
+            }
+
+            JFileChooser chooser = new JFileChooser();
+            chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+            if (chooser.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
+                Path target = chooser.getSelectedFile().toPath().resolve("swtcctv-rec_" + System.currentTimeMillis() / 1000);
+                new EvidenceExportFrame(videoDir.toPath(), target);
+            }
+        });
+    }
+}
--- a/src/main/java/io/swtc/proccessing/ui/iframe/CameraInternalFrame.java
+++ b/src/main/java/io/swtc/proccessing/ui/iframe/CameraInternalFrame.java
@@ -5,23 +5,13 @@ import io.swtc.proccessing.WebcamCaptureLoop;
 import io.swtc.proccessing.CameraPanel;
 import io.swtc.proccessing.ui.IconSetter;
 import io.swtc.proccessing.ui.ShowError;
-import io.swtc.recording.RecordingManager;
-import io.swtc.recording.VideoRecorder;
-import javax.imageio.ImageIO;
 import javax.swing.*;
-import javax.swing.border.EmptyBorder;
 import java.awt.*;
-import java.awt.image.BufferedImage;
-import java.awt.image.RescaleOp;
-import java.io.File;
-import java.io.IOException;
 import java.util.function.Consumer;

 public class CameraInternalFrame extends JInternalFrame {
    private final WebcamCaptureLoop captureLoop;
    private final CameraPanel cameraPanel;
-    private final VideoRecorder videoRecorder;
-    private final RecordingManager recordingManager;

    public CameraInternalFrame(Webcam webcam, Consumer<CameraInternalFrame> onOpenEffects) {
        super(webcam.getName(), true, true, true, true);
@@ -30,12 +20,8 @@ public class CameraInternalFrame extends JInternalFrame {
        setFrameIcon(new ImageIcon(ico));

        this.cameraPanel = new CameraPanel();
-        this.videoRecorder = new VideoRecorder();
-        this.recordingManager = new RecordingManager(cameraPanel); // Initialize recorder

-        this.captureLoop = new WebcamCaptureLoop(webcam, img ->
-            SwingUtilities.invokeLater(() -> cameraPanel.setImage(img))
-        );
+        this.captureLoop = new WebcamCaptureLoop(webcam, cameraPanel::setImage);

        setupUI(onOpenEffects);
        captureLoop.start();
@@ -49,7 +35,7 @@ public class CameraInternalFrame extends JInternalFrame {

        tabbedPane.addChangeListener(e -> {
            int index = tabbedPane.getSelectedIndex();
-            if (index == 1) { // the tab index for capture is 1
+            if (index == 1) {
                tabbedPane.setSelectedIndex(0);
                openRecordingFrame();
            } else if (index == 2) {
@@ -63,17 +49,16 @@ public class CameraInternalFrame extends JInternalFrame {
    }

    private void openRecordingFrame() {
-        RecordingFrame rf = new RecordingFrame(this.getTitle(),cameraPanel, videoRecorder);
+        RecordingFrame rf = new RecordingFrame(this.getTitle(), cameraPanel);
        JDesktopPane desktopPane = getDesktopPane();
        if (desktopPane != null) {
            desktopPane.add(rf);
            rf.setVisible(true);
-        }
-
-        try {
-            rf.setSelected(true);
-        } catch (java.beans.PropertyVetoException veto) {
-            ShowError.error(null,"VetoException"+veto.getMessage(),"veto");
+            try {
+                rf.setSelected(true);
+            } catch (java.beans.PropertyVetoException veto) {
+                ShowError.error(null, "Focus Error: " + veto.getMessage(), "Error");
+            }
        }
    }

@@ -81,9 +66,6 @@ public class CameraInternalFrame extends JInternalFrame {

    @Override
    public void dispose() {
-        if (videoRecorder.isRecording()) {
-            try { videoRecorder.stopRecording(); } catch (IOException ignored) {}
-        }
        captureLoop.stop();
        super.dispose();
    }
--- a/src/main/java/io/swtc/proccessing/ui/iframe/DesktopPane.java
+++ b/src/main/java/io/swtc/proccessing/ui/iframe/DesktopPane.java
@@ -2,7 +2,6 @@ package io.swtc.proccessing.ui.iframe;

 import javax.swing.*;
 import java.awt.*;
-import java.awt.geom.CubicCurve2D;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Random;
@@ -38,29 +37,8 @@ public class DesktopPane extends JDesktopPane {

            if (camera.isVisible() && effects.isVisible() && !camera.isIcon() && !effects.isIcon()) {
                g2d.setColor(getConnectionColor(camera));
-                drawBezierConnection(g2d, camera, effects);
            }
        }
        g2d.dispose();
    }
-
-    private void drawBezierConnection(Graphics2D g2d, JInternalFrame from, JInternalFrame to) {
-        Rectangle f = from.getBounds();
-        Rectangle t = to.getBounds();
-
-        int x1 = f.x + f.width;
-        int y1 = f.y + (f.height / 2);
-        int x2 = t.x;
-        int y2 = t.y + (t.height / 2);
-
-        int ctrlOffset = Math.min(Math.abs(x2 - x1) / 2, 150);
-        CubicCurve2D curve = new CubicCurve2D.Double(x1, y1, x1 + ctrlOffset, y1, x2 - ctrlOffset, y2, x2, y2);
-
-        //g2d.setStroke(new BasicStroke(3f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
-        //g2d.draw(curve);
-
-        // Terminals
-        //g2d.fillOval(x1 - 5, y1 - 5, 10, 10);
-        //g2d.fillOval(x2 - 5, y2 - 5, 10, 10);
-    }
 }
--- a/src/main/java/io/swtc/proccessing/ui/iframe/RecordingFrame.java
+++ b/src/main/java/io/swtc/proccessing/ui/iframe/RecordingFrame.java
@@ -3,7 +3,10 @@ package io.swtc.proccessing.ui.iframe;
 import io.swtc.proccessing.CameraPanel;
 import io.swtc.proccessing.ui.IconSetter;
 import io.swtc.proccessing.ui.ShowError;
-import io.swtc.recording.VideoRecorder;
+import io.swtc.proccessing.ui.sections.recording.ExportSection;
+import io.swtc.recording.cv.AVRecorder;
+import io.swtc.recording.cv.Quality;
+import io.swtc.recording.cv.RecorderConfig;

 import javax.swing.*;
 import java.awt.*;
@@ -13,30 +16,31 @@ import java.io.IOException;
 import javax.imageio.ImageIO;

 public class RecordingFrame extends JInternalFrame {
-    private final VideoRecorder videoRecorder;
+    private AVRecorder avRecorder;
+    private ExportSection exportSection;
    private final CameraPanel cameraPanel;

    private JButton recordBtn;
    private JLabel statusLabel;
    private JLabel statsLabel;
+    private JComboBox<Quality> presetCombo;

-    private File outputDirectory = new File(System.getProperty("user.home"));
+    private File outputDirectory;
    private File currentFile;
    private final Timer statsTimer;
    private long startTime;

-
-    // Cache for string building to avoid object allocation every second
    private final StringBuilder sb = new StringBuilder(32);

-    public RecordingFrame(String cameraName, CameraPanel cameraPanel, VideoRecorder videoRecorder) {
+    public RecordingFrame(String cameraName, CameraPanel cameraPanel) {
        super(cameraName + " Capture", true, true, false, true);

+        setupDirectory();
+
        Image ico = IconSetter.getIcon();
        setFrameIcon(new ImageIcon(ico));

        this.cameraPanel = cameraPanel;
-        this.videoRecorder = videoRecorder;

        initializeUI();

@@ -46,133 +50,172 @@ public class RecordingFrame extends JInternalFrame {
        pack();
    }

+    private void setupDirectory() {
+        File videoDir = new File(System.getProperty("user.home"), "Videos");
+        outputDirectory = new File(videoDir, "swtcctv-rec");
+
+        if (!outputDirectory.exists()) {
+            outputDirectory.mkdirs();
+        }
+    }
+
    private void initializeUI() {
        JPanel mainContent = new JPanel();
        mainContent.setLayout(new BoxLayout(mainContent, BoxLayout.Y_AXIS));
        mainContent.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));

-        mainContent.add(createStoragePanel());
+        exportSection = new ExportSection(this, outputDirectory, statusLabel);
+        JPanel settingsPanel = createSettingsPanel();
+        JPanel statsPanel = createStatsPanel();
+        JPanel actionPanel = createActionPanel();
+
+        mainContent.add(exportSection);
        mainContent.add(Box.createVerticalStrut(10));
-        mainContent.add(createActionPanel());
+
+        mainContent.add(settingsPanel);
        mainContent.add(Box.createVerticalStrut(10));
-        mainContent.add(createStatsPanel());
+
+        mainContent.add(statsPanel);
+        mainContent.add(Box.createVerticalStrut(10));
+
+        mainContent.add(actionPanel);

        getContentPane().add(mainContent);
    }

+    private JPanel createSettingsPanel() {
+        JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT));
+        panel.setBorder(BorderFactory.createTitledBorder("Encoding Settings"));
+
+        presetCombo = new JComboBox<>(Quality.values());
+        presetCombo.setSelectedItem(Quality.SUPERFAST); // Default
+
+        panel.add(new JLabel("CPU Preset:"));
+        panel.add(presetCombo);
+
+        // Disable combo box during recording to prevent mid-stream config changes
+        return panel;
+    }
+
    private JPanel createStatsPanel() {
        JPanel panel = new JPanel(new GridLayout(2, 1));
        panel.setBorder(BorderFactory.createTitledBorder("Session Info"));

        statusLabel = new JLabel("Status: Idle");
-
        statsLabel = new JLabel("Length: 00:00 | Size: 0.00 MB");
        statsLabel.setFont(new Font("Monospaced", Font.PLAIN, 12));

-        statsLabel.setPreferredSize(new Dimension(220, 20));
-
        panel.add(statusLabel);
        panel.add(statsLabel);
        return panel;
    }

-    private void updateStats() {
-        if (!videoRecorder.isRecording() || currentFile == null) return;
-
-        long elapsedSecs = (System.currentTimeMillis() - startTime) / 1000;
-        long minutes = elapsedSecs / 60;
-        long seconds = elapsedSecs % 60;
-
-        double sizeInMb = currentFile.length() / 1048576.0;
-
-        sb.setLength(0);
-        sb.append("Length: ")
-                .append(minutes < 10 ? "0" : "").append(minutes).append(":")
-                .append(seconds < 10 ? "0" : "").append(seconds)
-                .append(" | Size: ")
-                .append(Math.round(sizeInMb * 100.0) / 100.0)
-                .append(" MB");
-
-        statsLabel.setText(sb.toString());
-    }
-
-    private void toggleRecording() {
-        if (!videoRecorder.isRecording()) {
-            startRec();
-        } else {
-            stopRec();
-        }
-    }
-
-    private void startRec() {
-        try {
-            currentFile = new File(outputDirectory, "vid_" + System.currentTimeMillis() + ".mp4");
-            videoRecorder.startRecording(cameraPanel, currentFile);
-
-            startTime = System.currentTimeMillis();
-            statsTimer.start(); // Only run timer when needed
-
-            recordBtn.setText("Stop Recording");
-            statusLabel.setText("Currently Recording");
-        } catch (IOException ex) {
-            ShowError.error(null,"Error starting Recording" + ex.getMessage(), "Error");
-        }
-    }
-
-    private void stopRec() {
-        try {
-            videoRecorder.stopRecording();
-            statsTimer.stop();
-
-            recordBtn.setText("Started Recording");
-            recordBtn.setForeground(null);
-            statusLabel.setText("Finished recording");
-        } catch (IOException ex) {
-            ShowError.error(null,"RecordStop Error"+ex.getMessage(), "Error");
-        }
-    }
-
-    private JPanel createStoragePanel() {
-        JPanel panel = new JPanel(new BorderLayout(5, 5));
-        panel.setBorder(BorderFactory.createTitledBorder("Storage"));
-        JTextField pathField = new JTextField(outputDirectory.getAbsolutePath());
-        pathField.setEditable(false);
-        JButton browseBtn = new JButton("...");
-        browseBtn.addActionListener(e -> {
-            JFileChooser chooser = new JFileChooser(outputDirectory);
-            chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
-            if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
-                outputDirectory = chooser.getSelectedFile();
-                pathField.setText(outputDirectory.getAbsolutePath());
-            }
-        });
-        panel.add(pathField, BorderLayout.CENTER);
-        panel.add(browseBtn, BorderLayout.EAST);
-        return panel;
-    }
-
    private JPanel createActionPanel() {
        JPanel panel = new JPanel(new GridLayout(1, 2, 5, 5));
        recordBtn = new JButton("Start Recording");
        recordBtn.addActionListener(e -> toggleRecording());
+
        JButton snapBtn = new JButton("Snapshot");
        snapBtn.addActionListener(e -> takeSnapshot());
+
        panel.add(recordBtn);
        panel.add(snapBtn);
        return panel;
    }

+    private void startRec() {
+        BufferedImage sample = cameraPanel.getCurrentProcessedImage();
+        if (sample == null) {
+            ShowError.warning(this, "No camera feed detected.", "Warning");
+            return;
+        }
+
+        try {
+            currentFile = new File(outputDirectory, "vid_" + System.currentTimeMillis() + ".mp4");
+
+            Quality selected = (Quality) presetCombo.getSelectedItem();
+            String preset = (selected != null) ? selected.getFFmpegValue() : "superfast";
+
+            RecorderConfig config = new RecorderConfig(
+                    currentFile,
+                    sample.getWidth(),
+                    sample.getHeight(),
+                    20,
+                    18,
+                    preset
+            );
+
+            avRecorder = new AVRecorder(config);
+            avRecorder.start();
+
+            cameraPanel.setExternalRecorder(avRecorder);
+
+            startTime = System.currentTimeMillis();
+            statsTimer.start();
+
+            // UI Feedback
+            presetCombo.setEnabled(false); // Lock settings during recording
+            recordBtn.setText("Stop Recording");
+            recordBtn.setForeground(Color.RED);
+            statusLabel.setText("Recording...");
+        } catch (Exception ex) {
+            ShowError.error(this, "Failed to start: " + ex.getMessage(), "Error");
+        }
+    }
+
+    private void stopRec() {
+        if (avRecorder != null) {
+            statusLabel.setText("Finalizing file...");
+            avRecorder.stop();
+            cameraPanel.setExternalRecorder(null);
+        }
+
+        statsTimer.stop();
+        presetCombo.setEnabled(true); // Unlock settings
+        recordBtn.setText("Start Recording");
+        recordBtn.setForeground(null);
+
+        String fileName = (currentFile != null) ? currentFile.getName() : "N/A";
+        statusLabel.setText("File saved: " + fileName);
+    }
+
+    private void toggleRecording() {
+        if (avRecorder == null || !avRecorder.isRecording()) {
+            startRec();
+        } else {
+            stopRec();
+        }
+    }
+
+    private void updateStats() {
+        if (avRecorder == null || !avRecorder.isRecording() || currentFile == null) return;
+
+        long elapsedSecs = (System.currentTimeMillis() - startTime) / 1000;
+        long minutes = elapsedSecs / 60;
+        long seconds = elapsedSecs % 60;
+        double sizeInMb = currentFile.length() / 1048576.0;
+
+        sb.setLength(0);
+        sb.append("Length: ")
+                .append(minutes < 10 ? "0" : "").append(minutes).append(":")
+                .append(seconds < 10 ? "0" : "").append(seconds)
+                .append(" | Size: ")
+                .append(String.format("%.2f", sizeInMb))
+                .append(" MB");
+
+        statsLabel.setText(sb.toString());
+    }
+
    private void takeSnapshot() {
        BufferedImage img = cameraPanel.getCurrentProcessedImage();
        if (img != null) {
            try {
                File file = new File(outputDirectory, "snap_" + System.currentTimeMillis() + ".png");
                ImageIO.write(img, "PNG", file);
-                statusLabel.setText("Saved a Snapshot");
+                statusLabel.setText("Snapshot: " + file.getName());
            } catch (IOException ex) {
-                ShowError.error(null,"Snapshot failed"+ex.getMessage(),"Snapshot Error");
+                ShowError.error(this, "Snapshot failed: " + ex.getMessage(), "Error");
            }
        }
    }
-
 }
--- a/src/main/java/io/swtc/proccessing/ui/sections/recording/ExportSection.java
+++ b/src/main/java/io/swtc/proccessing/ui/sections/recording/ExportSection.java
@@ -0,0 +1,132 @@
+package io.swtc.proccessing.ui.sections.recording;
+
+import io.swtc.proccessing.ui.ShowError;
+import io.swtc.recording.evidence.USBExportManager;
+
+import javax.swing.*;
+import java.awt.*;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+
+public class ExportSection extends JPanel {
+    private final Component parent;
+    private File sourceDirectory;
+    private final JLabel statusLabel;
+    private final JTextField pathField;
+
+    public ExportSection(Component parent, File initialSource, JLabel statusLabel) {
+        this.parent = parent;
+        this.sourceDirectory = initialSource;
+        this.statusLabel = new JLabel("", SwingConstants.CENTER);
+
+
+        setLayout(new BorderLayout());
+
+        this.pathField = new JTextField(sourceDirectory.getAbsolutePath());
+        this.pathField.setEditable(false);
+
+        JTabbedPane tabbedPane = new JTabbedPane();
+        tabbedPane.addTab("Storage Settings", createSettingsTab());
+        tabbedPane.addTab("Evidence-Export", createTransferTab());
+
+
+        add(tabbedPane, BorderLayout.CENTER);
+    }
+
+    private JPanel createTransferTab() {
+        JPanel panel = new JPanel(new GridBagLayout());
+        panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+        GridBagConstraints gbc = new GridBagConstraints();
+        gbc.fill = GridBagConstraints.HORIZONTAL;
+        gbc.weightx = 1.0;
+
+        JButton exportBtn = new JButton("Export all Evidence");
+        exportBtn.addActionListener(e -> startUsbExport());
+
+        JLabel infoLabel = new JLabel("<html><small>" +
+                "Export Evidence (Can also be done via Desktop)" +
+                "</small></html>");
+
+        gbc.gridy = 0;
+        panel.add(exportBtn, gbc);
+        gbc.gridy = 1;
+        gbc.insets = new Insets(10, 0, 0, 0);
+        panel.add(infoLabel, gbc);
+
+        return panel;
+    }
+
+    private JPanel createSettingsTab() {
+        JPanel panel = new JPanel(new BorderLayout(5, 5));
+        panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+
+        JButton browseBtn = new JButton("Change Folder");
+        browseBtn.addActionListener(e -> changeSourceDirectory());
+
+        panel.add(new JLabel("Recording Path:"), BorderLayout.NORTH);
+        panel.add(pathField, BorderLayout.CENTER);
+        panel.add(browseBtn, BorderLayout.SOUTH);
+
+        return panel;
+    }
+
+    private void changeSourceDirectory() {
+        JFileChooser chooser = new JFileChooser(sourceDirectory);
+        chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+        if (chooser.showOpenDialog(parent) == JFileChooser.APPROVE_OPTION) {
+            this.sourceDirectory = chooser.getSelectedFile();
+            this.pathField.setText(sourceDirectory.getAbsolutePath());
+        }
+    }
+
+    private void startUsbExport() {
+        JFileChooser chooser = new JFileChooser();
+        chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+        chooser.setDialogTitle("Select USB Destination");
+
+        if (chooser.showSaveDialog(parent) != JFileChooser.APPROVE_OPTION) return;
+
+        Path usbRoot = chooser.getSelectedFile().toPath();
+        Path exportTarget = usbRoot.resolve("");
+
+        try {
+            long size = USBExportManager.calculateDirectorySize(sourceDirectory.toPath());
+
+            if (!USBExportManager.hasEnoughSpace(usbRoot, size)) {
+                ShowError.error(parent, "Not enough space on USB device.", "Export failed");
+                return;
+            }
+
+            JProgressBar bar = new JProgressBar(0, 100);
+            bar.setStringPainted(true);
+
+            JDialog dialog = new JDialog(SwingUtilities.getWindowAncestor(parent), "Exporting Data...");
+            dialog.setLayout(new BorderLayout());
+            dialog.add(new JLabel("Copying files ...", JLabel.CENTER), BorderLayout.NORTH);
+            dialog.add(bar, BorderLayout.CENTER);
+            dialog.setSize(300, 100);
+            dialog.setLocationRelativeTo(parent);
+            dialog.setModal(true);
+
+            USBExportManager.exportAsync(
+                    sourceDirectory.toPath(),
+                    exportTarget,
+                    stats -> SwingUtilities.invokeLater(() -> bar.setValue(stats.percent())),
+                    () -> {
+                        dialog.dispose();
+                        statusLabel.setText("Export completed successfully.");
+                    },
+                    ex -> {
+                        dialog.dispose();
+                        ShowError.error(parent, "Export error: " + ex.getMessage(), "Error");
+                    }
+            );
+
+            dialog.setVisible(true);
+
+        } catch (IOException ex) {
+            ShowError.error(parent, "IO Error: " + ex.getMessage(), "Export error");
+        }
+    }
+}
--- a/src/main/java/io/swtc/recording/RecordingManager.java
+++ b/src/main/java/io/swtc/recording/RecordingManager.java
@@ -1,70 +0,0 @@
-package io.swtc.recording;
-
-import io.swtc.proccessing.CameraPanel;
-import javax.swing.*;
-import java.awt.*;
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.util.function.Consumer;
-
-public class RecordingManager {
-    private final VideoRecorder recorder;
-    private final CameraPanel cameraPanel;
-
-    // Reuse a single buffer to avoid constant memory allocation (GC pressure)
-    private BufferedImage reuseBuffer;
-
-    public RecordingManager(CameraPanel cameraPanel) {
-        this.cameraPanel = cameraPanel;
-        this.recorder = new VideoRecorder();
-    }
-
-    public BufferedImage fastConvertToRGB(BufferedImage source) {
-        if (source.getType() == BufferedImage.TYPE_INT_RGB) {
-            return source;
-        }
-
-        // Initialize or resize reuseBuffer only when necessary
-        if (reuseBuffer == null ||
-                reuseBuffer.getWidth() != source.getWidth() ||
-                reuseBuffer.getHeight() != source.getHeight()) {
-            reuseBuffer = new BufferedImage(source.getWidth(), source.getHeight(), BufferedImage.TYPE_INT_RGB);
-        }
-
-        // Graphics2D.drawImage is much faster than manual setRGB loops
-        Graphics2D g = reuseBuffer.createGraphics();
-        g.drawImage(source, 0, 0, null);
-        g.dispose();
-
-        return reuseBuffer;
-    }
-
-    public void toggleRecording(File outputFile, Runnable onStart, Consumer<File> onStop, Consumer<Exception> onError) {
-        if (!recorder.isRecording()) {
-            new SwingWorker<Void, Void>() {
-                @Override
-                protected Void doInBackground() throws Exception {
-                    recorder.startRecording(cameraPanel, outputFile);
-                    return null;
-                }
-                @Override
-                protected void done() {
-                    try { get(); if (onStart != null) onStart.run(); }
-                    catch (Exception e) { if (onError != null) onError.accept(e); }
-                }
-            }.execute();
-        } else {
-            new SwingWorker<File, Void>() {
-                @Override
-                protected File doInBackground() throws Exception {
-                    return recorder.stopRecording();
-                }
-                @Override
-                protected void done() {
-                    try { File f = get(); if (onStop != null) onStop.accept(f); }
-                    catch (Exception e) { if (onError != null) onError.accept(e); }
-                }
-            }.execute();
-        }
-    }
-}
--- a/src/main/java/io/swtc/recording/VideoRecorder.java
+++ b/src/main/java/io/swtc/recording/VideoRecorder.java
@@ -1,87 +0,0 @@
-package io.swtc.recording;
-
-import io.swtc.proccessing.CameraPanel;
-import org.jcodec.api.awt.AWTSequenceEncoder;
-import org.jcodec.common.io.NIOUtils;
-import org.jcodec.common.io.SeekableByteChannel;
-import org.jcodec.common.model.Rational;
-
-import java.awt.*;
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.IOException;
-import java.util.concurrent.*;
-
-public class VideoRecorder {
-    private volatile boolean recording = false;
-    private File outputFile;
-    private AWTSequenceEncoder encoder;
-    private SeekableByteChannel channel;
-    private static final int FPS = 30;
-
-    private LinkedBlockingQueue<BufferedImage> frameQueue;
-    private ExecutorService workerThread;
-
-    public void startRecording(CameraPanel panel, File output) throws IOException {
-        this.outputFile = output;
-        this.channel = NIOUtils.writableFileChannel(output.getAbsolutePath());
-        this.encoder = new AWTSequenceEncoder(channel, Rational.R(FPS, 1));
-
-        this.frameQueue = new LinkedBlockingQueue<>(60);
-        this.recording = true;
-
-        workerThread = Executors.newSingleThreadExecutor();
-        workerThread.submit(this::processQueue);
-
-        new Thread(() -> {
-            while (recording) {
-                try {
-                    BufferedImage img = panel.getCurrentProcessedImage();
-                    if (img != null) {
-                        BufferedImage copy = snapshotToRGB(img);
-                        frameQueue.offer(copy);
-                    }
-                    Thread.sleep(1000 / FPS);
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                }
-            }
-        }).start();
-    }
-
-    private void processQueue() {
-        while (recording || !frameQueue.isEmpty()) {
-            try {
-                BufferedImage img = frameQueue.poll(500, TimeUnit.MILLISECONDS);
-                if (img != null) {
-                    encoder.encodeImage(img);
-                }
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    private BufferedImage snapshotToRGB(BufferedImage source) {
-        BufferedImage rgb = new BufferedImage(source.getWidth(), source.getHeight(), BufferedImage.TYPE_INT_RGB);
-        Graphics2D g = rgb.createGraphics();
-        g.drawImage(source, 0, 0, null);
-        g.dispose();
-        return rgb;
-    }
-
-    public File stopRecording() throws IOException {
-        recording = false;
-        workerThread.shutdown();
-        try {
-            workerThread.awaitTermination(5, TimeUnit.SECONDS);
-            if (encoder != null) encoder.finish();
-            if (channel != null) channel.close();
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-        }
-        return outputFile;
-    }
-
-    public boolean isRecording() { return recording; }
-}
--- a/src/main/java/io/swtc/recording/cv/AVRecorder.java
+++ b/src/main/java/io/swtc/recording/cv/AVRecorder.java
@@ -0,0 +1,60 @@
+package io.swtc.recording.cv;
+
+import io.swtc.proccessing.ui.ShowError;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+public class AVRecorder {
+    private final BlockingQueue<BufferedImage> queue = new LinkedBlockingQueue<>(120);
+    private final RecorderConfig config;
+    private volatile boolean running = false;
+
+    public AVRecorder(RecorderConfig config) {
+        this.config = config;
+    }
+
+    public void start() {
+        running = true;
+        Thread worker = new Thread(this::runLoop, "Recording-Worker");
+        worker.start();
+    }
+
+    private void runLoop() {
+        FrameProccessor processor = new FrameProccessor();
+        MediaSink sink = null;
+
+        try {
+            while (running || !queue.isEmpty()) {
+                BufferedImage img = queue.poll(500, TimeUnit.MILLISECONDS);
+                if (img == null) continue;
+
+                if (sink == null) {
+                    sink = new MediaSink(config);
+                }
+
+                sink.write(processor.convert(img));
+            }
+        } catch (Exception e) {
+            ShowError.error(null,"Error in AVRecorder", "AVRecorder isn't responding!");
+        } finally {
+            if (sink != null) sink.stop();
+            processor.close();
+        }
+    }
+
+    public void accept(BufferedImage img) {
+        if (!queue.offer(img)) {
+            System.err.println("Recorder lag: Frame dropped");
+        }
+    }
+
+    public boolean isRecording() { return running; }
+
+    public void stop() {
+        running = false;
+    }
+}
--- a/src/main/java/io/swtc/recording/cv/FrameProccessor.java
+++ b/src/main/java/io/swtc/recording/cv/FrameProccessor.java
@@ -0,0 +1,33 @@
+package io.swtc.recording.cv;
+
+import org.bytedeco.javacv.Frame;
+import org.bytedeco.javacv.Java2DFrameConverter;
+
+import java.awt.image.BufferedImage;
+import java.util.Objects;
+
+public class FrameProccessor {
+    private final Java2DFrameConverter converter = new Java2DFrameConverter();
+    private BufferedImage reuseImg;
+
+    public Frame convert(BufferedImage rawImg) {
+        if (Objects.isNull(reuseImg)) {
+            reuseImg = new BufferedImage(
+                    rawImg.getWidth(),
+                    rawImg.getHeight(),
+                    BufferedImage.TYPE_3BYTE_BGR
+            );
+        }
+
+        var g = reuseImg.createGraphics();
+        g.drawImage(rawImg, 0, 0, null);
+        g.dispose();
+
+        return converter.getFrame(reuseImg);
+    }
+
+    public void close() {
+        converter.close();
+        if (!Objects.isNull(reuseImg)) { reuseImg.flush(); }
+    }
+}
--- a/src/main/java/io/swtc/recording/cv/MediaSink.java
+++ b/src/main/java/io/swtc/recording/cv/MediaSink.java
@@ -0,0 +1,49 @@
+package io.swtc.recording.cv;
+
+import org.bytedeco.ffmpeg.global.avcodec;
+import org.bytedeco.javacv.FFmpegFrameRecorder;
+
+import org.bytedeco.ffmpeg.global.avutil;
+import org.bytedeco.javacv.Frame;
+
+public class MediaSink {
+    private final FFmpegFrameRecorder recorder;
+    private final long startNanos;
+
+    public MediaSink(RecorderConfig config) throws Exception {
+        this.recorder = new FFmpegFrameRecorder(config.outputFile(), config.width(), config.height());
+        this.startNanos = System.nanoTime();
+
+        avutil.av_log_set_level(avutil.AV_LOG_ERROR);
+
+        recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
+        recorder.setFormat("mp4");
+        recorder.setPixelFormat(avutil.AV_PIX_FMT_BGR24);
+        recorder.setFrameRate(config.fps());
+        /* this is essentially just building FFmpeg? Would've used ProccessBuilder for this lol */
+        recorder.setVideoOption("pixel_format", "yuv420p");
+        recorder.setVideoOption("preset", config.preset());
+        recorder.setVideoOption("crf", String.valueOf(config.crf()));
+        recorder.setVideoOption("tune", "zerolatency");
+        recorder.setVideoOption("x264opts", "keyint=40:min-keyint=20");
+        recorder.setVideoBitrate(0); // 0 tells the recorder to respect CRF strictly
+        recorder.setGopSize(config.fps() * 2);
+
+        recorder.start();
+    }
+
+    public void write(Frame frame) throws Exception {
+        long pts = (System.nanoTime() - startNanos) / 1000;
+        if (pts > recorder.getTimestamp()) {
+            recorder.setTimestamp(pts);
+            recorder.record(frame);
+        }
+    }
+
+    public void stop() {
+        try {
+            recorder.stop();
+            recorder.release();
+        } catch (Exception ignored) { /* Do absolutley nothing ;) */ }
+    }
+}
--- a/src/main/java/io/swtc/recording/cv/Quality.java
+++ b/src/main/java/io/swtc/recording/cv/Quality.java
@@ -0,0 +1,25 @@
+package io.swtc.recording.cv;
+
+public enum Quality {
+    ULTRAFAST("Ultrafast (Lowest CPU)"),
+    SUPERFAST("Superfast"),
+    VERYFAST("Very Fast"),
+    FASTER("Faster"),
+    FAST("Fast"),
+    MEDIUM("Medium (Best Quality/Size)");
+
+    private final String label;
+
+    Quality(String label) {
+        this.label = label;
+    }
+
+    public String getFFmpegValue() {
+        return this.name().toLowerCase();
+    }
+
+    @Override
+    public String toString() {
+        return label;
+    }
+}
--- a/src/main/java/io/swtc/recording/cv/RecorderConfig.java
+++ b/src/main/java/io/swtc/recording/cv/RecorderConfig.java
@@ -0,0 +1,12 @@
+package io.swtc.recording.cv;
+
+import java.io.File;
+
+public record RecorderConfig(
+        File outputFile,
+        int width,
+        int height,
+        int fps,
+        int crf, // Quality, 18 is high and 28 is low
+        String preset // ultrafast
+) { /* Record */ }
--- a/src/main/java/io/swtc/recording/evidence/ExportStats.java
+++ b/src/main/java/io/swtc/recording/evidence/ExportStats.java
@@ -0,0 +1,54 @@
+package io.swtc.recording.evidence;
+
+import java.util.concurrent.TimeUnit;
+
+public record ExportStats(
+        long totalBytes,
+        long copiedBytes,
+        long startTimeNanos,
+        String currentFileName
+) {
+
+    public int percent() {
+        if (totalBytes <= 0) return 0;
+        return (int) Math.min(100, (copiedBytes * 100) / totalBytes);
+    }
+
+    public String timeLeft() {
+        if (copiedBytes <= 0) return "Calculating...";
+
+        long elapsedNanos = System.nanoTime() - startTimeNanos;
+        if (elapsedNanos <= 0) return "Calculating...";
+
+        // Bytes per nanosecond
+        double bps = (double) copiedBytes / elapsedNanos;
+        long remainingBytes = totalBytes - copiedBytes;
+
+        if (remainingBytes <= 0) return "Done";
+
+        long remainingNanos = (long) (remainingBytes / bps);
+        return formatDuration(remainingNanos);
+    }
+
+    public String getSpeedMBps() {
+        long elapsedNanos = System.nanoTime() - startTimeNanos;
+        if (elapsedNanos <= 0 || copiedBytes <= 0) return "0 MB/s";
+
+        double seconds = elapsedNanos / 1_000_000_000.0;
+        double megabytes = copiedBytes / (1024.0 * 1024.0);
+        return String.format("%.1f MB/s", megabytes / seconds);
+    }
+
+    private static String formatDuration(long nanos) {
+        long totalSeconds = TimeUnit.NANOSECONDS.toSeconds(nanos);
+        if (totalSeconds < 1) return "less than a sec";
+
+        long mins = totalSeconds / 60;
+        long secs = totalSeconds % 60;
+
+        if (mins > 0) {
+            return String.format("%dm %ds", mins, secs);
+        }
+        return secs + "s";
+    }
+}
--- a/src/main/java/io/swtc/recording/evidence/USBExportManager.java
+++ b/src/main/java/io/swtc/recording/evidence/USBExportManager.java
@@ -0,0 +1,87 @@
+package io.swtc.recording.evidence;
+
+import java.io.IOException;
+import java.nio.file.*;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Stream;
+import java.util.function.Consumer;
+
+public class USBExportManager {
+
+    public static void exportAsync(Path source, Path target, Consumer<ExportStats> progress, Runnable onDone, Consumer<Throwable> onError) {
+        CompletableFuture.runAsync(() -> {
+            try {
+                performExport(source, target, progress);
+                onDone.run();
+            } catch (Exception e) {
+                onError.accept(e);
+            }
+        });
+    }
+
+    private static void performExport(Path source, Path target, Consumer<ExportStats> progress) throws IOException {
+        List<Path> allFiles;
+        try (Stream<Path> stream = Files.walk(source)) {
+            allFiles = stream.filter(Files::isRegularFile).toList();
+        }
+
+        long totalBytes = allFiles.stream().mapToLong(p -> p.toFile().length()).sum();
+
+        if (!hasEnoughSpace(target, totalBytes)) {
+            throw new IOException("Not enough space on target drive. Required: " + (totalBytes / 1024 / 1024) + " MB");
+        }
+
+        long totalCopied = 0;
+        long startTimeNanos = System.nanoTime();
+
+        for (Path file : allFiles) {
+            String fileName = file.getFileName().toString();
+
+            if (progress != null) {
+                progress.accept(new ExportStats(totalBytes, totalCopied, startTimeNanos, fileName));
+            }
+
+            Path relativePath = source.relativize(file);
+            Path destination = target.resolve(relativePath);
+
+            Files.createDirectories(destination.getParent());
+
+            Files.copy(file, destination, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES);
+
+            totalCopied += Files.size(file);
+
+            if (progress != null) {
+                progress.accept(new ExportStats(totalBytes, totalCopied, startTimeNanos, fileName));
+            }
+        }
+    }
+
+    public static boolean hasEnoughSpace(Path target, long requiredBytes) throws IOException {
+        Path root = target;
+        while (root != null && !Files.exists(root)) {
+            root = root.getParent();
+        }
+        if (root == null) return true;
+
+        FileStore store = Files.getFileStore(root);
+        return store.getUsableSpace() >= requiredBytes;
+    }
+
+
+    public static long calculateDirectorySize(Path dir) throws IOException {
+        if (dir == null || !Files.exists(dir)) return 0L;
+
+        try (Stream<Path> walk = Files.walk(dir)) {
+            return walk.filter(Files::isRegularFile)
+                    .mapToLong(p -> {
+                        try {
+                            return Files.size(p);
+                        } catch (IOException e) {
+                            return 0L; // Skip files that can't be read
+                        }
+                    })
+                    .sum();
+        }
+    }
+}
--- a/src/main/resources/font/OverlayFont.ttf
+++ b/src/main/resources/font/OverlayFont.ttf
--- a/src/main/resources/icons/save.png
+++ b/src/main/resources/icons/save.png
Author	SHA1	Message	Date
rattatwinko	e1003c20ff	A LOT of changes! Firstly a desktop icon system, secondly in the cameras ui you can now see time, thirdly you can now set the recording quality, lastly you have a desktop icon specifically for exporting!	2026-01-31 21:40:34 +01:00
rattatwinko	8239b910fe	recording was fucked up. FIX! mainly in RecordingFrame	2026-01-29 17:02:04 +01:00
rattatwinko	d775a33107	some more performance update: Changed: + FFmpeg with JavaCV + Exporting to a USB Removed: - JCodec!	2026-01-29 16:40:36 +01:00
rattatwinko	c0aa3421a4	some UI Updates for Picking a custom Background color, and having Multiple Monitor Fullscreen!	2026-01-25 19:39:03 +01:00