Package com.google.android.exoplayer2.mediacodec

## Class MediaCodecRenderer

- java.lang.Object
- - com.google.android.exoplayer2.BaseRenderer
  - - com.google.android.exoplayer2.mediacodec.MediaCodecRenderer

- All Implemented Interfaces:
    `PlayerMessage.Target`, `Renderer`, `RendererCapabilities`
  Direct Known Subclasses:
    `MediaCodecAudioRenderer`, `MediaCodecVideoRenderer`

      public abstract class MediaCodecRenderer
      extends BaseRenderer

  An abstract renderer that uses `MediaCodec` to decode samples for rendering.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static class` | `MediaCodecRenderer.DecoderInitializationException` | Thrown when a failure occurs instantiating a decoder.

    - ### Nested classes/interfaces inherited from interface com.google.android.exoplayer2.Renderer

      `Renderer.MessageType, Renderer.State, Renderer.WakeupListener`

    - ### Nested classes/interfaces inherited from interface com.google.android.exoplayer2.RendererCapabilities

      `RendererCapabilities.AdaptiveSupport, RendererCapabilities.Capabilities, RendererCapabilities.DecoderSupport, RendererCapabilities.FormatSupport, RendererCapabilities.HardwareAccelerationSupport, RendererCapabilities.TunnelingSupport`

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected static float` | `CODEC_OPERATING_RATE_UNSET` | Indicates no codec operating rate should be set.
    `protected DecoderCounters` | `decoderCounters` |

    - ### Fields inherited from interface com.google.android.exoplayer2.Renderer

      `MSG_CUSTOM_BASE, MSG_SET_AUDIO_ATTRIBUTES, MSG_SET_AUDIO_SESSION_ID, MSG_SET_AUX_EFFECT_INFO, MSG_SET_CAMERA_MOTION_LISTENER, MSG_SET_CHANGE_FRAME_RATE_STRATEGY, MSG_SET_PREFERRED_AUDIO_DEVICE, MSG_SET_SCALING_MODE, MSG_SET_SKIP_SILENCE_ENABLED, MSG_SET_VIDEO_FRAME_METADATA_LISTENER, MSG_SET_VIDEO_OUTPUT, MSG_SET_VOLUME, MSG_SET_WAKEUP_LISTENER, STATE_DISABLED, STATE_ENABLED, STATE_STARTED`

    - ### Fields inherited from interface com.google.android.exoplayer2.RendererCapabilities

      `ADAPTIVE_NOT_SEAMLESS, ADAPTIVE_NOT_SUPPORTED, ADAPTIVE_SEAMLESS, ADAPTIVE_SUPPORT_MASK, DECODER_SUPPORT_FALLBACK, DECODER_SUPPORT_FALLBACK_MIMETYPE, DECODER_SUPPORT_PRIMARY, FORMAT_EXCEEDS_CAPABILITIES, FORMAT_HANDLED, FORMAT_SUPPORT_MASK, FORMAT_UNSUPPORTED_DRM, FORMAT_UNSUPPORTED_SUBTYPE, FORMAT_UNSUPPORTED_TYPE, HARDWARE_ACCELERATION_NOT_SUPPORTED, HARDWARE_ACCELERATION_SUPPORT_MASK, HARDWARE_ACCELERATION_SUPPORTED, MODE_SUPPORT_MASK, TUNNELING_NOT_SUPPORTED, TUNNELING_SUPPORT_MASK, TUNNELING_SUPPORTED`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `MediaCodecRenderer​(@com.google.android.exoplayer2.C.TrackType int trackType, MediaCodecAdapter.Factory codecAdapterFactory, MediaCodecSelector mediaCodecSelector, boolean enableDecoderFallback, float assumedMinimumCodecOperatingRate)` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `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.
    `protected MediaCodecDecoderException` | `createDecoderException​(Throwable cause, MediaCodecInfo codecInfo)` |
    `protected boolean` | `flushOrReinitializeCodec()` | Flushes the codec.
    `protected boolean` | `flushOrReleaseCodec()` | Flushes the codec.
    `protected MediaCodecAdapter` | `getCodec()` |
    `protected MediaCodecInfo` | `getCodecInfo()` |
    `protected boolean` | `getCodecNeedsEosPropagation()` | Returns whether the codec needs the renderer to propagate the end-of-stream signal directly, rather than by using an end-of-stream buffer queued to the codec.
    `protected float` | `getCodecOperatingRate()` | Returns the operating rate used by the current codec
    `protected float` | `getCodecOperatingRateV23​(float targetPlaybackSpeed, Format format, Format[] streamFormats)` | Returns the `MediaFormat.KEY_OPERATING_RATE` value for a given playback speed, current `Format` and set of possible stream formats.
    `protected MediaFormat` | `getCodecOutputMediaFormat()` |
    `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 abstract MediaCodecAdapter.Configuration` | `getMediaCodecConfiguration​(MediaCodecInfo codecInfo, Format format, 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 long` | `getOutputStreamOffsetUs()` | Returns the offset that should be subtracted from `bufferPresentationTimeUs` in `processOutputBuffer(long, long, MediaCodecAdapter, ByteBuffer, int, int, int, long, boolean, boolean, Format)` to get the playback position with respect to the media.
    `protected float` | `getPlaybackSpeed()` | Returns the current playback speed, as set by `setPlaybackSpeed(float, float)`.
    `protected void` | `handleInputBufferSupplementalData​(DecoderInputBuffer buffer)` | Handles supplemental data associated with an input buffer.
    `boolean` | `isEnded()` | Whether the renderer is ready for the `ExoPlayer` instance to transition to `Player.STATE_ENDED`.
    `boolean` | `isReady()` | Whether the renderer is able to immediately render media from the current position.
    `protected void` | `maybeInitCodecOrBypass()` |
    `protected void` | `onCodecError​(Exception codecError)` | Called when a codec error has occurred.
    `protected void` | `onCodecInitialized​(String name, MediaCodecAdapter.Configuration configuration, long initializedTimestampMs, long initializationDurationMs)` | Called when a `MediaCodec` has been created and configured.
    `protected void` | `onCodecReleased​(String name)` | Called when a `MediaCodec` has been released.
    `protected void` | `onDisabled()` | Called when the renderer is disabled.
    `protected void` | `onEnabled​(boolean joining, boolean mayRenderStartOfStream)` | Called when the renderer is enabled.
    `protected DecoderReuseEvaluation` | `onInputFormatChanged​(FormatHolder formatHolder)` | Called when a new `Format` is read from the upstream `MediaPeriod`.
    `protected void` | `onOutputFormatChanged​(Format format, MediaFormat mediaFormat)` | Called when one of the output formats changes.
    `protected void` | `onOutputStreamOffsetUsChanged​(long outputStreamOffsetUs)` | Called after the output stream offset changes.
    `protected void` | `onPositionReset​(long positionUs, boolean joining)` | Called when the position is reset.
    `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.
    `protected void` | `onReset()` | Called when the renderer is reset.
    `protected void` | `onStarted()` | Called when the renderer is started.
    `protected void` | `onStopped()` | Called when the renderer is stopped.
    `protected void` | `onStreamChanged​(Format[] formats, long startPositionUs, long offsetUs)` | Called when the renderer's stream has changed.
    `protected abstract boolean` | `processOutputBuffer​(long positionUs, long elapsedRealtimeUs, MediaCodecAdapter codec, ByteBuffer buffer, int bufferIndex, int bufferFlags, int sampleCount, long bufferPresentationTimeUs, boolean isDecodeOnlyBuffer, boolean isLastBuffer, Format format)` | Processes an output media buffer.
    `protected void` | `releaseCodec()` |
    `void` | `render​(long positionUs, long elapsedRealtimeUs)` | Incrementally renders the `SampleStream`.
    `protected void` | `renderToEndOfStream()` | Incrementally renders any remaining output.
    `protected void` | `resetCodecStateForFlush()` | Resets the renderer internal state after a codec flush.
    `protected void` | `resetCodecStateForRelease()` | Resets the renderer internal state after a codec release.
    `protected void` | `setPendingOutputEndOfStream()` | Notifies the renderer that output end of stream is pending and should be handled on the next render.
    `protected void` | `setPendingPlaybackException​(ExoPlaybackException exception)` | Sets an exception to be re-thrown by render.
    `void` | `setPlaybackSpeed​(float currentPlaybackSpeed, float targetPlaybackSpeed)` | Indicates the playback speed to this renderer.
    `void` | `setRenderTimeLimitMs​(long renderTimeLimitMs)` | Sets a limit on the time a single `render(long, long)` call can spend draining and filling the decoder.
    `protected boolean` | `shouldInitCodec​(MediaCodecInfo codecInfo)` |
    `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` | `shouldUseBypass​(Format format)` | Returns whether buffers in the input format can be processed without a codec.
    `@com.google.android.exoplayer2.RendererCapabilities.Capabilities int` | `supportsFormat​(Format format)` | Returns the extent to which the `Renderer` supports a given format.
    `protected abstract @com.google.android.exoplayer2.RendererCapabilities.Capabilities int` | `supportsFormat​(MediaCodecSelector mediaCodecSelector, Format format)` | Returns the `RendererCapabilities.Capabilities` for the given `Format`.
    `protected static boolean` | `supportsFormatDrm​(Format format)` | Returns whether this renderer supports the given `Format's` DRM scheme.
    `@com.google.android.exoplayer2.RendererCapabilities.AdaptiveSupport int` | `supportsMixedMimeTypeAdaptation()` | Returns the extent to which the `Renderer` supports adapting between supported formats that have different MIME types.
    `protected 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 void` | `updateOutputFormatForTime​(long presentationTimeUs)` | Updates the output formats for the specified output buffer timestamp, calling `onOutputFormatChanged(com.google.android.exoplayer2.Format, android.media.MediaFormat)` if a change has occurred.

    - ### Methods inherited from class com.google.android.exoplayer2.BaseRenderer

      `createRendererException, createRendererException, disable, enable, getCapabilities, getConfiguration, getFormatHolder, getIndex, getLastResetPositionUs, getMediaClock, getPlayerId, getReadingPositionUs, getState, getStream, getStreamFormats, getTrackType, handleMessage, hasReadStreamToEnd, init, isCurrentStreamFinal, isSourceReady, maybeThrowStreamError, readSource, replaceStream, reset, resetPosition, setCurrentStreamFinal, skipSource, start, stop`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface com.google.android.exoplayer2.Renderer

      `getName`

    - ### Methods inherited from interface com.google.android.exoplayer2.RendererCapabilities

      `getName`

- - ### Field Detail

    - #### CODEC_OPERATING_RATE_UNSET

          protected static final float CODEC_OPERATING_RATE_UNSET

      Indicates no codec operating rate should be set.
      See Also:
        Constant Field Values

    - #### decoderCounters

          protected DecoderCounters decoderCounters

  - ### Constructor Detail

    - #### MediaCodecRenderer

          public MediaCodecRenderer​(@com.google.android.exoplayer2.C.TrackType int trackType,
                                    MediaCodecAdapter.Factory codecAdapterFactory,
                                    MediaCodecSelector mediaCodecSelector,
                                    boolean enableDecoderFallback,
                                    float assumedMinimumCodecOperatingRate)

      Parameters:
        `trackType` - The `track type` that the renderer handles.
        `mediaCodecSelector` - A decoder selector.
        `enableDecoderFallback` - Whether to enable fallback to lower-priority decoders if decoder initialization fails. This may result in using a decoder that is less efficient or slower than the primary decoder.
        `assumedMinimumCodecOperatingRate` - A codec operating rate that all codecs instantiated by this renderer are assumed to meet implicitly (i.e. without the operating rate being set explicitly using `MediaFormat.KEY_OPERATING_RATE`).

  - ### Method Detail

    - #### setRenderTimeLimitMs

          public void setRenderTimeLimitMs​(long renderTimeLimitMs)

      Sets a limit on the time a single `render(long, long)` call can spend draining and filling the decoder.

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

      Parameters:
        `renderTimeLimitMs` - The render time limit in milliseconds, or `C.TIME_UNSET` for no limit.

    - #### supportsMixedMimeTypeAdaptation

          public final @com.google.android.exoplayer2.RendererCapabilities.AdaptiveSupport int supportsMixedMimeTypeAdaptation()

      Description copied from interface: `RendererCapabilities`
      Returns the extent to which the `Renderer` supports adapting between supported formats that have different MIME types.
      Specified by:
        `supportsMixedMimeTypeAdaptation` in interface `RendererCapabilities`
      Overrides:
        `supportsMixedMimeTypeAdaptation` in class `BaseRenderer`
      Returns:
        The `RendererCapabilities.AdaptiveSupport` for adapting between supported formats that have different MIME types.

    - #### supportsFormat

          public final @com.google.android.exoplayer2.RendererCapabilities.Capabilities int supportsFormat​(Format format)
                                                                                                    throws ExoPlaybackException

      Description copied from interface: `RendererCapabilities`
      Returns the extent to which the `Renderer` supports a given format.
      Parameters:
        `format` - The format.
      Returns:
        The `RendererCapabilities.Capabilities` for this format.
      Throws:
        `ExoPlaybackException` - If an error occurs.

    - #### supportsFormat

          protected abstract @com.google.android.exoplayer2.RendererCapabilities.Capabilities int supportsFormat​(MediaCodecSelector mediaCodecSelector,
                                                                                                                 Format format)
                                                                                                          throws MediaCodecUtil.DecoderQueryException

      Returns the `RendererCapabilities.Capabilities` for the given `Format`.
      Parameters:
        `mediaCodecSelector` - The decoder selector.
        `format` - The `Format`.
      Returns:
        The `RendererCapabilities.Capabilities` for this `Format`.
      Throws:
        `MediaCodecUtil.DecoderQueryException` - If there was an error querying decoders.

    - #### getDecoderInfos

          protected abstract List<MediaCodecInfo> getDecoderInfos​(MediaCodecSelector mediaCodecSelector,
                                                                  Format format,
                                                                  boolean requiresSecureDecoder)
                                                           throws MediaCodecUtil.DecoderQueryException

      Returns a list of decoders that can decode media in the specified format, in priority order.
      Parameters:
        `mediaCodecSelector` - The decoder selector.
        `format` - The `Format` for which a decoder is required.
        `requiresSecureDecoder` - Whether a secure decoder is required.
      Returns:
        A list of `MediaCodecInfo`s corresponding to decoders. May be empty.
      Throws:
        `MediaCodecUtil.DecoderQueryException` - Thrown if there was an error querying decoders.

    - #### getMediaCodecConfiguration

          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.
      Parameters:
        `codecInfo` - Information about the `MediaCodec` being configured.
        `format` - The `Format` for which the codec is being configured.
        `crypto` - For drm protected playbacks, a `MediaCrypto` to use for decryption.
        `codecOperatingRate` - The codec operating rate, or `CODEC_OPERATING_RATE_UNSET` if no codec operating rate should be set.
      Returns:
        The parameters needed to call `MediaCodec.configure(android.media.MediaFormat, android.view.Surface, android.media.MediaCrypto, int)`.

    - #### maybeInitCodecOrBypass

          protected final void maybeInitCodecOrBypass()
                                               throws ExoPlaybackException

      Throws:
        `ExoPlaybackException`

    - #### shouldUseBypass

          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.

      Parameters:
        `format` - The input `Format`.
      Returns:
        Whether playback bypassing `MediaCodec` is supported.

    - #### shouldInitCodec

          protected boolean shouldInitCodec​(MediaCodecInfo codecInfo)

    - #### shouldReinitCodec

          protected boolean shouldReinitCodec()

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

    - #### getCodecNeedsEosPropagation

          protected boolean getCodecNeedsEosPropagation()

      Returns whether the codec needs the renderer to propagate the end-of-stream signal directly, rather than by using an end-of-stream buffer queued to the codec.

    - #### setPendingPlaybackException

          protected final void setPendingPlaybackException​(ExoPlaybackException exception)

      Sets an exception to be re-thrown by render.
      Parameters:
        `exception` - The exception.

    - #### updateOutputFormatForTime

          protected final void updateOutputFormatForTime​(long presentationTimeUs)
                                                  throws ExoPlaybackException

      Updates the output formats for the specified output buffer timestamp, calling `onOutputFormatChanged(com.google.android.exoplayer2.Format, android.media.MediaFormat)` 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).

      Throws:
        `ExoPlaybackException` - Thrown if an error occurs as a result of the output format change.

    - #### getCodec

          @Nullable
          protected final MediaCodecAdapter getCodec()

    - #### getCodecOutputMediaFormat

          @Nullable
          protected final MediaFormat getCodecOutputMediaFormat()

    - #### getCodecInfo

          @Nullable
          protected final MediaCodecInfo getCodecInfo()

    - #### onEnabled

          protected void onEnabled​(boolean joining,
                                   boolean mayRenderStartOfStream)
                            throws ExoPlaybackException

      Description copied from class: `BaseRenderer`
      Called when the renderer is enabled.

      The default implementation is a no-op.

      Overrides:
        `onEnabled` in class `BaseRenderer`
      Parameters:
        `joining` - Whether this renderer is being enabled to join an ongoing playback.
        `mayRenderStartOfStream` - Whether this renderer is allowed to render the start of the stream even if the state is not `Renderer.STATE_STARTED` yet.
      Throws:
        `ExoPlaybackException` - If an error occurs.

    - #### onStreamChanged

          protected void onStreamChanged​(Format[] formats,
                                         long startPositionUs,
                                         long offsetUs)
                                  throws ExoPlaybackException

      Description copied from class: `BaseRenderer`
      Called when the renderer's stream has changed. This occurs when the renderer is enabled after `BaseRenderer.onEnabled(boolean, boolean)` 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.

      Overrides:
        `onStreamChanged` in class `BaseRenderer`
      Parameters:
        `formats` - The enabled formats.
        `startPositionUs` - The start position of the new stream in renderer time (microseconds).
        `offsetUs` - The offset that will be added to the timestamps of buffers read via `BaseRenderer.readSource(com.google.android.exoplayer2.FormatHolder, com.google.android.exoplayer2.decoder.DecoderInputBuffer, @com.google.android.exoplayer2.source.SampleStream.ReadFlags int)` so that decoder input buffers have monotonically increasing timestamps.
      Throws:
        `ExoPlaybackException` - If an error occurs.

    - #### onPositionReset

          protected void onPositionReset​(long positionUs,
                                         boolean joining)
                                  throws ExoPlaybackException

      Description copied from class: `BaseRenderer`
      Called when the position is reset. This occurs when the renderer is enabled after `BaseRenderer.onStreamChanged(Format[], long, long)` 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.

      Overrides:
        `onPositionReset` in class `BaseRenderer`
      Parameters:
        `positionUs` - The new playback position in microseconds.
        `joining` - Whether this renderer is being enabled to join an ongoing playback.
      Throws:
        `ExoPlaybackException` - If an error occurs.

    - #### setPlaybackSpeed

          public void setPlaybackSpeed​(float currentPlaybackSpeed,
                                       float targetPlaybackSpeed)
                                throws ExoPlaybackException

      Description copied from interface: `Renderer`
      Indicates the playback speed to this renderer.

      The default implementation is a no-op.

      Parameters:
        `currentPlaybackSpeed` - The factor by which playback is currently sped up.
        `targetPlaybackSpeed` - The target factor by which playback should be sped up. This may be different from `currentPlaybackSpeed`, for example, if the speed is temporarily adjusted for live playback.
      Throws:
        `ExoPlaybackException` - If an error occurs handling the playback speed.

    - #### onDisabled

          protected void onDisabled()

      Description copied from class: `BaseRenderer`
      Called when the renderer is disabled.

      The default implementation is a no-op.

      Overrides:
        `onDisabled` in class `BaseRenderer`

    - #### onReset

          protected void onReset()

      Description copied from class: `BaseRenderer`
      Called when the renderer is reset.

      The default implementation is a no-op.

      Overrides:
        `onReset` in class `BaseRenderer`

    - #### releaseCodec

          protected void releaseCodec()

    - #### onStarted

          protected void onStarted()

      Description copied from class: `BaseRenderer`
      Called when the renderer is started.

      The default implementation is a no-op.

      Overrides:
        `onStarted` in class `BaseRenderer`

    - #### onStopped

          protected void onStopped()

      Description copied from class: `BaseRenderer`
      Called when the renderer is stopped.

      The default implementation is a no-op.

      Overrides:
        `onStopped` in class `BaseRenderer`

    - #### render

          public void render​(long positionUs,
                             long elapsedRealtimeUs)
                      throws ExoPlaybackException

      Description copied from interface: `Renderer`
      Incrementally renders the `SampleStream`.

      If the renderer is in the `Renderer.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 `Renderer.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 `Renderer.STATE_ENABLED` state, unless it's the initial start of the media after calling `Renderer.enable(RendererConfiguration, Format[], SampleStream, long, boolean, boolean, long, long)` 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: `Renderer.STATE_ENABLED`, `Renderer.STATE_STARTED`.

      Parameters:
        `positionUs` - The current media time in microseconds, measured at the start of the current iteration of the rendering loop.
        `elapsedRealtimeUs` - `SystemClock.elapsedRealtime()` in microseconds, measured at the start of the current iteration of the rendering loop.
      Throws:
        `ExoPlaybackException` - If an error occurs.

    - #### flushOrReinitializeCodec

          protected final boolean flushOrReinitializeCodec()
                                                    throws ExoPlaybackException

      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.

      Returns:
        Whether the codec was released and reinitialized, rather than being flushed.
      Throws:
        `ExoPlaybackException` - If an error occurs re-instantiating the codec.

    - #### flushOrReleaseCodec

          protected boolean flushOrReleaseCodec()

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

    - #### resetCodecStateForFlush

          @CallSuper
          protected void resetCodecStateForFlush()

      Resets the renderer internal state after a codec flush.

    - #### resetCodecStateForRelease

          @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()`.

    - #### createDecoderException

          protected MediaCodecDecoderException createDecoderException​(Throwable cause,
                                                                      @Nullable
                                                                      MediaCodecInfo codecInfo)

    - #### onCodecInitialized

          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.

      Parameters:
        `name` - The name of the codec that was initialized.
        `configuration` - The `MediaCodecAdapter.Configuration` used to configure the codec.
        `initializedTimestampMs` - `SystemClock.elapsedRealtime()` when initialization finished.
        `initializationDurationMs` - The time taken to initialize the codec in milliseconds.

    - #### onCodecReleased

          protected void onCodecReleased​(String name)

      Called when a `MediaCodec` has been released.

      The default implementation is a no-op.

      Parameters:
        `name` - The name of the codec that was released.

    - #### onCodecError

          protected void onCodecError​(Exception codecError)

      Called when a codec error has occurred.

      The default implementation is a no-op.

      Parameters:
        `codecError` - The error.

    - #### onInputFormatChanged

          @CallSuper
          @Nullable
          protected DecoderReuseEvaluation onInputFormatChanged​(FormatHolder formatHolder)
                                                         throws ExoPlaybackException

      Called when a new `Format` is read from the upstream `MediaPeriod`.
      Parameters:
        `formatHolder` - A `FormatHolder` that holds the new `Format`.
      Returns:
        The result of the evaluation to determine whether the existing decoder instance can be reused for the new format, or `null` if the renderer did not have a decoder.
      Throws:
        `ExoPlaybackException` - If an error occurs re-initializing the `MediaCodec`.

    - #### onOutputFormatChanged

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

      Called when one of the output formats changes.

      The default implementation is a no-op.

      Parameters:
        `format` - The input `Format` to which future output now corresponds. If the renderer is in bypass mode, this is also the output format.
        `mediaFormat` - The codec output `MediaFormat`, or `null` if the renderer is in bypass mode.
      Throws:
        `ExoPlaybackException` - Thrown if an error occurs configuring the output.

    - #### handleInputBufferSupplementalData

          protected void handleInputBufferSupplementalData​(DecoderInputBuffer buffer)
                                                    throws ExoPlaybackException

      Handles supplemental data associated with an input buffer.

      The default implementation is a no-op.

      Parameters:
        `buffer` - The input buffer that is about to be queued.
      Throws:
        `ExoPlaybackException` - Thrown if an error occurs handling supplemental data.

    - #### onQueueInputBuffer

          protected void onQueueInputBuffer​(DecoderInputBuffer buffer)
                                     throws ExoPlaybackException

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

      The default implementation is a no-op.

      Parameters:
        `buffer` - The buffer to be queued.
      Throws:
        `ExoPlaybackException` - Thrown if an error occurs handling the input buffer.

    - #### onProcessedOutputBuffer

          @CallSuper
          protected void onProcessedOutputBuffer​(long presentationTimeUs)

      Called when an output buffer is successfully processed.
      Parameters:
        `presentationTimeUs` - The timestamp associated with the output buffer.

    - #### onProcessedStreamChange

          protected void onProcessedStreamChange()

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

    - #### canReuseCodec

          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.

      Parameters:
        `codecInfo` - A `MediaCodecInfo` describing the decoder.
        `oldFormat` - The `Format` for which the existing instance is configured.
        `newFormat` - The new `Format`.
      Returns:
        The result of the evaluation.

    - #### onOutputStreamOffsetUsChanged

          protected void onOutputStreamOffsetUsChanged​(long outputStreamOffsetUs)

      Called after the output stream offset changes.

      The default implementation is a no-op.

      Parameters:
        `outputStreamOffsetUs` - The output stream offset in microseconds.

    - #### isEnded

          public boolean isEnded()

      Description copied from interface: `Renderer`
      Whether the renderer is ready for the `ExoPlayer` instance to transition to `Player.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: `Renderer.STATE_ENABLED`, `Renderer.STATE_STARTED`.

      Returns:
        Whether the renderer is ready for the player to transition to the ended state.

    - #### isReady

          public boolean isReady()

      Description copied from interface: `Renderer`
      Whether the renderer is able to immediately render media from the current position.

      If the renderer is in the `Renderer.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 `Renderer.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: `Renderer.STATE_ENABLED`, `Renderer.STATE_STARTED`.

      Returns:
        Whether the renderer is ready to render media.

    - #### getPlaybackSpeed

          protected float getPlaybackSpeed()

      Returns the current playback speed, as set by `setPlaybackSpeed(float, float)`.

    - #### getCodecOperatingRate

          protected float getCodecOperatingRate()

      Returns the operating rate used by the current codec

    - #### getCodecOperatingRateV23

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

      Returns the `MediaFormat.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`.

      Parameters:
        `targetPlaybackSpeed` - The target factor by which playback should be sped up. This may be different from the current playback speed, for example, if the speed is temporarily adjusted for live playback.
        `format` - The `Format` for which the codec is being configured.
        `streamFormats` - The possible stream formats.
      Returns:
        The codec operating rate, or `CODEC_OPERATING_RATE_UNSET` if no codec operating rate should be set.

    - #### updateCodecOperatingRate

          protected final boolean updateCodecOperatingRate()
                                                    throws ExoPlaybackException

      Updates the codec operating rate, or triggers codec release and re-initialization if a previously set operating rate needs to be cleared.
      Returns:
        False if codec release and re-initialization was triggered. True in all other cases.
      Throws:
        `ExoPlaybackException` - If an error occurs releasing or initializing a codec.

    - #### processOutputBuffer

          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)
                                                  throws ExoPlaybackException

      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(long, boolean)` will always receive a new `ByteBuffer` to be processed.

      Parameters:
        `positionUs` - The current media time in microseconds, measured at the start of the current iteration of the rendering loop.
        `elapsedRealtimeUs` - `SystemClock.elapsedRealtime()` in microseconds, measured at the start of the current iteration of the rendering loop.
        `codec` - The `MediaCodecAdapter` instance, or null in bypass mode were no codec is used.
        `buffer` - The output buffer to process, or null if the buffer data is not made available to the application layer (see `MediaCodec.getOutputBuffer(int)`). This `buffer` can only be null for video data. Note that the buffer data can still be rendered in this case by using the `bufferIndex`.
        `bufferIndex` - The index of the output buffer.
        `bufferFlags` - The flags attached to the output buffer.
        `sampleCount` - The number of samples extracted from the sample queue in the buffer. This allows handling multiple samples as a batch for efficiency.
        `bufferPresentationTimeUs` - The presentation time of the output buffer in microseconds.
        `isDecodeOnlyBuffer` - Whether the buffer was marked with `C.BUFFER_FLAG_DECODE_ONLY` by the source.
        `isLastBuffer` - Whether the buffer is known to contain the last sample of the current stream. This flag is set on a best effort basis, and any logic relying on it should degrade gracefully to handle cases where it's not set.
        `format` - The `Format` associated with the buffer.
      Returns:
        Whether the output buffer was fully processed (for example, rendered or skipped).
      Throws:
        `ExoPlaybackException` - If an error occurs processing the output buffer.

    - #### renderToEndOfStream

          protected void renderToEndOfStream()
                                      throws ExoPlaybackException

      Incrementally renders any remaining output.

      The default implementation is a no-op.

      Throws:
        `ExoPlaybackException` - Thrown if an error occurs rendering remaining output.

    - #### setPendingOutputEndOfStream

          protected final void setPendingOutputEndOfStream()

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

    - #### getOutputStreamOffsetUs

          protected final long getOutputStreamOffsetUs()

      Returns the offset that should be subtracted from `bufferPresentationTimeUs` in `processOutputBuffer(long, long, MediaCodecAdapter, ByteBuffer, int, int, int, long, boolean, boolean, Format)` to get the playback position with respect to the media.

    - #### supportsFormatDrm

          protected static boolean supportsFormatDrm​(Format format)

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