v0.4.9: kill BufferedImage path, release texture on close

Stutter fix (root cause):
- 0.4.7 made the GPU upload a memcpy, but toRgba() in JavaCvBackend was
  still doing BufferedImage.getRGB() + a per-pixel ARGB->RGBA loop. That
  loop ran 20-50ms per 1080p frame on the decode thread. When it slipped
  behind real-time, the audio buffer drained, backpressure vanished,
  the decoder burst-fired catch-up frames into the single-slot
  AtomicReference (dropping 11 of 12 for ~0.5s of buffer), then blocked
  again on the next audio refill -- exactly the periodic stutter the
  user reported.
- Force the grabber to output AV_PIX_FMT_RGBA (=26) via setPixelFormat.
  Now frame.image[0] is already a ByteBuffer of RGBA bytes; we just
  copy it into a fresh direct buffer and hand it to the upload path.
  The colorspace conversion happens inside swscale (native SIMD) at
  <1ms per frame, so the decoder consistently keeps real-time pace and
  the audio backpressure stays smooth.
- Removed Java2DFrameConverter / BufferedImage usage entirely.

Defensive delete fix (potential crash on anchor delete):
- Entry.close() now calls TextureManager.release(id) before closing the
  texture itself. Without this, a RenderType cached by Identifier could
  still try to bind the dead GL handle on the next frame and crash the
  render thread. The crash report the user reported couldn't be located
  (no crash-reports/ folder) so this is the most plausible suspect from
  reading the code; full diagnosis still pending the tail of latest.log.

src/main/java/com/ejclaw/videoplayer/client/playback/JavaCvBackend.java

@@ -29,9 +29,10 @@ import java.util.concurrent.atomic.AtomicReference;
 public class JavaCvBackend implements VideoBackend {
     private static final String GRABBER_CLASS = "org.bytedeco.javacv.FFmpegFrameGrabber";
     private static final String FRAME_CLASS   = "org.bytedeco.javacv.Frame";
-    private static final String CONVERTER_CLASS = "org.bytedeco.javacv.Java2DFrameConverter";
     /** {@code AV_SAMPLE_FMT_S16} from {@code org.bytedeco.ffmpeg.global.avutil}. */
     private static final int AV_SAMPLE_FMT_S16 = 1;
+    /** {@code AV_PIX_FMT_RGBA} from {@code org.bytedeco.ffmpeg.global.avutil}. */
+    private static final int AV_PIX_FMT_RGBA = 26;
 
     private final Object lock = new Object();
     private Thread worker;
@@ -137,6 +138,7 @@ public class JavaCvBackend implements VideoBackend {
             Method getAudioChannels = grabberCls.getMethod("getAudioChannels");
             Method setOpt = grabberCls.getMethod("setOption", String.class, String.class);
             Method setSampleFormat  = grabberCls.getMethod("setSampleFormat", int.class);
+            Method setPixelFormat   = grabberCls.getMethod("setPixelFormat", int.class);
 
             // HTTP(S) tuning for streaming URLs (webm via Range / chunked transfer).
             // Lower timeouts → close() snaps shut fast when an anchor is deleted mid-stream;
@@ -157,6 +159,16 @@ public class JavaCvBackend implements VideoBackend {
                 "video_player/" + com.ejclaw.videoplayer.VideoPlayerMod.MOD_ID); } catch (Throwable ignored) {}
             // Force interleaved signed 16-bit PCM so the audio sink path is single-shape.
             try { setSampleFormat.invoke(grabber, AV_SAMPLE_FMT_S16); } catch (Throwable ignored) {}
+            // Force RGBA output so frame.image[0] is a ByteBuffer we can memcpy straight into
+            // the GPU texture. Without this, frame.image[0] is BGR24 and we'd have to round-trip
+            // through Java2DFrameConverter → BufferedImage.getRGB() → per-pixel ARGB→RGBA loop,
+            // which spends 20-50ms of Java work per 1080p frame and was the dominant stutter
+            // source in 0.4.7/0.4.8: when the decoder fell behind real time, the audio buffer
+            // drained, backpressure vanished, and the decoder burst-fired catch-up frames into
+            // the single-slot AtomicReference (dropping all but the last) before the buffer
+            // refilled and blocked it again. swscale's native SIMD does the same conversion in
+            // <1ms per frame, so the decoder consistently keeps real-time pace.
+            try { setPixelFormat.invoke(grabber, AV_PIX_FMT_RGBA); } catch (Throwable ignored) {}
 
             start.invoke(grabber);
             this.width  = (int) getW.invoke(grabber);
@@ -171,9 +183,9 @@ public class JavaCvBackend implements VideoBackend {
             Class<?> frameCls    = Class.forName(FRAME_CLASS);
             Field imageField     = frameCls.getField("image");
             Field samplesField   = frameCls.getField("samples");
-            Class<?> convCls     = Class.forName(CONVERTER_CLASS);
-            Object converter     = convCls.getDeclaredConstructor().newInstance();
-            Method toImage       = convCls.getMethod("getBufferedImage", frameCls);
+            // Java2DFrameConverter is no longer used now that we read RGBA bytes directly,
+            // but we still resolve its class so a future code path could fall back to it if a
+            // grabber refuses setPixelFormat. Keep the lookup defensive.
 
             while (running.get() && !closed) {
                 if (paused.get()) { Thread.sleep(20); continue; }
@@ -200,12 +212,19 @@ public class JavaCvBackend implements VideoBackend {
                 }
 
                 Object[] images = (Object[]) imageField.get(frame);
-                if (images != null && images.length > 0) {
-                    java.awt.image.BufferedImage img =
-                        (java.awt.image.BufferedImage) toImage.invoke(converter, frame);
-                    if (img != null) {
-                        ByteBuffer buf = toRgba(img);
-                        if (buf != null) latest.set(buf);
+                if (images != null && images.length > 0 && images[0] instanceof ByteBuffer src) {
+                    // frame.image[0] is the swscale-converted RGBA plane, reused by the grabber
+                    // across grab() calls. Copy into a fresh direct buffer because the render
+                    // thread reads `latest` asynchronously and would otherwise see a buffer
+                    // already being overwritten by the next grab().
+                    int need = src.remaining();
+                    if (need > 0) {
+                        ByteBuffer copy = ByteBuffer.allocateDirect(need).order(ByteOrder.nativeOrder());
+                        int srcPos = src.position();
+                        copy.put(src);
+                        src.position(srcPos); // restore so JavaCV's own bookkeeping isn't disturbed
+                        copy.flip();
+                        latest.set(copy);
                     }
                 }
 
@@ -293,17 +312,4 @@ public class JavaCvBackend implements VideoBackend {
         try { return (int) m.invoke(target); } catch (Throwable t) { return 0; }
     }
 
-    private static ByteBuffer toRgba(java.awt.image.BufferedImage img) {
-        int w = img.getWidth(), h = img.getHeight();
-        int[] argb = img.getRGB(0, 0, w, h, null, 0, w);
-        ByteBuffer buf = ByteBuffer.allocateDirect(w * h * 4).order(ByteOrder.nativeOrder());
-        for (int p : argb) {
-            buf.put((byte) ((p >> 16) & 0xFF)); // R
-            buf.put((byte) ((p >>  8) & 0xFF)); // G
-            buf.put((byte) ( p        & 0xFF)); // B
-            buf.put((byte) ((p >> 24) & 0xFF)); // A
-        }
-        buf.flip();
-        return buf;
-    }
 }

src/main/java/com/ejclaw/videoplayer/client/playback/VideoPlayback.java

@@ -209,11 +209,24 @@ public final class VideoPlayback {
 
         void close() {
             try { backend.close(); } catch (Throwable ignored) {}
+            // Unregister from TextureManager BEFORE closing the texture itself, so any
+            // straggler binding by Identifier looks up "no such texture" instead of a closed
+            // GL handle (which crashes the renderer on the next frame). Renderer pipelines
+            // can cache RenderType objects keyed by Identifier across frames, and on delete
+            // the old anchor's frame can still be in flight in the submit buffer when its
+            // texture closes — without this release(), the bind would dereference a freed
+            // GL handle.
+            if (registered) {
+                Minecraft mc = Minecraft.getInstance();
+                if (mc != null) {
+                    try { mc.getTextureManager().release(id); } catch (Throwable ignored) {}
+                }
+                registered = false;
+            }
             if (texture != null) {
                 try { texture.close(); } catch (Throwable ignored) {}
                 texture = null;
             }
-            // texture manager keeps the registration; the texture itself is closed.
         }
     }
 }