FakeRenderer.java
/*
* Copyright (C) 2017 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.test.utils;
import androidx.annotation.Nullable;
import androidx.media3.common.C;
import androidx.media3.common.Format;
import androidx.media3.common.MimeTypes;
import androidx.media3.common.PlaybackException;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.common.util.Util;
import androidx.media3.decoder.DecoderInputBuffer;
import androidx.media3.exoplayer.BaseRenderer;
import androidx.media3.exoplayer.ExoPlaybackException;
import androidx.media3.exoplayer.FormatHolder;
import androidx.media3.exoplayer.Renderer;
import androidx.media3.exoplayer.RendererCapabilities;
import androidx.media3.exoplayer.drm.DrmSession;
import androidx.media3.exoplayer.source.SampleStream.ReadDataResult;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Fake {@link Renderer} that supports any format with the matching track type.
*
* <p>The renderer verifies that all the formats it reads have the provided track type.
*/
@UnstableApi
public class FakeRenderer extends BaseRenderer {
private static final String TAG = "FakeRenderer";
/**
* The amount of time ahead of the current playback position that the renderer reads from the
* source. A real renderer will typically read ahead by a small amount due to pipelining through
* decoders and the media output path.
*/
private static final long SOURCE_READAHEAD_US = 250_000;
private final DecoderInputBuffer buffer;
@Nullable private DrmSession currentDrmSession;
private long playbackPositionUs;
private long lastSamplePositionUs;
private boolean hasPendingBuffer;
private List<Format> formatsRead;
public boolean isEnded;
public int positionResetCount;
public int sampleBufferReadCount;
public int enabledCount;
public int resetCount;
public FakeRenderer(@C.TrackType int trackType) {
super(trackType);
buffer = new DecoderInputBuffer(DecoderInputBuffer.BUFFER_REPLACEMENT_MODE_NORMAL);
lastSamplePositionUs = Long.MIN_VALUE;
formatsRead = new ArrayList<>();
}
@Override
public String getName() {
return TAG;
}
@Override
protected void onPositionReset(long positionUs, boolean joining) throws ExoPlaybackException {
playbackPositionUs = positionUs;
lastSamplePositionUs = Long.MIN_VALUE;
hasPendingBuffer = false;
positionResetCount++;
isEnded = false;
}
@Override
public void render(long positionUs, long elapsedRealtimeUs) throws ExoPlaybackException {
if (isEnded) {
return;
}
playbackPositionUs = positionUs;
while (true) {
if (!hasPendingBuffer) {
FormatHolder formatHolder = getFormatHolder();
buffer.clear();
@ReadDataResult int result = readSource(formatHolder, buffer, /* readFlags= */ 0);
if (result == C.RESULT_FORMAT_READ) {
DrmSession.replaceSession(currentDrmSession, formatHolder.drmSession);
currentDrmSession = formatHolder.drmSession;
Format format = Assertions.checkNotNull(formatHolder.format);
if (MimeTypes.getTrackType(format.sampleMimeType) != getTrackType()) {
throw ExoPlaybackException.createForRenderer(
new IllegalStateException(
Util.formatInvariant(
"Format track type (%s) doesn't match renderer track type (%s).",
MimeTypes.getTrackType(format.sampleMimeType), getTrackType())),
getName(),
getIndex(),
format,
C.FORMAT_UNSUPPORTED_TYPE,
/* isRecoverable= */ false,
PlaybackException.ERROR_CODE_DECODING_FORMAT_UNSUPPORTED);
}
formatsRead.add(format);
onFormatChanged(format);
} else if (result == C.RESULT_BUFFER_READ) {
if (buffer.isEndOfStream()) {
isEnded = true;
return;
}
hasPendingBuffer = true;
} else {
Assertions.checkState(result == C.RESULT_NOTHING_READ);
return;
}
}
if (hasPendingBuffer) {
if (!shouldProcessBuffer(buffer.timeUs, positionUs)) {
return;
}
lastSamplePositionUs = buffer.timeUs;
sampleBufferReadCount++;
hasPendingBuffer = false;
}
}
}
@Override
protected void onEnabled(boolean joining, boolean mayRenderStartOfStream)
throws ExoPlaybackException {
enabledCount++;
}
@Override
protected void onReset() {
resetCount++;
}
@Override
public boolean isReady() {
return lastSamplePositionUs >= playbackPositionUs || hasPendingBuffer || isSourceReady();
}
@Override
public boolean isEnded() {
return isEnded;
}
@Override
public @Capabilities int supportsFormat(Format format) throws ExoPlaybackException {
int trackType = MimeTypes.getTrackType(format.sampleMimeType);
return trackType != C.TRACK_TYPE_UNKNOWN && trackType == getTrackType()
? RendererCapabilities.create(C.FORMAT_HANDLED, ADAPTIVE_SEAMLESS, TUNNELING_NOT_SUPPORTED)
: RendererCapabilities.create(C.FORMAT_UNSUPPORTED_TYPE);
}
@Override
protected void onDisabled() {
if (currentDrmSession != null) {
currentDrmSession.release(/* eventDispatcher= */ null);
currentDrmSession = null;
}
}
/** Called when the renderer reads a new format. */
protected void onFormatChanged(Format format) {}
/** Returns the list of formats read by the renderer. */
public List<Format> getFormatsRead() {
return Collections.unmodifiableList(formatsRead);
}
/**
* Called before the renderer processes a buffer.
*
* @param bufferTimeUs The buffer timestamp, in microseconds.
* @param playbackPositionUs The playback position, in microseconds
* @return Whether the buffer should be processed.
*/
protected boolean shouldProcessBuffer(long bufferTimeUs, long playbackPositionUs) {
return bufferTimeUs < playbackPositionUs + SOURCE_READAHEAD_US;
}
}