MediaCodecRenderer

protected static final float CODEC_OPERATING_RATE_UNSET = -1.0f

Indicates no codec operating rate should be set.

protected static final boolean DEBUG_LOG_ENABLED = false

Compile-time flag to enable detailed logging for codec interactions.

protected static final String DEBUG_LOG_TAG = "MCRdebug"

Logging tag that should be used for all DEBUG_LOG_ENABLED logs.

public void experimentalEnableProcessedStreamChangedAtStart()

Enables the renderer to invoke onProcessedStreamChange on the first stream.

When not enabled, onProcessedStreamChange is invoked from the second stream onwards.

public final long getDurationToProgressUs(long positionUs, long elapsedRealtimeUs)

Returns minimum amount of playback clock time that must pass in order for the render call to make progress.

This method may be called when the renderer is in the following states: STATE_ENABLED, STATE_STARTED.

The default return time is DEFAULT_DURATION_TO_PROGRESS_US if the renderer is in STATE_STARTED, or in STATE_ENABLED and not yet ready or ended. Otherwise, it returns DEFAULT_IDLE_DURATION_TO_PROGRESS_US.

public void handleMessage(
    @Renderer.MessageType int messageType,
    @Nullable Object message
)

Handles a message delivered to the target.

public boolean isEnded()

Whether the renderer is ready for the ExoPlayer instance to transition to STATE_ENDED. The player will make this transition as soon as true is returned by all of its renderers.

This method may be called when the renderer is in the following states: STATE_ENABLED, STATE_STARTED.

public boolean isReady()

Whether the renderer is able to immediately render media from the current position.

If the renderer is in the STATE_STARTED state then returning true indicates that the renderer has everything that it needs to continue playback. Returning false indicates that the player should pause until the renderer is ready.

If the renderer is in the STATE_ENABLED state then returning true indicates that the renderer is ready for playback to be started. Returning false indicates that it is not.

This method may be called when the renderer is in the following states: STATE_ENABLED, STATE_STARTED.

public void render(long positionUs, long elapsedRealtimeUs)

Incrementally renders the SampleStream.

If the renderer is in the STATE_ENABLED state then each call to this method will do work toward being ready to render the SampleStream when the renderer is started. If the renderer is in the STATE_STARTED state then calls to this method will render the SampleStream in sync with the specified media positions.

The renderer may also render the very start of the media at the current position (e.g. the first frame of a video stream) while still in the STATE_ENABLED state, unless it's the initial start of the media after calling enable with mayRenderStartOfStream set to false.

This method should return quickly, and should not block if the renderer is unable to make useful progress.

This method may be called when the renderer is in the following states: STATE_ENABLED, STATE_STARTED.

public void setPlaybackSpeed(float currentPlaybackSpeed, float targetPlaybackSpeed)

Indicates the playback speed to this renderer.

The default implementation is a no-op.

public void setRenderTimeLimitMs(long renderTimeLimitMs)

Sets a limit on the time a single render call can spend draining and filling the decoder.

This method should be called right after creating an instance of this class.

@RendererCapabilities.Capabilities
public final int supportsFormat(Format format)

Returns the extent to which the Renderer supports a given format.

@RendererCapabilities.AdaptiveSupport
public final int supportsMixedMimeTypeAdaptation()

Returns the extent to which the Renderer supports adapting between supported formats that have different MIME types.

protected final void applyCodecParametersToMediaFormat(MediaFormat mediaFormat)

Applies the currently active CodecParameters to the given MediaFormat.

protected DecoderReuseEvaluation canReuseCodec(
    MediaCodecInfo codecInfo,
    Format oldFormat,
    Format newFormat
)

Evaluates whether the existing MediaCodec can be kept for a new Format, and if it can whether it requires reconfiguration.

The default implementation does not allow decoder reuse.

protected final boolean flushOrReinitializeCodec()

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 null.

The implementation of this method calls flushOrReleaseCodec, and maybeInitCodecOrBypass if the codec needs to be re-instantiated.

protected int getCodecBufferFlags(DecoderInputBuffer buffer)

Returns the flags that should be set on queueInputBuffer or queueSecureInputBuffer for this buffer.

protected float getCodecOperatingRate()

Returns the operating rate used by the current codec

protected float getCodecOperatingRateV23(
    float targetPlaybackSpeed,
    Format format,
    Format[] streamFormats
)

Returns the KEY_OPERATING_RATE value for a given playback speed, current Format and set of possible stream formats.

The default implementation returns CODEC_OPERATING_RATE_UNSET.

protected abstract List<MediaCodecInfo> getDecoderInfos(
    MediaCodecSelector mediaCodecSelector,
    Format format,
    boolean requiresSecureDecoder
)

Returns a list of decoders that can decode media in the specified format, in priority order.

protected long getDurationToProgressUs(
    long positionUs,
    long elapsedRealtimeUs,
    boolean isOnBufferAvailableListenerRegistered
)

Returns minimum time playback must advance in order for the render call to make progress.

If the Renderer has a registered MediaCodecAdapter.OnBufferAvailableListener, then the Renderer will be notified when decoder input and output buffers become available. These callbacks may affect the calculated minimum time playback must advance before a render call can make progress.

protected long getLargestQueuedPresentationTimeUs()

Returns the largest presentation time of a buffer queued to the decoder.

If a buffer has not yet been queued to the decoder then the return value will be TIME_UNSET. The value is reset when the decoder is flushed or released.

protected long getLastBufferInStreamPresentationTimeUs()

Returns the presentation time of the last buffer in the stream.

If the last buffer has not yet been read off the sample queue then the return value will be TIME_UNSET.

protected final long getLastProcessedOutputBufferTimeUs()

Returns the presentation time of the last output buffer processed.

If an output buffer has not yet been processed then the return value will be TIME_UNSET.

protected abstract MediaCodecAdapter.Configuration getMediaCodecConfiguration(
    MediaCodecInfo codecInfo,
    Format format,
    @Nullable MediaCrypto crypto,
    float codecOperatingRate
)

Returns the MediaCodecAdapter.Configuration that will be used to create and configure a MediaCodec to decode the given Format for a playback.

protected final long getOutputStreamOffsetUs()

Returns the offset that should be subtracted from bufferPresentationTimeUs in processOutputBuffer to get the playback position with respect to the media.

protected final long getOutputStreamStartPositionUs()

Returns the start position of the current output stream in microseconds.

protected float getPlaybackSpeed()

Returns the current playback speed, as set by setPlaybackSpeed.

protected long getSkippedFlushOffsetUs()

Returns the offset added to buffer timestamps prior to decoding.

The skippedFlushOffset ensures timestamps are greater than the current "largestQueuedTimestamp" when skipping flushing the codec during a seek.

protected final @Nullable Renderer.WakeupListener getWakeupListener()

Returns listener used to signal that render should be called.

protected void handleInputBufferSupplementalData(DecoderInputBuffer buffer)

Handles supplemental data associated with an input buffer.

The default implementation is a no-op.

protected final boolean isBypassEnabled()

Returns whether bypass is enabled by the renderer.

protected final boolean isBypassPossible(Format format)

Returns whether buffers in the input format can be processed without a codec.

This method returns the possibility of bypass mode with checking both the renderer capabilities and DRM protection.

protected final boolean isReadyForDecoding()

Returns whether the renderer is ready to start or continue decoding.

protected boolean maybeInitializeProcessingPipeline(Format format)

Initializes the processing pipeline, if needed by the implementation.

The default implementation is a no-op.

protected void onCodecError(Exception codecError)

Called when a codec error has occurred.

The default implementation is a no-op.

protected void onCodecInitialized(
    String name,
    MediaCodecAdapter.Configuration configuration,
    long initializedTimestampMs,
    long initializationDurationMs
)

Called when a MediaCodec has been created and configured.

The default implementation is a no-op.

protected abstract void onCodecParametersChanged(CodecParameters codecParameters)

Called when one or more of the subscribed codec parameters have changed.

protected void onCodecReleased(String name)

Called when a MediaCodec has been released.

The default implementation is a no-op.

protected void onDisabled()

Called when the renderer is disabled.

The default implementation is a no-op.

protected void onEnabled(boolean joining, boolean mayRenderStartOfStream)

Called when the renderer is enabled.

The default implementation is a no-op.

@CallSuper
protected @Nullable DecoderReuseEvaluation onInputFormatChanged(FormatHolder formatHolder)

Called when a new Format is read from the upstream MediaPeriod.

protected void onOutputFormatChanged(Format format, @Nullable MediaFormat mediaFormat)

Called when one of the output formats changes.

The default implementation is a no-op.

protected void onOutputStreamOffsetUsChanged(long outputStreamOffsetUs)

Called after the output stream offset changes.

The default implementation is a no-op.

protected void onPositionReset(
    long positionUs,
    boolean joining,
    boolean sampleStreamIsResetToKeyFrame
)

Called when the position is reset. This occurs when the renderer is enabled after onStreamChanged has been called, and also when a position discontinuity is encountered.

After a position reset, the renderer's SampleStream is guaranteed to provide samples starting from a key frame if sampleStreamIsResetToKeyFrame is true. sampleStreamIsResetToKeyFrame is guaranteed to be true unless the implementation overrides supportsResetPositionWithoutKeyFrameReset to return true.

The default implementation is a no-op.

@CallSuper
protected void onProcessedOutputBuffer(long presentationTimeUs)

Called when an output buffer is successfully processed.

protected void onProcessedStreamChange()

Called after the last output buffer before a stream change has been processed.

protected void onQueueInputBuffer(DecoderInputBuffer buffer)

Called immediately before an input buffer is queued into the codec.

The default implementation is a no-op.

protected void onReset()

Called when the renderer is reset.

The default implementation is a no-op.

protected void onStarted()

Called when the renderer is started.

The default implementation is a no-op.

protected void onStopped()

Called when the renderer is stopped.

The default implementation is a no-op.

protected void onStreamChanged(
    Format[] formats,
    long startPositionUs,
    long offsetUs,
    MediaSource.MediaPeriodId mediaPeriodId
)

Called when the renderer's stream has changed. This occurs when the renderer is enabled after onEnabled has been called, and also when the stream has been replaced whilst the renderer is enabled or started.

The default implementation is a no-op.

protected abstract boolean processOutputBuffer(
    long positionUs,
    long elapsedRealtimeUs,
    @Nullable MediaCodecAdapter codec,
    @Nullable ByteBuffer buffer,
    int bufferIndex,
    int bufferFlags,
    int sampleCount,
    long bufferPresentationTimeUs,
    boolean isDecodeOnlyBuffer,
    boolean isLastBuffer,
    Format format
)

Processes an output media buffer.

When a new ByteBuffer is passed to this method its position and limit delineate the data to be processed. The return value indicates whether the buffer was processed in full. If true is returned then the next call to this method will receive a new buffer to be processed. If false is returned then the same buffer will be passed to the next call. An implementation of this method is free to modify the buffer and can assume that the buffer will not be externally modified between successive calls. Hence an implementation can, for example, modify the buffer's position to keep track of how much of the data it has processed.

Note that the first call to this method following a call to onPositionReset will always receive a new ByteBuffer to be processed.

protected void renderToEndOfStream()

Incrementally renders any remaining output.

The default implementation is a no-op.

@CallSuper
protected void resetCodecStateForFlush()

Resets the renderer internal state after a codec flush.

@CallSuper
protected void resetCodecStateForRelease()

Resets the renderer internal state after a codec release.

Note that this only needs to reset state variables that are changed in addition to those already changed in resetCodecStateForFlush.

protected final void setPendingOutputEndOfStream()

Notifies the renderer that output end of stream is pending and should be handled on the next render.

protected final void setPendingPlaybackException(ExoPlaybackException exception)

Sets an exception to be re-thrown by render.

protected boolean shouldDiscardDecoderInputBuffer(DecoderInputBuffer buffer)

Returns whether the input buffer should be discarded before decoding.

Implement this method to to skip decoding of buffers that are not needed during a seek, or to drop input buffers that cannot be rendered on time. See BUFFER_FLAG_NOT_DEPENDED_ON.

Subclasses that implement this method are responsible for updating decoderCounters. For codecs with out-of-order buffers, consecutive dropped input buffers may have to be counted after frame reordering. For example, in processOutputBuffer.

Implementations of this method must update the decoder input buffer contents. Data that is only used for output at the current timeUs should be removed. Data that is referenced by later input buffers should remain in the current buffer.

protected boolean shouldFlushCodec()

Returns whether the codec should be flushed in cases such that the codec was not released.

Default is true.

protected boolean shouldReinitCodec()

Returns whether the renderer needs to re-initialize the codec, possibly as a result of a change in device capabilities.

protected boolean shouldReleaseCodecInsteadOfFlushing()

Returns whether the codec should be released rather than flushed.

protected boolean shouldSkipDecoderInputBuffer(DecoderInputBuffer buffer)

Returns whether the input buffer should be skipped before the decoder.

This can be used to skip decoding of buffers that are not depended on during seeking. See BUFFER_FLAG_NOT_DEPENDED_ON.

protected boolean shouldUseBypass(Format format)

Returns whether buffers in the input format can be processed without a codec.

This method is only called if the content is not DRM protected, because if the content is DRM protected use of bypass is never possible.

@RendererCapabilities.Capabilities
protected abstract int supportsFormat(MediaCodecSelector mediaCodecSelector, Format format)

Returns the Capabilities for the given Format.

protected static boolean supportsFormatDrm(Format format)

Returns whether this renderer supports the given Format's DRM scheme.

protected final boolean updateCodecOperatingRate()

Updates the codec operating rate, or triggers codec release and re-initialization if a previously set operating rate needs to be cleared.

protected final void updateOutputFormatForTime(long presentationTimeUs)

Updates the output formats for the specified output buffer timestamp, calling onOutputFormatChanged if a change has occurred.

Subclasses should only call this method if operating in a mode where buffers are not dequeued from the decoder, for example when using video tunneling).