Expand and refactor `TransformerInternal#shouldTranscode`.

* Account for `AssetLoader` output types.
* Consider cases that are not audio/video specific.
* Use `Format#sampleMimeType` for track specific conditions to check.
* Untangle `SamplePipeline` initilization from `AssetLoader` state.

PiperOrigin-RevId: 511020865

library/transformer/src/main/java/com/google/android/exoplayer2/transformer/TransformerInternal.java

@@ -21,6 +21,7 @@ import static com.google.android.exoplayer2.transformer.AssetLoader.SUPPORTED_OU
 import static com.google.android.exoplayer2.transformer.ExportException.ERROR_CODE_FAILED_RUNTIME_CHECK;
 import static com.google.android.exoplayer2.transformer.ExportException.ERROR_CODE_FAILED_RUNTIME_CHECK;
 import static com.google.android.exoplayer2.transformer.ExportException.ERROR_CODE_MUXING_FAILED;
 import static com.google.android.exoplayer2.transformer.ExportException.ERROR_CODE_MUXING_FAILED;
 import static com.google.android.exoplayer2.transformer.Transformer.PROGRESS_STATE_NOT_STARTED;
 import static com.google.android.exoplayer2.transformer.Transformer.PROGRESS_STATE_NOT_STARTED;
+import static com.google.android.exoplayer2.util.Assertions.checkArgument;
 import static com.google.android.exoplayer2.util.Assertions.checkState;
 import static com.google.android.exoplayer2.util.Assertions.checkState;
 import static java.lang.annotation.ElementType.TYPE_USE;
 import static java.lang.annotation.ElementType.TYPE_USE;
 
 
@@ -372,7 +373,11 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 
 
       SamplePipeline samplePipeline =
       SamplePipeline samplePipeline =
           getSamplePipeline(
           getSamplePipeline(
-              firstInputFormat, supportedOutputTypes, streamStartPositionUs, streamOffsetUs);
+              firstInputFormat,
+              shouldTranscode(
+                  firstInputFormat, supportedOutputTypes, streamStartPositionUs, streamOffsetUs),
+              streamStartPositionUs,
+              streamOffsetUs);
       compositeAssetLoader.addOnMediaItemChangedListener(samplePipeline, trackType);
       compositeAssetLoader.addOnMediaItemChangedListener(samplePipeline, trackType);
       internalHandler.obtainMessage(MSG_REGISTER_SAMPLE_PIPELINE, samplePipeline).sendToTarget();
       internalHandler.obtainMessage(MSG_REGISTER_SAMPLE_PIPELINE, samplePipeline).sendToTarget();
 
 
@@ -421,59 +426,74 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 
 
     private SamplePipeline getSamplePipeline(
     private SamplePipeline getSamplePipeline(
         Format firstInputFormat,
         Format firstInputFormat,
-        @AssetLoader.SupportedOutputTypes int supportedOutputTypes,
+        boolean shouldTranscode,
         long streamStartPositionUs,
         long streamStartPositionUs,
         long streamOffsetUs)
         long streamOffsetUs)
         throws ExportException {
         throws ExportException {
-      checkState(supportedOutputTypes != 0);
-      boolean isAudio = MimeTypes.isAudio(firstInputFormat.sampleMimeType);
-      boolean shouldTranscode;
-      if (mediaItemCount > 1 && !transmux) {
-        shouldTranscode = true;
-      } else {
-        shouldTranscode =
-            isAudio
-                ? shouldTranscodeAudio(firstInputFormat)
-                : shouldTranscodeVideo(firstInputFormat, streamStartPositionUs, streamOffsetUs);
+      if (shouldTranscode) {
+        if (MimeTypes.isAudio(firstInputFormat.sampleMimeType)) {
+          return new AudioSamplePipeline(
+              firstInputFormat,
+              streamStartPositionUs,
+              streamOffsetUs,
+              transformationRequest,
+              firstEditedMediaItem.flattenForSlowMotion,
+              firstEditedMediaItem.effects.audioProcessors,
+              encoderFactory,
+              muxerWrapper,
+              fallbackListener);
+        }
+
+        if (MimeTypes.isVideo(firstInputFormat.sampleMimeType)) {
+          return new VideoSamplePipeline(
+              context,
+              firstInputFormat,
+              streamStartPositionUs,
+              streamOffsetUs,
+              transformationRequest,
+              firstEditedMediaItem.effects.videoEffects,
+              firstEditedMediaItem.effects.videoFrameProcessorFactory,
+              encoderFactory,
+              muxerWrapper,
+              /* errorConsumer= */ this::onError,
+              fallbackListener,
+              debugViewProvider);
+        }
       }
       }
-      boolean assetLoaderNeverDecodes = (supportedOutputTypes & SUPPORTED_OUTPUT_TYPE_DECODED) == 0;
-      checkState(!shouldTranscode || !assetLoaderNeverDecodes);
-      boolean assetLoaderAlwaysDecodes =
-          (supportedOutputTypes & SUPPORTED_OUTPUT_TYPE_ENCODED) == 0;
-      boolean shouldUseTranscodingPipeline = shouldTranscode || assetLoaderAlwaysDecodes;
-      if (isAudio && shouldUseTranscodingPipeline) {
-        return new AudioSamplePipeline(
-            firstInputFormat,
-            streamStartPositionUs,
-            streamOffsetUs,
-            transformationRequest,
-            firstEditedMediaItem.flattenForSlowMotion,
-            firstEditedMediaItem.effects.audioProcessors,
-            encoderFactory,
-            muxerWrapper,
-            fallbackListener);
-      } else if (shouldUseTranscodingPipeline) {
-        return new VideoSamplePipeline(
-            context,
-            firstInputFormat,
-            streamStartPositionUs,
-            streamOffsetUs,
-            transformationRequest,
-            firstEditedMediaItem.effects.videoEffects,
-            firstEditedMediaItem.effects.videoFrameProcessorFactory,
-            encoderFactory,
-            muxerWrapper,
-            /* errorConsumer= */ this::onError,
-            fallbackListener,
-            debugViewProvider);
-      } else {
-        return new EncodedSamplePipeline(
-            firstInputFormat,
-            streamStartPositionUs,
-            transformationRequest,
-            muxerWrapper,
-            fallbackListener);
+
+      return new EncodedSamplePipeline(
+          firstInputFormat,
+          streamStartPositionUs,
+          transformationRequest,
+          muxerWrapper,
+          fallbackListener);
+    }
+
+    private boolean shouldTranscode(
+        Format inputFormat,
+        @AssetLoader.SupportedOutputTypes int supportedOutputTypes,
+        long streamStartPositionUs,
+        long streamOffsetUs) {
+      boolean assetLoaderCanOutputDecoded =
+          (supportedOutputTypes & SUPPORTED_OUTPUT_TYPE_DECODED) != 0;
+      boolean assetLoaderCanOutputEncoded =
+          (supportedOutputTypes & SUPPORTED_OUTPUT_TYPE_ENCODED) != 0;
+      checkArgument(assetLoaderCanOutputDecoded || assetLoaderCanOutputEncoded);
+
+      boolean shouldTranscode = false;
+      if (!assetLoaderCanOutputEncoded) {
+        shouldTranscode = true;
+      } else if (mediaItemCount > 1 && !transmux) {
+        shouldTranscode = true;
+      } else if (MimeTypes.isAudio(inputFormat.sampleMimeType)) {
+        shouldTranscode = shouldTranscodeAudio(inputFormat);
+      } else if (MimeTypes.isVideo(inputFormat.sampleMimeType)) {
+        shouldTranscode = shouldTranscodeVideo(inputFormat, streamStartPositionUs, streamOffsetUs);
       }
       }
+
+      checkState(!shouldTranscode || assetLoaderCanOutputDecoded);
+
+      return shouldTranscode;
     }
     }
 
 
     private boolean shouldTranscodeAudio(Format inputFormat) {
     private boolean shouldTranscodeAudio(Format inputFormat) {