DefaultLoadControl

const val DEFAULT_AUDIO_BUFFER_SIZE = 13107200: Int

A default size in bytes for an audio buffer.

const val DEFAULT_BACK_BUFFER_DURATION_MS = 0: Int

The default back buffer duration in milliseconds.

const val DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS = 5000: Int

The default duration of media that must be buffered for playback to resume after a rebuffer, in milliseconds. A rebuffer is defined to be caused by buffer depletion rather than a user action.

const val DEFAULT_BUFFER_FOR_PLAYBACK_MS = 2500: Int

The default duration of media that must be buffered for playback to start or resume following a user action such as a seek, in milliseconds.

const val DEFAULT_CAMERA_MOTION_BUFFER_SIZE = 131072: Int

A default size in bytes for a camera motion buffer.

const val DEFAULT_IMAGE_BUFFER_SIZE = 131072: Int

A default size in bytes for an image buffer.

const val DEFAULT_MAX_BUFFER_MS = 50000: Int

The default maximum duration of media that the player will attempt to buffer, in milliseconds.

const val DEFAULT_METADATA_BUFFER_SIZE = 131072: Int

A default size in bytes for a metadata buffer.

const val DEFAULT_MIN_BUFFER_MS = 50000: Int

The default minimum duration of media that the player will attempt to ensure is buffered at all times, in milliseconds.

const val DEFAULT_MIN_BUFFER_SIZE = 13107200: Int

The buffer size in bytes that will be used as a minimum target buffer in all cases. This is also the default target buffer before tracks are selected.

const val DEFAULT_MUXED_BUFFER_SIZE = 144310272: Int

A default size in bytes for a muxed buffer (e.g. containing video, audio and text).

const val DEFAULT_PRIORITIZE_TIME_OVER_SIZE_THRESHOLDS = false: Boolean

The default prioritization of buffer time constraints over size constraints.

const val DEFAULT_RETAIN_BACK_BUFFER_FROM_KEYFRAME = false: Boolean

The default for whether the back buffer is retained from the previous keyframe.

const val DEFAULT_TARGET_BUFFER_BYTES = -1: Int

The default target buffer size in bytes. The value (LENGTH_UNSET) means that the load control will calculate the target buffer size based on the selected tracks.

const val DEFAULT_TEXT_BUFFER_SIZE = 131072: Int

A default size in bytes for a text buffer.

const val DEFAULT_VIDEO_BUFFER_SIZE = 131072000: Int

A default size in bytes for a video buffer.

DefaultLoadControl()

Constructs a new instance, using the DEFAULT_* constants defined in this class.

protected DefaultLoadControl(
    allocator: DefaultAllocator!,
    minBufferMs: Int,
    maxBufferMs: Int,
    bufferForPlaybackMs: Int,
    bufferForPlaybackAfterRebufferMs: Int,
    targetBufferBytes: Int,
    prioritizeTimeOverSizeThresholds: Boolean,
    backBufferDurationMs: Int,
    retainBackBufferFromKeyframe: Boolean
)

fun getAllocator(): Allocator!

Returns the Allocator that should be used to obtain media buffer allocations.

fun onPrepared(): Unit

Called by the player when prepared with a new source.

fun onReleased(): Unit

Called by the player when released.

fun onStopped(): Unit

Called by the player when stopped.

fun onTracksSelected(
    timeline: Timeline!,
    mediaPeriodId: MediaSource.MediaPeriodId!,
    renderers: Array<Renderer!>!,
    trackGroups: TrackGroupArray!,
    trackSelections: Array<ExoTrackSelection!>!
): Unit

Called by the player when a track selection occurs.

fun retainBackBufferFromKeyframe(): Boolean

Returns whether media should be retained from the keyframe before the current playback position minus getBackBufferDurationUs, rather than any sample before or at that position.

Warning: Returning true will cause the back-buffer size to depend on the spacing of keyframes in the media being played. Returning true is not recommended unless you control the media and are comfortable with the back-buffer size exceeding getBackBufferDurationUs by as much as the maximum duration between adjacent keyframes in the media.

Note: Implementations should return a single value. Dynamic changes to the back-buffer are not currently supported.

fun shouldContinueLoading(
    playbackPositionUs: Long,
    bufferedDurationUs: Long,
    playbackSpeed: Float
): Boolean

Called by the player to determine whether it should continue to load the source. If this method returns true, the MediaPeriod identified in the most recent onTracksSelected call will continue being loaded.

fun shouldStartPlayback(
    timeline: Timeline!,
    mediaPeriodId: MediaSource.MediaPeriodId!,
    bufferedDurationUs: Long,
    playbackSpeed: Float,
    rebuffering: Boolean,
    targetLiveOffsetUs: Long
): Boolean

Called repeatedly by the player when it's loading the source, has yet to start playback, and has the minimum amount of data necessary for playback to be started. The value returned determines whether playback is actually started. The load control may opt to return false until some condition has been met (e.g. a certain amount of media is buffered).

protected fun calculateTargetBufferBytes(
    renderers: Array<Renderer!>!,
    trackSelectionArray: Array<ExoTrackSelection!>!
): Int

Calculate target buffer size in bytes based on the selected tracks. The player will try not to exceed this target buffer. Only used when targetBufferBytes is LENGTH_UNSET.

val backBufferDurationUs: Long