fix: Qodo findings on #84 — decoder failures shown, limits respected, slots freed late

- A decoder that fails to start is reported to the cell ('Decoder error') instead of
  showing normal zero-fps stats
- While a codec's instance limit is unknown, its decoders start one at a time, so
  concurrent cells cannot exceed the limit before it is learnt (Android 5 and errors
  count as unlimited)
- The instance slot is given back only after the codec is released, so a waiting cell
  cannot start while the device still holds the maximum
- A decoder limit message is not replaced by a connection error
- Only playing cells are demoted or paused (#85 planner)

Author: compot-dev

android/app/src/main/java/com/openipc/decoder/DecodePlanner.java

@@ -40,6 +40,8 @@ static final class Cell {
         long fullLoad;
         /** The decoder lost frames of this cell in the last sample. */
         boolean lossy;
+        /** Connected and decoding: only such cells are demoted or paused (Qodo on #84). */
+        boolean playing = true;
 
         Cell(int index, boolean full, boolean known, long fullLoad, boolean lossy) {
             this.index = index;
@@ -119,7 +121,7 @@ Decision step(List<Cell> cells, long nowMs) {
             lossySamples = 0;
             for (int i = cells.size() - 1; i >= 0; i--) {
                 Cell c = cells.get(i);
-                if (c.full && !c.paused) {
+                if (c.full && !c.paused && c.playing && c.known) {
                     // Losses at this load: the capacity is below it, but not below a proven load
                     capacity = Math.max(proven, Math.round(load * 0.9));
                     learnt = true;
@@ -129,7 +131,9 @@ Decision step(List<Cell> cells, long nowMs) {
             // Even key frames are too much: pause the lowest-priority cell as a last resort
             for (int i = cells.size() - 1; i >= 0; i--) {
                 Cell c = cells.get(i);
-                if (!c.paused && countActive(cells) > 1) return change(nowMs, Action.PAUSE, c.index);
+                if (!c.paused && c.playing && countActive(cells) > 1) {
+                    return change(nowMs, Action.PAUSE, c.index);
+                }
             }
             return Decision.NONE;
         }

android/app/src/main/java/com/openipc/decoder/Decoder.java

@@ -983,6 +983,7 @@ private static DecodePlanner.Cell plannerCell(int index, QuadCell c, long now) {
         DecodePlanner.Cell pc = new DecodePlanner.Cell(index, !c.isKeyFramesOnly(),
                 c.knowsLoad(), c.knowsLoad() ? c.fullLoad() : 0, lossy);
         pc.paused = c.isPaused();
+        pc.playing = c.isPlaying();
         return pc;
     }
 

android/app/src/main/java/com/openipc/decoder/MediaCodecManager.java

@@ -99,7 +99,8 @@ static final class InstanceBudget {
         static synchronized boolean tryAcquire(String mime) {
             int u = used.containsKey(mime) ? used.get(mime) : 0;
             Integer max = limit.get(mime);
-            if (max != null && u >= max) return false;
+            // Until the first decoder of a type has told its limit, start one at a time
+            if (max == null ? u > 0 : u >= max) return false;
             used.put(mime, u + 1);
             return true;
         }
@@ -131,18 +132,28 @@ static synchronized void reset() {
      */
     static volatile long declaredBlocksPerSec;
 
-    /** Give the instance slot back; called wherever the decoder is detached (decoderLock held). */
-    private void releaseSlot() {
-        if (heldMime != null) {
-            InstanceBudget.release(heldMime);
-            heldMime = null;
-        }
+    /**
+     * Detach the instance slot from this manager (decoderLock held). The caller gives it back
+     * with {@link InstanceBudget#release} only after the codec itself is released, so another
+     * cell cannot start a decoder while the device still holds the maximum.
+     */
+    private String takeSlot() {
+        String m = heldMime;
+        heldMime = null;
+        return m;
+    }
+
+    private static void releaseSlot(String mime) {
+        if (mime != null) InstanceBudget.release(mime);
     }
 
     /** Learn the codec's instance limit and log its declared throughput, once per type. */
     private static void learnLimits(MediaCodec codec, String mime) {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return;
         if (InstanceBudget.limit(mime) >= 0) return;
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            InstanceBudget.learn(mime, Integer.MAX_VALUE); // not declared before Android 6
+            return;
+        }
         try {
             MediaCodecInfo.CodecCapabilities caps = codec.getCodecInfo().getCapabilitiesForType(mime);
             int max = caps.getMaxSupportedInstances();
@@ -160,6 +171,7 @@ private static void learnLimits(MediaCodec codec, String mime) {
             Log.i(TAG, "Decoder " + codec.getName() + " (" + mime + "): up to " + max
                     + " instances, declared 1080p frame rate in total " + fps1080);
         } catch (Exception e) {
+            InstanceBudget.learn(mime, Integer.MAX_VALUE);
             Log.w(TAG, "Decoder limits unknown: " + e.getMessage());
         }
     }
@@ -187,13 +199,15 @@ void setEnabled(boolean enabled) {
         final MediaCodec target = decoder;
         if (target == null) return;
         new Thread(() -> {
+            String slot;
             synchronized (decoderLock) {
                 if (decoder != target) return; // already replaced or released
                 decoder = null;
-                releaseSlot();
+                slot = takeSlot();
                 retry.onSuccess();
             }
             releaseNow(target);
+            releaseSlot(slot);
         }, "decoder-release").start();
     }
 
@@ -215,14 +229,15 @@ void closeDecoder() {
             lastFrameMs = 0;
             if (codec == null) return;
             decoder = null;
-            releaseSlot();
+            String slot = takeSlot();
             Log.i(TAG, "Close video decoder");
             try {
                 codec.stop();
                 codec.release();
             } catch (Exception e) {
                 Log.e(TAG, "Decoder close exception", e);
             }
+            releaseSlot(slot);
         }
     }
 
@@ -254,6 +269,8 @@ void createDecoder(boolean codecH265) {
             synchronized (decoderLock) {
                 retry.onFailure(nowMs());
             }
+            // Limit still unknown: another cell is creating the first decoder, just retry
+            if (limit < 0) return;
             Log.w(TAG, "Decoder limit reached: " + limit + " × " + type);
             if (listener != null) listener.onDecoderLimit(type, limit);
             return;
@@ -280,6 +297,7 @@ void createDecoder(boolean codecH265) {
                 retry.onFailure(nowMs());
             }
             Log.e(TAG, "Cannot setup decoder (attempt " + retry.failures() + "): " + e.getMessage());
+            if (listener != null) listener.onDecoderFailed();
             return;
         }
 
@@ -359,12 +377,13 @@ boolean decodeFrame(Frame buffer, boolean codecH265, long watchdogRef) {
                     drainOutput(codec);
                 } catch (Exception e) {
                     decoder = null;
-                    releaseSlot();
+                    String slot = takeSlot();
                     retry.onFailure(nowMs());
                     Log.e(TAG, "Codec exception, retry in "
                             + DecoderRetry.delayMs(retry.failures()) + " ms: " + e.getMessage());
                     try { codec.stop(); } catch (Exception ignored) {}
                     try { codec.release(); } catch (Exception ignored) {}
+                    releaseSlot(slot);
                     if (listener != null) listener.onDecoderFailed();
                 }
             }

android/app/src/main/java/com/openipc/decoder/QuadCell.java

@@ -109,7 +109,10 @@ void setAudioSink(AudioManager sink, int route) {
                 decoderStartedMs = System.nanoTime() / 1_000_000;
                 if (listener != null) listener.onRemoveOverlay(index);
             }
-            @Override public void onDecoderFailed() {}
+            @Override public void onDecoderFailed() {
+                // A decoder limit message says more; keep it
+                if (problem == null || !problem.startsWith("Decoder limit")) problem = "Decoder error";
+            }
             @Override public void onDecoderLimit(String mime, int limit) {
                 problem = "Decoder limit: " + (limit > 0 ? limit + " × " : "")
                         + (mime.contains("hevc") ? "H.265" : "H.264");
@@ -229,7 +232,9 @@ public void onStatus(String status) {
 
     @Override
     public void onFailure(String message) {
-        problem = shortError(message);
+        // A decoder problem stays visible; the connection retries on its own
+        String p = problem;
+        if (p == null || !p.startsWith("Decoder")) problem = shortError(message);
     }
 
     /** A connection error short enough for a cell corner. */
@@ -333,6 +338,11 @@ boolean showsVideo(long ms) {
         return pausedReason == null && "connected".equals(state) && decoder.renderedWithin(ms);
     }
 
+    /** Connected and decoding: its load is real, so demoting or pausing it helps (#85). */
+    boolean isPlaying() {
+        return pausedReason == null && "connected".equals(state) && decoder.hasDecoder();
+    }
+
     /** Playing long enough for its decode rate to mean something (#83). */
     boolean isSettled(long nowMs) {
         long started = decoderStartedMs;

android/app/src/test/java/com/openipc/decoder/CellStatsTest.java

@@ -102,8 +102,23 @@ public void instanceBudgetHoldsTheLearntLimit() {
                 MediaCodecManager.InstanceBudget.tryAcquire(hevc));
         MediaCodecManager.InstanceBudget.release(hevc);
         assertTrue(MediaCodecManager.InstanceBudget.tryAcquire(hevc));
-        // Other codecs are counted separately
+        // Other codecs are counted separately; while a limit is unknown, one at a time
         assertTrue(MediaCodecManager.InstanceBudget.tryAcquire("video/avc"));
         assertEquals(-1, MediaCodecManager.InstanceBudget.limit("video/avc"));
+        assertFalse("second decoder waits until the first has told its limit",
+                MediaCodecManager.InstanceBudget.tryAcquire("video/avc"));
+        MediaCodecManager.InstanceBudget.learn("video/avc", 16);
+        assertTrue(MediaCodecManager.InstanceBudget.tryAcquire("video/avc"));
+    }
+
+    @Test
+    public void decoderLimitIsNotHiddenByAConnectionError() {
+        QuadCell c = cell();
+        c.onStatus("connected");
+        c.setKeyFramesOnly(false);
+        c.onFailure("ECONNREFUSED");
+        assertEquals("Connection refused", c.sample(1000));
+        c.onStatus("connected");
+        assertEquals("H.264 0/0 fps", c.sample(2000));
     }
 }