Puts the {@link MediaItem.LocalConfiguration#uri} (encoded with {@link Charsets#UTF_8}) in a + * single sample belonging to a single {@link MediaPeriod}. + * + *
Typically used for image content that is managed by an external image management framework + * (for example, Glide). + */ +@UnstableApi +public final class ExternallyLoadedMediaSource extends BaseMediaSource { + + /** Factory for {@link ExternallyLoadedMediaSource}. */ + public static final class Factory implements MediaSource.Factory { + + private final long timelineDurationUs; + + /** + * Creates an instance. + * + * @param timelineDurationUs The duration of the {@link SinglePeriodTimeline} created. + */ + Factory(long timelineDurationUs) { + this.timelineDurationUs = timelineDurationUs; + } + + /** Does nothing. {@link ExternallyLoadedMediaSource} does not support DRM. */ + @Override + public MediaSource.Factory setDrmSessionManagerProvider( + DrmSessionManagerProvider drmSessionManagerProvider) { + return this; + } + + /** + * Does nothing. {@link ExternallyLoadedMediaSource} does not support error handling policies. + */ + @Override + public MediaSource.Factory setLoadErrorHandlingPolicy( + LoadErrorHandlingPolicy loadErrorHandlingPolicy) { + return this; + } + + @Override + public @C.ContentType int[] getSupportedTypes() { + return new int[] {C.CONTENT_TYPE_OTHER}; + } + + @Override + public ExternallyLoadedMediaSource createMediaSource(MediaItem mediaItem) { + return new ExternallyLoadedMediaSource(mediaItem, timelineDurationUs); + } + } + + private final MediaItem mediaItem; + private final Timeline timeline; + + private ExternallyLoadedMediaSource(MediaItem mediaItem, long timelineDurationUs) { + this.mediaItem = mediaItem; + this.timeline = + new SinglePeriodTimeline( + timelineDurationUs, + /* isSeekable= */ true, + /* isDynamic= */ false, + /* useLiveConfiguration= */ false, + /* manifest= */ null, + mediaItem); + } + + @Override + protected void prepareSourceInternal(@Nullable TransferListener mediaTransferListener) { + refreshSourceInfo(timeline); + } + + @Override + protected void releaseSourceInternal() { + // Do nothing. + } + + @Override + public MediaItem getMediaItem() { + return mediaItem; + } + + @Override + public void maybeThrowSourceInfoRefreshError() { + // Do nothing. + } + + @Override + public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator, long startPositionUs) { + checkNotNull(mediaItem.localConfiguration); + checkNotNull( + mediaItem.localConfiguration.mimeType, "Externally loaded mediaItems require a MIME type."); + return new ExternallyLoadedMediaPeriod( + mediaItem.localConfiguration.uri, mediaItem.localConfiguration.mimeType); + } + + @Override + public void releasePeriod(MediaPeriod mediaPeriod) {} +} diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/e2etest/ExternallyLoadedImagePlaybackTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/e2etest/ExternallyLoadedImagePlaybackTest.java new file mode 100644 index 0000000000..d1d7d7b89e --- /dev/null +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/e2etest/ExternallyLoadedImagePlaybackTest.java @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2023 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 androidx.media3.exoplayer.e2etest; + +import static com.google.common.truth.Truth.assertThat; +import static org.robolectric.annotation.GraphicsMode.Mode.NATIVE; + +import android.content.Context; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.net.Uri; +import androidx.annotation.Nullable; +import androidx.media3.common.C; +import androidx.media3.common.Format; +import androidx.media3.common.MediaItem; +import androidx.media3.common.MimeTypes; +import androidx.media3.common.Player; +import androidx.media3.common.util.Clock; +import androidx.media3.datasource.AssetDataSource; +import androidx.media3.datasource.DataSourceUtil; +import androidx.media3.datasource.DataSpec; +import androidx.media3.exoplayer.ExoPlayer; +import androidx.media3.exoplayer.RendererCapabilities; +import androidx.media3.exoplayer.image.BitmapFactoryImageDecoder; +import androidx.media3.exoplayer.image.ImageDecoder; +import androidx.media3.exoplayer.image.ImageDecoderException; +import androidx.media3.test.utils.CapturingRenderersFactory; +import androidx.media3.test.utils.DumpFileAsserts; +import androidx.media3.test.utils.FakeClock; +import androidx.media3.test.utils.robolectric.PlaybackOutput; +import androidx.media3.test.utils.robolectric.TestPlayerRunHelper; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.google.common.base.Charsets; +import java.io.IOException; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.annotation.GraphicsMode; + +/** End-to-end tests using image content loaded from an injected image management framework. */ +@RunWith(AndroidJUnit4.class) +@GraphicsMode(value = NATIVE) +public final class ExternallyLoadedImagePlaybackTest { + + private static final String INPUT_FILE = "png/non-motion-photo-shortened.png"; + + @Test + public void test() throws Exception { + Context applicationContext = ApplicationProvider.getApplicationContext(); + CapturingRenderersFactory renderersFactory = + new CapturingRenderersFactory(applicationContext, /* addImageRenderer= */ true) + .setImageDecoderFactory(new CustomImageDecoderFactory()); + Clock clock = new FakeClock(/* isAutoAdvancing= */ true); + ExoPlayer player = + new ExoPlayer.Builder(applicationContext, renderersFactory).setClock(clock).build(); + PlaybackOutput playbackOutput = PlaybackOutput.register(player, renderersFactory); + long durationMs = 5 * C.MILLIS_PER_SECOND; + player.setMediaItem( + new MediaItem.Builder() + .setUri("asset:///media/" + INPUT_FILE) + .setImageDurationMs(durationMs) + .setMimeType(MimeTypes.APPLICATION_EXTERNALLY_LOADED_IMAGE) + .build()); + player.prepare(); + + TestPlayerRunHelper.runUntilPlaybackState(player, Player.STATE_READY); + long playerStartedMs = clock.elapsedRealtime(); + player.play(); + TestPlayerRunHelper.runUntilPlaybackState(player, Player.STATE_ENDED); + long playbackDurationMs = clock.elapsedRealtime() - playerStartedMs; + player.release(); + + assertThat(playbackDurationMs).isAtLeast(durationMs); + DumpFileAsserts.assertOutput( + applicationContext, playbackOutput, "playbackdumps/" + INPUT_FILE + ".dump"); + } + + private static final class CustomImageDecoderFactory implements ImageDecoder.Factory { + + @Override + public @RendererCapabilities.Capabilities int supportsFormat(Format format) { + return format.sampleMimeType.equals(MimeTypes.APPLICATION_EXTERNALLY_LOADED_IMAGE) + ? RendererCapabilities.create(C.FORMAT_HANDLED) + : RendererCapabilities.create(C.FORMAT_UNSUPPORTED_TYPE); + } + + @Override + public ImageDecoder createImageDecoder() { + return new BitmapFactoryImageDecoder.Factory(ExternallyLoadedImagePlaybackTest::decode) + .createImageDecoder(); + } + } + + private static Bitmap decode(byte[] data, int length) throws ImageDecoderException { + String uriString = new String(data, Charsets.UTF_8); + AssetDataSource assetDataSource = + new AssetDataSource(ApplicationProvider.getApplicationContext()); + DataSpec dataSpec = new DataSpec(Uri.parse(uriString)); + @Nullable Bitmap bitmap; + + try { + assetDataSource.open(dataSpec); + byte[] imageData = DataSourceUtil.readToEnd(assetDataSource); + bitmap = BitmapFactory.decodeByteArray(imageData, /* offset= */ 0, imageData.length); + } catch (IOException e) { + throw new ImageDecoderException(e); + } + if (bitmap == null) { + throw new ImageDecoderException( + "Could not decode image data with BitmapFactory. uriString decoded from data = " + + uriString); + } + return bitmap; + } +} diff --git a/libraries/test_utils/src/main/java/androidx/media3/test/utils/CapturingRenderersFactory.java b/libraries/test_utils/src/main/java/androidx/media3/test/utils/CapturingRenderersFactory.java index d5752d24c8..ff0947077f 100644 --- a/libraries/test_utils/src/main/java/androidx/media3/test/utils/CapturingRenderersFactory.java +++ b/libraries/test_utils/src/main/java/androidx/media3/test/utils/CapturingRenderersFactory.java @@ -73,6 +73,7 @@ public class CapturingRenderersFactory implements RenderersFactory, Dumper.Dumpa private final CapturingMediaCodecAdapter.Factory mediaCodecAdapterFactory; private final CapturingAudioSink audioSink; private final CapturingImageOutput imageOutput; + private ImageDecoder.Factory imageDecoderFactory; /** * Creates an instance. @@ -96,6 +97,23 @@ public class CapturingRenderersFactory implements RenderersFactory, Dumper.Dumpa this.audioSink = new CapturingAudioSink(new DefaultAudioSink.Builder(context).build()); this.imageOutput = new CapturingImageOutput(); this.addImageRenderer = addImageRenderer; + this.imageDecoderFactory = ImageDecoder.Factory.DEFAULT; + } + + /** + * Sets the {@link ImageDecoder.Factory} used by the {@link ImageRenderer}. + * + *
Must {@code addImageRenderer} when creating the {@link + * CapturingRenderersFactory#CapturingRenderersFactory(Context, boolean)}. + * + * @param imageDecoderFactory The {@link ImageDecoder.Factory}. + * @return This factory, for convenience. + */ + public CapturingRenderersFactory setImageDecoderFactory( + ImageDecoder.Factory imageDecoderFactory) { + checkState(addImageRenderer); + this.imageDecoderFactory = imageDecoderFactory; + return this; } @Override @@ -149,7 +167,7 @@ public class CapturingRenderersFactory implements RenderersFactory, Dumper.Dumpa temp.add(new MetadataRenderer(metadataRendererOutput, eventHandler.getLooper())); if (addImageRenderer) { - temp.add(new ImageRenderer(ImageDecoder.Factory.DEFAULT, imageOutput)); + temp.add(new ImageRenderer(imageDecoderFactory, imageOutput)); } return temp.toArray(new Renderer[] {}); }