MediaCodecRenderer

protected const val CODEC_OPERATING_RATE_UNSET = -1.0f: Float

Indicates no codec operating rate should be set.

fun experimentalEnableProcessedStreamChangedAtStart(): Unit

Enables the renderer to invoke onProcessedStreamChange on the first stream.

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

fun getDurationToProgressUs(positionUs: Long, elapsedRealtimeUs: Long): Long

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

The default return time is DEFAULT_DURATION_TO_PROGRESS_US.

fun handleMessage(@Renderer.MessageType messageType: Int, message: Any?): Unit

Handles a message delivered to the target.

fun isEnded(): Boolean

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.

fun isReady(): Boolean

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.

fun render(positionUs: Long, elapsedRealtimeUs: Long): Unit

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.

fun setPlaybackSpeed(currentPlaybackSpeed: Float, targetPlaybackSpeed: Float): Unit

Indicates the playback speed to this renderer.

The default implementation is a no-op.

fun setRenderTimeLimitMs(renderTimeLimitMs: Long): Unit

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
fun supportsFormat(format: Format!): Int

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

@RendererCapabilities.AdaptiveSupport
fun supportsMixedMimeTypeAdaptation(): Int

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

protected fun canReuseCodec(
    codecInfo: MediaCodecInfo!,
    oldFormat: Format!,
    newFormat: Format!
): DecoderReuseEvaluation!

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 fun flushOrReinitializeCodec(): Boolean

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 fun flushOrReleaseCodec(): Boolean

Flushes the codec. If flushing is not possible, the codec will be released. This method is a no-op if the codec is null.

protected fun getCodecBufferFlags(buffer: DecoderInputBuffer!): Int

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

protected fun getCodecOperatingRateV23(
    targetPlaybackSpeed: Float,
    format: Format!,
    streamFormats: Array<Format!>!
): Float

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 fun getDecoderInfos(
    mediaCodecSelector: MediaCodecSelector!,
    format: Format!,
    requiresSecureDecoder: Boolean
): (Mutable)List<MediaCodecInfo!>!

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

protected fun getDurationToProgressUs(
    isOnBufferAvailableListenerRegistered: Boolean,
    positionUs: Long,
    elapsedRealtimeUs: Long
): Long

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

If the Renderer has a registered , 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 abstract fun getMediaCodecConfiguration(
    codecInfo: MediaCodecInfo!,
    format: Format!,
    crypto: MediaCrypto?,
    codecOperatingRate: Float
): MediaCodecAdapter.Configuration!

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

protected fun getOutputStreamOffsetUs(): Long

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

protected fun getOutputStreamStartPositionUs(): Long

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

protected fun getPlaybackSpeed(): Float

Returns the current playback speed, as set by setPlaybackSpeed.

protected fun handleInputBufferSupplementalData(buffer: DecoderInputBuffer!): Unit

Handles supplemental data associated with an input buffer.

The default implementation is a no-op.

protected fun isBypassEnabled(): Boolean

Returns whether bypass is enabled by the renderer.

protected fun isBypassPossible(format: Format!): Boolean

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 fun onCodecError(codecError: Exception!): Unit

Called when a codec error has occurred.

The default implementation is a no-op.

protected fun onCodecInitialized(
    name: String!,
    configuration: MediaCodecAdapter.Configuration!,
    initializedTimestampMs: Long,
    initializationDurationMs: Long
): Unit

Called when a MediaCodec has been created and configured.

The default implementation is a no-op.

protected fun onCodecReleased(name: String!): Unit

Called when a MediaCodec has been released.

The default implementation is a no-op.

protected fun onDisabled(): Unit

Called when the renderer is disabled.

The default implementation is a no-op.

protected fun onEnabled(joining: Boolean, mayRenderStartOfStream: Boolean): Unit

Called when the renderer is enabled.

The default implementation is a no-op.

@CallSuper
protected fun onInputFormatChanged(formatHolder: FormatHolder!): DecoderReuseEvaluation?

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

protected fun onOutputFormatChanged(format: Format!, mediaFormat: MediaFormat?): Unit

Called when one of the output formats changes.

The default implementation is a no-op.

protected fun onOutputStreamOffsetUsChanged(outputStreamOffsetUs: Long): Unit

Called after the output stream offset changes.

The default implementation is a no-op.

protected fun onPositionReset(positionUs: Long, joining: Boolean): Unit

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.

The default implementation is a no-op.

@CallSuper
protected fun onProcessedOutputBuffer(presentationTimeUs: Long): Unit

Called when an output buffer is successfully processed.

protected fun onProcessedStreamChange(): Unit

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

protected fun onQueueInputBuffer(buffer: DecoderInputBuffer!): Unit

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

The default implementation is a no-op.

protected fun onReadyToInitializeCodec(format: Format!): Unit

Called when ready to initialize the MediaCodecAdapter.

This method is called just before the renderer obtains the configuration for the MediaCodecAdapter and creates the adapter via the passed in MediaCodecAdapter.Factory.

The default implementation is a no-op.

protected fun onReset(): Unit

Called when the renderer is reset.

The default implementation is a no-op.

protected fun onStarted(): Unit

Called when the renderer is started.

The default implementation is a no-op.

protected fun onStopped(): Unit

Called when the renderer is stopped.

The default implementation is a no-op.

protected fun onStreamChanged(
    formats: Array<Format!>!,
    startPositionUs: Long,
    offsetUs: Long,
    mediaPeriodId: MediaSource.MediaPeriodId!
): Unit

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 fun processOutputBuffer(
    positionUs: Long,
    elapsedRealtimeUs: Long,
    codec: MediaCodecAdapter?,
    buffer: ByteBuffer?,
    bufferIndex: Int,
    bufferFlags: Int,
    sampleCount: Int,
    bufferPresentationTimeUs: Long,
    isDecodeOnlyBuffer: Boolean,
    isLastBuffer: Boolean,
    format: Format!
): Boolean

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 fun renderToEndOfStream(): Unit

Incrementally renders any remaining output.

The default implementation is a no-op.

@CallSuper
protected fun resetCodecStateForFlush(): Unit

Resets the renderer internal state after a codec flush.

@CallSuper
protected fun resetCodecStateForRelease(): Unit

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 fun setPendingOutputEndOfStream(): Unit

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

protected fun setPendingPlaybackException(exception: ExoPlaybackException!): Unit

Sets an exception to be re-thrown by render.

protected fun shouldReinitCodec(): Boolean

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

protected fun shouldSkipDecoderInputBuffer(buffer: DecoderInputBuffer!): Boolean

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 fun shouldUseBypass(format: Format!): Boolean

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 fun supportsFormat(mediaCodecSelector: MediaCodecSelector!, format: Format!): Int

Returns the Capabilities for the given Format.

protected java-static fun supportsFormatDrm(format: Format!): Boolean

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

protected fun updateCodecOperatingRate(): Boolean

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

protected fun updateOutputFormatForTime(presentationTimeUs: Long): Unit

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