Merge branch 'patch-5684' of https://github.com/mjd/SmartTube into mjd-patch-5684

Author: yuliskov

exoplayer-amzn-2.10.6/library/core/src/main/java/com/google/android/exoplayer2/mediacodec/MediaCodecRenderer.java

@@ -28,6 +28,7 @@
 import androidx.annotation.CheckResult;
 import androidx.annotation.IntDef;
 import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
 import com.google.android.exoplayer2.BaseRenderer;
 import com.google.android.exoplayer2.C;
 import com.google.android.exoplayer2.ExoPlaybackException;
@@ -342,6 +343,16 @@ private static String buildCustomDiagnosticInfo(int errorCode) {
   @DrainAction private int codecDrainAction;
   private boolean codecReceivedBuffers;
   private boolean codecReceivedEos;
+  // SmartTube fix: transient MediaCodec error recovery.
+  // A transient codec IllegalStateException is recovered in place (codec re-init) instead of
+  // surfacing as an unrecoverable TYPE_UNEXPECTED player error (full engine restart + error toast).
+  // A short per-window attempt budget prevents a permanently wedged codec from re-initializing in a
+  // tight loop; once exhausted we surface the error (with a real message) and let the app restart the
+  // engine, as it did before this fix.
+  private static final int MAX_CODEC_RECOVERY_ATTEMPTS = 3;
+  private static final long CODEC_RECOVERY_WINDOW_MS = 5_000;
+  private int codecRecoveryAttempts;
+  private long lastCodecRecoveryMs = C.TIME_UNSET;
   private long lastBufferInStreamPresentationTimeUs;
   private long largestQueuedPresentationTimeUs;
   private boolean inputStreamEnded;
@@ -667,9 +678,20 @@ public void render(long positionUs, long elapsedRealtimeUs) throws ExoPlaybackEx
     if (codec != null) {
       long drainStartTimeMs = SystemClock.elapsedRealtime();
       TraceUtil.beginSection("drainAndFeed");
-      while (drainOutputBuffer(positionUs, elapsedRealtimeUs)) {}
-      while (feedInputBuffer() && shouldContinueFeeding(drainStartTimeMs)) {}
-      TraceUtil.endSection();
+      try {
+        while (drainOutputBuffer(positionUs, elapsedRealtimeUs)) {}
+        while (feedInputBuffer() && shouldContinueFeeding(drainStartTimeMs)) {}
+      } catch (IllegalStateException e) {
+        // SmartTube fix: a native MediaCodec error would otherwise propagate as
+        // TYPE_UNEXPECTED. Try to recover in place; only surface a (typed) error if that fails.
+        if (isMediaCodecException(e)) {
+          maybeRecoverFromCodecError(e);
+        } else {
+          throw e;
+        }
+      } finally {
+        TraceUtil.endSection();
+      }
     } else {
       decoderCounters.skippedInputBufferCount += skipSource(positionUs);
       // We need to read any format changes despite not having a codec so that drmSession can be
@@ -681,6 +703,92 @@ public void render(long positionUs, long elapsedRealtimeUs) throws ExoPlaybackEx
     decoderCounters.ensureUpdated();
   }
 
+  /**
+   * SmartTube fix: recover from a transient MediaCodec
+   * {@link IllegalStateException} by re-initializing the codec in place, instead of letting it
+   * surface as an unrecoverable player error (which forces a full engine restart and an "Unexpected
+   * playback error" toast).
+   *
+   * <p>Repeated failures within {@link #CODEC_RECOVERY_WINDOW_MS} (a permanently wedged codec) exhaust
+   * {@link #MAX_CODEC_RECOVERY_ATTEMPTS} and fall through to {@link #createDecoderException}, so the
+   * old restart-based recovery still acts as a backstop.
+   */
+  private void maybeRecoverFromCodecError(IllegalStateException error) throws ExoPlaybackException {
+    long nowMs = SystemClock.elapsedRealtime();
+    if (lastCodecRecoveryMs == C.TIME_UNSET || nowMs - lastCodecRecoveryMs > CODEC_RECOVERY_WINDOW_MS) {
+      codecRecoveryAttempts = 0;
+    }
+    lastCodecRecoveryMs = nowMs;
+
+    if (codecRecoveryAttempts >= MAX_CODEC_RECOVERY_ATTEMPTS) {
+      throw createDecoderException(error);
+    }
+
+    codecRecoveryAttempts++;
+    Log.w(TAG, "Recovering from MediaCodec error, re-initializing decoder (attempt "
+        + codecRecoveryAttempts + "/" + MAX_CODEC_RECOVERY_ATTEMPTS + ")");
+    try {
+      // A wedged codec's stop() can throw inside releaseCodec(), but releaseCodec()'s own finally has
+      // already nulled the codec by then, so a fresh init can still proceed. Don't let that abort the
+      // recovery.
+      try {
+        releaseCodec();
+      } catch (Throwable ignored) {
+        // Codec already released; continue to re-init.
+      }
+      maybeInitCodec();
+    } catch (ExoPlaybackException reinitError) {
+      throw reinitError;
+    } catch (Throwable reinitError) {
+      throw createDecoderException(error);
+    }
+  }
+
+  /**
+   * Wraps a MediaCodec {@link IllegalStateException} (which normally carries a {@code null} message)
+   * with the decoder name and, when available, the codec's diagnostic info, and reports it as an
+   * {@code UNEXPECTED} error.
+   *
+   * <p>We deliberately do NOT use {@link ExoPlaybackException#createForRenderer} here. A
+   * {@code TYPE_RENDERER} video error routes into the app's ErrorFixerController, which reacts by
+   * persisting a fallback format ({@code VIDEO_FHD_AVC_30}) — wiping the user's saved video preset.
+   * Keeping {@code TYPE_UNEXPECTED} preserves the (non-destructive) pre-fix restart path for an
+   * unrecoverable transient error, while still replacing the bare {@code null} message with a real
+   * one so it's no longer reported as "Unexpected playback error null".
+   */
+  private ExoPlaybackException createDecoderException(IllegalStateException error) {
+    String diagnosticInfo = getCodecDiagnosticInfo(error);
+    String message = "MediaCodec decoder error (" + codecName + ")"
+        + (diagnosticInfo != null ? ": " + diagnosticInfo : "");
+    return ExoPlaybackException.createForUnexpected(new IllegalStateException(message, error));
+  }
+
+  private static String getCodecDiagnosticInfo(IllegalStateException error) {
+    if (Util.SDK_INT >= 21) {
+      return getCodecDiagnosticInfoV21(error);
+    }
+    return null;
+  }
+
+  @TargetApi(21)
+  private static String getCodecDiagnosticInfoV21(IllegalStateException error) {
+    return error instanceof CodecException ? ((CodecException) error).getDiagnosticInfo() : null;
+  }
+
+  @VisibleForTesting
+  /* package */ static boolean isMediaCodecException(IllegalStateException error) {
+    if (Util.SDK_INT >= 21 && isMediaCodecExceptionV21(error)) {
+      return true;
+    }
+    StackTraceElement[] stackTrace = error.getStackTrace();
+    return stackTrace.length > 0 && stackTrace[0].getClassName().equals("android.media.MediaCodec");
+  }
+
+  @TargetApi(21)
+  private static boolean isMediaCodecExceptionV21(IllegalStateException error) {
+    return error instanceof CodecException;
+  }
+
   /**
    * Flushes the codec. If flushing is not possible, the codec will be released and re-instantiated.
    * This method is a no-op if the codec is {@code null}.

exoplayer-amzn-2.10.6/library/core/src/test/java/com/google/android/exoplayer2/mediacodec/MediaCodecRendererTest.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.mediacodec;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+
+/**
+ * Unit test for the transient-MediaCodec-error classification used by the in-place codec recovery
+ * (SmartTube fix). {@link MediaCodecRenderer#isMediaCodecException} is the gate that decides
+ * whether a render-loop {@link IllegalStateException} is treated as a recoverable decoder error, so
+ * these tests pin the two real-world crash signatures we observed (a native {@code MediaCodec} frame
+ * at the top of the stack) and guard against unrelated exceptions being swallowed.
+ *
+ * <p>Deliberately a plain JUnit test (no Robolectric): it exercises only stack-trace inspection, and
+ * the 2019-era Robolectric bundled with this ExoPlayer fork cannot run under the JDK 17 required by
+ * the app's Android Gradle Plugin. Under a plain JVM {@code Util.SDK_INT} reads as 0, so this
+ * exercises the stack-frame branch — which is exactly the path that fired on the real crashes (both
+ * were plain {@link IllegalStateException}s, not {@code MediaCodec.CodecException}s).
+ */
+public class MediaCodecRendererTest {
+
+  @Test
+  public void isMediaCodecException_withNativeDequeueInputBufferFrame_returnsTrue() {
+    // Observed crash: MediaCodec.native_dequeueInputBuffer on VP9 1080p60.
+    IllegalStateException error =
+        illegalStateExceptionWithTopFrame(
+            "android.media.MediaCodec", "native_dequeueInputBuffer");
+
+    assertThat(MediaCodecRenderer.isMediaCodecException(error)).isTrue();
+  }
+
+  @Test
+  public void isMediaCodecException_withReleaseOutputBufferFrame_returnsTrue() {
+    // Observed crash: MediaCodec.releaseOutputBuffer on VP9 1920x960.
+    IllegalStateException error =
+        illegalStateExceptionWithTopFrame("android.media.MediaCodec", "releaseOutputBuffer");
+
+    assertThat(MediaCodecRenderer.isMediaCodecException(error)).isTrue();
+  }
+
+  @Test
+  public void isMediaCodecException_withUnrelatedFrame_returnsFalse() {
+    // A logic-bug ISE originating elsewhere must still propagate untouched.
+    IllegalStateException error =
+        illegalStateExceptionWithTopFrame(
+            "com.google.android.exoplayer2.SomeOtherComponent", "doWork");
+
+    assertThat(MediaCodecRenderer.isMediaCodecException(error)).isFalse();
+  }
+
+  @Test
+  public void isMediaCodecException_withEmptyStackTrace_returnsFalse() {
+    IllegalStateException error = new IllegalStateException();
+    error.setStackTrace(new StackTraceElement[0]);
+
+    assertThat(MediaCodecRenderer.isMediaCodecException(error)).isFalse();
+  }
+
+  private static IllegalStateException illegalStateExceptionWithTopFrame(
+      String className, String methodName) {
+    IllegalStateException error = new IllegalStateException();
+    error.setStackTrace(
+        new StackTraceElement[] {
+          new StackTraceElement(className, methodName, /* fileName= */ null, /* lineNumber= */ -2),
+          new StackTraceElement(
+              "com.google.android.exoplayer2.mediacodec.MediaCodecRenderer",
+              "feedInputBuffer",
+              "MediaCodecRenderer.java",
+              994)
+        });
+    return error;
+  }
+}